mirror of
https://github.com/python-pillow/Pillow.git
synced 2025-02-23 15:20:33 +03:00
Update pythoncapi_compat.h to fix building with PyPy3.11
Update `pythoncapi_compat.h` to upstream commit
c84545f0e1e21757d4901f75c47333d25a3fcff0, which includes fixes necessary
for Pillow to build against PyPy3.11. Otherwise, it fails due to
duplicate declarations:
```
In file included from src/encode.c:28:
src/thirdparty/pythoncapi_compat.h:295:1: error: static declaration of ‘PyThreadState_GetInterpreter’ follows non-static declaration
295 | PyThreadState_GetInterpreter(PyThreadState *tstate)
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/pypy3.11/Python.h:80,
from src/encode.c:26:
/usr/include/pypy3.11/pystate.h:35:33: note: previous declaration of ‘PyThreadState_GetInterpreter’ with type ‘PyInterpreterState *(PyThreadState *)’ {aka ‘struct _is *(struct _ts *)’}
35 | PyAPI_FUNC(PyInterpreterState*) PyThreadState_GetInterpreter(PyThreadState *tstate);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
This commit is contained in:
Michał Górny
parent
0364cfdfc4
commit
0fbe1860c4
521
src/thirdparty/pythoncapi_compat.h
vendored
521
src/thirdparty/pythoncapi_compat.h
vendored
|
|
@ -10,7 +10,7 @@
|
|||
// https://raw.githubusercontent.com/python/pythoncapi-compat/main/pythoncapi_compat.h
|
||||
//
|
||||
// This file was vendored from the following commit:
|
||||
// https://github.com/python/pythoncapi-compat/commit/0041177c4f348c8952b4c8980b2c90856e61c7c7
|
||||
// https://github.com/python/pythoncapi-compat/commit/c84545f0e1e21757d4901f75c47333d25a3fcff0
|
||||
//
|
||||
// SPDX-License-Identifier: 0BSD
|
||||
|
||||
|
|
@ -22,11 +22,15 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
#include <Python.h>
|
||||
#include <stddef.h> // offsetof()
|
||||
|
||||
// Python 3.11.0b4 added PyFrame_Back() to Python.h
|
||||
#if PY_VERSION_HEX < 0x030b00B4 && !defined(PYPY_VERSION)
|
||||
# include "frameobject.h" // PyFrameObject, PyFrame_GetBack()
|
||||
#endif
|
||||
#if PY_VERSION_HEX < 0x030C00A3
|
||||
# include <structmember.h> // T_SHORT, READONLY
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef _Py_CAST
|
||||
|
|
@ -290,7 +294,7 @@ PyFrame_GetVarString(PyFrameObject *frame, const char *name)
|
|||
|
||||
|
||||
// bpo-39947 added PyThreadState_GetInterpreter() to Python 3.9.0a5
|
||||
#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION)
|
||||
#if PY_VERSION_HEX < 0x030900A5 || (defined(PYPY_VERSION) && PY_VERSION_HEX < 0x030B0000)
|
||||
static inline PyInterpreterState *
|
||||
PyThreadState_GetInterpreter(PyThreadState *tstate)
|
||||
{
|
||||
|
|
@ -583,7 +587,7 @@ static inline int PyWeakref_GetRef(PyObject *ref, PyObject **pobj)
|
|||
return 0;
|
||||
}
|
||||
*pobj = Py_NewRef(obj);
|
||||
return (*pobj != NULL);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -921,7 +925,7 @@ static inline int
|
|||
PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg)
|
||||
{
|
||||
PyObject **dict = _PyObject_GetDictPtr(obj);
|
||||
if (*dict == NULL) {
|
||||
if (dict == NULL || *dict == NULL) {
|
||||
return -1;
|
||||
}
|
||||
Py_VISIT(*dict);
|
||||
|
|
@ -932,7 +936,7 @@ static inline void
|
|||
PyObject_ClearManagedDict(PyObject *obj)
|
||||
{
|
||||
PyObject **dict = _PyObject_GetDictPtr(obj);
|
||||
if (*dict == NULL) {
|
||||
if (dict == NULL || *dict == NULL) {
|
||||
return;
|
||||
}
|
||||
Py_CLEAR(*dict);
|
||||
|
|
@ -1207,11 +1211,11 @@ static inline int PyTime_PerfCounter(PyTime_t *result)
|
|||
#endif
|
||||
|
||||
// gh-111389 added hash constants to Python 3.13.0a5. These constants were
|
||||
// added first as private macros to Python 3.4.0b1 and PyPy 7.3.9.
|
||||
// added first as private macros to Python 3.4.0b1 and PyPy 7.3.8.
|
||||
#if (!defined(PyHASH_BITS) \
|
||||
&& ((!defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x030400B1) \
|
||||
|| (defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x03070000 \
|
||||
&& PYPY_VERSION_NUM >= 0x07090000)))
|
||||
&& PYPY_VERSION_NUM >= 0x07030800)))
|
||||
# define PyHASH_BITS _PyHASH_BITS
|
||||
# define PyHASH_MODULUS _PyHASH_MODULUS
|
||||
# define PyHASH_INF _PyHASH_INF
|
||||
|
|
@ -1523,6 +1527,36 @@ static inline int PyLong_GetSign(PyObject *obj, int *sign)
|
|||
}
|
||||
#endif
|
||||
|
||||
// gh-126061 added PyLong_IsPositive/Negative/Zero() to Python in 3.14.0a2
|
||||
#if PY_VERSION_HEX < 0x030E00A2
|
||||
static inline int PyLong_IsPositive(PyObject *obj)
|
||||
{
|
||||
if (!PyLong_Check(obj)) {
|
||||
PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name);
|
||||
return -1;
|
||||
}
|
||||
return _PyLong_Sign(obj) == 1;
|
||||
}
|
||||
|
||||
static inline int PyLong_IsNegative(PyObject *obj)
|
||||
{
|
||||
if (!PyLong_Check(obj)) {
|
||||
PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name);
|
||||
return -1;
|
||||
}
|
||||
return _PyLong_Sign(obj) == -1;
|
||||
}
|
||||
|
||||
static inline int PyLong_IsZero(PyObject *obj)
|
||||
{
|
||||
if (!PyLong_Check(obj)) {
|
||||
PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name);
|
||||
return -1;
|
||||
}
|
||||
return _PyLong_Sign(obj) == 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// gh-124502 added PyUnicode_Equal() to Python 3.14.0a0
|
||||
#if PY_VERSION_HEX < 0x030E00A0
|
||||
|
|
@ -1693,6 +1727,479 @@ static inline int PyLong_AsUInt64(PyObject *obj, uint64_t *pvalue)
|
|||
#endif
|
||||
|
||||
|
||||
// gh-102471 added import and export API for integers to 3.14.0a2.
|
||||
#if PY_VERSION_HEX < 0x030E00A2 && PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
|
||||
// Helpers to access PyLongObject internals.
|
||||
static inline void
|
||||
_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size)
|
||||
{
|
||||
#if PY_VERSION_HEX >= 0x030C0000
|
||||
op->long_value.lv_tag = (uintptr_t)(1 - sign) | ((uintptr_t)(size) << 3);
|
||||
#elif PY_VERSION_HEX >= 0x030900A4
|
||||
Py_SET_SIZE(op, sign * size);
|
||||
#else
|
||||
Py_SIZE(op) = sign * size;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline Py_ssize_t
|
||||
_PyLong_DigitCount(const PyLongObject *op)
|
||||
{
|
||||
#if PY_VERSION_HEX >= 0x030C0000
|
||||
return (Py_ssize_t)(op->long_value.lv_tag >> 3);
|
||||
#else
|
||||
return _PyLong_Sign((PyObject*)op) < 0 ? -Py_SIZE(op) : Py_SIZE(op);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline digit*
|
||||
_PyLong_GetDigits(const PyLongObject *op)
|
||||
{
|
||||
#if PY_VERSION_HEX >= 0x030C0000
|
||||
return (digit*)(op->long_value.ob_digit);
|
||||
#else
|
||||
return (digit*)(op->ob_digit);
|
||||
#endif
|
||||
}
|
||||
|
||||
typedef struct PyLongLayout {
|
||||
uint8_t bits_per_digit;
|
||||
uint8_t digit_size;
|
||||
int8_t digits_order;
|
||||
int8_t digit_endianness;
|
||||
} PyLongLayout;
|
||||
|
||||
typedef struct PyLongExport {
|
||||
int64_t value;
|
||||
uint8_t negative;
|
||||
Py_ssize_t ndigits;
|
||||
const void *digits;
|
||||
Py_uintptr_t _reserved;
|
||||
} PyLongExport;
|
||||
|
||||
typedef struct PyLongWriter PyLongWriter;
|
||||
|
||||
static inline const PyLongLayout*
|
||||
PyLong_GetNativeLayout(void)
|
||||
{
|
||||
static const PyLongLayout PyLong_LAYOUT = {
|
||||
PyLong_SHIFT,
|
||||
sizeof(digit),
|
||||
-1, // least significant first
|
||||
PY_LITTLE_ENDIAN ? -1 : 1,
|
||||
};
|
||||
|
||||
return &PyLong_LAYOUT;
|
||||
}
|
||||
|
||||
static inline int
|
||||
PyLong_Export(PyObject *obj, PyLongExport *export_long)
|
||||
{
|
||||
if (!PyLong_Check(obj)) {
|
||||
memset(export_long, 0, sizeof(*export_long));
|
||||
PyErr_Format(PyExc_TypeError, "expected int, got %s",
|
||||
Py_TYPE(obj)->tp_name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Fast-path: try to convert to a int64_t
|
||||
PyLongObject *self = (PyLongObject*)obj;
|
||||
int overflow;
|
||||
#if SIZEOF_LONG == 8
|
||||
long value = PyLong_AsLongAndOverflow(obj, &overflow);
|
||||
#else
|
||||
// Windows has 32-bit long, so use 64-bit long long instead
|
||||
long long value = PyLong_AsLongLongAndOverflow(obj, &overflow);
|
||||
#endif
|
||||
Py_BUILD_ASSERT(sizeof(value) == sizeof(int64_t));
|
||||
// the function cannot fail since obj is a PyLongObject
|
||||
assert(!(value == -1 && PyErr_Occurred()));
|
||||
|
||||
if (!overflow) {
|
||||
export_long->value = value;
|
||||
export_long->negative = 0;
|
||||
export_long->ndigits = 0;
|
||||
export_long->digits = 0;
|
||||
export_long->_reserved = 0;
|
||||
}
|
||||
else {
|
||||
export_long->value = 0;
|
||||
export_long->negative = _PyLong_Sign(obj) < 0;
|
||||
export_long->ndigits = _PyLong_DigitCount(self);
|
||||
if (export_long->ndigits == 0) {
|
||||
export_long->ndigits = 1;
|
||||
}
|
||||
export_long->digits = _PyLong_GetDigits(self);
|
||||
export_long->_reserved = (Py_uintptr_t)Py_NewRef(obj);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void
|
||||
PyLong_FreeExport(PyLongExport *export_long)
|
||||
{
|
||||
PyObject *obj = (PyObject*)export_long->_reserved;
|
||||
|
||||
if (obj) {
|
||||
export_long->_reserved = 0;
|
||||
Py_DECREF(obj);
|
||||
}
|
||||
}
|
||||
|
||||
static inline PyLongWriter*
|
||||
PyLongWriter_Create(int negative, Py_ssize_t ndigits, void **digits)
|
||||
{
|
||||
if (ndigits <= 0) {
|
||||
PyErr_SetString(PyExc_ValueError, "ndigits must be positive");
|
||||
return NULL;
|
||||
}
|
||||
assert(digits != NULL);
|
||||
|
||||
PyLongObject *obj = _PyLong_New(ndigits);
|
||||
if (obj == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
_PyLong_SetSignAndDigitCount(obj, negative?-1:1, ndigits);
|
||||
|
||||
*digits = _PyLong_GetDigits(obj);
|
||||
return (PyLongWriter*)obj;
|
||||
}
|
||||
|
||||
static inline void
|
||||
PyLongWriter_Discard(PyLongWriter *writer)
|
||||
{
|
||||
PyLongObject *obj = (PyLongObject *)writer;
|
||||
|
||||
assert(Py_REFCNT(obj) == 1);
|
||||
Py_DECREF(obj);
|
||||
}
|
||||
|
||||
static inline PyObject*
|
||||
PyLongWriter_Finish(PyLongWriter *writer)
|
||||
{
|
||||
PyObject *obj = (PyObject *)writer;
|
||||
PyLongObject *self = (PyLongObject*)obj;
|
||||
Py_ssize_t j = _PyLong_DigitCount(self);
|
||||
Py_ssize_t i = j;
|
||||
int sign = _PyLong_Sign(obj);
|
||||
|
||||
assert(Py_REFCNT(obj) == 1);
|
||||
|
||||
// Normalize and get singleton if possible
|
||||
while (i > 0 && _PyLong_GetDigits(self)[i-1] == 0) {
|
||||
--i;
|
||||
}
|
||||
if (i != j) {
|
||||
if (i == 0) {
|
||||
sign = 0;
|
||||
}
|
||||
_PyLong_SetSignAndDigitCount(self, sign, i);
|
||||
}
|
||||
if (i <= 1) {
|
||||
long val = sign * (long)(_PyLong_GetDigits(self)[0]);
|
||||
Py_DECREF(obj);
|
||||
return PyLong_FromLong(val);
|
||||
}
|
||||
|
||||
return obj;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if PY_VERSION_HEX < 0x030C00A3
|
||||
# define Py_T_SHORT T_SHORT
|
||||
# define Py_T_INT T_INT
|
||||
# define Py_T_LONG T_LONG
|
||||
# define Py_T_FLOAT T_FLOAT
|
||||
# define Py_T_DOUBLE T_DOUBLE
|
||||
# define Py_T_STRING T_STRING
|
||||
# define _Py_T_OBJECT T_OBJECT
|
||||
# define Py_T_CHAR T_CHAR
|
||||
# define Py_T_BYTE T_BYTE
|
||||
# define Py_T_UBYTE T_UBYTE
|
||||
# define Py_T_USHORT T_USHORT
|
||||
# define Py_T_UINT T_UINT
|
||||
# define Py_T_ULONG T_ULONG
|
||||
# define Py_T_STRING_INPLACE T_STRING_INPLACE
|
||||
# define Py_T_BOOL T_BOOL
|
||||
# define Py_T_OBJECT_EX T_OBJECT_EX
|
||||
# define Py_T_LONGLONG T_LONGLONG
|
||||
# define Py_T_ULONGLONG T_ULONGLONG
|
||||
# define Py_T_PYSSIZET T_PYSSIZET
|
||||
|
||||
# if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
|
||||
# define _Py_T_NONE T_NONE
|
||||
# endif
|
||||
|
||||
# define Py_READONLY READONLY
|
||||
# define Py_AUDIT_READ READ_RESTRICTED
|
||||
# define _Py_WRITE_RESTRICTED PY_WRITE_RESTRICTED
|
||||
#endif
|
||||
|
||||
|
||||
// gh-127350 added Py_fopen() and Py_fclose() to Python 3.14a4
|
||||
#if PY_VERSION_HEX < 0x030E00A4
|
||||
static inline FILE* Py_fopen(PyObject *path, const char *mode)
|
||||
{
|
||||
#if 0x030400A2 <= PY_VERSION_HEX && !defined(PYPY_VERSION)
|
||||
PyAPI_FUNC(FILE*) _Py_fopen_obj(PyObject *path, const char *mode);
|
||||
|
||||
return _Py_fopen_obj(path, mode);
|
||||
#else
|
||||
FILE *f;
|
||||
PyObject *bytes;
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
if (!PyUnicode_FSConverter(path, &bytes)) {
|
||||
return NULL;
|
||||
}
|
||||
#else
|
||||
if (!PyString_Check(path)) {
|
||||
PyErr_SetString(PyExc_TypeError, "except str");
|
||||
return NULL;
|
||||
}
|
||||
bytes = Py_NewRef(path);
|
||||
#endif
|
||||
const char *path_bytes = PyBytes_AS_STRING(bytes);
|
||||
|
||||
f = fopen(path_bytes, mode);
|
||||
Py_DECREF(bytes);
|
||||
|
||||
if (f == NULL) {
|
||||
PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, path);
|
||||
return NULL;
|
||||
}
|
||||
return f;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int Py_fclose(FILE *file)
|
||||
{
|
||||
return fclose(file);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if 0x03090000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030E0000 && !defined(PYPY_VERSION)
|
||||
static inline PyObject*
|
||||
PyConfig_Get(const char *name)
|
||||
{
|
||||
typedef enum {
|
||||
_PyConfig_MEMBER_INT,
|
||||
_PyConfig_MEMBER_UINT,
|
||||
_PyConfig_MEMBER_ULONG,
|
||||
_PyConfig_MEMBER_BOOL,
|
||||
_PyConfig_MEMBER_WSTR,
|
||||
_PyConfig_MEMBER_WSTR_OPT,
|
||||
_PyConfig_MEMBER_WSTR_LIST,
|
||||
} PyConfigMemberType;
|
||||
|
||||
typedef struct {
|
||||
const char *name;
|
||||
size_t offset;
|
||||
PyConfigMemberType type;
|
||||
const char *sys_attr;
|
||||
} PyConfigSpec;
|
||||
|
||||
#define PYTHONCAPI_COMPAT_SPEC(MEMBER, TYPE, sys_attr) \
|
||||
{#MEMBER, offsetof(PyConfig, MEMBER), \
|
||||
_PyConfig_MEMBER_##TYPE, sys_attr}
|
||||
|
||||
static const PyConfigSpec config_spec[] = {
|
||||
PYTHONCAPI_COMPAT_SPEC(argv, WSTR_LIST, "argv"),
|
||||
PYTHONCAPI_COMPAT_SPEC(base_exec_prefix, WSTR_OPT, "base_exec_prefix"),
|
||||
PYTHONCAPI_COMPAT_SPEC(base_executable, WSTR_OPT, "_base_executable"),
|
||||
PYTHONCAPI_COMPAT_SPEC(base_prefix, WSTR_OPT, "base_prefix"),
|
||||
PYTHONCAPI_COMPAT_SPEC(bytes_warning, UINT, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(exec_prefix, WSTR_OPT, "exec_prefix"),
|
||||
PYTHONCAPI_COMPAT_SPEC(executable, WSTR_OPT, "executable"),
|
||||
PYTHONCAPI_COMPAT_SPEC(inspect, BOOL, _Py_NULL),
|
||||
#if 0x030C0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(int_max_str_digits, UINT, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(interactive, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(module_search_paths, WSTR_LIST, "path"),
|
||||
PYTHONCAPI_COMPAT_SPEC(optimization_level, UINT, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(parser_debug, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(platlibdir, WSTR, "platlibdir"),
|
||||
PYTHONCAPI_COMPAT_SPEC(prefix, WSTR_OPT, "prefix"),
|
||||
PYTHONCAPI_COMPAT_SPEC(pycache_prefix, WSTR_OPT, "pycache_prefix"),
|
||||
PYTHONCAPI_COMPAT_SPEC(quiet, BOOL, _Py_NULL),
|
||||
#if 0x030B0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(stdlib_dir, WSTR_OPT, "_stdlib_dir"),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(use_environment, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(verbose, UINT, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(warnoptions, WSTR_LIST, "warnoptions"),
|
||||
PYTHONCAPI_COMPAT_SPEC(write_bytecode, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(xoptions, WSTR_LIST, "_xoptions"),
|
||||
PYTHONCAPI_COMPAT_SPEC(buffered_stdio, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(check_hash_pycs_mode, WSTR, _Py_NULL),
|
||||
#if 0x030B0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(code_debug_ranges, BOOL, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(configure_c_stdio, BOOL, _Py_NULL),
|
||||
#if 0x030D0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(cpu_count, INT, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(dev_mode, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(dump_refs, BOOL, _Py_NULL),
|
||||
#if 0x030B0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(dump_refs_file, WSTR_OPT, _Py_NULL),
|
||||
#endif
|
||||
#ifdef Py_GIL_DISABLED
|
||||
PYTHONCAPI_COMPAT_SPEC(enable_gil, INT, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(faulthandler, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(filesystem_encoding, WSTR, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(filesystem_errors, WSTR, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(hash_seed, ULONG, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(home, WSTR_OPT, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(import_time, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(install_signal_handlers, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(isolated, BOOL, _Py_NULL),
|
||||
#ifdef MS_WINDOWS
|
||||
PYTHONCAPI_COMPAT_SPEC(legacy_windows_stdio, BOOL, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(malloc_stats, BOOL, _Py_NULL),
|
||||
#if 0x030A0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(orig_argv, WSTR_LIST, "orig_argv"),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(parse_argv, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(pathconfig_warnings, BOOL, _Py_NULL),
|
||||
#if 0x030C0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(perf_profiling, UINT, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(program_name, WSTR, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(run_command, WSTR_OPT, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(run_filename, WSTR_OPT, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(run_module, WSTR_OPT, _Py_NULL),
|
||||
#if 0x030B0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(safe_path, BOOL, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(show_ref_count, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(site_import, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(skip_source_first_line, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(stdio_encoding, WSTR, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(stdio_errors, WSTR, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(tracemalloc, UINT, _Py_NULL),
|
||||
#if 0x030B0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(use_frozen_modules, BOOL, _Py_NULL),
|
||||
#endif
|
||||
PYTHONCAPI_COMPAT_SPEC(use_hash_seed, BOOL, _Py_NULL),
|
||||
PYTHONCAPI_COMPAT_SPEC(user_site_directory, BOOL, _Py_NULL),
|
||||
#if 0x030A0000 <= PY_VERSION_HEX
|
||||
PYTHONCAPI_COMPAT_SPEC(warn_default_encoding, BOOL, _Py_NULL),
|
||||
#endif
|
||||
};
|
||||
|
||||
#undef PYTHONCAPI_COMPAT_SPEC
|
||||
|
||||
const PyConfigSpec *spec;
|
||||
int found = 0;
|
||||
for (size_t i=0; i < sizeof(config_spec) / sizeof(config_spec[0]); i++) {
|
||||
spec = &config_spec[i];
|
||||
if (strcmp(spec->name, name) == 0) {
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found) {
|
||||
if (spec->sys_attr != NULL) {
|
||||
PyObject *value = PySys_GetObject(spec->sys_attr);
|
||||
if (value == NULL) {
|
||||
PyErr_Format(PyExc_RuntimeError, "lost sys.%s", spec->sys_attr);
|
||||
return NULL;
|
||||
}
|
||||
return Py_NewRef(value);
|
||||
}
|
||||
|
||||
PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
|
||||
|
||||
const PyConfig *config = _Py_GetConfig();
|
||||
void *member = (char *)config + spec->offset;
|
||||
switch (spec->type) {
|
||||
case _PyConfig_MEMBER_INT:
|
||||
case _PyConfig_MEMBER_UINT:
|
||||
{
|
||||
int value = *(int *)member;
|
||||
return PyLong_FromLong(value);
|
||||
}
|
||||
case _PyConfig_MEMBER_BOOL:
|
||||
{
|
||||
int value = *(int *)member;
|
||||
return PyBool_FromLong(value != 0);
|
||||
}
|
||||
case _PyConfig_MEMBER_ULONG:
|
||||
{
|
||||
unsigned long value = *(unsigned long *)member;
|
||||
return PyLong_FromUnsignedLong(value);
|
||||
}
|
||||
case _PyConfig_MEMBER_WSTR:
|
||||
case _PyConfig_MEMBER_WSTR_OPT:
|
||||
{
|
||||
wchar_t *wstr = *(wchar_t **)member;
|
||||
if (wstr != NULL) {
|
||||
return PyUnicode_FromWideChar(wstr, -1);
|
||||
}
|
||||
else {
|
||||
return Py_NewRef(Py_None);
|
||||
}
|
||||
}
|
||||
case _PyConfig_MEMBER_WSTR_LIST:
|
||||
{
|
||||
const PyWideStringList *list = (const PyWideStringList *)member;
|
||||
PyObject *tuple = PyTuple_New(list->length);
|
||||
if (tuple == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (Py_ssize_t i = 0; i < list->length; i++) {
|
||||
PyObject *item = PyUnicode_FromWideChar(list->items[i], -1);
|
||||
if (item == NULL) {
|
||||
Py_DECREF(tuple);
|
||||
return NULL;
|
||||
}
|
||||
PyTuple_SET_ITEM(tuple, i, item);
|
||||
}
|
||||
return tuple;
|
||||
}
|
||||
default:
|
||||
Py_UNREACHABLE();
|
||||
}
|
||||
}
|
||||
|
||||
PyErr_Format(PyExc_ValueError, "unknown config option name: %s", name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline int
|
||||
PyConfig_GetInt(const char *name, int *value)
|
||||
{
|
||||
PyObject *obj = PyConfig_Get(name);
|
||||
if (obj == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!PyLong_Check(obj)) {
|
||||
Py_DECREF(obj);
|
||||
PyErr_Format(PyExc_TypeError, "config option %s is not an int", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int as_int = PyLong_AsInt(obj);
|
||||
Py_DECREF(obj);
|
||||
if (as_int == -1 && PyErr_Occurred()) {
|
||||
PyErr_Format(PyExc_OverflowError,
|
||||
"config option %s value does not fit into a C int", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
*value = as_int;
|
||||
return 0;
|
||||
}
|
||||
#endif // PY_VERSION_HEX > 0x03090000 && !defined(PYPY_VERSION)
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user