diff --git a/Include/cpython/object.h b/Include/cpython/object.h index b018dab..8691994 100644 --- a/Include/cpython/object.h +++ b/Include/cpython/object.h @@ -45,7 +45,11 @@ typedef struct _Py_Identifier { // For now we are keeping _Py_IDENTIFIER for continued use // in non-builtin extensions (and naughty PyPI modules). +#if defined(_MSC_VER) && _MSC_VER < 1300 +#define _Py_static_string_init(value) { value, -1 } +#else #define _Py_static_string_init(value) { .string = value, .index = -1 } +#endif #define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value) #define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname) diff --git a/Include/internal/pycore_atomic.h b/Include/internal/pycore_atomic.h index 425d69f..748de28 100644 --- a/Include/internal/pycore_atomic.h +++ b/Include/internal/pycore_atomic.h @@ -16,7 +16,21 @@ extern "C" { #endif -#if defined(_MSC_VER) +/* Visual C++ 6.0 (_MSC_VER 1200) predates and the _Interlocked* + * compiler intrinsics (both introduced in Visual Studio 2005, _MSC_VER + * 1400) as well as . This port only targets 32-bit x86 under + * VC6, so gate the modern-MSVC include on that combination and give VC6/x86 + * a project-local branch below (_Py_ATOMIC_VC6_X86) built on the Win32 + * Interlocked* API instead. Every other compiler/version keeps the + * unmodified upstream behavior. + */ +#if defined(_MSC_VER) && _MSC_VER < 1300 && defined(_M_IX86) +# define _Py_ATOMIC_VC6_X86 1 + /* Declares InterlockedExchange()/InterlockedCompareExchange(), used by + * the _Py_ATOMIC_VC6_X86 branch below in place of the _Interlocked* + * intrinsics the modern-MSVC branch gets from . */ +# include +#elif defined(_MSC_VER) #include #if defined(_M_IX86) || defined(_M_X64) # include @@ -238,7 +252,87 @@ _Py_ANNOTATE_MEMORY_ORDER(const volatile void *address, _Py_memory_order order) This might affect performance but likely only in some very specific and hard to measure scenario. */ -#if defined(_M_IX86) || defined(_M_X64) +#if defined(_Py_ATOMIC_VC6_X86) +/* VC6 / Windows 9x, 32-bit x86 only (_M_X64 is never defined by VC6). + VC6 has neither /_Interlocked* compiler intrinsics (Visual + Studio 2005+) nor the _HLEAcquire/_HLERelease hardware-lock-elision + variants (Visual Studio 2013+) used by the modern-MSVC branch below. + Substitute the plain Win32 InterlockedExchange/InterlockedCompareExchange + functions, which are exported by KERNEL32.DLL on Windows 98 (this VC6 + SDK's WINBASE.H declares them for _M_IX86 as compiler-intrinsic-backed + APIs, not the newer MRx000/Alpha-only intrinsic path above them in that + header). Like the modern-MSVC intrinsics, these give a full memory + barrier, so -- as with the HLE fallback described above -- every + _Py_memory_order maps to the same fully-fenced operation; there is no + separate acquire/release-only path to take. + + _Py_atomic_address (uintptr_t) and _Py_atomic_int (int) are both 4 + bytes on this 32-bit-only target, so the 64-bit store/load paths used + by the modern-MSVC branch below (guarded there by `sizeof(...) == 8`) + are unreachable here and are intentionally not implemented: this port + has no Win9x-era substitute for CMPXCHG8B-based 64-bit atomics. Fail + loudly at compile time rather than silently mishandling a 64-bit + target if this header is ever pulled into a VC6 build configured for + one (VC6 itself never defines _M_X64, so this should not trigger). +*/ +#if defined(_M_X64) +#error "VC6 64-bit atomics are not implemented; this port only targets 32-bit x86 (_M_IX86)." +#endif + +typedef enum _Py_memory_order { + _Py_memory_order_relaxed, + _Py_memory_order_acquire, + _Py_memory_order_release, + _Py_memory_order_acq_rel, + _Py_memory_order_seq_cst +} _Py_memory_order; + +typedef struct _Py_atomic_address { + volatile uintptr_t _value; +} _Py_atomic_address; + +typedef struct _Py_atomic_int { + volatile int _value; +} _Py_atomic_int; + +static __inline long +_Py_vc6_InterlockedExchange(volatile long *target, long value) +{ + return InterlockedExchange((LPLONG)target, value); +} + +static __inline long +_Py_vc6_InterlockedCompareExchange(volatile long *destination, long exchange, long comperand) +{ + return (long)InterlockedCompareExchange( + (PVOID *)destination, (PVOID)exchange, (PVOID)comperand); +} + +#define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \ + ((void)_Py_vc6_InterlockedExchange( \ + (volatile long *)&((ATOMIC_VAL)->_value), (long)(NEW_VAL))) + +static __inline int +_Py_atomic_load_32bit_impl(volatile int *value, int order) +{ + long old; + (void)order; + do { + old = *(volatile long *)value; + } while (_Py_vc6_InterlockedCompareExchange((volatile long *)value, old, old) != old); + return (int)old; +} + +#define _Py_atomic_load_32bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_32bit_impl((volatile int *)&((ATOMIC_VAL)->_value), (ORDER)) + +#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ + _Py_atomic_store_32bit((ATOMIC_VAL), (NEW_VAL), (ORDER)) + +#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_32bit((ATOMIC_VAL), (ORDER)) + +#elif defined(_M_IX86) || defined(_M_X64) typedef enum _Py_memory_order { _Py_memory_order_relaxed, _Py_memory_order_acquire, diff --git a/Include/internal/pycore_bitutils.h b/Include/internal/pycore_bitutils.h index e6bf61e..ba46128 100644 --- a/Include/internal/pycore_bitutils.h +++ b/Include/internal/pycore_bitutils.h @@ -25,7 +25,7 @@ extern "C" { # define _PY_HAVE_BUILTIN_BSWAP #endif -#ifdef _MSC_VER +#if defined(_MSC_VER) && _MSC_VER >= 1300 /* Get _byteswap_ushort(), _byteswap_ulong(), _byteswap_uint64() */ # include #endif @@ -35,7 +35,7 @@ _Py_bswap16(uint16_t word) { #if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap16) return __builtin_bswap16(word); -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1300 Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned short)); return _byteswap_ushort(word); #else @@ -50,7 +50,7 @@ _Py_bswap32(uint32_t word) { #if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap32) return __builtin_bswap32(word); -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1300 Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned long)); return _byteswap_ulong(word); #else @@ -67,7 +67,7 @@ _Py_bswap64(uint64_t word) { #if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap64) return __builtin_bswap64(word); -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1300 return _byteswap_uint64(word); #else // Portable implementation which doesn't rely on circular bit shift @@ -154,7 +154,7 @@ _Py_bit_length(unsigned long x) else { return 0; } -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1300 // _BitScanReverse() is documented to search 32 bits. Py_BUILD_ASSERT(sizeof(unsigned long) <= 4); unsigned long msb; diff --git a/Include/internal/pycore_call.h b/Include/internal/pycore_call.h index 3ccacfa..3098e1e 100644 --- a/Include/internal/pycore_call.h +++ b/Include/internal/pycore_call.h @@ -38,18 +38,21 @@ extern PyObject * _PyObject_CallMethodFormat( static inline vectorcallfunc _PyVectorcall_FunctionInline(PyObject *callable) { + PyTypeObject *tp; + Py_ssize_t offset; + vectorcallfunc ptr; + assert(callable != NULL); - PyTypeObject *tp = Py_TYPE(callable); + tp = Py_TYPE(callable); if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { return NULL; } assert(PyCallable_Check(callable)); - Py_ssize_t offset = tp->tp_vectorcall_offset; + offset = tp->tp_vectorcall_offset; assert(offset > 0); - vectorcallfunc ptr; memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); return ptr; } diff --git a/Include/internal/pycore_code.h b/Include/internal/pycore_code.h index 3a24a65..4db8abc 100644 --- a/Include/internal/pycore_code.h +++ b/Include/internal/pycore_code.h @@ -149,18 +149,20 @@ typedef unsigned char _PyLocals_Kind; static inline _PyLocals_Kind _PyLocals_GetKind(PyObject *kinds, int i) { + char *ptr; assert(PyBytes_Check(kinds)); assert(0 <= i && i < PyBytes_GET_SIZE(kinds)); - char *ptr = PyBytes_AS_STRING(kinds); + ptr = PyBytes_AS_STRING(kinds); return (_PyLocals_Kind)(ptr[i]); } static inline void _PyLocals_SetKind(PyObject *kinds, int i, _PyLocals_Kind kind) { + char *ptr; assert(PyBytes_Check(kinds)); assert(0 <= i && i < PyBytes_GET_SIZE(kinds)); - char *ptr = PyBytes_AS_STRING(kinds); + ptr = PyBytes_AS_STRING(kinds); ptr[i] = (char) kind; } @@ -520,11 +522,12 @@ adaptive_counter_start(void) { static inline uint16_t adaptive_counter_backoff(uint16_t counter) { unsigned int backoff = counter & ((1< MAX_BACKOFF_VALUE) { backoff = MAX_BACKOFF_VALUE; } - unsigned int value = (1 << backoff) - 1; + value = (1 << backoff) - 1; return adaptive_counter_bits(value, backoff); } diff --git a/Include/internal/pycore_dict.h b/Include/internal/pycore_dict.h index dc308fe..16feaf3 100644 --- a/Include/internal/pycore_dict.h +++ b/Include/internal/pycore_dict.h @@ -163,9 +163,11 @@ extern PyObject *_PyDict_FromItems( static inline void _PyDictValues_AddToInsertionOrder(PyDictValues *values, Py_ssize_t ix) { + uint8_t *size_ptr; + int size; assert(ix < SHARED_KEYS_MAX_SIZE); - uint8_t *size_ptr = ((uint8_t *)values)-2; - int size = *size_ptr; + size_ptr = ((uint8_t *)values)-2; + size = *size_ptr; assert(size+2 < ((uint8_t *)values)[-1]); size++; size_ptr[-size] = (uint8_t)ix; diff --git a/Include/internal/pycore_frame.h b/Include/internal/pycore_frame.h index 4866ea2..17ca4f8 100644 --- a/Include/internal/pycore_frame.h +++ b/Include/internal/pycore_frame.h @@ -162,9 +162,10 @@ _PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame); static inline PyFrameObject * _PyFrame_GetFrameObject(_PyInterpreterFrame *frame) { + PyFrameObject *res; assert(!_PyFrame_IsIncomplete(frame)); - PyFrameObject *res = frame->frame_obj; + res = frame->frame_obj; if (res != NULL) { return res; } @@ -211,7 +212,9 @@ static inline _PyInterpreterFrame * _PyThreadState_BumpFramePointer(PyThreadState *tstate, size_t size) { if (_PyThreadState_HasStackSpace(tstate, size)) { - _PyInterpreterFrame *res = (_PyInterpreterFrame *)tstate->datastack_top; + _PyInterpreterFrame *res; + + res = (_PyInterpreterFrame *)tstate->datastack_top; tstate->datastack_top += size; return res; } @@ -229,8 +232,10 @@ int _PyInterpreterFrame_GetLine(_PyInterpreterFrame *frame); static inline PyGenObject *_PyFrame_GetGenerator(_PyInterpreterFrame *frame) { + size_t offset_in_gen; + assert(frame->owner == FRAME_OWNED_BY_GENERATOR); - size_t offset_in_gen = offsetof(PyGenObject, gi_iframe); + offset_in_gen = offsetof(PyGenObject, gi_iframe); return (PyGenObject *)(((char *)frame) - offset_in_gen); } diff --git a/Include/internal/pycore_initconfig.h b/Include/internal/pycore_initconfig.h index d765600..dcdd359 100644 --- a/Include/internal/pycore_initconfig.h +++ b/Include/internal/pycore_initconfig.h @@ -14,22 +14,56 @@ struct pyruntimestate; /* --- PyStatus ----------------------------------------------- */ /* Almost all errors causing Python initialization to fail */ -#ifdef _MSC_VER +#if defined(_MSC_VER) && _MSC_VER < 1300 + /* VC6 has neither C99 __func__ nor later MSVC __FUNCTION__. */ +# define _PyStatus_GET_FUNC() NULL +#elif defined(_MSC_VER) /* Visual Studio 2015 doesn't implement C99 __func__ in C */ # define _PyStatus_GET_FUNC() __FUNCTION__ #else # define _PyStatus_GET_FUNC() __func__ #endif -#define _PyStatus_OK() \ +#if defined(_MSC_VER) && _MSC_VER < 1300 +/* VC6 cannot parse the C99 compound literals/designated initializers below. + Keep the helpers local to this internal header and construct the status + objects field-by-field so PyStatus_Ok() can safely return _PyStatus_OK() + without recursing back into itself. */ +static PyStatus +_PyStatus_OK_VC6(void) +{ + PyStatus status; + status._type = _PyStatus_TYPE_OK; + status.func = NULL; + status.err_msg = NULL; + status.exitcode = 0; + return status; +} + +static PyStatus +_PyStatus_ERR_VC6(const char *err_msg) +{ + PyStatus status; + status._type = _PyStatus_TYPE_ERROR; + status.func = _PyStatus_GET_FUNC(); + status.err_msg = err_msg; + status.exitcode = 0; + return status; +} + +# define _PyStatus_OK() _PyStatus_OK_VC6() +# define _PyStatus_ERR(ERR_MSG) _PyStatus_ERR_VC6(ERR_MSG) +#else +# define _PyStatus_OK() \ (PyStatus){._type = _PyStatus_TYPE_OK,} /* other fields are set to 0 */ -#define _PyStatus_ERR(ERR_MSG) \ +# define _PyStatus_ERR(ERR_MSG) \ (PyStatus){ \ ._type = _PyStatus_TYPE_ERROR, \ .func = _PyStatus_GET_FUNC(), \ .err_msg = (ERR_MSG)} /* other fields are set to 0 */ +#endif #define _PyStatus_NO_MEMORY() _PyStatus_ERR("memory allocation failed") #define _PyStatus_EXIT(EXITCODE) \ (PyStatus){ \ diff --git a/Include/internal/pycore_list.h b/Include/internal/pycore_list.h index 860dce1..da38ee6 100644 --- a/Include/internal/pycore_list.h +++ b/Include/internal/pycore_list.h @@ -43,10 +43,12 @@ _PyList_AppendTakeRefListResize(PyListObject *self, PyObject *newitem); static inline int _PyList_AppendTakeRef(PyListObject *self, PyObject *newitem) { + Py_ssize_t len; + Py_ssize_t allocated; assert(self != NULL && newitem != NULL); assert(PyList_Check(self)); - Py_ssize_t len = PyList_GET_SIZE(self); - Py_ssize_t allocated = self->allocated; + len = PyList_GET_SIZE(self); + allocated = self->allocated; assert((size_t)len + 1 < PY_SSIZE_T_MAX); if (allocated > len) { PyList_SET_ITEM(self, len, newitem); diff --git a/Include/internal/pycore_moduleobject.h b/Include/internal/pycore_moduleobject.h index 76361b8..2b9861b 100644 --- a/Include/internal/pycore_moduleobject.h +++ b/Include/internal/pycore_moduleobject.h @@ -29,8 +29,10 @@ static inline void* _PyModule_GetState(PyObject* mod) { } static inline PyObject* _PyModule_GetDict(PyObject *mod) { + PyObject *dict; + assert(PyModule_Check(mod)); - PyObject *dict = ((PyModuleObject *)mod) -> md_dict; + dict = ((PyModuleObject *)mod) -> md_dict; // _PyModule_GetDict(mod) must not be used after calling module_clear(mod) assert(dict != NULL); return dict; diff --git a/Include/internal/pycore_object.h b/Include/internal/pycore_object.h index f022f82..d1c55ae 100644 --- a/Include/internal/pycore_object.h +++ b/Include/internal/pycore_object.h @@ -14,6 +14,14 @@ extern "C" { #include "pycore_pystate.h" // _PyInterpreterState_GET() #include "pycore_runtime.h" // _PyRuntime +/* Visual C++ 6.0 predates C99's __func__ predefined identifier. It also + lacks MSVC's later __FUNCTION__ extension, so provide a VC6-only fallback + for debug/fatal diagnostics in this header without changing any other + compiler's function-name reporting. */ +#if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(__func__) +# define __func__ "" +#endif + #define _PyObject_IMMORTAL_INIT(type) \ { \ .ob_refcnt = 999999999, \ @@ -125,19 +133,24 @@ static inline void _PyObject_GC_TRACK( #endif PyObject *op) { + PyGC_Head *gc; + PyInterpreterState *interp; + PyGC_Head *generation0; + PyGC_Head *last; + _PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op), "object already tracked by the garbage collector", filename, lineno, __func__); - PyGC_Head *gc = _Py_AS_GC(op); + gc = _Py_AS_GC(op); _PyObject_ASSERT_FROM(op, (gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0, "object is in generation which is garbage collected", filename, lineno, __func__); - PyInterpreterState *interp = _PyInterpreterState_GET(); - PyGC_Head *generation0 = interp->gc.generation0; - PyGC_Head *last = (PyGC_Head*)(generation0->_gc_prev); + interp = _PyInterpreterState_GET(); + generation0 = interp->gc.generation0; + last = (PyGC_Head*)(generation0->_gc_prev); _PyGCHead_SET_NEXT(last, gc); _PyGCHead_SET_PREV(gc, last); _PyGCHead_SET_NEXT(gc, generation0); @@ -161,13 +174,17 @@ static inline void _PyObject_GC_UNTRACK( #endif PyObject *op) { + PyGC_Head *gc; + PyGC_Head *prev; + PyGC_Head *next; + _PyObject_ASSERT_FROM(op, _PyObject_GC_IS_TRACKED(op), "object not tracked by the garbage collector", filename, lineno, __func__); - PyGC_Head *gc = _Py_AS_GC(op); - PyGC_Head *prev = _PyGCHead_PREV(gc); - PyGC_Head *next = _PyGCHead_NEXT(gc); + gc = _Py_AS_GC(op); + prev = _PyGCHead_PREV(gc); + next = _PyGCHead_NEXT(gc); _PyGCHead_SET_NEXT(prev, next); _PyGCHead_SET_PREV(next, prev); gc->_gc_next = 0; diff --git a/Include/internal/pycore_runtime_init.h b/Include/internal/pycore_runtime_init.h index 13eae1e..91faff4 100644 --- a/Include/internal/pycore_runtime_init.h +++ b/Include/internal/pycore_runtime_init.h @@ -14,6 +14,11 @@ extern "C" { /* The static initializers defined here should only be used in the runtime init code (in pystate.c and pylifecycle.c). */ +#if defined(_MSC_VER) && _MSC_VER < 1300 +/* VC6 does not support the nested C99 designated initializers below. + pystate.c provides a field-by-field initializer for the same defaults. */ +extern void _PyRuntimeState_InitStaticDefaults(_PyRuntimeState *runtime); +#else #define _PyRuntimeState_INIT \ { \ @@ -72,6 +77,8 @@ extern "C" { .context_ver = 1, \ } +#endif /* !(defined(_MSC_VER) && _MSC_VER < 1300) */ + // global objects diff --git a/Include/longobject.h b/Include/longobject.h index 778cb62..d25edf7 100644 --- a/Include/longobject.h +++ b/Include/longobject.h @@ -81,12 +81,12 @@ PyAPI_FUNC(double) PyLong_AsDouble(PyObject *); PyAPI_FUNC(PyObject *) PyLong_FromVoidPtr(void *); PyAPI_FUNC(void *) PyLong_AsVoidPtr(PyObject *); -PyAPI_FUNC(PyObject *) PyLong_FromLongLong(long long); -PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned long long); -PyAPI_FUNC(long long) PyLong_AsLongLong(PyObject *); -PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLong(PyObject *); -PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLongMask(PyObject *); -PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject *, int *); +PyAPI_FUNC(PyObject *) PyLong_FromLongLong(PY_LONG_LONG); +PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG); +PyAPI_FUNC(PY_LONG_LONG) PyLong_AsLongLong(PyObject *); +PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLong(PyObject *); +PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLongMask(PyObject *); +PyAPI_FUNC(PY_LONG_LONG) PyLong_AsLongLongAndOverflow(PyObject *, int *); PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int); diff --git a/Include/pyexpat.h b/Include/pyexpat.h index a676e16..017e86d 100644 --- a/Include/pyexpat.h +++ b/Include/pyexpat.h @@ -54,12 +54,12 @@ struct PyExpat_CAPI XML_Bool (*SetReparseDeferralEnabled)(XML_Parser parser, XML_Bool enabled); /* might be NULL for expat < 2.7.2 */ XML_Bool (*SetAllocTrackerActivationThreshold)( - XML_Parser parser, unsigned long long activationThresholdBytes); + XML_Parser parser, unsigned PY_LONG_LONG activationThresholdBytes); XML_Bool (*SetAllocTrackerMaximumAmplification)( XML_Parser parser, float maxAmplificationFactor); /* might be NULL for expat < 2.4.0 */ XML_Bool (*SetBillionLaughsAttackProtectionActivationThreshold)( - XML_Parser parser, unsigned long long activationThresholdBytes); + XML_Parser parser, unsigned PY_LONG_LONG activationThresholdBytes); XML_Bool (*SetBillionLaughsAttackProtectionMaximumAmplification)( XML_Parser parser, float maxAmplificationFactor); /* might be NULL for expat < 2.8.0 */ diff --git a/Include/pymath.h b/Include/pymath.h index 772b67e..7b90016 100644 --- a/Include/pymath.h +++ b/Include/pymath.h @@ -52,10 +52,13 @@ // Py_NAN: Value that evaluates to a quiet Not-a-Number (NaN). #if !defined(Py_NAN) -# if _Py__has_builtin(__builtin_nan) +# if defined(_MSC_VER) && _MSC_VER < 1300 + // VC6 has no C99 NAN macro. IEEE infinity times zero produces NaN. +# define Py_NAN (Py_HUGE_VAL * 0.0) +# elif _Py__has_builtin(__builtin_nan) // Built-in implementation of the ISO C99 function nan(): quiet NaN. # define Py_NAN (__builtin_nan("")) -#else +# else // Use C99 NAN constant: quiet Not-A-Number. // NAN is a float, Py_NAN is a double: cast to double. # define Py_NAN ((double)NAN) diff --git a/Include/pyport.h b/Include/pyport.h index b3b8b6f..938d131 100644 --- a/Include/pyport.h +++ b/Include/pyport.h @@ -97,6 +97,13 @@ Used in: Py_SAFE_DOWNCAST #define PY_ULLONG_MAX ULLONG_MAX #endif +/* Spelling of 64 bit integer literal suffixes; see PC/pyconfig.h for the + compilers that need something other than the C99 LL/ULL suffixes. */ +#ifndef PY_LL +#define PY_LL(x) x##LL +#define PY_ULL(x) x##ULL +#endif + #define PY_UINT32_T uint32_t #define PY_UINT64_T uint64_t @@ -334,9 +341,12 @@ extern "C" { #if defined(__GNUC__) \ && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__)) -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1300 #define Py_DEPRECATED(VERSION) __declspec(deprecated( \ "deprecated in " #VERSION)) +#elif defined(_MSC_VER) +/* Visual C++ 6.0 has no supported deprecation declaration syntax. */ +#define Py_DEPRECATED(VERSION_UNUSED) #else #define Py_DEPRECATED(VERSION_UNUSED) #endif @@ -352,10 +362,14 @@ extern "C" { #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") #define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop") -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1300 #define _Py_COMP_DIAG_PUSH __pragma(warning(push)) #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996)) #define _Py_COMP_DIAG_POP __pragma(warning(pop)) +#elif defined(_MSC_VER) +#define _Py_COMP_DIAG_PUSH +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS +#define _Py_COMP_DIAG_POP #else #define _Py_COMP_DIAG_PUSH #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS @@ -425,7 +439,7 @@ extern "C" { // Py_NO_INLINE static int random(void) { return 4; } #if defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) # define Py_NO_INLINE __attribute__ ((noinline)) -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1300 # define Py_NO_INLINE __declspec(noinline) #else # define Py_NO_INLINE diff --git a/Include/pythread.h b/Include/pythread.h index a483290..defdaf1 100644 --- a/Include/pythread.h +++ b/Include/pythread.h @@ -40,23 +40,23 @@ PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int); module exposes a higher-level API, with timeouts expressed in seconds and floating-point numbers allowed. */ -#define PY_TIMEOUT_T long long +#define PY_TIMEOUT_T PY_LONG_LONG #if defined(_POSIX_THREADS) /* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000), convert microseconds to nanoseconds. */ -# define PY_TIMEOUT_MAX (LLONG_MAX / 1000) +# define PY_TIMEOUT_MAX (PY_LLONG_MAX / 1000) #elif defined (NT_THREADS) // WaitForSingleObject() accepts timeout in milliseconds in the range // [0; 0xFFFFFFFE] (DWORD type). INFINITE value (0xFFFFFFFF) means no // timeout. 0xFFFFFFFE milliseconds is around 49.7 days. -# if 0xFFFFFFFELL * 1000 < LLONG_MAX -# define PY_TIMEOUT_MAX (0xFFFFFFFELL * 1000) +# if PY_LL(0xFFFFFFFE) * 1000 < PY_LLONG_MAX +# define PY_TIMEOUT_MAX (PY_LL(0xFFFFFFFE) * 1000) # else -# define PY_TIMEOUT_MAX LLONG_MAX +# define PY_TIMEOUT_MAX PY_LLONG_MAX # endif #else -# define PY_TIMEOUT_MAX LLONG_MAX +# define PY_TIMEOUT_MAX PY_LLONG_MAX #endif diff --git a/Modules/_abc.c b/Modules/_abc.c index b22daa8..69cfd5c 100644 --- a/Modules/_abc.c +++ b/Modules/_abc.c @@ -19,7 +19,7 @@ PyDoc_STRVAR(_abc__doc__, typedef struct { PyTypeObject *_abc_data_type; - unsigned long long abc_invalidation_counter; + unsigned PY_LONG_LONG abc_invalidation_counter; } _abcmodule_state; static inline _abcmodule_state* @@ -38,7 +38,7 @@ typedef struct { PyObject *_abc_registry; PyObject *_abc_cache; /* Normal set of weak references. */ PyObject *_abc_negative_cache; /* Normal set of weak references. */ - unsigned long long _abc_negative_cache_version; + unsigned PY_LONG_LONG _abc_negative_cache_version; } _abc_data; static int @@ -63,8 +63,9 @@ abc_data_clear(_abc_data *self) static void abc_data_dealloc(_abc_data *self) { + PyTypeObject *tp; PyObject_GC_UnTrack(self); - PyTypeObject *tp = Py_TYPE(self); + tp = Py_TYPE(self); (void)abc_data_clear(self); tp->tp_free(self); Py_DECREF(tp); @@ -105,10 +106,11 @@ static PyType_Slot _abc_data_type_spec_slots[] = { }; static PyType_Spec _abc_data_type_spec = { - .name = "_abc._abc_data", - .basicsize = sizeof(_abc_data), - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, - .slots = _abc_data_type_spec_slots, + "_abc._abc_data", + sizeof(_abc_data), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + _abc_data_type_spec_slots, }; static _abc_data * @@ -130,10 +132,12 @@ _get_impl(PyObject *module, PyObject *self) static int _in_weak_set(PyObject *set, PyObject *obj) { + PyObject *ref; + int res; if (set == NULL || PySet_GET_SIZE(set) == 0) { return 0; } - PyObject *ref = PyWeakref_NewRef(obj, NULL); + ref = PyWeakref_NewRef(obj, NULL); if (ref == NULL) { if (PyErr_ExceptionMatches(PyExc_TypeError)) { PyErr_Clear(); @@ -141,7 +145,7 @@ _in_weak_set(PyObject *set, PyObject *obj) } return -1; } - int res = PySet_Contains(set, ref); + res = PySet_Contains(set, ref); Py_DECREF(ref); return res; } @@ -170,6 +174,10 @@ static PyMethodDef _destroy_def = { static int _add_to_weak_set(PyObject **pset, PyObject *obj) { + PyObject *set; + PyObject *ref, *wr; + PyObject *destroy_cb; + int ret; if (*pset == NULL) { *pset = PySet_New(NULL); if (*pset == NULL) { @@ -177,9 +185,7 @@ _add_to_weak_set(PyObject **pset, PyObject *obj) } } - PyObject *set = *pset; - PyObject *ref, *wr; - PyObject *destroy_cb; + set = *pset; wr = PyWeakref_NewRef(set, NULL); if (wr == NULL) { return -1; @@ -195,7 +201,7 @@ _add_to_weak_set(PyObject **pset, PyObject *obj) Py_DECREF(wr); return -1; } - int ret = PySet_Add(set, ref); + ret = PySet_Add(set, ref); Py_DECREF(wr); Py_DECREF(ref); return ret; @@ -279,14 +285,15 @@ _abc__get_dump(PyObject *module, PyObject *self) /*[clinic end generated code: output=9d9569a8e2c1c443 input=2c5deb1bfe9e3c79]*/ { _abc_data *impl = _get_impl(module, self); + PyObject *res; if (impl == NULL) { return NULL; } - PyObject *res = Py_BuildValue("NNNK", - PySet_New(impl->_abc_registry), - PySet_New(impl->_abc_cache), - PySet_New(impl->_abc_negative_cache), - impl->_abc_negative_cache_version); + res = Py_BuildValue("NNNK", + PySet_New(impl->_abc_registry), + PySet_New(impl->_abc_cache), + PySet_New(impl->_abc_negative_cache), + impl->_abc_negative_cache_version); Py_DECREF(impl); return res; } @@ -297,12 +304,12 @@ compute_abstract_methods(PyObject *self) { int ret = -1; PyObject *abstracts = PyFrozenSet_New(NULL); + PyObject *ns = NULL, *items = NULL, *bases = NULL; // Py_XDECREF()ed on error. + Py_ssize_t pos; if (abstracts == NULL) { return -1; } - PyObject *ns = NULL, *items = NULL, *bases = NULL; // Py_XDECREF()ed on error. - /* Stage 1: direct abstract methods. */ ns = PyObject_GetAttr(self, &_Py_ID(__dict__)); if (!ns) { @@ -316,8 +323,11 @@ compute_abstract_methods(PyObject *self) goto error; } assert(PyList_Check(items)); - for (Py_ssize_t pos = 0; pos < PyList_GET_SIZE(items); pos++) { - PyObject *it = PySequence_Fast( + for (pos = 0; pos < PyList_GET_SIZE(items); pos++) { + PyObject *it; + PyObject *key, *value; + int is_abstract; + it = PySequence_Fast( PyList_GET_ITEM(items, pos), "items() returned non-iterable"); if (!it) { @@ -331,12 +341,12 @@ compute_abstract_methods(PyObject *self) } // borrowed - PyObject *key = PySequence_Fast_GET_ITEM(it, 0); - PyObject *value = PySequence_Fast_GET_ITEM(it, 1); + key = PySequence_Fast_GET_ITEM(it, 0); + value = PySequence_Fast_GET_ITEM(it, 1); // items or it may be cleared while accessing __abstractmethod__ // So we need to keep strong reference for key Py_INCREF(key); - int is_abstract = _PyObject_IsAbstract(value); + is_abstract = _PyObject_IsAbstract(value); if (is_abstract < 0 || (is_abstract && PySet_Add(abstracts, key) < 0)) { Py_DECREF(it); @@ -357,10 +367,12 @@ compute_abstract_methods(PyObject *self) goto error; } - for (Py_ssize_t pos = 0; pos < PyTuple_GET_SIZE(bases); pos++) { - PyObject *item = PyTuple_GET_ITEM(bases, pos); // borrowed + for (pos = 0; pos < PyTuple_GET_SIZE(bases); pos++) { + PyObject *item; PyObject *base_abstracts, *iter; + PyObject *key, *value; + item = PyTuple_GET_ITEM(bases, pos); // borrowed if (_PyObject_LookupAttr(item, &_Py_ID(__abstractmethods__), &base_abstracts) < 0) { goto error; @@ -373,8 +385,8 @@ compute_abstract_methods(PyObject *self) goto error; } Py_DECREF(base_abstracts); - PyObject *key, *value; while ((key = PyIter_Next(iter))) { + int is_abstract; if (_PyObject_LookupAttr(self, key, &value) < 0) { Py_DECREF(key); Py_DECREF(iter); @@ -385,7 +397,7 @@ compute_abstract_methods(PyObject *self) continue; } - int is_abstract = _PyObject_IsAbstract(value); + is_abstract = _PyObject_IsAbstract(value); Py_DECREF(value); if (is_abstract < 0 || (is_abstract && PySet_Add(abstracts, key) < 0)) @@ -482,6 +494,8 @@ _abc__abc_init(PyObject *module, PyObject *self) static void set_collection_flag_recursive(PyTypeObject *child, unsigned long flag) { + PyObject *grandchildren; + Py_ssize_t i; assert(flag == Py_TPFLAGS_MAPPING || flag == Py_TPFLAGS_SEQUENCE); if (PyType_HasFeature(child, Py_TPFLAGS_IMMUTABLETYPE) || (child->tp_flags & COLLECTION_FLAGS) == flag) @@ -492,12 +506,12 @@ set_collection_flag_recursive(PyTypeObject *child, unsigned long flag) child->tp_flags &= ~COLLECTION_FLAGS; child->tp_flags |= flag; - PyObject *grandchildren = _PyType_GetSubclasses(child); + grandchildren = _PyType_GetSubclasses(child); if (grandchildren == NULL) { return; } - for (Py_ssize_t i = 0; i < PyList_GET_SIZE(grandchildren); i++) { + for (i = 0; i < PyList_GET_SIZE(grandchildren); i++) { PyObject *grandchild = PyList_GET_ITEM(grandchildren, i); set_collection_flag_recursive((PyTypeObject *)grandchild, flag); } @@ -518,11 +532,13 @@ static PyObject * _abc__abc_register_impl(PyObject *module, PyObject *self, PyObject *subclass) /*[clinic end generated code: output=7851e7668c963524 input=ca589f8c3080e67f]*/ { + int result; + _abc_data *impl; if (!PyType_Check(subclass)) { PyErr_SetString(PyExc_TypeError, "Can only register classes"); return NULL; } - int result = PyObject_IsSubclass(subclass, self); + result = PyObject_IsSubclass(subclass, self); if (result > 0) { Py_INCREF(subclass); return subclass; /* Already a subclass. */ @@ -541,7 +557,7 @@ _abc__abc_register_impl(PyObject *module, PyObject *self, PyObject *subclass) if (result < 0) { return NULL; } - _abc_data *impl = _get_impl(module, self); + impl = _get_impl(module, self); if (impl == NULL) { return NULL; } @@ -583,6 +599,7 @@ _abc__abc_instancecheck_impl(PyObject *module, PyObject *self, { PyObject *subtype, *result = NULL, *subclass = NULL; _abc_data *impl = _get_impl(module, self); + int incache; if (impl == NULL) { return NULL; } @@ -593,7 +610,7 @@ _abc__abc_instancecheck_impl(PyObject *module, PyObject *self, return NULL; } /* Inline the cache checking. */ - int incache = _in_weak_set(impl->_abc_cache, subclass); + incache = _in_weak_set(impl->_abc_cache, subclass); if (incache < 0) { goto end; } @@ -670,16 +687,18 @@ _abc__abc_subclasscheck_impl(PyObject *module, PyObject *self, PyObject *subclass) /*[clinic end generated code: output=b56c9e4a530e3894 input=1d947243409d10b8]*/ { + PyObject *ok, *subclasses = NULL, *result = NULL; + _abcmodule_state *state = NULL; + Py_ssize_t pos; + int incache; + _abc_data *impl; + PyObject *mro; if (!PyType_Check(subclass)) { PyErr_SetString(PyExc_TypeError, "issubclass() arg 1 must be a class"); return NULL; } - PyObject *ok, *subclasses = NULL, *result = NULL; - _abcmodule_state *state = NULL; - Py_ssize_t pos; - int incache; - _abc_data *impl = _get_impl(module, self); + impl = _get_impl(module, self); if (impl == NULL) { return NULL; } @@ -747,7 +766,7 @@ _abc__abc_subclasscheck_impl(PyObject *module, PyObject *self, Py_DECREF(ok); /* 4. Check if it's a direct subclass. */ - PyObject *mro = ((PyTypeObject *)subclass)->tp_mro; + mro = ((PyTypeObject *)subclass)->tp_mro; assert(PyTuple_Check(mro)); for (pos = 0; pos < PyTuple_GET_SIZE(mro); pos++) { PyObject *mro_item = PyTuple_GET_ITEM(mro, pos); @@ -777,9 +796,11 @@ _abc__abc_subclasscheck_impl(PyObject *module, PyObject *self, goto end; } for (pos = 0; pos < PyList_GET_SIZE(subclasses); pos++) { - PyObject *scls = PyList_GET_ITEM(subclasses, pos); + PyObject *scls; + int r; + scls = PyList_GET_ITEM(subclasses, pos); Py_INCREF(scls); - int r = PyObject_IsSubclass(subclass, scls); + r = PyObject_IsSubclass(subclass, scls); Py_DECREF(scls); if (r > 0) { if (_add_to_weak_set(&impl->_abc_cache, subclass) < 0) { @@ -811,8 +832,16 @@ static int subclasscheck_check_registry(_abc_data *impl, PyObject *subclass, PyObject **result) { + int ret; + Py_ssize_t registry_size; + PyObject **copy; + PyObject *key; + Py_ssize_t pos = 0; + Py_hash_t hash; + Py_ssize_t i = 0; + // Fast path: check subclass is in weakref directly. - int ret = _in_weak_set(impl->_abc_registry, subclass); + ret = _in_weak_set(impl->_abc_registry, subclass); if (ret < 0) { *result = NULL; return -1; @@ -825,21 +854,17 @@ subclasscheck_check_registry(_abc_data *impl, PyObject *subclass, if (impl->_abc_registry == NULL) { return 0; } - Py_ssize_t registry_size = PySet_Size(impl->_abc_registry); + registry_size = PySet_Size(impl->_abc_registry); if (registry_size == 0) { return 0; } // Weakref callback may remove entry from set. // So we take snapshot of registry first. - PyObject **copy = PyMem_Malloc(sizeof(PyObject*) * registry_size); + copy = PyMem_Malloc(sizeof(PyObject*) * registry_size); if (copy == NULL) { PyErr_NoMemory(); return -1; } - PyObject *key; - Py_ssize_t pos = 0; - Py_hash_t hash; - Py_ssize_t i = 0; while (_PySet_NextEntry(impl->_abc_registry, &pos, &key, &hash)) { Py_INCREF(key); @@ -848,7 +873,9 @@ subclasscheck_check_registry(_abc_data *impl, PyObject *subclass, assert(i == registry_size); for (i = 0; i < registry_size; i++) { - PyObject *rkey = PyWeakref_GetObject(copy[i]); + PyObject *rkey; + int r; + rkey = PyWeakref_GetObject(copy[i]); if (rkey == NULL) { // Someone inject non-weakref type in the registry. ret = -1; @@ -858,7 +885,7 @@ subclasscheck_check_registry(_abc_data *impl, PyObject *subclass, continue; } Py_INCREF(rkey); - int r = PyObject_IsSubclass(subclass, rkey); + r = PyObject_IsSubclass(subclass, rkey); Py_DECREF(rkey); if (r < 0) { ret = -1; @@ -954,14 +981,14 @@ static PyModuleDef_Slot _abcmodule_slots[] = { static struct PyModuleDef _abcmodule = { PyModuleDef_HEAD_INIT, - .m_name = "_abc", - .m_doc = _abc__doc__, - .m_size = sizeof(_abcmodule_state), - .m_methods = _abcmodule_methods, - .m_slots = _abcmodule_slots, - .m_traverse = _abcmodule_traverse, - .m_clear = _abcmodule_clear, - .m_free = _abcmodule_free, + "_abc", + _abc__doc__, + sizeof(_abcmodule_state), + _abcmodule_methods, + _abcmodule_slots, + _abcmodule_traverse, + _abcmodule_clear, + _abcmodule_free, }; PyMODINIT_FUNC diff --git a/Modules/_bisectmodule.c b/Modules/_bisectmodule.c index 0caa92b..1bfd7d3 100644 --- a/Modules/_bisectmodule.c +++ b/Modules/_bisectmodule.c @@ -326,13 +326,14 @@ static PyModuleDef_Slot bisect_slots[] = { static struct PyModuleDef _bisectmodule = { PyModuleDef_HEAD_INIT, - .m_name = "_bisect", - .m_size = sizeof(bisect_state), - .m_doc = module_doc, - .m_methods = bisect_methods, - .m_slots = bisect_slots, - .m_clear = bisect_clear, - .m_free = bisect_free, + "_bisect", + module_doc, + sizeof(bisect_state), + bisect_methods, + bisect_slots, + NULL, + bisect_clear, + bisect_free, }; PyMODINIT_FUNC diff --git a/Modules/_blake2/blake2b_impl.c b/Modules/_blake2/blake2b_impl.c index c2cac98..c9c5d88 100644 --- a/Modules/_blake2/blake2b_impl.c +++ b/Modules/_blake2/blake2b_impl.c @@ -91,7 +91,7 @@ static PyObject * py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size, Py_buffer *key, Py_buffer *salt, Py_buffer *person, int fanout, int depth, unsigned long leaf_size, - unsigned long long node_offset, int node_depth, + unsigned PY_LONG_LONG node_offset, int node_depth, int inner_size, int last_node, int usedforsecurity) /*[clinic end generated code: output=32bfd8f043c6896f input=b947312abff46977]*/ { @@ -385,6 +385,7 @@ static void py_blake2b_dealloc(PyObject *self) { BLAKE2bObject *obj = (BLAKE2bObject *)self; + PyTypeObject *type; /* Try not to leave state in memory. */ secure_zero_memory(&obj->param, sizeof(obj->param)); @@ -394,7 +395,7 @@ py_blake2b_dealloc(PyObject *self) obj->lock = NULL; } - PyTypeObject *type = Py_TYPE(self); + type = Py_TYPE(self); PyObject_Free(self); Py_DECREF(type); } @@ -409,8 +410,9 @@ static PyType_Slot blake2b_type_slots[] = { }; PyType_Spec blake2b_type_spec = { - .name = "_blake2.blake2b", - .basicsize = sizeof(BLAKE2bObject), - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, - .slots = blake2b_type_slots + "_blake2.blake2b", + sizeof(BLAKE2bObject), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, + blake2b_type_slots }; diff --git a/Modules/_blake2/blake2module.c b/Modules/_blake2/blake2module.c index 93478f5..afd2e33 100644 --- a/Modules/_blake2/blake2module.c +++ b/Modules/_blake2/blake2module.c @@ -84,6 +84,7 @@ static int blake2_exec(PyObject *m) { Blake2State* st = blake2_get_state(m); + PyObject *d; st->blake2b_type = (PyTypeObject *)PyType_FromModuleAndSpec( m, &blake2b_type_spec, NULL); @@ -95,7 +96,7 @@ blake2_exec(PyObject *m) return -1; } - PyObject *d = st->blake2b_type->tp_dict; + d = st->blake2b_type->tp_dict; ADD_INT(d, "SALT_SIZE", BLAKE2B_SALTBYTES); ADD_INT(d, "PERSON_SIZE", BLAKE2B_PERSONALBYTES); ADD_INT(d, "MAX_KEY_SIZE", BLAKE2B_KEYBYTES); @@ -142,13 +143,13 @@ static PyModuleDef_Slot _blake2_slots[] = { static struct PyModuleDef blake2_module = { PyModuleDef_HEAD_INIT, "_blake2", - .m_doc = blake2mod__doc__, - .m_size = sizeof(Blake2State), - .m_methods = blake2mod_functions, - .m_slots = _blake2_slots, - .m_traverse = _blake2_traverse, - .m_clear = _blake2_clear, - .m_free = _blake2_free, + blake2mod__doc__, + sizeof(Blake2State), + blake2mod_functions, + _blake2_slots, + _blake2_traverse, + _blake2_clear, + _blake2_free, }; PyMODINIT_FUNC diff --git a/Modules/_blake2/blake2s_impl.c b/Modules/_blake2/blake2s_impl.c index 1c47328..6104437 100644 --- a/Modules/_blake2/blake2s_impl.c +++ b/Modules/_blake2/blake2s_impl.c @@ -91,7 +91,7 @@ static PyObject * py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, Py_buffer *key, Py_buffer *salt, Py_buffer *person, int fanout, int depth, unsigned long leaf_size, - unsigned long long node_offset, int node_depth, + unsigned PY_LONG_LONG node_offset, int node_depth, int inner_size, int last_node, int usedforsecurity) /*[clinic end generated code: output=556181f73905c686 input=4dda87723f23abb0]*/ { @@ -160,7 +160,7 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, store32(&(self->param.leaf_length), leaf_size); #ifdef HAVE_BLAKE2S - if (node_offset > 0xFFFFFFFFFFFFULL) { + if (node_offset > PY_ULL(0xFFFFFFFFFFFF)) { /* maximum 2**48 - 1 */ PyErr_SetString(PyExc_OverflowError, "node_offset is too large"); goto error; @@ -385,6 +385,7 @@ static void py_blake2s_dealloc(PyObject *self) { BLAKE2sObject *obj = (BLAKE2sObject *)self; + PyTypeObject *type; /* Try not to leave state in memory. */ secure_zero_memory(&obj->param, sizeof(obj->param)); @@ -394,7 +395,7 @@ py_blake2s_dealloc(PyObject *self) obj->lock = NULL; } - PyTypeObject *type = Py_TYPE(self); + type = Py_TYPE(self); PyObject_Free(self); Py_DECREF(type); } @@ -409,8 +410,9 @@ static PyType_Slot blake2s_type_slots[] = { }; PyType_Spec blake2s_type_spec = { - .name = "_blake2.blake2s", - .basicsize = sizeof(BLAKE2sObject), - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, - .slots = blake2s_type_slots + "_blake2.blake2s", + sizeof(BLAKE2sObject), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, + blake2s_type_slots }; diff --git a/Modules/_blake2/clinic/blake2b_impl.c.h b/Modules/_blake2/clinic/blake2b_impl.c.h index 4e74e08..4b079b3 100644 --- a/Modules/_blake2/clinic/blake2b_impl.c.h +++ b/Modules/_blake2/clinic/blake2b_impl.c.h @@ -15,7 +15,7 @@ static PyObject * py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size, Py_buffer *key, Py_buffer *salt, Py_buffer *person, int fanout, int depth, unsigned long leaf_size, - unsigned long long node_offset, int node_depth, + unsigned PY_LONG_LONG node_offset, int node_depth, int inner_size, int last_node, int usedforsecurity); static PyObject * @@ -36,7 +36,7 @@ py_blake2b_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) int fanout = 1; int depth = 1; unsigned long leaf_size = 0; - unsigned long long node_offset = 0; + unsigned PY_LONG_LONG node_offset = 0; int node_depth = 0; int inner_size = 0; int last_node = 0; diff --git a/Modules/_blake2/clinic/blake2s_impl.c.h b/Modules/_blake2/clinic/blake2s_impl.c.h index 0f0d983..a25b6cb 100644 --- a/Modules/_blake2/clinic/blake2s_impl.c.h +++ b/Modules/_blake2/clinic/blake2s_impl.c.h @@ -15,7 +15,7 @@ static PyObject * py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, Py_buffer *key, Py_buffer *salt, Py_buffer *person, int fanout, int depth, unsigned long leaf_size, - unsigned long long node_offset, int node_depth, + unsigned PY_LONG_LONG node_offset, int node_depth, int inner_size, int last_node, int usedforsecurity); static PyObject * @@ -36,7 +36,7 @@ py_blake2s_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) int fanout = 1; int depth = 1; unsigned long leaf_size = 0; - unsigned long long node_offset = 0; + unsigned PY_LONG_LONG node_offset = 0; int node_depth = 0; int inner_size = 0; int last_node = 0; diff --git a/Modules/_blake2/impl/blake2b-ref.c b/Modules/_blake2/impl/blake2b-ref.c index e58c436..b386ac5 100644 --- a/Modules/_blake2/impl/blake2b-ref.c +++ b/Modules/_blake2/impl/blake2b-ref.c @@ -20,10 +20,10 @@ static const uint64_t blake2b_IV[8] = { - 0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, - 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, - 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, - 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL + PY_ULL(0x6a09e667f3bcc908), PY_ULL(0xbb67ae8584caa73b), + PY_ULL(0x3c6ef372fe94f82b), PY_ULL(0xa54ff53a5f1d36f1), + PY_ULL(0x510e527fade682d1), PY_ULL(0x9b05688c2b3e6c1f), + PY_ULL(0x1f83d9abfb41bd6b), PY_ULL(0x5be0cd19137e2179) }; static const uint8_t blake2b_sigma[12][16] = @@ -45,13 +45,13 @@ static const uint8_t blake2b_sigma[12][16] = static inline int blake2b_set_lastnode( blake2b_state *S ) { - S->f[1] = ~0ULL; + S->f[1] = ~PY_ULL(0); return 0; } static inline int blake2b_clear_lastnode( blake2b_state *S ) { - S->f[1] = 0ULL; + S->f[1] = PY_ULL(0); return 0; } @@ -60,7 +60,7 @@ static inline int blake2b_set_lastblock( blake2b_state *S ) { if( S->last_node ) blake2b_set_lastnode( S ); - S->f[0] = ~0ULL; + S->f[0] = ~PY_ULL(0); return 0; } @@ -68,7 +68,7 @@ static inline int blake2b_clear_lastblock( blake2b_state *S ) { if( S->last_node ) blake2b_clear_lastnode( S ); - S->f[0] = 0ULL; + S->f[0] = PY_ULL(0); return 0; } @@ -138,9 +138,11 @@ static inline int blake2b_param_set_personal( blake2b_param *P, const uint8_t pe static inline int blake2b_init0( blake2b_state *S ) { + int i; + memset( S, 0, sizeof( blake2b_state ) ); - for( int i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i]; + for( i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i]; return 0; } @@ -161,11 +163,14 @@ extern "C" { /* init xors IV with input parameter block */ int blake2b_init_param( blake2b_state *S, const blake2b_param *P ) { + uint8_t *p; + size_t i; + blake2b_init0( S ); - uint8_t *p = ( uint8_t * )( P ); + p = ( uint8_t * )( P ); /* IV XOR ParamBlock */ - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) S->h[i] ^= load64( p + sizeof( S->h[i] ) * i ); S->outlen = P->digest_length; diff --git a/Modules/_blake2/impl/blake2s-ref.c b/Modules/_blake2/impl/blake2s-ref.c index ab86cc1..12b89d9 100644 --- a/Modules/_blake2/impl/blake2s-ref.c +++ b/Modules/_blake2/impl/blake2s-ref.c @@ -131,9 +131,11 @@ static inline int blake2s_param_set_personal( blake2s_param *P, const uint8_t pe static inline int blake2s_init0( blake2s_state *S ) { + int i; + memset( S, 0, sizeof( blake2s_state ) ); - for( int i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i]; + for( i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i]; return 0; } @@ -154,11 +156,14 @@ extern "C" { /* init2 xors IV with input parameter block */ int blake2s_init_param( blake2s_state *S, const blake2s_param *P ) { + uint32_t *p; + size_t i; + blake2s_init0( S ); - uint32_t *p = ( uint32_t * )( P ); + p = ( uint32_t * )( P ); /* IV XOR ParamBlock */ - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) S->h[i] ^= load32( &p[i] ); S->outlen = P->digest_length; @@ -224,11 +229,12 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK { uint32_t m[16]; uint32_t v[16]; + size_t i; - for( size_t i = 0; i < 16; ++i ) + for( i = 0; i < 16; ++i ) m[i] = load32( block + i * sizeof( m[i] ) ); - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) v[i] = S->h[i]; v[ 8] = blake2s_IV[0]; @@ -272,7 +278,7 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK ROUND( 8 ); ROUND( 9 ); - for( size_t i = 0; i < 8; ++i ) + for( i = 0; i < 8; ++i ) S->h[i] = S->h[i] ^ v[i] ^ v[i + 8]; #undef G diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index 900d906..1cba998 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -2138,6 +2138,7 @@ static PyObject* defdict_or(PyObject* left, PyObject* right) { PyObject *self, *other; + PyObject *new; if (PyObject_TypeCheck(left, &defdict_type)) { self = left; other = right; @@ -2151,7 +2152,7 @@ defdict_or(PyObject* left, PyObject* right) } // Like copy(), this calls the object's class. // Override __or__/__ror__ for subclasses with different constructors. - PyObject *new = new_defdict((defdictobject*)self, left); + new = new_defdict((defdictobject*)self, left); if (!new) { return NULL; } @@ -2162,9 +2163,7 @@ defdict_or(PyObject* left, PyObject* right) return new; } -static PyNumberMethods defdict_as_number = { - .nb_or = defdict_or, -}; +static PyNumberMethods defdict_as_number; static int defdict_traverse(PyObject *self, visitproc visit, void *arg) @@ -2295,6 +2294,7 @@ _collections__count_elements_impl(PyObject *module, PyObject *mapping, PyObject *mapping_setitem; PyObject *dict_setitem; PyObject *one = _PyLong_GetOne(); // borrowed reference + PyObject *zero; it = PyObject_GetIter(iterable); if (it == NULL) @@ -2359,7 +2359,7 @@ _collections__count_elements_impl(PyObject *module, PyObject *mapping, if (bound_get == NULL) goto done; - PyObject *zero = _PyLong_GetZero(); // borrowed reference + zero = _PyLong_GetZero(); // borrowed reference while (1) { key = PyIter_Next(it); if (key == NULL) @@ -2580,10 +2580,12 @@ collections_exec(PyObject *module) { &dequereviter_type, &tuplegetter_type }; + size_t i; + defdict_as_number.nb_or = defdict_or; defdict_type.tp_base = &PyDict_Type; - for (size_t i = 0; i < Py_ARRAY_LENGTH(typelist); i++) { + for (i = 0; i < Py_ARRAY_LENGTH(typelist); i++) { if (PyModule_AddType(module, typelist[i]) < 0) { return -1; } diff --git a/Modules/_csv.c b/Modules/_csv.c index 045b71a..3c16361 100644 --- a/Modules/_csv.c +++ b/Modules/_csv.c @@ -242,6 +242,7 @@ _set_int(const char *name, int *target, PyObject *src, int dflt) static int _set_char_or_none(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt) { + Py_ssize_t len; if (src == NULL) { *target = dflt; } @@ -254,7 +255,7 @@ _set_char_or_none(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt Py_TYPE(src)->tp_name); return -1; } - Py_ssize_t len = PyUnicode_GetLength(src); + len = PyUnicode_GetLength(src); if (len < 0) { return -1; } @@ -274,6 +275,7 @@ _set_char_or_none(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt static int _set_char(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt) { + Py_ssize_t len; if (src == NULL) { *target = dflt; } @@ -284,7 +286,7 @@ _set_char(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt) Py_TYPE(src)->tp_name); return -1; } - Py_ssize_t len = PyUnicode_GetLength(src); + len = PyUnicode_GetLength(src); if (len < 0) { return -1; } @@ -381,10 +383,11 @@ static _csvstate * _csv_state_from_type(PyTypeObject *type, const char *name) { PyObject *module = PyType_GetModuleByDef(type, &_csvmodule); + _csvstate *module_state; if (module == NULL) { return NULL; } - _csvstate *module_state = PyModule_GetState(module); + module_state = PyModule_GetState(module); if (module_state == NULL) { PyErr_Format(PyExc_SystemError, "%s: No _csv module state found", name); @@ -398,6 +401,7 @@ dialect_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { DialectObj *self; PyObject *ret = NULL; + _csvstate *module_state; PyObject *dialect = NULL; PyObject *delimiter = NULL; PyObject *doublequote = NULL; @@ -421,7 +425,7 @@ dialect_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) &strict)) return NULL; - _csvstate *module_state = _csv_state_from_type(type, "dialect_new"); + module_state = _csv_state_from_type(type, "dialect_new"); if (module_state == NULL) { return NULL; } @@ -581,11 +585,12 @@ static PyType_Slot Dialect_Type_slots[] = { }; PyType_Spec Dialect_Type_spec = { - .name = "_csv.Dialect", - .basicsize = sizeof(DialectObj), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | - Py_TPFLAGS_IMMUTABLETYPE), - .slots = Dialect_Type_slots, + "_csv.Dialect", + sizeof(DialectObj), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_IMMUTABLETYPE), + Dialect_Type_slots }; @@ -639,10 +644,12 @@ parse_save_field(ReaderObj *self) static int parse_grow_buff(ReaderObj *self) { + Py_ssize_t field_size_new; + Py_UCS4 *field_new; assert((size_t)self->field_size <= PY_SSIZE_T_MAX / sizeof(Py_UCS4)); - Py_ssize_t field_size_new = self->field_size ? 2 * self->field_size : 4096; - Py_UCS4 *field_new = self->field; + field_size_new = self->field_size ? 2 * self->field_size : 4096; + field_new = self->field; PyMem_Resize(field_new, Py_UCS4, field_size_new); if (field_new == NULL) { PyErr_NoMemory(); @@ -998,11 +1005,12 @@ static PyType_Slot Reader_Type_slots[] = { }; PyType_Spec Reader_Type_spec = { - .name = "_csv.reader", - .basicsize = sizeof(ReaderObj), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | - Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), - .slots = Reader_Type_slots + "_csv.reader", + sizeof(ReaderObj), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), + Reader_Type_slots }; @@ -1435,11 +1443,12 @@ static PyType_Slot Writer_Type_slots[] = { }; PyType_Spec Writer_Type_spec = { - .name = "_csv.writer", - .basicsize = sizeof(WriterObj), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | - Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), - .slots = Writer_Type_slots, + "_csv.writer", + sizeof(WriterObj), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), + Writer_Type_slots }; @@ -1616,9 +1625,11 @@ static PyType_Slot error_slots[] = { }; PyType_Spec error_spec = { - .name = "_csv.Error", - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, - .slots = error_slots, + "_csv.Error", + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, + error_slots }; /* @@ -1734,6 +1745,7 @@ static int csv_exec(PyObject *module) { const StyleDesc *style; PyObject *temp; + PyObject *bases; _csvstate *module_state = get_csv_state(module); temp = PyType_FromModuleAndSpec(module, &Dialect_Type_spec, NULL); @@ -1777,7 +1789,7 @@ csv_exec(PyObject *module) { } /* Add the CSV exception object to the module. */ - PyObject *bases = PyTuple_Pack(1, PyExc_Exception); + bases = PyTuple_Pack(1, PyExc_Exception); if (bases == NULL) { return -1; } diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c index df0ce72..dc29ee8 100644 --- a/Modules/_datetimemodule.c +++ b/Modules/_datetimemodule.c @@ -398,6 +398,9 @@ iso_week1_monday(int year) static int iso_to_ymd(const int iso_year, const int iso_week, const int iso_day, int *year, int *month, int *day) { + int day_1; + int day_offset; + if (iso_week <= 0 || iso_week >= 53) { int out_of_range = 1; if (iso_week == 53) { @@ -419,9 +422,9 @@ iso_to_ymd(const int iso_year, const int iso_week, const int iso_day, } // Convert (Y, W, D) to (Y, M, D) in-place - int day_1 = iso_week1_monday(iso_year); + day_1 = iso_week1_monday(iso_year); - int day_offset = (iso_week - 1)*7 + iso_day - 1; + day_offset = (iso_week - 1)*7 + iso_day - 1; ord_to_ymd(day_1 + day_offset, year, month, day); return 0; @@ -721,7 +724,9 @@ is_digit(const char c) { static const char * parse_digits(const char *ptr, int *var, size_t num_digits) { - for (size_t i = 0; i < num_digits; ++i) { + size_t i; + + for (i = 0; i < num_digits; ++i) { unsigned int tmp = (unsigned int)(*(ptr++) - '0'); if (tmp > 9) { return NULL; @@ -747,12 +752,16 @@ parse_isoformat_date(const char *dtstr, const size_t len, int *year, int *month, * -5, -6: Failure in iso_to_ymd */ const char *p = dtstr; + unsigned char uses_separator; + int iso_week; + int iso_day; + int rv; p = parse_digits(p, year, 4); if (NULL == p) { return -1; } - const unsigned char uses_separator = (*p == '-'); + uses_separator = (*p == '-'); if (uses_separator) { ++p; } @@ -760,8 +769,8 @@ parse_isoformat_date(const char *dtstr, const size_t len, int *year, int *month, if(*p == 'W') { // This is an isocalendar-style date string p++; - int iso_week = 0; - int iso_day = 0; + iso_week = 0; + iso_day = 0; p = parse_digits(p, &iso_week, 2); if (NULL == p) { @@ -782,7 +791,7 @@ parse_isoformat_date(const char *dtstr, const size_t len, int *year, int *month, iso_day = 1; } - int rv = iso_to_ymd(*year, iso_week, iso_day, year, month, day); + rv = iso_to_ymd(*year, iso_week, iso_day, year, month, day); if (rv) { return -3 + rv; } else { @@ -809,21 +818,32 @@ static int parse_hh_mm_ss_ff(const char *tstr, const char *tstr_end, int *hour, int *minute, int *second, int *microsecond) { - *hour = *minute = *second = *microsecond = 0; const char *p = tstr; const char *p_end = tstr_end; - int *vals[3] = {hour, minute, second}; + int *vals[3]; // This is initialized to satisfy an erroneous compiler warning. unsigned char has_separator = 1; + size_t i; + size_t len_remains; + size_t to_parse; + static int correction[] = { + 100000, 10000, 1000, 100, 10 + }; + + *hour = *minute = *second = *microsecond = 0; + vals[0] = hour; + vals[1] = minute; + vals[2] = second; // Parse [HH[:?MM[:?SS]]] - for (size_t i = 0; i < 3; ++i) { + for (i = 0; i < 3; ++i) { + char c; p = parse_digits(p, vals[i], 2); if (NULL == p) { return -3; } - char c = *(p++); + c = *(p++); if (i == 0) { has_separator = (c == ':'); } @@ -844,8 +864,8 @@ parse_hh_mm_ss_ff(const char *tstr, const char *tstr_end, int *hour, } // Parse fractional components - size_t len_remains = p_end - p; - size_t to_parse = len_remains; + len_remains = p_end - p; + to_parse = len_remains; if (len_remains >= 6) { to_parse = 6; } @@ -855,10 +875,6 @@ parse_hh_mm_ss_ff(const char *tstr, const char *tstr_end, int *hour, return -3; } - static int correction[] = { - 100000, 10000, 1000, 100, 10 - }; - if (to_parse < 6) { *microsecond *= correction[to_parse-1]; } @@ -889,14 +905,20 @@ parse_isoformat_time(const char *dtstr, size_t dtlen, int *hour, int *minute, const char *p_end = dtstr + dtlen; const char *tzinfo_pos = p; + int rv; + int tzsign; + int tzhour; + int tzminute; + int tzsecond; + do { if (*tzinfo_pos == 'Z' || *tzinfo_pos == '+' || *tzinfo_pos == '-') { break; } } while (++tzinfo_pos < p_end); - int rv = parse_hh_mm_ss_ff(dtstr, tzinfo_pos, hour, minute, second, - microsecond); + rv = parse_hh_mm_ss_ff(dtstr, tzinfo_pos, hour, minute, second, + microsecond); if (rv < 0) { return rv; @@ -924,9 +946,11 @@ parse_isoformat_time(const char *dtstr, size_t dtlen, int *hour, int *minute, } } - int tzsign = (*tzinfo_pos == '-') ? -1 : 1; + tzsign = (*tzinfo_pos == '-') ? -1 : 1; tzinfo_pos++; - int tzhour = 0, tzminute = 0, tzsecond = 0; + tzhour = 0; + tzminute = 0; + tzsecond = 0; rv = parse_hh_mm_ss_ff(tzinfo_pos, p_end, &tzhour, &tzminute, &tzsecond, tzmicrosecond); @@ -1401,6 +1425,7 @@ static inline PyObject * tzinfo_from_isoformat_results(int rv, int tzoffset, int tz_useconds) { PyObject *tzinfo; + PyObject *delta; if (rv == 1) { // Create a timezone from offset in seconds (0 returns UTC) if (tzoffset == 0) { @@ -1408,7 +1433,7 @@ tzinfo_from_isoformat_results(int rv, int tzoffset, int tz_useconds) return PyDateTime_TimeZone_UTC; } - PyObject *delta = new_delta(0, tzoffset, tz_useconds, 1); + delta = new_delta(0, tzoffset, tz_useconds, 1); if (delta == NULL) { return NULL; } @@ -2629,13 +2654,15 @@ delta_bool(PyDateTime_Delta *self) static PyObject * delta_repr(PyDateTime_Delta *self) { + const char *sep; + PyObject *repr; PyObject *args = PyUnicode_FromString(""); if (args == NULL) { return NULL; } - const char *sep = ""; + sep = ""; if (GET_TD_DAYS(self) != 0) { Py_SETREF(args, PyUnicode_FromFormat("days=%d", GET_TD_DAYS(self))); @@ -2669,8 +2696,8 @@ delta_repr(PyDateTime_Delta *self) } } - PyObject *repr = PyUnicode_FromFormat("%s(%S)", Py_TYPE(self)->tp_name, - args); + repr = PyUnicode_FromFormat("%s(%S)", Py_TYPE(self)->tp_name, + args); Py_DECREF(args); return repr; } @@ -3057,6 +3084,11 @@ date_fromordinal(PyObject *cls, PyObject *args) static PyObject * date_fromisoformat(PyObject *cls, PyObject *dtstr) { + Py_ssize_t len; + const char *dt_ptr; + int year, month, day; + int rv; + assert(dtstr != NULL); if (!PyUnicode_Check(dtstr)) { @@ -3065,16 +3097,14 @@ date_fromisoformat(PyObject *cls, PyObject *dtstr) return NULL; } - Py_ssize_t len; - - const char *dt_ptr = PyUnicode_AsUTF8AndSize(dtstr, &len); + dt_ptr = PyUnicode_AsUTF8AndSize(dtstr, &len); if (dt_ptr == NULL) { goto invalid_string_error; } - int year = 0, month = 0, day = 0; - - int rv; + year = 0; + month = 0; + day = 0; if (len == 7 || len == 8 || len == 10) { rv = parse_isoformat_date(dt_ptr, len, &year, &month, &day); } @@ -3102,6 +3132,8 @@ date_fromisocalendar(PyObject *cls, PyObject *args, PyObject *kw) }; int year, week, day; + int month; + int rv; if (PyArg_ParseTupleAndKeywords(args, kw, "iii:fromisocalendar", keywords, &year, &week, &day) == 0) { @@ -3119,8 +3151,7 @@ date_fromisocalendar(PyObject *cls, PyObject *args, PyObject *kw) return NULL; } - int month; - int rv = iso_to_ymd(year, week, day, &year, &month, &day); + rv = iso_to_ymd(year, week, day, &year, &month, &day); if (rv == -2) { @@ -3312,14 +3343,16 @@ static PyObject * iso_calendar_date_repr(PyDateTime_IsoCalendarDate *self) { PyObject* year = PyTuple_GetItem((PyObject *)self, 0); + PyObject* week; + PyObject* weekday; if (year == NULL) { return NULL; } - PyObject* week = PyTuple_GetItem((PyObject *)self, 1); + week = PyTuple_GetItem((PyObject *)self, 1); if (week == NULL) { return NULL; } - PyObject* weekday = PyTuple_GetItem((PyObject *)self, 2); + weekday = PyTuple_GetItem((PyObject *)self, 2); if (weekday == NULL) { return NULL; } @@ -3390,15 +3423,44 @@ static PyMethodDef iso_calendar_date_methods[] = { static PyTypeObject PyDateTime_IsoCalendarDateType = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "datetime.IsoCalendarDate", - .tp_basicsize = sizeof(PyDateTime_IsoCalendarDate), - .tp_repr = (reprfunc) iso_calendar_date_repr, - .tp_flags = Py_TPFLAGS_DEFAULT, - .tp_doc = iso_calendar_date__doc__, - .tp_methods = iso_calendar_date_methods, - .tp_getset = iso_calendar_date_getset, - // .tp_base = &PyTuple_Type, // filled in PyInit__datetime - .tp_new = iso_calendar_date_new, + "datetime.IsoCalendarDate", + sizeof(PyDateTime_IsoCalendarDate), + 0, + 0, + 0, + 0, + 0, + 0, + (reprfunc) iso_calendar_date_repr, + 0, + 0, + 0, + 0, + 0, + 0, + PyObject_GenericGetAttr, + 0, + 0, + Py_TPFLAGS_DEFAULT, + iso_calendar_date__doc__, + 0, + 0, + 0, + 0, + 0, + 0, + iso_calendar_date_methods, + 0, + iso_calendar_date_getset, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + iso_calendar_date_new, + 0, }; /*[clinic input] @@ -3431,6 +3493,7 @@ iso_calendar_date_new_impl(PyTypeObject *type, int year, int week, static PyObject * date_isocalendar(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored)) { + PyObject* v; int year = GET_YEAR(self); int week1_monday = iso_week1_monday(year); int today = ymd_to_ord(year, GET_MONTH(self), GET_DAY(self)); @@ -3448,7 +3511,7 @@ date_isocalendar(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored)) week = 0; } - PyObject* v = iso_calendar_date_new_impl(&PyDateTime_IsoCalendarDateType, + v = iso_calendar_date_new_impl(&PyDateTime_IsoCalendarDateType, year, week + 1, day + 1); if (v == NULL) { return NULL; @@ -4626,6 +4689,14 @@ time_replace(PyDateTime_Time *self, PyObject *args, PyObject *kw) static PyObject * time_fromisoformat(PyObject *cls, PyObject *tstr) { + Py_ssize_t len; + const char *p; + int hour, minute, second, microsecond; + int tzoffset, tzimicrosecond; + int rv; + PyObject *tzinfo; + PyObject *t; + assert(tstr != NULL); if (!PyUnicode_Check(tstr)) { @@ -4633,8 +4704,7 @@ time_fromisoformat(PyObject *cls, PyObject *tstr) { return NULL; } - Py_ssize_t len; - const char *p = PyUnicode_AsUTF8AndSize(tstr, &len); + p = PyUnicode_AsUTF8AndSize(tstr, &len); if (p == NULL) { goto invalid_string_error; @@ -4648,24 +4718,23 @@ time_fromisoformat(PyObject *cls, PyObject *tstr) { len -= 1; } - int hour = 0, minute = 0, second = 0, microsecond = 0; - int tzoffset = 0, tzimicrosecond = 0; - int rv = parse_isoformat_time(p, len, - &hour, &minute, &second, µsecond, - &tzoffset, &tzimicrosecond); + hour = minute = second = microsecond = 0; + tzoffset = tzimicrosecond = 0; + rv = parse_isoformat_time(p, len, + &hour, &minute, &second, µsecond, + &tzoffset, &tzimicrosecond); if (rv < 0) { goto invalid_string_error; } - PyObject *tzinfo = tzinfo_from_isoformat_results(rv, tzoffset, - tzimicrosecond); + tzinfo = tzinfo_from_isoformat_results(rv, tzoffset, + tzimicrosecond); if (tzinfo == NULL) { return NULL; } - PyObject *t; if ( (PyTypeObject *)cls == &PyDateTime_TimeType ) { t = new_time(hour, minute, second, microsecond, tzinfo, 0); } else { @@ -4981,15 +5050,15 @@ typedef int (*TM_FUNC)(time_t timer, struct tm*); /* As of version 2015f max fold in IANA database is * 23 hours at 1969-09-30 13:00:00 in Kwajalein. */ -static long long max_fold_seconds = 24 * 3600; +static PY_LONG_LONG max_fold_seconds = 24 * 3600; /* NB: date(1970,1,1).toordinal() == 719163 */ -static long long epoch = 719163LL * 24 * 60 * 60; +static PY_LONG_LONG epoch = PY_LL(719163) * 24 * 60 * 60; -static long long +static PY_LONG_LONG utc_to_seconds(int year, int month, int day, int hour, int minute, int second) { - long long ordinal; + PY_LONG_LONG ordinal; /* ymd_to_ord() doesn't support year <= 0 */ if (year < MINYEAR || year > MAXYEAR) { @@ -5001,8 +5070,8 @@ utc_to_seconds(int year, int month, int day, return ((ordinal * 24 + hour) * 60 + minute) * 60 + second; } -static long long -local(long long u) +static PY_LONG_LONG +local(PY_LONG_LONG u) { struct tm local_time; time_t t; @@ -5067,7 +5136,7 @@ datetime_from_timet_and_us(PyObject *cls, TM_FUNC f, time_t timet, int us, && (timet - max_fold_seconds > 0) #endif ) { - long long probe_seconds, result_seconds, transition; + PY_LONG_LONG probe_seconds, result_seconds, transition; result_seconds = utc_to_seconds(year, month, day, hour, minute, second); @@ -5272,6 +5341,12 @@ datetime_combine(PyObject *cls, PyObject *args, PyObject *kw) static PyObject * _sanitize_isoformat_str(PyObject *dtstr) { + static const size_t potential_separators[3] = {7, 8, 10}; + const void *unicode_data; + unsigned int kind; + size_t surrogate_separator; + size_t idx; + PyObject *str_out; Py_ssize_t len = PyUnicode_GetLength(dtstr); if (len < 7) { // All valid ISO 8601 strings are at least 7 characters long return NULL; @@ -5283,17 +5358,16 @@ _sanitize_isoformat_str(PyObject *dtstr) // replaces any surrogate character separators with `T`. // // The result of this, if not NULL, returns a new reference - const void* const unicode_data = PyUnicode_DATA(dtstr); - const unsigned int kind = PyUnicode_KIND(dtstr); + unicode_data = PyUnicode_DATA(dtstr); + kind = PyUnicode_KIND(dtstr); // Depending on the format of the string, the separator can only ever be // in positions 7, 8 or 10. We'll check each of these for a surrogate and // if we find one, replace it with `T`. If there is more than one surrogate, // we don't have to bother sanitizing it, because the function will later // fail when we try to encode the string as ASCII. - static const size_t potential_separators[3] = {7, 8, 10}; - size_t surrogate_separator = 0; - for(size_t idx = 0; + surrogate_separator = 0; + for (idx = 0; idx < sizeof(potential_separators) / sizeof(*potential_separators); ++idx) { size_t pos = potential_separators[idx]; @@ -5312,7 +5386,7 @@ _sanitize_isoformat_str(PyObject *dtstr) return dtstr; } - PyObject *str_out = _PyUnicode_Copy(dtstr); + str_out = _PyUnicode_Copy(dtstr); if (str_out == NULL) { return NULL; } @@ -5428,6 +5502,18 @@ _find_isoformat_datetime_separator(const char *dtstr, Py_ssize_t len) { static PyObject * datetime_fromisoformat(PyObject *cls, PyObject *dtstr) { + PyObject *dtstr_clean; + Py_ssize_t len; + const char *dt_ptr; + Py_ssize_t separator_location; + const char *p; + int year, month, day; + int hour, minute, second, microsecond; + int tzoffset, tzusec; + int rv; + PyObject *tzinfo; + PyObject *dt; + assert(dtstr != NULL); if (!PyUnicode_Check(dtstr)) { @@ -5441,13 +5527,12 @@ datetime_fromisoformat(PyObject *cls, PyObject *dtstr) // we don't have to sanitize it anything because that can only happen when // the separator is either '-' or a number. This should mostly be a noop // but it makes the reference counting easier if we still sanitize. - PyObject *dtstr_clean = _sanitize_isoformat_str(dtstr); + dtstr_clean = _sanitize_isoformat_str(dtstr); if (dtstr_clean == NULL) { goto invalid_string_error; } - Py_ssize_t len; - const char *dt_ptr = PyUnicode_AsUTF8AndSize(dtstr_clean, &len); + dt_ptr = PyUnicode_AsUTF8AndSize(dtstr_clean, &len); if (dt_ptr == NULL) { if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) { @@ -5459,18 +5544,18 @@ datetime_fromisoformat(PyObject *cls, PyObject *dtstr) } } - const Py_ssize_t separator_location = _find_isoformat_datetime_separator( + separator_location = _find_isoformat_datetime_separator( dt_ptr, len); - const char *p = dt_ptr; + p = dt_ptr; - int year = 0, month = 0, day = 0; - int hour = 0, minute = 0, second = 0, microsecond = 0; - int tzoffset = 0, tzusec = 0; + year = 0; month = 0; day = 0; + hour = 0; minute = 0; second = 0; microsecond = 0; + tzoffset = 0; tzusec = 0; // date runs up to separator_location - int rv = parse_isoformat_date(p, separator_location, &year, &month, &day); + rv = parse_isoformat_date(p, separator_location, &year, &month, &day); if (!rv && len > separator_location) { // In UTF-8, the length of multi-byte characters is encoded in the MSB @@ -5500,13 +5585,13 @@ datetime_fromisoformat(PyObject *cls, PyObject *dtstr) goto invalid_string_error; } - PyObject *tzinfo = tzinfo_from_isoformat_results(rv, tzoffset, tzusec); + tzinfo = tzinfo_from_isoformat_results(rv, tzoffset, tzusec); if (tzinfo == NULL) { goto error; } - PyObject *dt = new_datetime_subclass_ex(year, month, day, hour, minute, - second, microsecond, tzinfo, cls); + dt = new_datetime_subclass_ex(year, month, day, hour, minute, + second, microsecond, tzinfo, cls); Py_DECREF(tzinfo); Py_DECREF(dtstr_clean); @@ -6172,14 +6257,14 @@ local_timezone(PyDateTime_DateTime *utc_time) return local_timezone_from_timestamp(timestamp); } -static long long +static PY_LONG_LONG local_to_seconds(int year, int month, int day, int hour, int minute, int second, int fold); static PyObject * local_timezone_from_local(PyDateTime_DateTime *local_dt) { - long long seconds; + PY_LONG_LONG seconds; time_t timestamp; seconds = local_to_seconds(GET_YEAR(local_dt), GET_MONTH(local_dt), @@ -6324,11 +6409,11 @@ datetime_timetuple(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored)) dstflag); } -static long long +static PY_LONG_LONG local_to_seconds(int year, int month, int day, int hour, int minute, int second, int fold) { - long long t, a, b, u1, u2, t1, t2, lt; + PY_LONG_LONG t, a, b, u1, u2, t1, t2, lt; t = utc_to_seconds(year, month, day, hour, minute, second); /* Our goal is to solve t = local(u) for u. */ lt = local(t); @@ -6372,7 +6457,7 @@ local_to_seconds(int year, int month, int day, } /* date(1970,1,1).toordinal() == 719163 */ -#define EPOCH_SECONDS (719163LL * 24 * 60 * 60) +#define EPOCH_SECONDS (PY_LL(719163) * 24 * 60 * 60) static PyObject * datetime_timestamp(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored)) @@ -6388,7 +6473,7 @@ datetime_timestamp(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored)) Py_DECREF(delta); } else { - long long seconds; + PY_LONG_LONG seconds; seconds = local_to_seconds(GET_YEAR(self), GET_MONTH(self), GET_DAY(self), @@ -6719,13 +6804,6 @@ datetime_destructor(PyObject *op) static int _datetime_exec(PyObject *module) { - // `&...` is not a constant expression according to a strict reading - // of C standards. Fill tp_base at run-time rather than statically. - // See https://bugs.python.org/issue40777 - PyDateTime_IsoCalendarDateType.tp_base = &PyTuple_Type; - PyDateTime_TimeZoneType.tp_base = &PyDateTime_TZInfoType; - PyDateTime_DateTimeType.tp_base = &PyDateTime_DateType; - PyTypeObject *types[] = { &PyDateTime_DateType, &PyDateTime_DateTimeType, @@ -6734,8 +6812,20 @@ _datetime_exec(PyObject *module) &PyDateTime_TZInfoType, &PyDateTime_TimeZoneType, }; + size_t i; + PyObject *d; + PyObject *delta; + PyObject *x; + PyDateTime_CAPI *capi; + + // `&...` is not a constant expression according to a strict reading + // of C standards. Fill tp_base at run-time rather than statically. + // See https://bugs.python.org/issue40777 + PyDateTime_IsoCalendarDateType.tp_base = &PyTuple_Type; + PyDateTime_TimeZoneType.tp_base = &PyDateTime_TZInfoType; + PyDateTime_DateTimeType.tp_base = &PyDateTime_DateType; - for (size_t i = 0; i < Py_ARRAY_LENGTH(types); i++) { + for (i = 0; i < Py_ARRAY_LENGTH(types); i++) { if (PyModule_AddType(module, types[i]) < 0) { return -1; } @@ -6759,7 +6849,7 @@ _datetime_exec(PyObject *module) } while(0) /* timedelta values */ - PyObject *d = PyDateTime_DeltaType.tp_dict; + d = PyDateTime_DeltaType.tp_dict; DATETIME_ADD_MACRO(d, "resolution", new_delta(0, 0, 1, 0)); DATETIME_ADD_MACRO(d, "min", new_delta(-MAX_DELTA_DAYS, 0, 0, 0)); DATETIME_ADD_MACRO(d, "max", @@ -6787,12 +6877,12 @@ _datetime_exec(PyObject *module) /* timezone values */ d = PyDateTime_TimeZoneType.tp_dict; - PyObject *delta = new_delta(0, 0, 0, 0); + delta = new_delta(0, 0, 0, 0); if (delta == NULL) { return -1; } - PyObject *x = create_timezone(delta, NULL); + x = create_timezone(delta, NULL); Py_DECREF(delta); if (x == NULL) { return -1; @@ -6840,7 +6930,7 @@ _datetime_exec(PyObject *module) return -1; } - PyDateTime_CAPI *capi = get_datetime_capi(); + capi = get_datetime_capi(); if (capi == NULL) { return -1; } @@ -6925,10 +7015,11 @@ _datetime_exec(PyObject *module) static struct PyModuleDef datetimemodule = { PyModuleDef_HEAD_INIT, - .m_name = "_datetime", - .m_doc = "Fast implementation of the datetime type.", - .m_size = -1, - .m_methods = module_methods, + "_datetime", + "Fast implementation of the datetime type.", + -1, + module_methods, + NULL }; PyMODINIT_FUNC diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c index 3abb7fd..072c07f 100644 --- a/Modules/_functoolsmodule.c +++ b/Modules/_functoolsmodule.c @@ -192,8 +192,9 @@ partial_vectorcall_fallback(PyThreadState *tstate, partialobject *pto, PyObject *const *args, size_t nargsf, PyObject *kwnames) { + Py_ssize_t nargs; pto->vectorcall = NULL; - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + nargs = PyVectorcall_NARGS(nargsf); return _PyObject_MakeTpCall(tstate, (PyObject *)pto, args, nargs, kwnames); } @@ -202,21 +203,33 @@ static PyObject * partial_vectorcall(partialobject *pto, PyObject *const *args, size_t nargsf, PyObject *kwnames) { - PyThreadState *tstate = _PyThreadState_GET(); + PyThreadState *tstate; + Py_ssize_t nargs; + Py_ssize_t nargs_total; + PyObject **pto_args; + Py_ssize_t pto_nargs; + PyObject **newargs; + PyObject *tmp; + PyObject *ret; + Py_ssize_t newnargs_total; + PyObject *small_stack[_PY_FASTCALL_SMALL_STACK]; + PyObject **stack; + + tstate = _PyThreadState_GET(); /* pto->kw is mutable, so need to check every time */ if (PyDict_GET_SIZE(pto->kw)) { return partial_vectorcall_fallback(tstate, pto, args, nargsf, kwnames); } - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); - Py_ssize_t nargs_total = nargs; + nargs = PyVectorcall_NARGS(nargsf); + nargs_total = nargs; if (kwnames != NULL) { nargs_total += PyTuple_GET_SIZE(kwnames); } - PyObject **pto_args = _PyTuple_ITEMS(pto->args); - Py_ssize_t pto_nargs = PyTuple_GET_SIZE(pto->args); + pto_args = _PyTuple_ITEMS(pto->args); + pto_nargs = PyTuple_GET_SIZE(pto->args); /* Fast path if we're called without arguments */ if (nargs_total == 0) { @@ -227,20 +240,16 @@ partial_vectorcall(partialobject *pto, PyObject *const *args, /* Fast path using PY_VECTORCALL_ARGUMENTS_OFFSET to prepend a single * positional argument */ if (pto_nargs == 1 && (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET)) { - PyObject **newargs = (PyObject **)args - 1; - PyObject *tmp = newargs[0]; + newargs = (PyObject **)args - 1; + tmp = newargs[0]; newargs[0] = pto_args[0]; - PyObject *ret = _PyObject_VectorcallTstate(tstate, pto->fn, + ret = _PyObject_VectorcallTstate(tstate, pto->fn, newargs, nargs + 1, kwnames); newargs[0] = tmp; return ret; } - Py_ssize_t newnargs_total = pto_nargs + nargs_total; - - PyObject *small_stack[_PY_FASTCALL_SMALL_STACK]; - PyObject *ret; - PyObject **stack; + newnargs_total = pto_nargs + nargs_total; if (newnargs_total <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) { stack = small_stack; @@ -285,12 +294,15 @@ partial_setvectorcall(partialobject *pto) static PyObject * partial_call(partialobject *pto, PyObject *args, PyObject *kwargs) { + PyObject *kwargs2; + PyObject *args2; + PyObject *res; + assert(PyCallable_Check(pto->fn)); assert(PyTuple_Check(pto->args)); assert(PyDict_Check(pto->kw)); /* Merge keywords */ - PyObject *kwargs2; if (PyDict_GET_SIZE(pto->kw) == 0) { /* kwargs can be NULL */ kwargs2 = kwargs; @@ -315,13 +327,13 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kwargs) /* Merge positional arguments */ /* Note: tupleconcat() is optimized for empty tuples */ - PyObject *args2 = PySequence_Concat(pto->args, args); + args2 = PySequence_Concat(pto->args, args); if (args2 == NULL) { Py_XDECREF(kwargs2); return NULL; } - PyObject *res = PyObject_Call(pto->fn, args2, kwargs2); + res = PyObject_Call(pto->fn, args2, kwargs2); Py_DECREF(args2); Py_XDECREF(kwargs2); return res; @@ -489,12 +501,13 @@ static PyType_Slot partial_type_slots[] = { }; static PyType_Spec partial_type_spec = { - .name = "functools.partial", - .basicsize = sizeof(partialobject), - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | - Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_VECTORCALL | - Py_TPFLAGS_IMMUTABLETYPE, - .slots = partial_type_slots + "functools.partial", + sizeof(partialobject), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_VECTORCALL | + Py_TPFLAGS_IMMUTABLETYPE, + partial_type_slots }; @@ -558,11 +571,12 @@ static PyType_Slot keyobject_type_slots[] = { }; static PyType_Spec keyobject_type_spec = { - .name = "functools.KeyWrapper", - .basicsize = sizeof(keyobject), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | - Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE), - .slots = keyobject_type_slots + "functools.KeyWrapper", + sizeof(keyobject), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE), + keyobject_type_slots }; static PyObject * @@ -781,11 +795,12 @@ static PyType_Slot lru_list_elem_type_slots[] = { }; static PyType_Spec lru_list_elem_type_spec = { - .name = "functools._lru_list_elem", - .basicsize = sizeof(lru_list_elem), - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | - Py_TPFLAGS_IMMUTABLETYPE, - .slots = lru_list_elem_type_slots + "functools._lru_list_elem", + sizeof(lru_list_elem), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_IMMUTABLETYPE, + lru_list_elem_type_slots }; @@ -993,6 +1008,7 @@ bounded_lru_cache_wrapper(lru_cache_object *self, PyObject *args, PyObject *kwds { lru_list_elem *link; PyObject *key, *result, *testresult; + PyObject *oldkey, *oldresult, *popresult; Py_hash_t hash; key = lru_cache_make_key(self->kwd_mark, args, kwds, self->typed); @@ -1086,8 +1102,6 @@ bounded_lru_cache_wrapper(lru_cache_object *self, PyObject *args, PyObject *kwds make sense to reinsert the link, so we leave it out and the cache will no longer register as full. */ - PyObject *oldkey, *oldresult, *popresult; - /* Extract the oldest item. */ assert(self->root.next != &self->root); link = self->root.next; @@ -1345,10 +1359,13 @@ lru_cache_deepcopy(PyObject *self, PyObject *unused) static int lru_cache_tp_traverse(lru_cache_object *self, visitproc visit, void *arg) { + lru_list_elem *link; + lru_list_elem *next; + Py_VISIT(Py_TYPE(self)); - lru_list_elem *link = self->root.next; + link = self->root.next; while (link != &self->root) { - lru_list_elem *next = link->next; + next = link->next; Py_VISIT(link->key); Py_VISIT(link->result); Py_VISIT(Py_TYPE(link)); @@ -1417,11 +1434,12 @@ static PyType_Slot lru_cache_type_slots[] = { }; static PyType_Spec lru_cache_type_spec = { - .name = "functools._lru_cache_wrapper", - .basicsize = sizeof(lru_cache_object), - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | - Py_TPFLAGS_METHOD_DESCRIPTOR | Py_TPFLAGS_IMMUTABLETYPE, - .slots = lru_cache_type_slots + "functools._lru_cache_wrapper", + sizeof(lru_cache_object), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_METHOD_DESCRIPTOR | Py_TPFLAGS_IMMUTABLETYPE, + lru_cache_type_slots }; @@ -1441,6 +1459,7 @@ static int _functools_exec(PyObject *module) { _functools_state *state = get_functools_state(module); + PyObject *lru_cache_type; state->kwd_mark = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type); if (state->kwd_mark == NULL) { return -1; @@ -1455,7 +1474,7 @@ _functools_exec(PyObject *module) return -1; } - PyObject *lru_cache_type = PyType_FromModuleAndSpec(module, + lru_cache_type = PyType_FromModuleAndSpec(module, &lru_cache_type_spec, NULL); if (lru_cache_type == NULL) { return -1; @@ -1520,14 +1539,14 @@ static struct PyModuleDef_Slot _functools_slots[] = { static struct PyModuleDef _functools_module = { PyModuleDef_HEAD_INIT, - .m_name = "_functools", - .m_doc = _functools_doc, - .m_size = sizeof(_functools_state), - .m_methods = _functools_methods, - .m_slots = _functools_slots, - .m_traverse = _functools_traverse, - .m_clear = _functools_clear, - .m_free = _functools_free, + "_functools", + _functools_doc, + sizeof(_functools_state), + _functools_methods, + _functools_slots, + _functools_traverse, + _functools_clear, + _functools_free }; PyMODINIT_FUNC diff --git a/Modules/_heapqmodule.c b/Modules/_heapqmodule.c index 3dbaaa0..5b17473 100644 --- a/Modules/_heapqmodule.c +++ b/Modules/_heapqmodule.c @@ -250,6 +250,7 @@ _heapq_heappushpop_impl(PyObject *module, PyObject *heap, PyObject *item) /*[clinic end generated code: output=67231dc98ed5774f input=5dc701f1eb4a4aa7]*/ { PyObject *returnitem; + PyObject *top; int cmp; if (PyList_GET_SIZE(heap) == 0) { @@ -257,7 +258,7 @@ _heapq_heappushpop_impl(PyObject *module, PyObject *heap, PyObject *item) return item; } - PyObject* top = PyList_GET_ITEM(heap, 0); + top = PyList_GET_ITEM(heap, 0); Py_INCREF(top); cmp = PyObject_RichCompareBool(top, item, Py_LT); Py_DECREF(top); diff --git a/Modules/_json.c b/Modules/_json.c index 9464b9f..eada42f 100644 --- a/Modules/_json.c +++ b/Modules/_json.c @@ -317,21 +317,24 @@ escape_unicode(PyObject *pystr) static void raise_errmsg(const char *msg, PyObject *s, Py_ssize_t end) { + PyObject *decoder; + PyObject *JSONDecodeError; + PyObject *exc; + _Py_IDENTIFIER(JSONDecodeError); + /* Use JSONDecodeError exception to raise a nice looking ValueError subclass */ _Py_static_string(PyId_decoder, "json.decoder"); - PyObject *decoder = _PyImport_GetModuleId(&PyId_decoder); + decoder = _PyImport_GetModuleId(&PyId_decoder); if (decoder == NULL) { return; } - _Py_IDENTIFIER(JSONDecodeError); - PyObject *JSONDecodeError = _PyObject_GetAttrId(decoder, &PyId_JSONDecodeError); + JSONDecodeError = _PyObject_GetAttrId(decoder, &PyId_JSONDecodeError); Py_DECREF(decoder); if (JSONDecodeError == NULL) { return; } - PyObject *exc; exc = PyObject_CallFunction(JSONDecodeError, "zOn", msg, s, end); Py_DECREF(JSONDecodeError); if (exc) { @@ -394,11 +397,11 @@ scanstring_unicode(PyObject *pystr, Py_ssize_t end, int strict, Py_ssize_t *next Py_ssize_t next /* = begin */; const void *buf; int kind; + _PyUnicodeWriter writer; if (PyUnicode_READY(pystr) == -1) return 0; - _PyUnicodeWriter writer; _PyUnicodeWriter_Init(&writer); writer.overallocate = 1; @@ -1227,11 +1230,11 @@ static PyType_Slot PyScannerType_slots[] = { }; static PyType_Spec PyScannerType_spec = { - .name = "_json.Scanner", - .basicsize = sizeof(PyScannerObject), - .itemsize = 0, - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, - .slots = PyScannerType_slots, + "_json.Scanner", + sizeof(PyScannerObject), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + PyScannerType_slots }; static PyObject * @@ -1786,11 +1789,11 @@ static PyType_Slot PyEncoderType_slots[] = { }; static PyType_Spec PyEncoderType_spec = { - .name = "_json.Encoder", - .basicsize = sizeof(PyEncoderObject), - .itemsize = 0, - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, - .slots = PyEncoderType_slots + "_json.Encoder", + sizeof(PyEncoderObject), + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + PyEncoderType_slots }; static PyMethodDef speedups_methods[] = { diff --git a/Modules/_localemodule.c b/Modules/_localemodule.c index ac9709c..edbd0a9 100644 --- a/Modules/_localemodule.c +++ b/Modules/_localemodule.c @@ -191,10 +191,13 @@ locale_decode_monetary(PyObject *dict, struct lconv *lc) } } -#define GET_LOCALE_STRING(ATTR) PyUnicode_DecodeLocale(lc->ATTR, NULL) #else /* MS_WINDOWS */ +#if defined(_MSC_VER) && _MSC_VER < 1300 +#define GET_LOCALE_STRING(ATTR) PyUnicode_DecodeLocale(lc->ATTR, NULL) +#else /* Use _W_* fields of Windows struct lconv */ #define GET_LOCALE_STRING(ATTR) PyUnicode_FromWideChar(lc->_W_ ## ATTR, -1) +#endif #endif /* MS_WINDOWS */ int res = -1; @@ -245,6 +248,7 @@ _locale_localeconv_impl(PyObject *module) PyObject* result; struct lconv *lc; PyObject *x; + PyObject *decimal_point = NULL, *thousands_sep = NULL; result = PyDict_New(); if (!result) { @@ -268,7 +272,9 @@ _locale_localeconv_impl(PyObject *module) Py_DECREF(obj); \ } while (0) -#ifdef MS_WINDOWS +#if defined(MS_WINDOWS) && defined(_MSC_VER) && _MSC_VER < 1300 +#define GET_LOCALE_STRING(ATTR) PyUnicode_DecodeLocale(lc->ATTR, NULL) +#elif defined(MS_WINDOWS) /* Use _W_* fields of Windows struct lconv */ #define GET_LOCALE_STRING(ATTR) PyUnicode_FromWideChar(lc->_W_ ## ATTR, -1) #else @@ -305,7 +311,6 @@ _locale_localeconv_impl(PyObject *module) RESULT_INT(n_sign_posn); /* Numeric information: LC_NUMERIC encoding */ - PyObject *decimal_point = NULL, *thousands_sep = NULL; if (_Py_GetLocaleconvNumeric(lc, &decimal_point, &thousands_sep) < 0) { Py_XDECREF(decimal_point); Py_XDECREF(thousands_sep); @@ -828,6 +833,7 @@ _locale_exec(PyObject *module) } \ } while (0) + _locale_state *state; ADD_INT(module, LC_CTYPE); ADD_INT(module, LC_TIME); ADD_INT(module, LC_COLLATE); @@ -841,7 +847,7 @@ _locale_exec(PyObject *module) ADD_INT(module, LC_ALL); ADD_INT(module, CHAR_MAX); - _locale_state *state = get_locale_state(module); + state = get_locale_state(module); state->Error = PyErr_NewException("locale.Error", NULL, NULL); if (state->Error == NULL) { return -1; diff --git a/Modules/_lsprof.c b/Modules/_lsprof.c index a0e262b..f785e94 100644 --- a/Modules/_lsprof.c +++ b/Modules/_lsprof.c @@ -82,14 +82,16 @@ _lsprof_get_state(PyObject *module) static _PyTime_t CallExternalTimer(ProfilerObject *pObj) { - PyObject *o = _PyObject_CallNoArgs(pObj->externalTimer); + PyObject *o; + _PyTime_t result; + int err; + + o = _PyObject_CallNoArgs(pObj->externalTimer); if (o == NULL) { PyErr_WriteUnraisable(pObj->externalTimer); return 0; } - _PyTime_t result; - int err; if (pObj->externalTimerUnit > 0.0) { /* interpret the result as an integer that will be scaled in profiler_getstats() */ @@ -494,17 +496,17 @@ static PyStructSequence_Field profiler_subentry_fields[] = { }; static PyStructSequence_Desc profiler_entry_desc = { - .name = "_lsprof.profiler_entry", - .fields = profiler_entry_fields, - .doc = NULL, - .n_in_sequence = 6 + "_lsprof.profiler_entry", + NULL, + profiler_entry_fields, + 6 }; static PyStructSequence_Desc profiler_subentry_desc = { - .name = "_lsprof.profiler_subentry", - .fields = profiler_subentry_fields, - .doc = NULL, - .n_in_sequence = 5 + "_lsprof.profiler_subentry", + NULL, + profiler_subentry_fields, + 5 }; typedef struct { @@ -670,6 +672,7 @@ profiler_enable(ProfilerObject *self, PyObject *args, PyObject *kwds) int subcalls = -1; int builtins = -1; static char *kwlist[] = {"subcalls", "builtins", 0}; + PyThreadState *tstate; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ii:enable", kwlist, &subcalls, &builtins)) return NULL; @@ -677,7 +680,7 @@ profiler_enable(ProfilerObject *self, PyObject *args, PyObject *kwds) return NULL; } - PyThreadState *tstate = _PyThreadState_GET(); + tstate = _PyThreadState_GET(); if (_PyEval_SetProfile(tstate, profiler_callback, (PyObject*)self) < 0) { return NULL; } @@ -747,9 +750,11 @@ profiler_traverse(ProfilerObject *op, visitproc visit, void *arg) static void profiler_dealloc(ProfilerObject *op) { + PyTypeObject *tp; + PyThreadState *tstate; PyObject_GC_UnTrack(op); if (op->flags & POF_ENABLED) { - PyThreadState *tstate = _PyThreadState_GET(); + tstate = _PyThreadState_GET(); if (_PyEval_SetProfile(tstate, NULL, NULL) < 0) { _PyErr_WriteUnraisableMsg("When destroying _lsprof profiler", NULL); } @@ -758,7 +763,7 @@ profiler_dealloc(ProfilerObject *op) flush_unmatched(op); clearEntries(op); Py_XDECREF(op->externalTimer); - PyTypeObject *tp = Py_TYPE(op); + tp = Py_TYPE(op); tp->tp_free(op); Py_DECREF(tp); } @@ -817,11 +822,12 @@ static PyType_Slot _lsprof_profiler_type_spec_slots[] = { }; static PyType_Spec _lsprof_profiler_type_spec = { - .name = "_lsprof.Profiler", - .basicsize = sizeof(ProfilerObject), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | - Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE), - .slots = _lsprof_profiler_type_spec_slots, + "_lsprof.Profiler", + sizeof(ProfilerObject), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | + Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE), + _lsprof_profiler_type_spec_slots }; static PyMethodDef moduleMethods[] = { @@ -895,14 +901,14 @@ static PyModuleDef_Slot _lsprofslots[] = { static struct PyModuleDef _lsprofmodule = { PyModuleDef_HEAD_INIT, - .m_name = "_lsprof", - .m_doc = "Fast profiler", - .m_size = sizeof(_lsprof_state), - .m_methods = moduleMethods, - .m_slots = _lsprofslots, - .m_traverse = _lsprof_traverse, - .m_clear = _lsprof_clear, - .m_free = _lsprof_free + "_lsprof", + "Fast profiler", + sizeof(_lsprof_state), + moduleMethods, + _lsprofslots, + _lsprof_traverse, + _lsprof_clear, + _lsprof_free }; PyMODINIT_FUNC diff --git a/Modules/_pickle.c b/Modules/_pickle.c index f0cb302..47ba9e5 100644 --- a/Modules/_pickle.c +++ b/Modules/_pickle.c @@ -761,7 +761,10 @@ PyMemoTable_New(void) static PyMemoTable * PyMemoTable_Copy(PyMemoTable *self) { - PyMemoTable *new = PyMemoTable_New(); + PyMemoTable *new; + size_t i; + + new = PyMemoTable_New(); if (new == NULL) return NULL; @@ -777,7 +780,7 @@ PyMemoTable_Copy(PyMemoTable *self) PyErr_NoMemory(); return NULL; } - for (size_t i = 0; i < self->mt_allocated; i++) { + for (i = 0; i < self->mt_allocated; i++) { Py_XINCREF(self->mt_table[i].me_key); } memcpy(new->mt_table, self->mt_table, @@ -911,6 +914,7 @@ static int PyMemoTable_Set(PyMemoTable *self, PyObject *key, Py_ssize_t value) { PyMemoEntry *entry; + size_t desired_size; assert(key != NULL); @@ -934,11 +938,11 @@ PyMemoTable_Set(PyMemoTable *self, PyObject *key, Py_ssize_t value) * Very large memo tables (over 50K items) use doubling instead. * This may help applications with severe memory constraints. */ - if (SIZE_MAX / 3 >= self->mt_used && self->mt_used * 3 < self->mt_allocated * 2) { + if (((size_t)-1) / 3 >= self->mt_used && self->mt_used * 3 < self->mt_allocated * 2) { return 0; } // self->mt_used is always < PY_SSIZE_T_MAX, so this can't overflow. - size_t desired_size = (self->mt_used > 50000 ? 2 : 4) * self->mt_used; + desired_size = (self->mt_used > 50000 ? 2 : 4) * self->mt_used; return _PyMemoTable_ResizeTable(self, desired_size); } @@ -1116,18 +1120,22 @@ _Pickler_Write(PicklerObject *self, const char *s, Py_ssize_t data_len) static PicklerObject * _Pickler_New(void) { - PyMemoTable *memo = PyMemoTable_New(); + PyMemoTable *memo; + const Py_ssize_t max_output_len = WRITE_BUF_SIZE; + PyObject *output_buffer; + PicklerObject *self; + + memo = PyMemoTable_New(); if (memo == NULL) { return NULL; } - const Py_ssize_t max_output_len = WRITE_BUF_SIZE; - PyObject *output_buffer = PyBytes_FromStringAndSize(NULL, max_output_len); + output_buffer = PyBytes_FromStringAndSize(NULL, max_output_len); if (output_buffer == NULL) { goto error; } - PicklerObject *self = PyObject_GC_New(PicklerObject, &Pickler_Type); + self = PyObject_GC_New(PicklerObject, &Pickler_Type); if (self == NULL) { goto error; } @@ -1377,12 +1385,20 @@ _Unpickler_ReadImpl(UnpicklerObject *self, char **s, Py_ssize_t n) static Py_ssize_t _Unpickler_ReadInto(UnpicklerObject *self, char *buf, Py_ssize_t n) { + Py_ssize_t in_buffer; + Py_ssize_t to_read; + PyObject *len; + PyObject *data; + PyObject *buf_obj; + PyObject *read_size_obj; + Py_ssize_t read_size; + assert(n != READ_WHOLE_LINE); /* Read from available buffer data, if any */ - Py_ssize_t in_buffer = self->input_len - self->next_read_idx; + in_buffer = self->input_len - self->next_read_idx; if (in_buffer > 0) { - Py_ssize_t to_read = Py_MIN(in_buffer, n); + to_read = Py_MIN(in_buffer, n); memcpy(buf, self->input_buffer + self->next_read_idx, to_read); self->next_read_idx += to_read; buf += to_read; @@ -1405,11 +1421,11 @@ _Unpickler_ReadInto(UnpicklerObject *self, char *buf, Py_ssize_t n) if (!self->readinto) { /* readinto() not supported on file-like object, fall back to read() * and copy into destination buffer (bpo-39681) */ - PyObject* len = PyLong_FromSsize_t(n); + len = PyLong_FromSsize_t(n); if (len == NULL) { return -1; } - PyObject* data = _Pickle_FastCall(self->read, len); + data = _Pickle_FastCall(self->read, len); if (data == NULL) { return -1; } @@ -1420,7 +1436,7 @@ _Unpickler_ReadInto(UnpicklerObject *self, char *buf, Py_ssize_t n) Py_DECREF(data); return -1; } - Py_ssize_t read_size = PyBytes_GET_SIZE(data); + read_size = PyBytes_GET_SIZE(data); if (read_size < n) { Py_DECREF(data); return bad_readline(); @@ -1431,15 +1447,15 @@ _Unpickler_ReadInto(UnpicklerObject *self, char *buf, Py_ssize_t n) } /* Call readinto() into user buffer */ - PyObject *buf_obj = PyMemoryView_FromMemory(buf, n, PyBUF_WRITE); + buf_obj = PyMemoryView_FromMemory(buf, n, PyBUF_WRITE); if (buf_obj == NULL) { return -1; } - PyObject *read_size_obj = _Pickle_FastCall(self->readinto, buf_obj); + read_size_obj = _Pickle_FastCall(self->readinto, buf_obj); if (read_size_obj == NULL) { return -1; } - Py_ssize_t read_size = PyLong_AsSsize_t(read_size_obj); + read_size = PyLong_AsSsize_t(read_size_obj); Py_DECREF(read_size_obj); if (read_size < 0) { @@ -1527,10 +1543,11 @@ static int _Unpickler_ResizeMemoList(UnpicklerObject *self, size_t new_size) { size_t i; + PyObject **memo_new; assert(new_size > self->memo_size); - PyObject **memo_new = self->memo; + memo_new = self->memo; PyMem_RESIZE(memo_new, PyObject *, new_size); if (memo_new == NULL) { PyErr_NoMemory(); @@ -1610,17 +1627,21 @@ static UnpicklerObject * _Unpickler_New(void) { const int MEMO_SIZE = 32; - PyObject **memo = _Unpickler_NewMemo(MEMO_SIZE); + PyObject **memo; + PyObject *stack; + UnpicklerObject *self; + + memo = _Unpickler_NewMemo(MEMO_SIZE); if (memo == NULL) { return NULL; } - PyObject *stack = Pdata_New(); + stack = Pdata_New(); if (stack == NULL) { goto error; } - UnpicklerObject *self = PyObject_GC_New(UnpicklerObject, &Unpickler_Type); + self = PyObject_GC_New(UnpicklerObject, &Unpickler_Type); if (self == NULL) { goto error; } @@ -1914,6 +1935,8 @@ static int _checkmodule(PyObject *module_name, PyObject *module, PyObject *global, PyObject *dotted_path) { + PyObject *candidate; + if (module == Py_None) { return -1; } @@ -1922,7 +1945,7 @@ _checkmodule(PyObject *module_name, PyObject *module, return -1; } - PyObject *candidate = get_deep_attribute(module, dotted_path, NULL); + candidate = get_deep_attribute(module, dotted_path, NULL); if (candidate == NULL) { return -1; } @@ -1940,6 +1963,7 @@ whichmodule(PyObject *global, PyObject *dotted_path) PyObject *module_name; PyObject *module = NULL; Py_ssize_t i; + PyThreadState *tstate; PyObject *modules; if (_PyObject_LookupAttr(global, &_Py_ID(__module__), &module_name) < 0) { @@ -1956,7 +1980,7 @@ whichmodule(PyObject *global, PyObject *dotted_path) assert(module_name == NULL); /* Fallback on walking sys.modules */ - PyThreadState *tstate = _PyThreadState_GET(); + tstate = _PyThreadState_GET(); modules = _PySys_GetAttr(tstate, &_Py_ID(modules)); if (modules == NULL) { PyErr_SetString(PyExc_RuntimeError, "unable to get sys.modules"); @@ -2018,6 +2042,8 @@ whichmodule(PyObject *global, PyObject *dotted_path) static int fast_save_enter(PicklerObject *self, PyObject *obj) { + int r; + /* if fast_nesting < 0, we're doing an error exit. */ if (++self->fast_nesting >= FAST_NESTING_LIMIT) { PyObject *key = NULL; @@ -2033,7 +2059,7 @@ fast_save_enter(PicklerObject *self, PyObject *obj) self->fast_nesting = -1; return 0; } - int r = PyDict_Contains(self->fast_memo, key); + r = PyDict_Contains(self->fast_memo, key); if (r > 0) { PyErr_Format(PyExc_ValueError, "fast mode: can't pickle cyclic objects " @@ -2381,11 +2407,11 @@ static int _save_bytes_data(PicklerObject *self, PyObject *obj, const char *data, Py_ssize_t size) { - assert(self->proto >= 3); - char header[9]; Py_ssize_t len; + assert(self->proto >= 3); + if (size < 0) return -1; @@ -2479,11 +2505,11 @@ static int _save_bytearray_data(PicklerObject *self, PyObject *obj, const char *data, Py_ssize_t size) { - assert(self->proto >= 5); - char header[9]; Py_ssize_t len; + assert(self->proto >= 5); + if (size < 0) return -1; @@ -2541,13 +2567,16 @@ save_bytearray(PicklerObject *self, PyObject *obj) static int save_picklebuffer(PicklerObject *self, PyObject *obj) { + const Py_buffer *view; + int in_band; + if (self->proto < 5) { PickleState *st = _Pickle_GetGlobalState(); PyErr_SetString(st->PicklingError, "PickleBuffer can only pickled with protocol >= 5"); return -1; } - const Py_buffer* view = PyPickleBuffer_GetBuffer(obj); + view = PyPickleBuffer_GetBuffer(obj); if (view == NULL) { return -1; } @@ -2558,7 +2587,7 @@ save_picklebuffer(PicklerObject *self, PyObject *obj) "pointing to a non-contiguous buffer"); return -1; } - int in_band = 1; + in_band = 1; if (self->buffer_callback != NULL) { PyObject *ret = PyObject_CallOneArg(self->buffer_callback, obj); if (ret == NULL) { @@ -3021,6 +3050,7 @@ batch_list_exact(PicklerObject *self, PyObject *obj) { PyObject *item = NULL; Py_ssize_t this_batch, total; + int err; const char append_op = APPEND; const char appends_op = APPENDS; @@ -3033,7 +3063,7 @@ batch_list_exact(PicklerObject *self, PyObject *obj) if (PyList_GET_SIZE(obj) == 1) { item = PyList_GET_ITEM(obj, 0); Py_INCREF(item); - int err = save(self, item, 0); + err = save(self, item, 0); Py_DECREF(item); if (err < 0) return -1; @@ -3051,7 +3081,7 @@ batch_list_exact(PicklerObject *self, PyObject *obj) while (total < PyList_GET_SIZE(obj)) { item = PyList_GET_ITEM(obj, total); Py_INCREF(item); - int err = save(self, item, 0); + err = save(self, item, 0); Py_DECREF(item); if (err < 0) return -1; @@ -3414,6 +3444,7 @@ save_set(PicklerObject *self, PyObject *obj) { PyObject *item; int i; + int err; Py_ssize_t set_size, ppos = 0; Py_hash_t hash; @@ -3458,7 +3489,7 @@ save_set(PicklerObject *self, PyObject *obj) return -1; while (_PySet_NextEntry(obj, &ppos, &item, &hash)) { Py_INCREF(item); - int err = save(self, item, 0); + err = save(self, item, 0); Py_CLEAR(item); if (err < 0) return -1; @@ -4685,13 +4716,15 @@ Pickler_dealloc(PicklerObject *self) static int Pickler_traverse(PicklerObject *self, visitproc visit, void *arg) { + PyMemoTable *memo; + Py_VISIT(self->write); Py_VISIT(self->pers_func); Py_VISIT(self->dispatch_table); Py_VISIT(self->fast_memo); Py_VISIT(self->reducer_override); Py_VISIT(self->buffer_callback); - PyMemoTable *memo = self->memo; + memo = self->memo; if (memo && memo->mt_table) { Py_ssize_t i = memo->mt_allocated; while (--i >= 0) { @@ -4855,11 +4888,12 @@ _pickle_PicklerMemoProxy_copy_impl(PicklerMemoProxyObject *self) { PyMemoTable *memo; PyObject *new_memo = PyDict_New(); + size_t i; if (new_memo == NULL) return NULL; memo = self->pickler->memo; - for (size_t i = 0; i < memo->mt_allocated; ++i) { + for (i = 0; i < memo->mt_allocated; ++i) { PyMemoEntry entry = memo->mt_table[i]; if (entry.me_key != NULL) { int status; @@ -5618,17 +5652,20 @@ load_counted_bytearray(UnpicklerObject *self) static int load_next_buffer(UnpicklerObject *self) { + PickleState *st; + PyObject *buf; + if (self->buffers == NULL) { - PickleState *st = _Pickle_GetGlobalState(); + st = _Pickle_GetGlobalState(); PyErr_SetString(st->UnpicklingError, "pickle stream refers to out-of-band data " "but no *buffers* argument was given"); return -1; } - PyObject *buf = PyIter_Next(self->buffers); + buf = PyIter_Next(self->buffers); if (buf == NULL) { if (!PyErr_Occurred()) { - PickleState *st = _Pickle_GetGlobalState(); + st = _Pickle_GetGlobalState(); PyErr_SetString(st->UnpicklingError, "not enough out-of-band buffers"); } @@ -5642,13 +5679,17 @@ load_next_buffer(UnpicklerObject *self) static int load_readonly_buffer(UnpicklerObject *self) { - Py_ssize_t len = Py_SIZE(self->stack); + Py_ssize_t len; + PyObject *obj; + PyObject *view; + + len = Py_SIZE(self->stack); if (len <= self->stack->fence) { return Pdata_stack_underflow(self->stack); } - PyObject *obj = self->stack->data[len - 1]; - PyObject *view = PyMemoryView_FromObject(obj); + obj = self->stack->data[len - 1]; + view = PyMemoryView_FromObject(obj); if (view == NULL) { return -1; } @@ -7215,6 +7256,8 @@ Unpickler_dealloc(UnpicklerObject *self) static int Unpickler_traverse(UnpicklerObject *self, visitproc visit, void *arg) { + PyObject **memo; + Py_VISIT(self->readline); Py_VISIT(self->readinto); Py_VISIT(self->read); @@ -7222,7 +7265,7 @@ Unpickler_traverse(UnpicklerObject *self, visitproc visit, void *arg) Py_VISIT(self->stack); Py_VISIT(self->pers_func); Py_VISIT(self->buffers); - PyObject **memo = self->memo; + memo = self->memo; if (memo) { Py_ssize_t i = self->memo_size; while (--i >= 0) { @@ -7527,6 +7570,7 @@ Unpickler_set_memo(UnpicklerObject *self, PyObject *obj, void *Py_UNUSED(ignored { PyObject **new_memo; size_t new_memo_size = 0; + size_t i; if (obj == NULL) { PyErr_SetString(PyExc_TypeError, @@ -7543,7 +7587,7 @@ Unpickler_set_memo(UnpicklerObject *self, PyObject *obj, void *Py_UNUSED(ignored if (new_memo == NULL) return -1; - for (size_t i = 0; i < new_memo_size; i++) { + for (i = 0; i < new_memo_size; i++) { Py_XINCREF(unpickler->memo[i]); new_memo[i] = unpickler->memo[i]; } @@ -7591,7 +7635,7 @@ Unpickler_set_memo(UnpicklerObject *self, PyObject *obj, void *Py_UNUSED(ignored error: if (new_memo_size) { - for (size_t i = new_memo_size - 1; i != SIZE_MAX; i--) { + for (i = new_memo_size; i-- > 0;) { Py_XDECREF(new_memo[i]); } PyMem_Free(new_memo); diff --git a/Modules/_randommodule.c b/Modules/_randommodule.c index d96c037..26bbb56 100644 --- a/Modules/_randommodule.c +++ b/Modules/_randommodule.c @@ -585,6 +585,8 @@ static int _random_exec(PyObject *module) { _randomstate *state = get_random_state(module); + PyObject *longval; + PyObject *longtype; state->Random_Type = PyType_FromModuleAndSpec( module, &Random_Type_spec, NULL); @@ -596,12 +598,12 @@ _random_exec(PyObject *module) } /* Look up and save int.__abs__, which is needed in random_seed(). */ - PyObject *longval = PyLong_FromLong(0); + longval = PyLong_FromLong(0); if (longval == NULL) { return -1; } - PyObject *longtype = PyObject_Type(longval); + longtype = PyObject_Type(longval); Py_DECREF(longval); if (longtype == NULL) { return -1; diff --git a/Modules/_sha3/sha3module.c b/Modules/_sha3/sha3module.c index bd1dd59..7abc300 100644 --- a/Modules/_sha3/sha3module.c +++ b/Modules/_sha3/sha3module.c @@ -176,11 +176,13 @@ py_sha3_new_impl(PyTypeObject *type, PyObject *data, int usedforsecurity) static void SHA3_dealloc(SHA3object *self) { + PyTypeObject *tp; + if (self->lock) { PyThread_free_lock(self->lock); } - PyTypeObject *tp = Py_TYPE(self); + tp = Py_TYPE(self); PyObject_Free(self); Py_DECREF(tp); } @@ -412,10 +414,11 @@ static PyGetSetDef SHA3_getseters[] = { // cannot be subclassed: it does not have the Py_TPFLAGS_BASETYPE flag. #define SHA3_TYPE_SPEC(type_spec_obj, type_name, type_slots) \ static PyType_Spec type_spec_obj = { \ - .name = "_sha3." type_name, \ - .basicsize = sizeof(SHA3object), \ - .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, \ - .slots = type_slots \ + "_sha3." type_name, \ + sizeof(SHA3object), \ + 0, \ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, \ + type_slots \ } PyDoc_STRVAR(sha3_224__doc__, @@ -646,12 +649,14 @@ static PyModuleDef_Slot _sha3_slots[] = { /* Initialize this module. */ static struct PyModuleDef _sha3module = { PyModuleDef_HEAD_INIT, - .m_name = "_sha3", - .m_size = sizeof(SHA3State), - .m_slots = _sha3_slots, - .m_traverse = _sha3_traverse, - .m_clear = _sha3_clear, - .m_free = _sha3_free, + "_sha3", + NULL, + sizeof(SHA3State), + NULL, + _sha3_slots, + _sha3_traverse, + _sha3_clear, + _sha3_free, }; diff --git a/Modules/_sre/sre.c b/Modules/_sre/sre.c index 3bad9d8..53c8ce0 100644 --- a/Modules/_sre/sre.c +++ b/Modules/_sre/sre.c @@ -1655,6 +1655,7 @@ _validate_inner(SRE_CODE *code, SRE_CODE *end, Py_ssize_t groups) SRE_CODE op; SRE_CODE arg; SRE_CODE skip; + int rc; VTRACE(("code=%p, end=%p\n", code, end)); @@ -1922,7 +1923,7 @@ _validate_inner(SRE_CODE *code, SRE_CODE *end, Py_ssize_t groups) for a JUMP opcode preceding our skip target. */ VTRACE(("then part:\n")); - int rc = _validate_inner(code+1, code+skip-1, groups); + rc = _validate_inner(code+1, code+skip-1, groups); if (rc == 1) { VTRACE(("else part:\n")); code += skip-2; /* Position after JUMP, at */ @@ -2822,12 +2823,12 @@ static PyType_Slot pattern_slots[] = { }; static PyType_Spec pattern_spec = { - .name = "re.Pattern", - .basicsize = sizeof(PatternObject), - .itemsize = sizeof(SRE_CODE), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | - Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC), - .slots = pattern_slots, + "re.Pattern", + sizeof(PatternObject), + sizeof(SRE_CODE), + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC), + pattern_slots, }; static PyMethodDef match_methods[] = { @@ -2890,12 +2891,12 @@ static PyType_Slot match_slots[] = { }; static PyType_Spec match_spec = { - .name = "re.Match", - .basicsize = sizeof(MatchObject), - .itemsize = sizeof(Py_ssize_t), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | - Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC), - .slots = match_slots, + "re.Match", + sizeof(MatchObject), + sizeof(Py_ssize_t), + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC), + match_slots, }; static PyMethodDef scanner_methods[] = { @@ -2920,11 +2921,12 @@ static PyType_Slot scanner_slots[] = { }; static PyType_Spec scanner_spec = { - .name = "_" SRE_MODULE ".SRE_Scanner", - .basicsize = sizeof(ScannerObject), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | - Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC), - .slots = scanner_slots, + "_" SRE_MODULE ".SRE_Scanner", + sizeof(ScannerObject), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC), + scanner_slots, }; static PyMethodDef _functions[] = { @@ -2978,9 +2980,10 @@ do { \ #define ADD_ULONG_CONSTANT(module, name, value) \ do { \ PyObject *o = PyLong_FromUnsignedLong(value); \ + int res; \ if (!o) \ goto error; \ - int res = PyModule_AddObjectRef(module, name, o); \ + res = PyModule_AddObjectRef(module, name, o); \ Py_DECREF(o); \ if (res < 0) { \ goto error; \ @@ -3025,14 +3028,15 @@ static PyModuleDef_Slot sre_slots[] = { }; static struct PyModuleDef sremodule = { - .m_base = PyModuleDef_HEAD_INIT, - .m_name = "_" SRE_MODULE, - .m_size = sizeof(_sremodulestate), - .m_methods = _functions, - .m_slots = sre_slots, - .m_traverse = sre_traverse, - .m_free = sre_free, - .m_clear = sre_clear, + PyModuleDef_HEAD_INIT, + "_" SRE_MODULE, + NULL, + sizeof(_sremodulestate), + _functions, + sre_slots, + sre_traverse, + sre_clear, + sre_free, }; PyMODINIT_FUNC diff --git a/Modules/_sre/sre_lib.h b/Modules/_sre/sre_lib.h index 95c1ada..e73bccf 100644 --- a/Modules/_sre/sre_lib.h +++ b/Modules/_sre/sre_lib.h @@ -560,6 +560,8 @@ LOCAL(Py_ssize_t) SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel) { const SRE_CHAR* end = (const SRE_CHAR *)state->end; + const SRE_CHAR *ptr; + SRE_REPEAT *repeat_of_tail; Py_ssize_t alloc_pos, ctx_pos = -1; Py_ssize_t ret = 0; int jump; @@ -583,7 +585,7 @@ SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel) entrance: ; // Fashion statement. - const SRE_CHAR *ptr = (SRE_CHAR *)state->ptr; + ptr = (SRE_CHAR *)state->ptr; if (pattern[0] == SRE_OP_INFO) { /* optimization info block */ @@ -1211,7 +1213,7 @@ SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel) MARK_PUSH(ctx->lastmark); DO_JUMP(JUMP_MIN_UNTIL_2, jump_min_until_2, pattern); - SRE_REPEAT *repeat_of_tail = state->repeat; + repeat_of_tail = state->repeat; state->repeat = ctx->u.rep; // restore repeat before return if (ret) { diff --git a/Modules/_stat.c b/Modules/_stat.c index 6e0d690..20f6e58 100644 --- a/Modules/_stat.c +++ b/Modules/_stat.c @@ -30,6 +30,19 @@ extern "C" { #include typedef unsigned short mode_t; +/* These constants are not present in the VC6 Windows headers. */ +#ifndef FILE_ATTRIBUTE_DEVICE +# define FILE_ATTRIBUTE_DEVICE 0x0040 +#endif + +#ifndef FILE_ATTRIBUTE_VIRTUAL +# define FILE_ATTRIBUTE_VIRTUAL 0x10000 +#endif + +#ifndef IO_REPARSE_TAG_SYMLINK +# define IO_REPARSE_TAG_SYMLINK 0xA000000CL +#endif + /* FILE_ATTRIBUTE_INTEGRITY_STREAM and FILE_ATTRIBUTE_NO_SCRUB_DATA are not present in VC2010, so define them manually */ #ifndef FILE_ATTRIBUTE_INTEGRITY_STREAM @@ -499,6 +512,20 @@ ST_CTIME\n\ static int stat_exec(PyObject *module) { + const char* st_constants[] = { + "ST_MODE", + "ST_INO", + "ST_DEV", + "ST_NLINK", + "ST_UID", + "ST_GID", + "ST_SIZE", + "ST_ATIME", + "ST_MTIME", + "ST_CTIME" + }; + int i; + #define ADD_INT_MACRO(module, macro) \ do { \ if (PyModule_AddIntConstant(module, #macro, macro) < 0) { \ @@ -554,20 +581,7 @@ stat_exec(PyObject *module) ADD_INT_MACRO(module, SF_NOUNLINK); ADD_INT_MACRO(module, SF_SNAPSHOT); - const char* st_constants[] = { - "ST_MODE", - "ST_INO", - "ST_DEV", - "ST_NLINK", - "ST_UID", - "ST_GID", - "ST_SIZE", - "ST_ATIME", - "ST_MTIME", - "ST_CTIME" - }; - - for (int i = 0; i < (int)Py_ARRAY_LENGTH(st_constants); i++) { + for (i = 0; i < (int)Py_ARRAY_LENGTH(st_constants); i++) { if (PyModule_AddIntConstant(module, st_constants[i], i) < 0) { return -1; } @@ -618,11 +632,14 @@ static PyModuleDef_Slot stat_slots[] = { static struct PyModuleDef statmodule = { PyModuleDef_HEAD_INIT, - .m_name = "_stat", - .m_doc = module_doc, - .m_size = 0, - .m_methods = stat_methods, - .m_slots = stat_slots, + "_stat", + module_doc, + 0, + stat_methods, + stat_slots, + NULL, + NULL, + NULL, }; diff --git a/Modules/_struct.c b/Modules/_struct.c index 9d66568..97921b1 100644 --- a/Modules/_struct.c +++ b/Modules/_struct.c @@ -14,6 +14,11 @@ #include "structmember.h" // PyMemberDef #include +#if defined(_MSC_VER) && _MSC_VER < 1300 +/* MSVC6 has no C99 _Bool; preserve the one-byte layout used by struct. */ +typedef unsigned char _Bool; +#endif + /*[clinic input] class Struct "PyStructObject *" "&PyStructType" [clinic start generated code]*/ @@ -95,8 +100,8 @@ typedef struct { char c; _Bool x; } st_bool; /* We can't support q and Q in native mode unless the compiler does; in std mode, they're 8 bytes on all platforms. */ -typedef struct { char c; long long x; } s_long_long; -#define LONG_LONG_ALIGN (sizeof(s_long_long) - sizeof(long long)) +typedef struct { char c; PY_LONG_LONG x; } s_long_long; +#define LONG_LONG_ALIGN (sizeof(s_long_long) - sizeof(PY_LONG_LONG)) #ifdef __powerc #pragma options align=reset @@ -203,9 +208,9 @@ get_ulong(_structmodulestate *state, PyObject *v, unsigned long *p) /* Same, but handling native long long. */ static int -get_longlong(_structmodulestate *state, PyObject *v, long long *p) +get_longlong(_structmodulestate *state, PyObject *v, PY_LONG_LONG *p) { - long long x; + PY_LONG_LONG x; v = get_pylong(state, v); if (v == NULL) @@ -213,7 +218,7 @@ get_longlong(_structmodulestate *state, PyObject *v, long long *p) assert(PyLong_Check(v)); x = PyLong_AsLongLong(v); Py_DECREF(v); - if (x == (long long)-1 && PyErr_Occurred()) { + if (x == (PY_LONG_LONG)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_SetString(state->StructError, "argument out of range"); @@ -226,9 +231,9 @@ get_longlong(_structmodulestate *state, PyObject *v, long long *p) /* Same, but handling native unsigned long long. */ static int -get_ulonglong(_structmodulestate *state, PyObject *v, unsigned long long *p) +get_ulonglong(_structmodulestate *state, PyObject *v, unsigned PY_LONG_LONG *p) { - unsigned long long x; + unsigned PY_LONG_LONG x; v = get_pylong(state, v); if (v == NULL) @@ -236,7 +241,7 @@ get_ulonglong(_structmodulestate *state, PyObject *v, unsigned long long *p) assert(PyLong_Check(v)); x = PyLong_AsUnsignedLongLong(v); Py_DECREF(v); - if (x == (unsigned long long)-1 && PyErr_Occurred()) { + if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_SetString(state->StructError, "argument out of range"); @@ -485,7 +490,7 @@ nu_size_t(_structmodulestate *state, const char *p, const formatdef *f) static PyObject * nu_longlong(_structmodulestate *state, const char *p, const formatdef *f) { - long long x; + PY_LONG_LONG x; memcpy((char *)&x, p, sizeof x); return PyLong_FromLongLong(x); } @@ -493,7 +498,7 @@ nu_longlong(_structmodulestate *state, const char *p, const formatdef *f) static PyObject * nu_ulonglong(_structmodulestate *state, const char *p, const formatdef *f) { - unsigned long long x; + unsigned PY_LONG_LONG x; memcpy((char *)&x, p, sizeof x); return PyLong_FromUnsignedLongLong(x); } @@ -694,7 +699,7 @@ np_size_t(_structmodulestate *state, char *p, PyObject *v, const formatdef *f) static int np_longlong(_structmodulestate *state, char *p, PyObject *v, const formatdef *f) { - long long x; + PY_LONG_LONG x; if (get_longlong(state, v, &x) < 0) return -1; memcpy(p, (char *)&x, sizeof x); @@ -704,7 +709,7 @@ np_longlong(_structmodulestate *state, char *p, PyObject *v, const formatdef *f) static int np_ulonglong(_structmodulestate *state, char *p, PyObject *v, const formatdef *f) { - unsigned long long x; + unsigned PY_LONG_LONG x; if (get_ulonglong(state, v, &x) < 0) return -1; memcpy(p, (char *)&x, sizeof x); @@ -793,8 +798,8 @@ static const formatdef native_table[] = { {'L', sizeof(long), LONG_ALIGN, nu_ulong, np_ulong}, {'n', sizeof(size_t), SIZE_T_ALIGN, nu_ssize_t, np_ssize_t}, {'N', sizeof(size_t), SIZE_T_ALIGN, nu_size_t, np_size_t}, - {'q', sizeof(long long), LONG_LONG_ALIGN, nu_longlong, np_longlong}, - {'Q', sizeof(long long), LONG_LONG_ALIGN, nu_ulonglong,np_ulonglong}, + {'q', sizeof(PY_LONG_LONG), LONG_LONG_ALIGN, nu_longlong, np_longlong}, + {'Q', sizeof(PY_LONG_LONG), LONG_LONG_ALIGN, nu_ulonglong,np_ulonglong}, {'?', sizeof(_Bool), BOOL_ALIGN, nu_bool, np_bool}, {'e', sizeof(short), SHORT_ALIGN, nu_halffloat, np_halffloat}, {'f', sizeof(float), FLOAT_ALIGN, nu_float, np_float}, @@ -835,7 +840,7 @@ bu_uint(_structmodulestate *state, const char *p, const formatdef *f) static PyObject * bu_longlong(_structmodulestate *state, const char *p, const formatdef *f) { - long long x = 0; + PY_LONG_LONG x = 0; Py_ssize_t i = f->size; const unsigned char *bytes = (const unsigned char *)p; do { @@ -843,14 +848,14 @@ bu_longlong(_structmodulestate *state, const char *p, const formatdef *f) } while (--i > 0); /* Extend the sign bit. */ if (SIZEOF_LONG_LONG > f->size) - x |= -(x & ((long long)1 << ((8 * f->size) - 1))); + x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1))); return PyLong_FromLongLong(x); } static PyObject * bu_ulonglong(_structmodulestate *state, const char *p, const formatdef *f) { - unsigned long long x = 0; + unsigned PY_LONG_LONG x = 0; Py_ssize_t i = f->size; const unsigned char *bytes = (const unsigned char *)p; do { @@ -1056,7 +1061,7 @@ lu_uint(_structmodulestate *state, const char *p, const formatdef *f) static PyObject * lu_longlong(_structmodulestate *state, const char *p, const formatdef *f) { - long long x = 0; + PY_LONG_LONG x = 0; Py_ssize_t i = f->size; const unsigned char *bytes = (const unsigned char *)p; do { @@ -1064,14 +1069,14 @@ lu_longlong(_structmodulestate *state, const char *p, const formatdef *f) } while (i > 0); /* Extend the sign bit. */ if (SIZEOF_LONG_LONG > f->size) - x |= -(x & ((long long)1 << ((8 * f->size) - 1))); + x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1))); return PyLong_FromLongLong(x); } static PyObject * lu_ulonglong(_structmodulestate *state, const char *p, const formatdef *f) { - unsigned long long x = 0; + unsigned PY_LONG_LONG x = 0; Py_ssize_t i = f->size; const unsigned char *bytes = (const unsigned char *)p; do { @@ -1437,9 +1442,10 @@ static PyObject * s_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *self; + allocfunc alloc_func; assert(type != NULL); - allocfunc alloc_func = PyType_GetSlot(type, Py_tp_alloc); + alloc_func = PyType_GetSlot(type, Py_tp_alloc); assert(alloc_func != NULL); self = alloc_func(type, 0); @@ -1514,7 +1520,10 @@ s_traverse(PyStructObject *s, visitproc visit, void *arg) static void s_dealloc(PyStructObject *s) { - PyTypeObject *tp = Py_TYPE(s); + PyTypeObject *tp; + freefunc free_func; + + tp = Py_TYPE(s); PyObject_GC_UnTrack(s); if (s->weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *)s); @@ -1522,7 +1531,7 @@ s_dealloc(PyStructObject *s) PyMem_Free(s->s_codes); } Py_XDECREF(s->s_format); - freefunc free_func = PyType_GetSlot(Py_TYPE(s), Py_tp_free); + free_func = PyType_GetSlot(Py_TYPE(s), Py_tp_free); free_func(s); Py_DECREF(tp); } @@ -1902,6 +1911,7 @@ s_pack(PyObject *self, PyObject *const *args, Py_ssize_t nargs) char *buf; PyStructObject *soself; _structmodulestate *state = get_struct_state_structinst(self); + _PyBytesWriter writer; /* Validate arguments. */ soself = (PyStructObject *)self; @@ -1915,7 +1925,6 @@ s_pack(PyObject *self, PyObject *const *args, Py_ssize_t nargs) } /* Allocate a new string */ - _PyBytesWriter writer; _PyBytesWriter_Init(&writer); buf = _PyBytesWriter_Alloc(&writer, soself->s_size); if (buf == NULL) { @@ -2472,14 +2481,14 @@ static PyModuleDef_Slot _structmodule_slots[] = { static struct PyModuleDef _structmodule = { PyModuleDef_HEAD_INIT, - .m_name = "_struct", - .m_doc = module_doc, - .m_size = sizeof(_structmodulestate), - .m_methods = module_functions, - .m_slots = _structmodule_slots, - .m_traverse = _structmodule_traverse, - .m_clear = _structmodule_clear, - .m_free = _structmodule_free, + "_struct", + module_doc, + sizeof(_structmodulestate), + module_functions, + _structmodule_slots, + _structmodule_traverse, + _structmodule_clear, + _structmodule_free, }; PyMODINIT_FUNC diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c index 7699b19..f05985a 100644 --- a/Modules/arraymodule.c +++ b/Modules/arraymodule.c @@ -258,18 +258,19 @@ static int u_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { PyObject *u; + Py_ssize_t len; + wchar_t w; if (!PyArg_Parse(v, "U;array item must be unicode character", &u)) { return -1; } - Py_ssize_t len = PyUnicode_AsWideChar(u, NULL, 0); + len = PyUnicode_AsWideChar(u, NULL, 0); if (len != 2) { PyErr_SetString(PyExc_TypeError, "array item must be unicode character"); return -1; } - wchar_t w; len = PyUnicode_AsWideChar(u, &w, 1); assert(len == 1); @@ -445,17 +446,17 @@ LL_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) static PyObject * q_getitem(arrayobject *ap, Py_ssize_t i) { - return PyLong_FromLongLong(((long long *)ap->ob_item)[i]); + return PyLong_FromLongLong(((PY_LONG_LONG *)ap->ob_item)[i]); } static int q_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { - long long x; + PY_LONG_LONG x; if (!PyArg_Parse(v, "L;array item must be integer", &x)) return -1; if (i >= 0) - ((long long *)ap->ob_item)[i] = x; + ((PY_LONG_LONG *)ap->ob_item)[i] = x; return 0; } @@ -463,13 +464,13 @@ static PyObject * QQ_getitem(arrayobject *ap, Py_ssize_t i) { return PyLong_FromUnsignedLongLong( - ((unsigned long long *)ap->ob_item)[i]); + ((unsigned PY_LONG_LONG *)ap->ob_item)[i]); } static int QQ_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { - unsigned long long x; + unsigned PY_LONG_LONG x; int do_decref = 0; /* if nb_int was called */ if (!PyLong_Check(v)) { @@ -480,14 +481,14 @@ QQ_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) do_decref = 1; } x = PyLong_AsUnsignedLongLong(v); - if (x == (unsigned long long)-1 && PyErr_Occurred()) { + if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) { if (do_decref) { Py_DECREF(v); } return -1; } if (i >= 0) - ((unsigned long long *)ap->ob_item)[i] = x; + ((unsigned PY_LONG_LONG *)ap->ob_item)[i] = x; if (do_decref) { Py_DECREF(v); @@ -534,7 +535,8 @@ d_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) code##_compareitems(const void *lhs, const void *rhs, Py_ssize_t length) \ { \ const type *a = lhs, *b = rhs; \ - for (Py_ssize_t i = 0; i < length; ++i) \ + Py_ssize_t i; \ + for (i = 0; i < length; ++i) \ if (a[i] != b[i]) \ return a[i] < b[i] ? -1 : 1; \ return 0; \ @@ -549,8 +551,8 @@ DEFINE_COMPAREITEMS(i, int) DEFINE_COMPAREITEMS(II, unsigned int) DEFINE_COMPAREITEMS(l, long) DEFINE_COMPAREITEMS(LL, unsigned long) -DEFINE_COMPAREITEMS(q, long long) -DEFINE_COMPAREITEMS(QQ, unsigned long long) +DEFINE_COMPAREITEMS(q, PY_LONG_LONG) +DEFINE_COMPAREITEMS(QQ, unsigned PY_LONG_LONG) /* Description of types. * @@ -567,8 +569,8 @@ static const struct arraydescr descriptors[] = { {'I', sizeof(int), II_getitem, II_setitem, II_compareitems, "I", 1, 0}, {'l', sizeof(long), l_getitem, l_setitem, l_compareitems, "l", 1, 1}, {'L', sizeof(long), LL_getitem, LL_setitem, LL_compareitems, "L", 1, 0}, - {'q', sizeof(long long), q_getitem, q_setitem, q_compareitems, "q", 1, 1}, - {'Q', sizeof(long long), QQ_getitem, QQ_setitem, QQ_compareitems, "Q", 1, 0}, + {'q', sizeof(PY_LONG_LONG), q_getitem, q_setitem, q_compareitems, "q", 1, 1}, + {'Q', sizeof(PY_LONG_LONG), QQ_getitem, QQ_setitem, QQ_compareitems, "Q", 1, 0}, {'f', sizeof(float), f_getitem, f_setitem, NULL, "f", 0, 0}, {'d', sizeof(double), d_getitem, d_setitem, NULL, "d", 0, 0}, {'\0', 0, 0, 0, 0, 0, 0} /* Sentinel */ @@ -623,11 +625,11 @@ newarrayobject(PyTypeObject *type, Py_ssize_t size, const struct arraydescr *des static PyObject * getarrayitem(PyObject *op, Py_ssize_t i) { + arrayobject *ap; #ifndef NDEBUG array_state *state = find_array_state_by_type(Py_TYPE(op)); assert(array_Check(op, state)); #endif - arrayobject *ap; ap = (arrayobject *)op; assert(i>=0 && iob_descr->getitem)(ap, i); @@ -693,8 +695,9 @@ array_richcompare(PyObject *v, PyObject *w, int op) arrayobject *va, *wa; PyObject *vi = NULL; PyObject *wi = NULL; - Py_ssize_t i, k; + Py_ssize_t i, k, vs, ws; PyObject *res; + int cmp; if (!array_Check(v, state) || !array_Check(w, state)) Py_RETURN_NOTIMPLEMENTED; @@ -721,7 +724,6 @@ array_richcompare(PyObject *v, PyObject *w, int op) if (result == 0) goto compare_sizes; - int cmp; switch (op) { case Py_LT: cmp = result < 0; break; case Py_LE: cmp = result <= 0; break; @@ -731,7 +733,7 @@ array_richcompare(PyObject *v, PyObject *w, int op) case Py_GE: cmp = result >= 0; break; default: return NULL; /* cannot happen */ } - PyObject *res = cmp ? Py_True : Py_False; + res = cmp ? Py_True : Py_False; Py_INCREF(res); return res; } @@ -761,9 +763,8 @@ array_richcompare(PyObject *v, PyObject *w, int op) if (k) { /* No more items to compare -- compare sizes */ compare_sizes: ; - Py_ssize_t vs = Py_SIZE(va); - Py_ssize_t ws = Py_SIZE(wa); - int cmp; + vs = Py_SIZE(va); + ws = Py_SIZE(wa); switch (op) { case Py_LT: cmp = vs < ws; break; case Py_LE: cmp = vs <= ws; break; @@ -913,22 +914,27 @@ static PyObject * array_repeat(arrayobject *a, Py_ssize_t n) { array_state *state = find_array_state_by_type(Py_TYPE(a)); + Py_ssize_t array_length; + Py_ssize_t size; + arrayobject *np; + Py_ssize_t oldbytes; + Py_ssize_t newbytes; if (n < 0) n = 0; - const Py_ssize_t array_length = Py_SIZE(a); + array_length = Py_SIZE(a); if ((array_length != 0) && (n > PY_SSIZE_T_MAX / array_length)) { return PyErr_NoMemory(); } - Py_ssize_t size = array_length * n; - arrayobject* np = (arrayobject *) newarrayobject(state->ArrayType, size, a->ob_descr); + size = array_length * n; + np = (arrayobject *) newarrayobject(state->ArrayType, size, a->ob_descr); if (np == NULL) return NULL; if (size == 0) return (PyObject *)np; - const Py_ssize_t oldbytes = array_length * a->ob_descr->itemsize; - const Py_ssize_t newbytes = oldbytes * n; + oldbytes = array_length * a->ob_descr->itemsize; + newbytes = oldbytes * n; _PyBytes_Repeat(np->ob_item, newbytes, a->ob_item, oldbytes); return (PyObject *)np; @@ -1069,6 +1075,7 @@ static PyObject * array_inplace_repeat(arrayobject *self, Py_ssize_t n) { const Py_ssize_t array_size = Py_SIZE(self); + Py_ssize_t size; if (array_size > 0 && n != 1 ) { if (n < 0) @@ -1077,7 +1084,7 @@ array_inplace_repeat(arrayobject *self, Py_ssize_t n) (array_size > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) { return PyErr_NoMemory(); } - Py_ssize_t size = array_size * self->ob_descr->itemsize; + size = array_size * self->ob_descr->itemsize; if (n > 0 && size > PY_SSIZE_T_MAX / n) { return PyErr_NoMemory(); } @@ -1151,6 +1158,8 @@ array_array_index_impl(arrayobject *self, PyObject *v, Py_ssize_t start, Py_ssize_t stop) /*[clinic end generated code: output=c45e777880c99f52 input=089dff7baa7e5a7e]*/ { + Py_ssize_t i; + if (start < 0) { start += Py_SIZE(self); if (start < 0) { @@ -1162,7 +1171,7 @@ array_array_index_impl(arrayobject *self, PyObject *v, Py_ssize_t start, } // Use Py_SIZE() for every iteration in case the array is mutated // during PyObject_RichCompareBool() - for (Py_ssize_t i = start; i < stop && i < Py_SIZE(self); i++) { + for (i = start; i < stop && i < Py_SIZE(self); i++) { PyObject *selfi; int cmp; @@ -1474,6 +1483,7 @@ array_array_fromfile_impl(arrayobject *self, PyTypeObject *cls, PyObject *f, Py_ssize_t itemsize = self->ob_descr->itemsize; Py_ssize_t nbytes; int not_enough_bytes; + array_state *state; if (n < 0) { PyErr_SetString(PyExc_ValueError, "negative count"); @@ -1485,7 +1495,7 @@ array_array_fromfile_impl(arrayobject *self, PyTypeObject *cls, PyObject *f, } - array_state *state = get_array_state_by_class(cls); + state = get_array_state_by_class(cls); assert(state != NULL); nbytes = n * itemsize; @@ -1538,12 +1548,13 @@ array_array_tofile_impl(arrayobject *self, PyTypeObject *cls, PyObject *f) int BLOCKSIZE = 64*1024; Py_ssize_t nblocks = (nbytes + BLOCKSIZE - 1) / BLOCKSIZE; Py_ssize_t i; + array_state *state; if (Py_SIZE(self) == 0) goto done; - array_state *state = get_array_state_by_class(cls); + state = get_array_state_by_class(cls); assert(state != NULL); for (i = 0; i < nblocks; i++) { @@ -1725,6 +1736,8 @@ static PyObject * array_array_fromunicode_impl(arrayobject *self, PyObject *ustr) /*[clinic end generated code: output=24359f5e001a7f2b input=025db1fdade7a4ce]*/ { + Py_ssize_t ustr_length; + if (self->ob_descr->typecode != 'u') { PyErr_SetString(PyExc_ValueError, "fromunicode() may only be called on " @@ -1732,11 +1745,13 @@ array_array_fromunicode_impl(arrayobject *self, PyObject *ustr) return NULL; } - Py_ssize_t ustr_length = PyUnicode_AsWideChar(ustr, NULL, 0); + ustr_length = PyUnicode_AsWideChar(ustr, NULL, 0); assert(ustr_length > 0); if (ustr_length > 1) { + Py_ssize_t old_size; + ustr_length--; /* trim trailing NUL character */ - Py_ssize_t old_size = Py_SIZE(self); + old_size = Py_SIZE(self); if (array_resize(self, old_size + ustr_length) == -1) { return NULL; } @@ -1893,11 +1908,11 @@ typecode_to_mformat_code(char typecode) is_signed = 0; break; case 'q': - intsize = sizeof(long long); + intsize = sizeof(PY_LONG_LONG); is_signed = 1; break; case 'Q': - intsize = sizeof(long long); + intsize = sizeof(PY_LONG_LONG); is_signed = 0; break; default: @@ -2788,8 +2803,8 @@ narrow builds this is 2-bytes on wide builds this is 4-bytes.\n\ NOTE: The 'q' and 'Q' type codes are only available if the platform\n\ C compiler used to build Python supports 'long long', or, on Windows,\n\ '__int64'.\n\ -\n\ -Methods:\n\ +\n" +"Methods:\n\ \n\ append() -- append a new item to the end of the array\n\ buffer_info() -- return information giving the current memory info\n\ @@ -2858,12 +2873,13 @@ static PyType_Slot array_slots[] = { }; static PyType_Spec array_spec = { - .name = "array.array", - .basicsize = sizeof(arrayobject), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | - Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC | - Py_TPFLAGS_SEQUENCE), - .slots = array_slots, + "array.array", + sizeof(arrayobject), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_SEQUENCE), + array_slots, }; /*********************** Array Iterator **************************/ @@ -2900,10 +2916,11 @@ static PyObject * arrayiter_next(arrayiterobject *it) { arrayobject *ao; + array_state *state; assert(it != NULL); #ifndef NDEBUG - array_state *state = find_array_state_by_type(Py_TYPE(it)); + state = find_array_state_by_type(Py_TYPE(it)); assert(PyObject_TypeCheck(it, state->ArrayIterType)); #endif ao = it->ao; @@ -2953,10 +2970,12 @@ static PyObject * array_arrayiterator___reduce___impl(arrayiterobject *self, PyTypeObject *cls) /*[clinic end generated code: output=4b032417a2c8f5e6 input=ac64e65a87ad452e]*/ { + array_state *state; + PyObject *func; - array_state *state = get_array_state_by_class(cls); + state = get_array_state_by_class(cls); assert(state != NULL); - PyObject *func = _PyEval_GetBuiltin(state->str_iter); + func = _PyEval_GetBuiltin(state->str_iter); if (self->ao == NULL) { return Py_BuildValue("N(())", func); } @@ -3004,11 +3023,12 @@ static PyType_Slot arrayiter_slots[] = { }; static PyType_Spec arrayiter_spec = { - .name = "array.arrayiterator", - .basicsize = sizeof(arrayiterobject), - .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | - Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE), - .slots = arrayiter_slots, + "array.arrayiterator", + sizeof(arrayiterobject), + 0, + (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE), + arrayiter_slots, }; @@ -3072,6 +3092,9 @@ array_modexec(PyObject *m) array_state *state = get_array_state(m); char buffer[Py_ARRAY_LENGTH(descriptors)], *p; PyObject *typecodes; + PyObject *abc_mod; + PyObject *mutablesequence; + PyObject *res; const struct arraydescr *descr; /* Add interned strings */ @@ -3091,18 +3114,18 @@ array_modexec(PyObject *m) return -1; } - PyObject *abc_mod = PyImport_ImportModule("collections.abc"); + abc_mod = PyImport_ImportModule("collections.abc"); if (!abc_mod) { Py_DECREF((PyObject *)state->ArrayType); return -1; } - PyObject *mutablesequence = PyObject_GetAttrString(abc_mod, "MutableSequence"); + mutablesequence = PyObject_GetAttrString(abc_mod, "MutableSequence"); Py_DECREF(abc_mod); if (!mutablesequence) { Py_DECREF((PyObject *)state->ArrayType); return -1; } - PyObject *res = PyObject_CallMethod(mutablesequence, "register", "O", + res = PyObject_CallMethod(mutablesequence, "register", "O", (PyObject *)state->ArrayType); Py_DECREF(mutablesequence); if (!res) { @@ -3135,15 +3158,15 @@ static PyModuleDef_Slot arrayslots[] = { static struct PyModuleDef arraymodule = { - .m_base = PyModuleDef_HEAD_INIT, - .m_name = "array", - .m_size = sizeof(array_state), - .m_doc = module_doc, - .m_methods = a_methods, - .m_slots = arrayslots, - .m_traverse = array_traverse, - .m_clear = array_clear, - .m_free = array_free, + PyModuleDef_HEAD_INIT, + "array", + module_doc, + sizeof(array_state), + a_methods, + arrayslots, + array_traverse, + array_clear, + array_free, }; diff --git a/Modules/atexitmodule.c b/Modules/atexitmodule.c index a1c511e..08a5a53 100644 --- a/Modules/atexitmodule.c +++ b/Modules/atexitmodule.c @@ -40,7 +40,8 @@ static void atexit_cleanup(struct atexit_state *state) { atexit_callback *cb; - for (int i = 0; i < state->ncallbacks; i++) { + int i; + for (i = 0; i < state->ncallbacks; i++) { cb = state->callbacks[i]; if (cb == NULL) continue; @@ -81,21 +82,24 @@ _PyAtExit_Fini(PyInterpreterState *interp) static void atexit_callfuncs(struct atexit_state *state) { + int i; + PyObject *the_func; + PyObject *res; assert(!PyErr_Occurred()); if (state->ncallbacks == 0) { return; } - for (int i = state->ncallbacks - 1; i >= 0; i--) { + for (i = state->ncallbacks - 1; i >= 0; i--) { atexit_callback *cb = state->callbacks[i]; if (cb == NULL) { continue; } // bpo-46025: Increment the refcount of cb->func as the call itself may unregister it - PyObject* the_func = Py_NewRef(cb->func); - PyObject *res = PyObject_Call(cb->func, cb->args, cb->kwargs); + the_func = Py_NewRef(cb->func); + res = PyObject_Call(cb->func, cb->args, cb->kwargs); if (res == NULL) { _PyErr_WriteUnraisableMsg("in atexit callback", the_func); } @@ -137,24 +141,29 @@ Register a function to be executed upon normal program termination\n\ static PyObject * atexit_register(PyObject *module, PyObject *args, PyObject *kwargs) { + PyObject *func; + struct atexit_state *state; + atexit_callback **r; + size_t size; + atexit_callback *callback; + if (PyTuple_GET_SIZE(args) == 0) { PyErr_SetString(PyExc_TypeError, "register() takes at least 1 argument (0 given)"); return NULL; } - PyObject *func = PyTuple_GET_ITEM(args, 0); + func = PyTuple_GET_ITEM(args, 0); if (!PyCallable_Check(func)) { PyErr_SetString(PyExc_TypeError, "the first argument must be callable"); return NULL; } - struct atexit_state *state = get_atexit_state(); + state = get_atexit_state(); if (state->ncallbacks >= state->callback_len) { - atexit_callback **r; state->callback_len += 16; - size_t size = sizeof(atexit_callback*) * (size_t)state->callback_len; + size = sizeof(atexit_callback*) * (size_t)state->callback_len; r = (atexit_callback**)PyMem_Realloc(state->callbacks, size); if (r == NULL) { return PyErr_NoMemory(); @@ -162,7 +171,7 @@ atexit_register(PyObject *module, PyObject *args, PyObject *kwargs) state->callbacks = r; } - atexit_callback *callback = PyMem_Malloc(sizeof(atexit_callback)); + callback = PyMem_Malloc(sizeof(atexit_callback)); if (callback == NULL) { return PyErr_NoMemory(); } @@ -231,14 +240,18 @@ static PyObject * atexit_unregister(PyObject *module, PyObject *func) { struct atexit_state *state = get_atexit_state(); - for (int i = 0; i < state->ncallbacks; i++) + int i; + atexit_callback *cb; + int eq; + + for (i = 0; i < state->ncallbacks; i++) { - atexit_callback *cb = state->callbacks[i]; + cb = state->callbacks[i]; if (cb == NULL) { continue; } - int eq = PyObject_RichCompareBool(cb->func, func, Py_EQ); + eq = PyObject_RichCompareBool(cb->func, func, Py_EQ); if (eq < 0) { return NULL; } @@ -277,10 +290,10 @@ Two public functions, register and unregister, are defined.\n\ static struct PyModuleDef atexitmodule = { PyModuleDef_HEAD_INIT, - .m_name = "atexit", - .m_doc = atexit__doc__, - .m_size = 0, - .m_methods = atexit_methods, + "atexit", + atexit__doc__, + 0, + atexit_methods, }; PyMODINIT_FUNC diff --git a/Modules/audioop.c b/Modules/audioop.c index 88bb4c1..73bee0d 100644 --- a/Modules/audioop.c +++ b/Modules/audioop.c @@ -1372,7 +1372,7 @@ audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width, weightA /= d; weightB /= d; - if ((size_t)nchannels > SIZE_MAX/sizeof(int)) { + if ((size_t)nchannels > ((size_t)-1)/sizeof(int)) { PyErr_SetString(PyExc_MemoryError, "not enough memory for output buffer"); return NULL; diff --git a/Modules/binascii.c b/Modules/binascii.c index de3c2d8..d1dfc0d 100644 --- a/Modules/binascii.c +++ b/Modules/binascii.c @@ -388,21 +388,34 @@ static PyObject * binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode) /*[clinic end generated code: output=5409557788d4f975 input=3a30c4e3528317c6]*/ { + const unsigned char *ascii_data; + size_t ascii_len; + binascii_state *state; + char padding_started; + Py_ssize_t bin_len; + _PyBytesWriter writer; + unsigned char *bin_data; + unsigned char *bin_data_start; + int quad_pos; + unsigned char leftchar; + int pads; + size_t i; + unsigned char this_ch; + assert(data->len >= 0); - const unsigned char *ascii_data = data->buf; - size_t ascii_len = data->len; - binascii_state *state = NULL; - char padding_started = 0; + ascii_data = data->buf; + ascii_len = data->len; + state = NULL; + padding_started = 0; /* Allocate the buffer */ - Py_ssize_t bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */ - _PyBytesWriter writer; + bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */ _PyBytesWriter_Init(&writer); - unsigned char *bin_data = _PyBytesWriter_Alloc(&writer, bin_len); + bin_data = _PyBytesWriter_Alloc(&writer, bin_len); if (bin_data == NULL) return NULL; - unsigned char *bin_data_start = bin_data; + bin_data_start = bin_data; if (strict_mode && ascii_len > 0 && ascii_data[0] == '=') { state = get_binascii_state(module); @@ -412,11 +425,11 @@ binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode) goto error_end; } - int quad_pos = 0; - unsigned char leftchar = 0; - int pads = 0; - for (size_t i = 0; i < ascii_len; i++) { - unsigned char this_ch = ascii_data[i]; + quad_pos = 0; + leftchar = 0; + pads = 0; + for (i = 0; i < ascii_len; i++) { + this_ch = ascii_data[i]; /* Check for pad sequences and ignore ** the invalid ones. diff --git a/Modules/clinic/_codecsmodule.c.h b/Modules/clinic/_codecsmodule.c.h index 29e9d5e..7bc9c5c 100644 --- a/Modules/clinic/_codecsmodule.c.h +++ b/Modules/clinic/_codecsmodule.c.h @@ -43,12 +43,12 @@ _codecs_lookup(PyObject *module, PyObject *arg) { PyObject *return_value = NULL; const char *encoding; + Py_ssize_t encoding_length; if (!PyUnicode_Check(arg)) { _PyArg_BadArgument("lookup", "argument", "str", arg); goto exit; } - Py_ssize_t encoding_length; encoding = PyUnicode_AsUTF8AndSize(arg, &encoding_length); if (encoding == NULL) { goto exit; @@ -93,6 +93,8 @@ _codecs_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje PyObject *obj; const char *encoding = NULL; const char *errors = NULL; + Py_ssize_t encoding_length; + Py_ssize_t errors_length; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); if (!args) { @@ -107,7 +109,6 @@ _codecs_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje _PyArg_BadArgument("encode", "argument 'encoding'", "str", args[1]); goto exit; } - Py_ssize_t encoding_length; encoding = PyUnicode_AsUTF8AndSize(args[1], &encoding_length); if (encoding == NULL) { goto exit; @@ -124,7 +125,6 @@ _codecs_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje _PyArg_BadArgument("encode", "argument 'errors'", "str", args[2]); goto exit; } - Py_ssize_t errors_length; errors = PyUnicode_AsUTF8AndSize(args[2], &errors_length); if (errors == NULL) { goto exit; @@ -170,6 +170,8 @@ _codecs_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje PyObject *obj; const char *encoding = NULL; const char *errors = NULL; + Py_ssize_t encoding_length; + Py_ssize_t errors_length; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); if (!args) { @@ -184,7 +186,6 @@ _codecs_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje _PyArg_BadArgument("decode", "argument 'encoding'", "str", args[1]); goto exit; } - Py_ssize_t encoding_length; encoding = PyUnicode_AsUTF8AndSize(args[1], &encoding_length); if (encoding == NULL) { goto exit; @@ -201,7 +202,6 @@ _codecs_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje _PyArg_BadArgument("decode", "argument 'errors'", "str", args[2]); goto exit; } - Py_ssize_t errors_length; errors = PyUnicode_AsUTF8AndSize(args[2], &errors_length); if (errors == NULL) { goto exit; @@ -2730,6 +2730,7 @@ _codecs_register_error(PyObject *module, PyObject *const *args, Py_ssize_t nargs PyObject *return_value = NULL; const char *errors; PyObject *handler; + Py_ssize_t errors_length; if (!_PyArg_CheckPositional("register_error", nargs, 2, 2)) { goto exit; @@ -2738,7 +2739,6 @@ _codecs_register_error(PyObject *module, PyObject *const *args, Py_ssize_t nargs _PyArg_BadArgument("register_error", "argument 1", "str", args[0]); goto exit; } - Py_ssize_t errors_length; errors = PyUnicode_AsUTF8AndSize(args[0], &errors_length); if (errors == NULL) { goto exit; @@ -2774,12 +2774,12 @@ _codecs_lookup_error(PyObject *module, PyObject *arg) { PyObject *return_value = NULL; const char *name; + Py_ssize_t name_length; if (!PyUnicode_Check(arg)) { _PyArg_BadArgument("lookup_error", "argument", "str", arg); goto exit; } - Py_ssize_t name_length; name = PyUnicode_AsUTF8AndSize(arg, &name_length); if (name == NULL) { goto exit; diff --git a/Modules/clinic/_pickle.c.h b/Modules/clinic/_pickle.c.h index 5dc62fe..7f4e83f 100644 --- a/Modules/clinic/_pickle.c.h +++ b/Modules/clinic/_pickle.c.h @@ -336,6 +336,8 @@ _pickle_Unpickler___init__(PyObject *self, PyObject *args, PyObject *kwargs) int fix_imports = 1; const char *encoding = "ASCII"; const char *errors = "strict"; + Py_ssize_t encoding_length; + Py_ssize_t errors_length; PyObject *buffers = NULL; fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf); @@ -360,7 +362,6 @@ _pickle_Unpickler___init__(PyObject *self, PyObject *args, PyObject *kwargs) _PyArg_BadArgument("Unpickler", "argument 'encoding'", "str", fastargs[2]); goto exit; } - Py_ssize_t encoding_length; encoding = PyUnicode_AsUTF8AndSize(fastargs[2], &encoding_length); if (encoding == NULL) { goto exit; @@ -378,7 +379,6 @@ _pickle_Unpickler___init__(PyObject *self, PyObject *args, PyObject *kwargs) _PyArg_BadArgument("Unpickler", "argument 'errors'", "str", fastargs[3]); goto exit; } - Py_ssize_t errors_length; errors = PyUnicode_AsUTF8AndSize(fastargs[3], &errors_length); if (errors == NULL) { goto exit; @@ -671,6 +671,8 @@ _pickle_load(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject int fix_imports = 1; const char *encoding = "ASCII"; const char *errors = "strict"; + Py_ssize_t encoding_length; + Py_ssize_t errors_length; PyObject *buffers = NULL; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf); @@ -695,7 +697,6 @@ _pickle_load(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject _PyArg_BadArgument("load", "argument 'encoding'", "str", args[2]); goto exit; } - Py_ssize_t encoding_length; encoding = PyUnicode_AsUTF8AndSize(args[2], &encoding_length); if (encoding == NULL) { goto exit; @@ -713,7 +714,6 @@ _pickle_load(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject _PyArg_BadArgument("load", "argument 'errors'", "str", args[3]); goto exit; } - Py_ssize_t errors_length; errors = PyUnicode_AsUTF8AndSize(args[3], &errors_length); if (errors == NULL) { goto exit; @@ -774,6 +774,8 @@ _pickle_loads(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec int fix_imports = 1; const char *encoding = "ASCII"; const char *errors = "strict"; + Py_ssize_t encoding_length; + Py_ssize_t errors_length; PyObject *buffers = NULL; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf); @@ -798,7 +800,6 @@ _pickle_loads(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec _PyArg_BadArgument("loads", "argument 'encoding'", "str", args[2]); goto exit; } - Py_ssize_t encoding_length; encoding = PyUnicode_AsUTF8AndSize(args[2], &encoding_length); if (encoding == NULL) { goto exit; @@ -816,7 +817,6 @@ _pickle_loads(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec _PyArg_BadArgument("loads", "argument 'errors'", "str", args[3]); goto exit; } - Py_ssize_t errors_length; errors = PyUnicode_AsUTF8AndSize(args[3], &errors_length); if (errors == NULL) { goto exit; diff --git a/Modules/cmathmodule.c b/Modules/cmathmodule.c index 7fffb31..51f5782 100644 --- a/Modules/cmathmodule.c +++ b/Modules/cmathmodule.c @@ -1414,11 +1414,11 @@ static PyModuleDef_Slot cmath_slots[] = { static struct PyModuleDef cmathmodule = { PyModuleDef_HEAD_INIT, - .m_name = "cmath", - .m_doc = module_doc, - .m_size = 0, - .m_methods = cmath_methods, - .m_slots = cmath_slots + "cmath", + module_doc, + 0, + cmath_methods, + cmath_slots }; PyMODINIT_FUNC diff --git a/Modules/errnomodule.c b/Modules/errnomodule.c index a63ac72..9a065af 100644 --- a/Modules/errnomodule.c +++ b/Modules/errnomodule.c @@ -49,18 +49,22 @@ static PyMethodDef errno_methods[] = { static int _add_errcode(PyObject *module_dict, PyObject *error_dict, const char *name_str, int code_int) { - PyObject *name = PyUnicode_FromString(name_str); + PyObject *name; + PyObject *code; + int ret; + + name = PyUnicode_FromString(name_str); if (!name) { return -1; } - PyObject *code = PyLong_FromLong(code_int); + code = PyLong_FromLong(code_int); if (!code) { Py_DECREF(name); return -1; } - int ret = -1; + ret = -1; /* insert in modules dict */ if (PyDict_SetItem(module_dict, name, code) < 0) { goto end; @@ -79,11 +83,14 @@ _add_errcode(PyObject *module_dict, PyObject *error_dict, const char *name_str, static int errno_exec(PyObject *module) { - PyObject *module_dict = PyModule_GetDict(module); // Borrowed ref. + PyObject *module_dict; + PyObject *error_dict; + + module_dict = PyModule_GetDict(module); // Borrowed ref. if (module_dict == NULL) { return -1; } - PyObject *error_dict = PyDict_New(); + error_dict = PyDict_New(); if (error_dict == NULL) { return -1; } @@ -960,11 +967,14 @@ e.g. os.strerror(2) could return 'No such file or directory'."); static struct PyModuleDef errnomodule = { PyModuleDef_HEAD_INIT, - .m_name = "errno", - .m_doc = errno__doc__, - .m_size = 0, - .m_methods = errno_methods, - .m_slots = errno_slots, + "errno", + errno__doc__, + 0, + errno_methods, + errno_slots, + NULL, + NULL, + NULL }; PyMODINIT_FUNC diff --git a/Modules/faulthandler.c b/Modules/faulthandler.c index 520b7b6..67d9fc1 100644 --- a/Modules/faulthandler.c +++ b/Modules/faulthandler.c @@ -231,6 +231,7 @@ faulthandler_dump_traceback(int fd, int all_threads, PyInterpreterState *interp) { static volatile int reentrant = 0; + PyThreadState *tstate; if (reentrant) return; @@ -245,7 +246,7 @@ faulthandler_dump_traceback(int fd, int all_threads, fault if the thread released the GIL, and so this function cannot be used. Read the thread specific storage (TSS) instead: call PyGILState_GetThisThreadState(). */ - PyThreadState *tstate = PyGILState_GetThisThreadState(); + tstate = PyGILState_GetThisThreadState(); if (all_threads) { (void)_Py_DumpTracebackThreads(fd, NULL, tstate); @@ -406,8 +407,13 @@ static LONG WINAPI faulthandler_exc_handler(struct _EXCEPTION_POINTERS *exc_info) { const int fd = fatal_error.fd; - DWORD code = exc_info->ExceptionRecord->ExceptionCode; - DWORD flags = exc_info->ExceptionRecord->ExceptionFlags; + DWORD code; + DWORD flags; + size_t i; + fault_handler_t *handler; + + code = exc_info->ExceptionRecord->ExceptionCode; + flags = exc_info->ExceptionRecord->ExceptionFlags; if (faulthandler_ignore_exception(code)) { /* ignore the exception: call the next exception handler */ @@ -433,8 +439,8 @@ faulthandler_exc_handler(struct _EXCEPTION_POINTERS *exc_info) if (code == EXCEPTION_ACCESS_VIOLATION) { /* disable signal handler for SIGSEGV */ - for (size_t i=0; i < faulthandler_nsignals; i++) { - fault_handler_t *handler = &faulthandler_handlers[i]; + for (i = 0; i < faulthandler_nsignals; i++) { + handler = &faulthandler_handlers[i]; if (handler->signum == SIGSEGV) { faulthandler_disable_fatal_handler(handler); break; @@ -455,6 +461,8 @@ faulthandler_exc_handler(struct _EXCEPTION_POINTERS *exc_info) static int faulthandler_allocate_stack(void) { + int err; + if (stack.ss_sp != NULL) { return 0; } @@ -466,7 +474,7 @@ faulthandler_allocate_stack(void) return -1; } - int err = sigaltstack(&stack, &old_stack); + err = sigaltstack(&stack, &old_stack); if (err) { PyErr_SetFromErrno(PyExc_OSError); /* Release the stack to retry sigaltstack() next time */ @@ -484,6 +492,10 @@ faulthandler_allocate_stack(void) static int faulthandler_enable(void) { + size_t i; + fault_handler_t *handler; + int err; + if (fatal_error.enabled) { return 0; } @@ -495,10 +507,7 @@ faulthandler_enable(void) } #endif - for (size_t i=0; i < faulthandler_nsignals; i++) { - fault_handler_t *handler; - int err; - + for (i = 0; i < faulthandler_nsignals; i++) { handler = &faulthandler_handlers[i]; assert(!handler->enabled); #ifdef HAVE_SIGACTION @@ -572,10 +581,12 @@ faulthandler_py_enable(PyObject *self, PyObject *args, PyObject *kwargs) static void faulthandler_disable(void) { + size_t i; + fault_handler_t *handler; + if (fatal_error.enabled) { fatal_error.enabled = 0; - for (size_t i=0; i < faulthandler_nsignals; i++) { - fault_handler_t *handler; + for (i = 0; i < faulthandler_nsignals; i++) { handler = &faulthandler_handlers[i]; faulthandler_disable_fatal_handler(handler); } @@ -1027,8 +1038,10 @@ faulthandler_suppress_crash_report(void) #ifdef _MSC_VER /* Visual Studio: configure abort() to not display an error message nor open a popup asking to report the fault. */ +#if defined(_WRITE_ABORT_MSG) && defined(_CALL_REPORTFAULT) _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); #endif +#endif } static PyObject* _Py_NO_SANITIZE_UNDEFINED @@ -1087,7 +1100,7 @@ faulthandler_sigsegv(PyObject *self, PyObject *args) static void _Py_NO_RETURN faulthandler_fatal_error_thread(void *plock) { - Py_FatalError("in new thread"); + _Py_FatalErrorFunc("faulthandler_fatal_error_thread", "in new thread"); } static PyObject * @@ -1123,11 +1136,16 @@ faulthandler_fatal_error_c_thread(PyObject *self, PyObject *args) static PyObject* _Py_NO_SANITIZE_UNDEFINED faulthandler_sigfpe(PyObject *self, PyObject *args) { + volatile int x; + volatile int y; + volatile int z; + faulthandler_suppress_crash_report(); /* Do an integer division by zero: raise a SIGFPE on Intel CPU, but not on PowerPC. Use volatile to disable compile-time optimizations. */ - volatile int x = 1, y = 0, z; + x = 1; + y = 0; z = x / y; /* If the division by zero didn't raise a SIGFPE (e.g. on PowerPC), @@ -1332,11 +1350,14 @@ static PyModuleDef_Slot faulthandler_slots[] = { static struct PyModuleDef module_def = { PyModuleDef_HEAD_INIT, - .m_name = "faulthandler", - .m_doc = module_doc, - .m_methods = module_methods, - .m_traverse = faulthandler_traverse, - .m_slots = faulthandler_slots + "faulthandler", + module_doc, + -1, + module_methods, + faulthandler_slots, + faulthandler_traverse, + NULL, + NULL }; PyMODINIT_FUNC @@ -1348,12 +1369,15 @@ PyInit_faulthandler(void) static int faulthandler_init_enable(void) { - PyObject *module = PyImport_ImportModule("faulthandler"); + PyObject *module; + PyObject *res; + + module = PyImport_ImportModule("faulthandler"); if (module == NULL) { return -1; } - PyObject *res = PyObject_CallMethodNoArgs(module, &_Py_ID(enable)); + res = PyObject_CallMethodNoArgs(module, &_Py_ID(enable)); Py_DECREF(module); if (res == NULL) { return -1; diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c index 347ded8..082ee66 100644 --- a/Modules/gcmodule.c +++ b/Modules/gcmodule.c @@ -139,13 +139,14 @@ get_gc_state(void) void _PyGC_InitState(GCState *gcstate) { + int i; #define INIT_HEAD(GEN) \ do { \ GEN.head._gc_next = (uintptr_t)&GEN.head; \ GEN.head._gc_prev = (uintptr_t)&GEN.head; \ } while (0) - for (int i = 0; i < NUM_GENERATIONS; i++) { + for (i = 0; i < NUM_GENERATIONS; i++) { assert(gcstate->generations[i].count == 0); INIT_HEAD(gcstate->generations[i]); }; @@ -278,6 +279,7 @@ gc_list_remove(PyGC_Head *node) static void gc_list_move(PyGC_Head *node, PyGC_Head *list) { + PyGC_Head *to_prev; /* Unlink from current list. */ PyGC_Head *from_prev = GC_PREV(node); PyGC_Head *from_next = GC_NEXT(node); @@ -286,7 +288,7 @@ gc_list_move(PyGC_Head *node, PyGC_Head *list) /* Relink at end of new list. */ // list must not have flags. So we can skip macros. - PyGC_Head *to_prev = (PyGC_Head*)list->_gc_prev; + to_prev = (PyGC_Head*)list->_gc_prev; _PyGCHead_SET_PREV(node, to_prev); _PyGCHead_SET_NEXT(to_prev, node); list->_gc_prev = (uintptr_t)node; @@ -485,12 +487,16 @@ subtract_refs(PyGC_Head *containers) static int visit_reachable(PyObject *op, PyGC_Head *reachable) { + PyGC_Head *gc; + PyGC_Head *prev; + PyGC_Head *next; + Py_ssize_t gc_refs; if (!_PyObject_IS_GC(op)) { return 0; } - PyGC_Head *gc = AS_GC(op); - const Py_ssize_t gc_refs = gc_get_refs(gc); + gc = AS_GC(op); + gc_refs = gc_get_refs(gc); // Ignore objects in other generation. // This also skips objects "to the left" of the current position in @@ -512,8 +518,8 @@ visit_reachable(PyObject *op, PyGC_Head *reachable) */ // Manually unlink gc from unreachable list because the list functions // don't work right in the presence of NEXT_MASK_UNREACHABLE flags. - PyGC_Head *prev = GC_PREV(gc); - PyGC_Head *next = (PyGC_Head*)(gc->_gc_next & ~NEXT_MASK_UNREACHABLE); + prev = GC_PREV(gc); + next = (PyGC_Head*)(gc->_gc_next & ~NEXT_MASK_UNREACHABLE); _PyObject_ASSERT(FROM_GC(prev), prev->_gc_next & NEXT_MASK_UNREACHABLE); _PyObject_ASSERT(FROM_GC(next), @@ -557,6 +563,9 @@ visit_reachable(PyObject *op, PyGC_Head *reachable) static void move_unreachable(PyGC_Head *young, PyGC_Head *unreachable) { + PyObject *op; + traverseproc traverse; + PyGC_Head *last; // previous elem in the young list, used for restore gc_prev. PyGC_Head *prev = young; PyGC_Head *gc = GC_NEXT(young); @@ -580,8 +589,8 @@ move_unreachable(PyGC_Head *young, PyGC_Head *unreachable) * so we have to wait until it returns to determine * the next object to visit. */ - PyObject *op = FROM_GC(gc); - traverseproc traverse = Py_TYPE(op)->tp_traverse; + op = FROM_GC(gc); + traverse = Py_TYPE(op)->tp_traverse; _PyObject_ASSERT_WITH_MSG(op, gc_get_refs(gc) > 0, "refcount is too small"); // NOTE: visit_reachable may change gc->_gc_next when @@ -609,7 +618,7 @@ move_unreachable(PyGC_Head *young, PyGC_Head *unreachable) // We can't use gc_list_append() here because we use // NEXT_MASK_UNREACHABLE here. - PyGC_Head *last = GC_PREV(unreachable); + last = GC_PREV(unreachable); // NOTE: Since all objects in unreachable set has // NEXT_MASK_UNREACHABLE flag, we set it unconditionally. // But this may pollute the unreachable list head's 'next' pointer @@ -695,10 +704,10 @@ move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers) static inline void clear_unreachable_mask(PyGC_Head *unreachable) { + PyGC_Head *gc, *next; /* Check that the list head does not have the unreachable bit set */ assert(((uintptr_t)unreachable & NEXT_MASK_UNREACHABLE) == 0); - PyGC_Head *gc, *next; assert((unreachable->_gc_next & NEXT_MASK_UNREACHABLE) == 0); for (gc = GC_NEXT(unreachable); gc != unreachable; gc = next) { _PyObject_ASSERT((PyObject*)FROM_GC(gc), gc->_gc_next & NEXT_MASK_UNREACHABLE); @@ -929,12 +938,14 @@ handle_legacy_finalizers(PyThreadState *tstate, GCState *gcstate, PyGC_Head *finalizers, PyGC_Head *old) { + PyGC_Head *gc; + PyObject *op; assert(!_PyErr_Occurred(tstate)); assert(gcstate->garbage != NULL); - PyGC_Head *gc = GC_NEXT(finalizers); + gc = GC_NEXT(finalizers); for (; gc != finalizers; gc = GC_NEXT(gc)) { - PyObject *op = FROM_GC(gc); + op = FROM_GC(gc); if ((gcstate->debug & DEBUG_SAVEALL) || has_legacy_finalizer(op)) { if (PyList_Append(gcstate->garbage, op) < 0) { @@ -1046,10 +1057,11 @@ clear_freelists(PyInterpreterState *interp) static void show_stats_each_generations(GCState *gcstate) { + int i; char buf[100]; size_t pos = 0; - for (int i = 0; i < NUM_GENERATIONS && pos < sizeof(buf); i++) { + for (i = 0; i < NUM_GENERATIONS && pos < sizeof(buf); i++) { pos += PyOS_snprintf(buf+pos, sizeof(buf)-pos, " %zd", gc_list_size(GEN_HEAD(gcstate, i))); @@ -1157,6 +1169,7 @@ static inline void handle_resurrected_objects(PyGC_Head *unreachable, PyGC_Head* still_unreachable, PyGC_Head *old_generation) { + PyGC_Head *resurrected; // Remove the PREV_MASK_COLLECTING from unreachable // to prepare it for a new call to 'deduce_unreachable' gc_list_clear_collecting(unreachable); @@ -1164,7 +1177,7 @@ handle_resurrected_objects(PyGC_Head *unreachable, PyGC_Head* still_unreachable, // After the call to deduce_unreachable, the 'still_unreachable' set will // have the PREV_MARK_COLLECTING set, but the objects are going to be // removed so we can skip the expense of clearing the flag. - PyGC_Head* resurrected = unreachable; + resurrected = unreachable; deduce_unreachable(resurrected, still_unreachable); clear_unreachable_mask(still_unreachable); @@ -1179,6 +1192,7 @@ gc_collect_main(PyThreadState *tstate, int generation, Py_ssize_t *n_collected, Py_ssize_t *n_uncollectable, int nofail) { + struct gc_generation_stats *stats; int i; Py_ssize_t m = 0; /* # objects collected */ Py_ssize_t n = 0; /* # unreachable objects that couldn't be collected */ @@ -1186,6 +1200,7 @@ gc_collect_main(PyThreadState *tstate, int generation, PyGC_Head *old; /* next older generation */ PyGC_Head unreachable; /* non-problematic unreachable trash */ PyGC_Head finalizers; /* objects with, & reachable from, __del__ */ + PyGC_Head final_unreachable; PyGC_Head *gc; _PyTime_t t1 = 0; /* initialize to prevent a compiler warning */ GCState *gcstate = &tstate->interp->gc; @@ -1276,7 +1291,6 @@ gc_collect_main(PyThreadState *tstate, int generation, /* Handle any objects that may have resurrected after the call * to 'finalize_garbage' and continue the collection with the * objects that are still unreachable */ - PyGC_Head final_unreachable; handle_resurrected_objects(&unreachable, &final_unreachable, old); /* Call tp_clear on objects in the final_unreachable set. This will cause @@ -1330,7 +1344,7 @@ gc_collect_main(PyThreadState *tstate, int generation, *n_uncollectable = n; } - struct gc_generation_stats *stats = &gcstate->generation_stats[generation]; + stats = &gcstate->generation_stats[generation]; stats->collections++; stats->collected += m; stats->uncollectable += n; @@ -1351,17 +1365,21 @@ invoke_gc_callback(PyThreadState *tstate, const char *phase, int generation, Py_ssize_t collected, Py_ssize_t uncollectable) { + GCState *gcstate; + PyObject *info = NULL; + PyObject *r; + PyObject *cb; + Py_ssize_t i; assert(!_PyErr_Occurred(tstate)); /* we may get called very early */ - GCState *gcstate = &tstate->interp->gc; + gcstate = &tstate->interp->gc; if (gcstate->callbacks == NULL) { return; } /* The local variable cannot be rebound, check it for sanity */ assert(PyList_CheckExact(gcstate->callbacks)); - PyObject *info = NULL; if (PyList_GET_SIZE(gcstate->callbacks) != 0) { info = Py_BuildValue("{sisnsn}", "generation", generation, @@ -1372,8 +1390,8 @@ invoke_gc_callback(PyThreadState *tstate, const char *phase, return; } } - for (Py_ssize_t i=0; icallbacks); i++) { - PyObject *r, *cb = PyList_GET_ITEM(gcstate->callbacks, i); + for (i=0; icallbacks); i++) { + cb = PyList_GET_ITEM(gcstate->callbacks, i); Py_INCREF(cb); /* make sure cb doesn't go away */ r = PyObject_CallFunction(cb, "sO", phase, info); if (r == NULL) { @@ -1394,8 +1412,8 @@ invoke_gc_callback(PyThreadState *tstate, const char *phase, static Py_ssize_t gc_collect_with_callback(PyThreadState *tstate, int generation) { - assert(!_PyErr_Occurred(tstate)); Py_ssize_t result, collected, uncollectable; + assert(!_PyErr_Occurred(tstate)); invoke_gc_callback(tstate, "start", generation, 0, 0); result = gc_collect_main(tstate, generation, &collected, &uncollectable, 0); invoke_gc_callback(tstate, "stop", generation, collected, uncollectable); @@ -1406,12 +1424,13 @@ gc_collect_with_callback(PyThreadState *tstate, int generation) static Py_ssize_t gc_collect_generations(PyThreadState *tstate) { + int i; GCState *gcstate = &tstate->interp->gc; /* Find the oldest generation (highest numbered) where the count * exceeds the threshold. Objects in the that generation and * generations younger than it will be collected. */ Py_ssize_t n = 0; - for (int i = NUM_GENERATIONS-1; i >= 0; i--) { + for (i = NUM_GENERATIONS-1; i >= 0; i--) { if (gcstate->generations[i].count > gcstate->generations[i].threshold) { /* Avoid quadratic performance degradation in number of tracked objects (see also issue #4074): @@ -1520,15 +1539,18 @@ static Py_ssize_t gc_collect_impl(PyObject *module, int generation) /*[clinic end generated code: output=b697e633043233c7 input=40720128b682d879]*/ { - PyThreadState *tstate = _PyThreadState_GET(); + PyThreadState *tstate; + GCState *gcstate; + Py_ssize_t n; + + tstate = _PyThreadState_GET(); if (generation < 0 || generation >= NUM_GENERATIONS) { _PyErr_SetString(tstate, PyExc_ValueError, "invalid generation"); return -1; } - GCState *gcstate = &tstate->interp->gc; - Py_ssize_t n; + gcstate = &tstate->interp->gc; if (gcstate->collecting) { /* already collecting, don't do anything */ n = 0; @@ -1591,13 +1613,14 @@ PyDoc_STRVAR(gc_set_thresh__doc__, static PyObject * gc_set_threshold(PyObject *self, PyObject *args) { + int i; GCState *gcstate = get_gc_state(); if (!PyArg_ParseTuple(args, "i|ii:set_threshold", &gcstate->generations[0].threshold, &gcstate->generations[1].threshold, &gcstate->generations[2].threshold)) return NULL; - for (int i = 3; i < NUM_GENERATIONS; i++) { + for (i = 3; i < NUM_GENERATIONS; i++) { /* generations higher than 2 get the same threshold */ gcstate->generations[i].threshold = gcstate->generations[2].threshold; } @@ -1674,17 +1697,20 @@ Return the list of objects that directly refer to any of objs."); static PyObject * gc_get_referrers(PyObject *self, PyObject *args) { + PyObject *result; + GCState *gcstate; + int i; if (PySys_Audit("gc.get_referrers", "(O)", args) < 0) { return NULL; } - PyObject *result = PyList_New(0); + result = PyList_New(0); if (!result) { return NULL; } - GCState *gcstate = get_gc_state(); - for (int i = 0; i < NUM_GENERATIONS; i++) { + gcstate = get_gc_state(); + for (i = 0; i < NUM_GENERATIONS; i++) { if (!(gc_referrers_for(args, GEN_HEAD(gcstate, i), result))) { Py_DECREF(result); return NULL; @@ -1708,17 +1734,19 @@ static PyObject * gc_get_referents(PyObject *self, PyObject *args) { Py_ssize_t i; + PyObject *result; + traverseproc traverse; + PyObject *obj; if (PySys_Audit("gc.get_referents", "(O)", args) < 0) { return NULL; } - PyObject *result = PyList_New(0); + result = PyList_New(0); if (result == NULL) return NULL; for (i = 0; i < PyTuple_GET_SIZE(args); i++) { - traverseproc traverse; - PyObject *obj = PyTuple_GET_ITEM(args, i); + obj = PyTuple_GET_ITEM(args, i); if (!_PyObject_IS_GC(obj)) continue; @@ -1810,6 +1838,7 @@ gc_get_stats_impl(PyObject *module) { int i; struct gc_generation_stats stats[NUM_GENERATIONS], *st; + PyObject *result; /* To get consistent values despite allocations while constructing the result list, we use a snapshot of the running stats. */ @@ -1818,7 +1847,7 @@ gc_get_stats_impl(PyObject *module) stats[i] = gcstate->generation_stats[i]; } - PyObject *result = PyList_New(0); + result = PyList_New(0); if (result == NULL) return NULL; @@ -1905,7 +1934,8 @@ gc_freeze_impl(PyObject *module) /*[clinic end generated code: output=502159d9cdc4c139 input=b602b16ac5febbe5]*/ { GCState *gcstate = get_gc_state(); - for (int i = 0; i < NUM_GENERATIONS; ++i) { + int i; + for (i = 0; i < NUM_GENERATIONS; ++i) { gc_list_merge(GEN_HEAD(gcstate, i), &gcstate->permanent_generation.head); gcstate->generations[i].count = 0; } @@ -2024,11 +2054,11 @@ static PyModuleDef_Slot gcmodule_slots[] = { static struct PyModuleDef gcmodule = { PyModuleDef_HEAD_INIT, - .m_name = "gc", - .m_doc = gc__doc__, - .m_size = 0, // per interpreter state, see: get_gc_state() - .m_methods = GcMethods, - .m_slots = gcmodule_slots + "gc", + gc__doc__, + 0, + GcMethods, + gcmodule_slots }; PyMODINIT_FUNC @@ -2069,18 +2099,20 @@ PyGC_Collect(void) { PyThreadState *tstate = _PyThreadState_GET(); GCState *gcstate = &tstate->interp->gc; + Py_ssize_t n; + PyObject *exc; + PyObject *value; + PyObject *tb; if (!gcstate->enabled) { return 0; } - Py_ssize_t n; if (gcstate->collecting) { /* already collecting, don't do anything */ n = 0; } else { - PyObject *exc, *value, *tb; gcstate->collecting = 1; _PyErr_Fetch(tstate, &exc, &value, &tb); n = gc_collect_with_callback(tstate, NUM_GENERATIONS - 1); @@ -2094,6 +2126,7 @@ PyGC_Collect(void) Py_ssize_t _PyGC_CollectNoFail(PyThreadState *tstate) { + Py_ssize_t n; /* Ideally, this function is only called on interpreter shutdown, and therefore not recursively. Unfortunately, when there are daemon threads, a daemon thread can start a cyclic garbage collection @@ -2104,8 +2137,6 @@ _PyGC_CollectNoFail(PyThreadState *tstate) if (gcstate->collecting) { return 0; } - - Py_ssize_t n; gcstate->collecting = 1; n = gc_collect_main(tstate, NUM_GENERATIONS - 1, NULL, NULL, 1); gcstate->collecting = 0; @@ -2170,6 +2201,8 @@ gc_fini_untrack(PyGC_Head *list) void _PyGC_Fini(PyInterpreterState *interp) { + int i; + PyGC_Head *gen; GCState *gcstate = &interp->gc; Py_CLEAR(gcstate->garbage); Py_CLEAR(gcstate->callbacks); @@ -2180,8 +2213,8 @@ _PyGC_Fini(PyInterpreterState *interp) // calling PyObject_GC_UnTrack() on the object crashs if the previous // or the next object of the PyGC_Head structure became a dangling // pointer. - for (int i = 0; i < NUM_GENERATIONS; i++) { - PyGC_Head *gen = GEN_HEAD(gcstate, i); + for (i = 0; i < NUM_GENERATIONS; i++) { + gen = GEN_HEAD(gcstate, i); gc_fini_untrack(gen); } } @@ -2252,11 +2285,15 @@ PyObject_IS_GC(PyObject *obj) void _PyObject_GC_Link(PyObject *op) { - PyGC_Head *g = AS_GC(op); + PyGC_Head *g; + PyThreadState *tstate; + GCState *gcstate; + + g = AS_GC(op); assert(((uintptr_t)g & (sizeof(uintptr_t)-1)) == 0); // g must be correctly aligned - PyThreadState *tstate = _PyThreadState_GET(); - GCState *gcstate = &tstate->interp->gc; + tstate = _PyThreadState_GET(); + gcstate = &tstate->interp->gc; g->_gc_next = 0; g->_gc_prev = 0; gcstate->generations[0].count++; /* number of allocated GC objects */ @@ -2275,18 +2312,23 @@ _PyObject_GC_Link(PyObject *op) static PyObject * gc_alloc(size_t basicsize, size_t presize) { - PyThreadState *tstate = _PyThreadState_GET(); + PyThreadState *tstate; + size_t size; + char *mem; + PyObject *op; + + tstate = _PyThreadState_GET(); if (basicsize > PY_SSIZE_T_MAX - presize) { return _PyErr_NoMemory(tstate); } - size_t size = presize + basicsize; - char *mem = PyObject_Malloc(size); + size = presize + basicsize; + mem = PyObject_Malloc(size); if (mem == NULL) { return _PyErr_NoMemory(tstate); } ((PyObject **)mem)[0] = NULL; ((PyObject **)mem)[1] = NULL; - PyObject *op = (PyObject *)(mem + presize); + op = (PyObject *)(mem + presize); _PyObject_GC_Link(op); return op; } @@ -2307,13 +2349,14 @@ PyVarObject * _PyObject_GC_NewVar(PyTypeObject *tp, Py_ssize_t nitems) { size_t size; + size_t presize; PyVarObject *op; if (nitems < 0) { PyErr_BadInternalCall(); return NULL; } - size_t presize = _PyType_PreHeaderSize(tp); + presize = _PyType_PreHeaderSize(tp); size = _PyObject_VAR_SIZE(tp, nitems); op = (PyVarObject *)gc_alloc(size, presize); if (op == NULL) { @@ -2327,12 +2370,13 @@ PyVarObject * _PyObject_GC_Resize(PyVarObject *op, Py_ssize_t nitems) { const size_t basicsize = _PyObject_VAR_SIZE(Py_TYPE(op), nitems); + PyGC_Head *g; _PyObject_ASSERT((PyObject *)op, !_PyObject_GC_IS_TRACKED(op)); if (basicsize > PY_SSIZE_T_MAX - sizeof(PyGC_Head)) { return (PyVarObject *)PyErr_NoMemory(); } - PyGC_Head *g = AS_GC(op); + g = AS_GC(op); g = (PyGC_Head *)PyObject_Realloc(g, sizeof(PyGC_Head) + basicsize); if (g == NULL) return (PyVarObject *)PyErr_NoMemory(); @@ -2344,6 +2388,7 @@ _PyObject_GC_Resize(PyVarObject *op, Py_ssize_t nitems) void PyObject_GC_Del(void *op) { + GCState *gcstate; size_t presize = _PyType_PreHeaderSize(((PyObject *)op)->ob_type); PyGC_Head *g = AS_GC(op); if (_PyObject_GC_IS_TRACKED(op)) { @@ -2360,7 +2405,7 @@ PyObject_GC_Del(void *op) PyErr_Restore(exc, exc_value, exc_tb); #endif } - GCState *gcstate = get_gc_state(); + gcstate = get_gc_state(); if (gcstate->generations[0].count > 0) { gcstate->generations[0].count--; } diff --git a/Modules/getpath.c b/Modules/getpath.c index 61d6540..e7489ee 100644 --- a/Modules/getpath.c +++ b/Modules/getpath.c @@ -12,6 +12,9 @@ #ifdef MS_WINDOWS # include // GetFullPathNameW(), MAX_PATH # include +# if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(INVALID_FILE_ATTRIBUTES) +# define INVALID_FILE_ATTRIBUTES ((DWORD)-1) +# endif #endif #ifdef __APPLE__ @@ -60,10 +63,10 @@ getpath_abspath(PyObject *Py_UNUSED(self), PyObject *args) PyObject *r = NULL; PyObject *pathobj; wchar_t *path; + Py_ssize_t len; if (!PyArg_ParseTuple(args, "U", &pathobj)) { return NULL; } - Py_ssize_t len; path = PyUnicode_AsWideCharString(pathobj, &len); if (path) { wchar_t *abs; @@ -83,11 +86,13 @@ static PyObject * getpath_basename(PyObject *Py_UNUSED(self), PyObject *args) { PyObject *path; + Py_ssize_t end; + Py_ssize_t pos; if (!PyArg_ParseTuple(args, "U", &path)) { return NULL; } - Py_ssize_t end = PyUnicode_GET_LENGTH(path); - Py_ssize_t pos = PyUnicode_FindChar(path, SEP, 0, end, -1); + end = PyUnicode_GET_LENGTH(path); + pos = PyUnicode_FindChar(path, SEP, 0, end, -1); if (pos < 0) { return Py_NewRef(path); } @@ -99,11 +104,13 @@ static PyObject * getpath_dirname(PyObject *Py_UNUSED(self), PyObject *args) { PyObject *path; + Py_ssize_t end; + Py_ssize_t pos; if (!PyArg_ParseTuple(args, "U", &path)) { return NULL; } - Py_ssize_t end = PyUnicode_GET_LENGTH(path); - Py_ssize_t pos = PyUnicode_FindChar(path, SEP, 0, end, -1); + end = PyUnicode_GET_LENGTH(path); + pos = PyUnicode_FindChar(path, SEP, 0, end, -1); if (pos < 0) { return PyUnicode_FromStringAndSize(NULL, 0); } @@ -138,10 +145,10 @@ getpath_hassuffix(PyObject *Py_UNUSED(self), PyObject *args) PyObject *suffixobj; const wchar_t *path; const wchar_t *suffix; + Py_ssize_t len, suffixLen; if (!PyArg_ParseTuple(args, "UU", &pathobj, &suffixobj)) { return NULL; } - Py_ssize_t len, suffixLen; path = PyUnicode_AsWideCharString(pathobj, &len); if (path) { suffix = PyUnicode_AsWideCharString(suffixobj, &suffixLen); @@ -172,17 +179,21 @@ getpath_isdir(PyObject *Py_UNUSED(self), PyObject *args) PyObject *r = NULL; PyObject *pathobj; const wchar_t *path; +#ifdef MS_WINDOWS + DWORD attr; +#else + struct stat st; +#endif if (!PyArg_ParseTuple(args, "U", &pathobj)) { return NULL; } path = PyUnicode_AsWideCharString(pathobj, NULL); if (path) { #ifdef MS_WINDOWS - DWORD attr = GetFileAttributesW(path); + attr = GetFileAttributesW(path); r = (attr != INVALID_FILE_ATTRIBUTES) && (attr & FILE_ATTRIBUTE_DIRECTORY) ? Py_True : Py_False; #else - struct stat st; r = (_Py_wstat(path, &st) == 0) && S_ISDIR(st.st_mode) ? Py_True : Py_False; #endif PyMem_Free((void *)path); @@ -198,17 +209,21 @@ getpath_isfile(PyObject *Py_UNUSED(self), PyObject *args) PyObject *r = NULL; PyObject *pathobj; const wchar_t *path; +#ifdef MS_WINDOWS + DWORD attr; +#else + struct stat st; +#endif if (!PyArg_ParseTuple(args, "U", &pathobj)) { return NULL; } path = PyUnicode_AsWideCharString(pathobj, NULL); if (path) { #ifdef MS_WINDOWS - DWORD attr = GetFileAttributesW(path); + attr = GetFileAttributesW(path); r = (attr != INVALID_FILE_ATTRIBUTES) && !(attr & FILE_ATTRIBUTE_DIRECTORY) ? Py_True : Py_False; #else - struct stat st; r = (_Py_wstat(path, &st) == 0) && S_ISREG(st.st_mode) ? Py_True : Py_False; #endif PyMem_Free((void *)path); @@ -225,21 +240,25 @@ getpath_isxfile(PyObject *Py_UNUSED(self), PyObject *args) PyObject *pathobj; const wchar_t *path; Py_ssize_t cchPath; +#ifdef MS_WINDOWS + const wchar_t *ext; + DWORD attr; +#else + struct stat st; +#endif if (!PyArg_ParseTuple(args, "U", &pathobj)) { return NULL; } path = PyUnicode_AsWideCharString(pathobj, &cchPath); if (path) { #ifdef MS_WINDOWS - const wchar_t *ext; - DWORD attr = GetFileAttributesW(path); + attr = GetFileAttributesW(path); r = (attr != INVALID_FILE_ATTRIBUTES) && !(attr & FILE_ATTRIBUTE_DIRECTORY) && SUCCEEDED(PathCchFindExtension(path, cchPath + 1, &ext)) && (CompareStringOrdinal(ext, -1, L".exe", -1, 1 /* ignore case */) == CSTR_EQUAL) ? Py_True : Py_False; #else - struct stat st; r = (_Py_wstat(path, &st) == 0) && S_ISREG(st.st_mode) && (st.st_mode & 0111) @@ -255,27 +274,35 @@ getpath_isxfile(PyObject *Py_UNUSED(self), PyObject *args) static PyObject * getpath_joinpath(PyObject *Py_UNUSED(self), PyObject *args) { + Py_ssize_t n; + wchar_t **parts; + Py_ssize_t cchFinal; + Py_ssize_t first; + Py_ssize_t i; + PyObject *s; + Py_ssize_t cch; + wchar_t *final; + PyObject *r; if (!PyTuple_Check(args)) { PyErr_SetString(PyExc_TypeError, "requires tuple of arguments"); return NULL; } - Py_ssize_t n = PyTuple_GET_SIZE(args); + n = PyTuple_GET_SIZE(args); if (n == 0) { return PyUnicode_FromStringAndSize(NULL, 0); } /* Convert all parts to wchar and accumulate max final length */ - wchar_t **parts = (wchar_t **)PyMem_Malloc(n * sizeof(wchar_t *)); + parts = (wchar_t **)PyMem_Malloc(n * sizeof(wchar_t *)); if (parts == NULL) { PyErr_NoMemory(); return NULL; } memset(parts, 0, n * sizeof(wchar_t *)); - Py_ssize_t cchFinal = 0; - Py_ssize_t first = 0; + cchFinal = 0; + first = 0; - for (Py_ssize_t i = 0; i < n; ++i) { - PyObject *s = PyTuple_GET_ITEM(args, i); - Py_ssize_t cch; + for (i = 0; i < n; ++i) { + s = PyTuple_GET_ITEM(args, i); if (s == Py_None) { cch = 0; } else if (PyUnicode_Check(s)) { @@ -295,9 +322,9 @@ getpath_joinpath(PyObject *Py_UNUSED(self), PyObject *args) cchFinal += cch + 1; } - wchar_t *final = cchFinal > 0 ? (wchar_t *)PyMem_Malloc(cchFinal * sizeof(wchar_t)) : NULL; + final = cchFinal > 0 ? (wchar_t *)PyMem_Malloc(cchFinal * sizeof(wchar_t)) : NULL; if (!final) { - for (Py_ssize_t i = 0; i < n; ++i) { + for (i = 0; i < n; ++i) { PyMem_Free(parts[i]); } PyMem_Free(parts); @@ -310,7 +337,7 @@ getpath_joinpath(PyObject *Py_UNUSED(self), PyObject *args) final[0] = '\0'; /* Now join all the paths. The final result should be shorter than the buffer */ - for (Py_ssize_t i = 0; i < n; ++i) { + for (i = 0; i < n; ++i) { if (!parts[i]) { continue; } @@ -331,7 +358,7 @@ getpath_joinpath(PyObject *Py_UNUSED(self), PyObject *args) PyErr_SetString(PyExc_SystemError, "failed to join paths"); return NULL; } - PyObject *r = PyUnicode_FromWideChar(_Py_normpath(final, -1), -1); + r = PyUnicode_FromWideChar(_Py_normpath(final, -1), -1); PyMem_Free(final); return r; } @@ -343,6 +370,16 @@ getpath_readlines(PyObject *Py_UNUSED(self), PyObject *args) PyObject *r = NULL; PyObject *pathobj; const wchar_t *path; + FILE *fp; + const size_t MAX_FILE = 32 * 1024; + char *buffer; + size_t cb; + size_t len; + wchar_t *wbuffer; + wchar_t *p1; + wchar_t *p2; + Py_ssize_t line_len; + PyObject *u; if (!PyArg_ParseTuple(args, "U", &pathobj)) { return NULL; } @@ -350,7 +387,7 @@ getpath_readlines(PyObject *Py_UNUSED(self), PyObject *args) if (!path) { return NULL; } - FILE *fp = _Py_wfopen(path, L"rb"); + fp = _Py_wfopen(path, L"rb"); if (!fp) { PyErr_SetFromErrno(PyExc_OSError); PyMem_Free((void *)path); @@ -363,15 +400,14 @@ getpath_readlines(PyObject *Py_UNUSED(self), PyObject *args) fclose(fp); return NULL; } - const size_t MAX_FILE = 32 * 1024; - char *buffer = (char *)PyMem_Malloc(MAX_FILE); + buffer = (char *)PyMem_Malloc(MAX_FILE); if (!buffer) { Py_DECREF(r); fclose(fp); return NULL; } - size_t cb = fread(buffer, 1, MAX_FILE, fp); + cb = fread(buffer, 1, MAX_FILE, fp); fclose(fp); if (!cb) { return r; @@ -384,8 +420,7 @@ getpath_readlines(PyObject *Py_UNUSED(self), PyObject *args) } buffer[cb] = '\0'; - size_t len; - wchar_t *wbuffer = _Py_DecodeUTF8_surrogateescape(buffer, cb, &len); + wbuffer = _Py_DecodeUTF8_surrogateescape(buffer, cb, &len); PyMem_Free((void *)buffer); if (!wbuffer) { Py_DECREF(r); @@ -393,14 +428,14 @@ getpath_readlines(PyObject *Py_UNUSED(self), PyObject *args) return NULL; } - wchar_t *p1 = wbuffer; - wchar_t *p2 = p1; + p1 = wbuffer; + p2 = p1; while ((p2 = wcschr(p1, L'\n')) != NULL) { - Py_ssize_t cb = p2 - p1; - while (cb >= 0 && (p1[cb] == L'\n' || p1[cb] == L'\r')) { - --cb; + line_len = p2 - p1; + while (line_len >= 0 && (p1[line_len] == L'\n' || p1[line_len] == L'\r')) { + --line_len; } - PyObject *u = PyUnicode_FromWideChar(p1, cb >= 0 ? cb + 1 : 0); + u = PyUnicode_FromWideChar(p1, line_len >= 0 ? line_len + 1 : 0); if (!u || PyList_Append(r, u) < 0) { Py_XDECREF(u); Py_CLEAR(r); @@ -410,7 +445,7 @@ getpath_readlines(PyObject *Py_UNUSED(self), PyObject *args) p1 = p2 + 1; } if (r && p1 && *p1) { - PyObject *u = PyUnicode_FromWideChar(p1, -1); + u = PyUnicode_FromWideChar(p1, -1); if (!u || PyList_Append(r, u) < 0) { Py_CLEAR(r); } @@ -562,8 +597,11 @@ static PyMethodDef getpath_nowarn_method = {"warn", getpath_nowarn, METH_VARARGS static int funcs_to_dict(PyObject *dict, int warnings) { - for (PyMethodDef *m = getpath_methods; m->ml_name; ++m) { - PyObject *f = PyCFunction_NewEx(m, NULL, NULL); + PyMethodDef *m; + PyMethodDef *m2; + PyObject *f; + for (m = getpath_methods; m->ml_name; ++m) { + f = PyCFunction_NewEx(m, NULL, NULL); if (!f) { return 0; } @@ -573,8 +611,8 @@ funcs_to_dict(PyObject *dict, int warnings) } Py_DECREF(f); } - PyMethodDef *m2 = warnings ? &getpath_warn_method : &getpath_nowarn_method; - PyObject *f = PyCFunction_NewEx(m2, NULL, NULL); + m2 = warnings ? &getpath_warn_method : &getpath_nowarn_method; + f = PyCFunction_NewEx(m2, NULL, NULL); if (!f) { return 0; } @@ -614,9 +652,10 @@ decode_to_dict(PyObject *dict, const char *key, const char *s) { PyObject *u = NULL; int r; + size_t len; + const wchar_t *w; if (s && s[0]) { - size_t len; - const wchar_t *w = Py_DecodeLocale(s, &len); + w = Py_DecodeLocale(s, &len); if (w) { u = PyUnicode_FromWideChar(w, len); PyMem_RawFree((void *)w); @@ -639,18 +678,27 @@ env_to_dict(PyObject *dict, const char *key, int and_clear) { PyObject *u = NULL; int r = 0; +#ifdef MS_WINDOWS + wchar_t wkey[64]; + wchar_t *wp; + const char *p; + const wchar_t *v; +#else + const char *v; + size_t len; + const wchar_t *w; +#endif assert(strncmp(key, "ENV_", 4) == 0); assert(strlen(key) < 64); #ifdef MS_WINDOWS - wchar_t wkey[64]; // Quick convert to wchar_t, since we know key is ASCII - wchar_t *wp = wkey; - for (const char *p = &key[4]; *p; ++p) { + wp = wkey; + for (p = &key[4]; *p; ++p) { assert(*p < 128); *wp++ = *p; } *wp = L'\0'; - const wchar_t *v = _wgetenv(wkey); + v = _wgetenv(wkey); if (v) { u = PyUnicode_FromWideChar(v, -1); if (!u) { @@ -658,10 +706,9 @@ env_to_dict(PyObject *dict, const char *key, int and_clear) } } #else - const char *v = getenv(&key[4]); + v = getenv(&key[4]); if (v) { - size_t len; - const wchar_t *w = Py_DecodeLocale(v, &len); + w = Py_DecodeLocale(v, &len); if (w) { u = PyUnicode_FromWideChar(w, len); if (!u) { @@ -709,7 +756,9 @@ static int winmodule_to_dict(PyObject *dict, const char *key, HMODULE mod) { wchar_t *buffer = NULL; - for (DWORD cch = 256; buffer == NULL && cch < (1024 * 1024); cch *= 2) { + DWORD cch; + int r; + for (cch = 256; buffer == NULL && cch < (1024 * 1024); cch *= 2) { buffer = (wchar_t*)PyMem_RawMalloc(cch * sizeof(wchar_t)); if (buffer) { if (GetModuleFileNameW(mod, buffer, cch) == cch) { @@ -718,7 +767,7 @@ winmodule_to_dict(PyObject *dict, const char *key, HMODULE mod) } } } - int r = wchar_to_dict(dict, key, buffer); + r = wchar_to_dict(dict, key, buffer); PyMem_RawFree(buffer); return r; } @@ -826,6 +875,13 @@ PyStatus _PyConfig_InitPathConfig(PyConfig *config, int compute_path_config) { PyStatus status = _PyPathConfig_ReadGlobal(config); + PyObject *configDict; + PyObject *dict; + PyObject *co; +#ifdef MS_WINDOWS + PyObject *winreg; +#endif + PyObject *r; if (_PyStatus_EXCEPTION(status) || !compute_path_config) { return status; @@ -835,13 +891,13 @@ _PyConfig_InitPathConfig(PyConfig *config, int compute_path_config) return PyStatus_Error("cannot calculate path configuration without GIL"); } - PyObject *configDict = _PyConfig_AsDict(config); + configDict = _PyConfig_AsDict(config); if (!configDict) { PyErr_Clear(); return PyStatus_NoMemory(); } - PyObject *dict = PyDict_New(); + dict = PyDict_New(); if (!dict) { PyErr_Clear(); Py_DECREF(configDict); @@ -857,7 +913,7 @@ _PyConfig_InitPathConfig(PyConfig *config, int compute_path_config) /* reference now held by dict */ Py_DECREF(configDict); - PyObject *co = _Py_Get_Getpath_CodeObject(); + co = _Py_Get_Getpath_CodeObject(); if (!co || !PyCode_Check(co)) { PyErr_Clear(); Py_XDECREF(co); @@ -866,7 +922,7 @@ _PyConfig_InitPathConfig(PyConfig *config, int compute_path_config) } #ifdef MS_WINDOWS - PyObject *winreg = PyImport_ImportModule("winreg"); + winreg = PyImport_ImportModule("winreg"); if (!winreg || PyDict_SetItemString(dict, "winreg", winreg) < 0) { PyErr_Clear(); Py_XDECREF(winreg); @@ -924,7 +980,7 @@ _PyConfig_InitPathConfig(PyConfig *config, int compute_path_config) return PyStatus_Error("error evaluating initial values"); } - PyObject *r = PyEval_EvalCode(co, dict, dict); + r = PyEval_EvalCode(co, dict, dict); Py_DECREF(co); if (!r) { diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c index 7a02a0d..b65b001 100644 --- a/Modules/itertoolsmodule.c +++ b/Modules/itertoolsmodule.c @@ -871,6 +871,7 @@ tee_fromiterable(PyObject *iterable) { teeobject *to; PyObject *it; + PyObject *dataobj; it = PyObject_GetIter(iterable); if (it == NULL) @@ -880,7 +881,7 @@ tee_fromiterable(PyObject *iterable) goto done; } - PyObject *dataobj = teedataobject_newinternal(it); + dataobj = teedataobject_newinternal(it); if (!dataobj) { to = NULL; goto done; @@ -4849,6 +4850,7 @@ combinations_with_replacement(p, r)\n\ static int itertoolsmodule_exec(PyObject *m) { + size_t i; PyTypeObject *typelist[] = { &accumulate_type, &combinations_type, @@ -4875,7 +4877,7 @@ itertoolsmodule_exec(PyObject *m) Py_SET_TYPE(&teedataobject_type, &PyType_Type); - for (size_t i = 0; i < Py_ARRAY_LENGTH(typelist); i++) { + for (i = 0; i < Py_ARRAY_LENGTH(typelist); i++) { if (PyModule_AddType(m, typelist[i]) < 0) { return -1; } diff --git a/Modules/main.c b/Modules/main.c index f6dade1..011ae59 100644 --- a/Modules/main.c +++ b/Modules/main.c @@ -35,13 +35,14 @@ static PyStatus pymain_init(const _PyArgv *args) { PyStatus status; + PyPreConfig preconfig; + PyConfig config; status = _PyRuntime_Initialize(); if (_PyStatus_EXCEPTION(status)) { return status; } - PyPreConfig preconfig; PyPreConfig_InitPythonConfig(&preconfig); status = _Py_PreInitializeFromPyArgv(&preconfig, args); @@ -49,7 +50,6 @@ pymain_init(const _PyArgv *args) return status; } - PyConfig config; PyConfig_InitPythonConfig(&config); /* pass NULL as the config: config is read from command line arguments, @@ -68,7 +68,13 @@ pymain_init(const _PyArgv *args) if (_PyStatus_EXCEPTION(status)) { goto done; } - status = _PyStatus_OK(); + /* VC6 (MSVC600) has no C99 compound literals, so _PyStatus_OK() (a + compound literal macro) cannot be used here; PyStatus_Ok() is the + public API function that returns the identical value + (Python/initconfig.c: `PyStatus PyStatus_Ok(void) { return + _PyStatus_OK(); }`), so this is not a behavior change for any + compiler. */ + status = PyStatus_Ok(); done: PyConfig_Clear(&config); @@ -202,6 +208,8 @@ pymain_header(const PyConfig *config) static void pymain_import_readline(const PyConfig *config) { + PyObject *mod; + if (config->isolated) { return; } @@ -212,7 +220,7 @@ pymain_import_readline(const PyConfig *config) return; } - PyObject *mod = PyImport_ImportModule("readline"); + mod = PyImport_ImportModule("readline"); if (mod == NULL) { PyErr_Clear(); } @@ -234,6 +242,7 @@ pymain_run_command(wchar_t *command) { PyObject *unicode, *bytes; int ret; + PyCompilerFlags cf; unicode = PyUnicode_FromWideChar(command, -1); if (unicode == NULL) { @@ -250,7 +259,12 @@ pymain_run_command(wchar_t *command) goto error; } - PyCompilerFlags cf = _PyCompilerFlags_INIT; + /* VC6 has no C99 compound literals/designated initializers, so + _PyCompilerFlags_INIT (`(PyCompilerFlags){.cf_flags = 0, + .cf_feature_version = PY_MINOR_VERSION}`) cannot be used as an + initializer here; assign the same two fields explicitly instead. */ + cf.cf_flags = 0; + cf.cf_feature_version = PY_MINOR_VERSION; cf.cf_flags |= PyCF_IGNORE_COOKIE; ret = PyRun_SimpleStringFlags(PyBytes_AsString(bytes), &cf); Py_DECREF(bytes); @@ -317,11 +331,16 @@ static int pymain_run_file_obj(PyObject *program_name, PyObject *filename, int skip_source_first_line) { + FILE *fp; + struct _Py_stat_struct sb; + PyCompilerFlags cf; + int run; + if (PySys_Audit("cpython.run_file", "O", filename) < 0) { return pymain_exit_err_print(); } - FILE *fp = _Py_fopen_obj(filename, "rb"); + fp = _Py_fopen_obj(filename, "rb"); if (fp == NULL) { // Ignore the OSError PyErr_Clear(); @@ -341,7 +360,6 @@ pymain_run_file_obj(PyObject *program_name, PyObject *filename, } } - struct _Py_stat_struct sb; if (_Py_fstat_noraise(fileno(fp), &sb) == 0 && S_ISDIR(sb.st_mode)) { PySys_FormatStderr("%S: %R is a directory, cannot continue\n", program_name, filename); @@ -356,28 +374,35 @@ pymain_run_file_obj(PyObject *program_name, PyObject *filename, } /* PyRun_AnyFileExFlags(closeit=1) calls fclose(fp) before running code */ - PyCompilerFlags cf = _PyCompilerFlags_INIT; - int run = _PyRun_AnyFileObject(fp, filename, 1, &cf); + /* See pymain_run_command() above for why this is not + _PyCompilerFlags_INIT (VC6 has no compound literals). */ + cf.cf_flags = 0; + cf.cf_feature_version = PY_MINOR_VERSION; + run = _PyRun_AnyFileObject(fp, filename, 1, &cf); return (run != 0); } static int pymain_run_file(const PyConfig *config) { - PyObject *filename = PyUnicode_FromWideChar(config->run_filename, -1); + PyObject *filename; + PyObject *program_name; + int res; + + filename = PyUnicode_FromWideChar(config->run_filename, -1); if (filename == NULL) { PyErr_Print(); return -1; } - PyObject *program_name = PyUnicode_FromWideChar(config->program_name, -1); + program_name = PyUnicode_FromWideChar(config->program_name, -1); if (program_name == NULL) { Py_DECREF(filename); PyErr_Print(); return -1; } - int res = pymain_run_file_obj(program_name, filename, - config->skip_source_first_line); + res = pymain_run_file_obj(program_name, filename, + config->skip_source_first_line); Py_DECREF(filename); Py_DECREF(program_name); return res; @@ -388,12 +413,20 @@ static int pymain_run_startup(PyConfig *config, int *exitcode) { int ret; + PyObject *startup = NULL; +#ifdef MS_WINDOWS + const wchar_t *env; +#else + const char *env; +#endif + FILE *fp; + PyCompilerFlags cf; + if (!config->use_environment) { return 0; } - PyObject *startup = NULL; #ifdef MS_WINDOWS - const wchar_t *env = _wgetenv(L"PYTHONSTARTUP"); + env = _wgetenv(L"PYTHONSTARTUP"); if (env == NULL || env[0] == L'\0') { return 0; } @@ -402,7 +435,7 @@ pymain_run_startup(PyConfig *config, int *exitcode) goto error; } #else - const char *env = _Py_GetEnv(config->use_environment, "PYTHONSTARTUP"); + env = _Py_GetEnv(config->use_environment, "PYTHONSTARTUP"); if (env == NULL) { return 0; } @@ -415,7 +448,7 @@ pymain_run_startup(PyConfig *config, int *exitcode) goto error; } - FILE *fp = _Py_fopen_obj(startup, "r"); + fp = _Py_fopen_obj(startup, "r"); if (fp == NULL) { int save_errno = errno; PyErr_Clear(); @@ -426,7 +459,10 @@ pymain_run_startup(PyConfig *config, int *exitcode) goto error; } - PyCompilerFlags cf = _PyCompilerFlags_INIT; + /* See pymain_run_command() above for why this is not + _PyCompilerFlags_INIT (VC6 has no compound literals). */ + cf.cf_flags = 0; + cf.cf_feature_version = PY_MINOR_VERSION; (void) _PyRun_SimpleFileObject(fp, startup, 0, &cf); PyErr_Clear(); fclose(fp); @@ -482,11 +518,15 @@ pymain_run_interactive_hook(int *exitcode) static int pymain_run_stdin(PyConfig *config) { + PyCompilerFlags cf; + int run; + if (stdin_is_interactive(config)) { + int exitcode; + config->inspect = 0; Py_InspectFlag = 0; /* do exit on SystemExit */ - int exitcode; if (pymain_run_startup(config, &exitcode)) { return exitcode; } @@ -505,8 +545,11 @@ pymain_run_stdin(PyConfig *config) return pymain_exit_err_print(); } - PyCompilerFlags cf = _PyCompilerFlags_INIT; - int run = PyRun_AnyFileExFlags(stdin, "", 0, &cf); + /* See pymain_run_command() above for why this is not + _PyCompilerFlags_INIT (VC6 has no compound literals). */ + cf.cf_flags = 0; + cf.cf_feature_version = PY_MINOR_VERSION; + run = PyRun_AnyFileExFlags(stdin, "", 0, &cf); return (run != 0); } @@ -514,6 +557,9 @@ pymain_run_stdin(PyConfig *config) static void pymain_repl(PyConfig *config, int *exitcode) { + PyCompilerFlags cf; + int res; + /* Check this environment variable at the end, to give programs the opportunity to set it from Python. */ if (!config->inspect && _Py_GetEnv(config->use_environment, "PYTHONINSPECT")) { @@ -535,8 +581,11 @@ pymain_repl(PyConfig *config, int *exitcode) return; } - PyCompilerFlags cf = _PyCompilerFlags_INIT; - int res = PyRun_AnyFileFlags(stdin, "", &cf); + /* See pymain_run_command() above for why this is not + _PyCompilerFlags_INIT (VC6 has no compound literals). */ + cf.cf_flags = 0; + cf.cf_feature_version = PY_MINOR_VERSION; + res = PyRun_AnyFileFlags(stdin, "", &cf); *exitcode = (res != 0); } @@ -718,11 +767,15 @@ pymain_main(_PyArgv *args) int Py_Main(int argc, wchar_t **argv) { - _PyArgv args = { - .argc = argc, - .use_bytes_argv = 0, - .bytes_argv = NULL, - .wchar_argv = argv}; + /* VC6 has no C99 designated initializers, so the aggregate initializer + below cannot be used; assign each field explicitly instead (field + order does not matter for plain assignment, unlike the initializer + list it replaces). */ + _PyArgv args; + args.argc = argc; + args.use_bytes_argv = 0; + args.bytes_argv = NULL; + args.wchar_argv = argv; return pymain_main(&args); } @@ -730,11 +783,12 @@ Py_Main(int argc, wchar_t **argv) int Py_BytesMain(int argc, char **argv) { - _PyArgv args = { - .argc = argc, - .use_bytes_argv = 1, - .bytes_argv = argv, - .wchar_argv = NULL}; + /* See Py_Main() above: VC6 has no C99 designated initializers. */ + _PyArgv args; + args.argc = argc; + args.use_bytes_argv = 1; + args.bytes_argv = argv; + args.wchar_argv = NULL; return pymain_main(&args); } diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c index 5f5b71c..999fa85 100644 --- a/Modules/mathmodule.c +++ b/Modules/mathmodule.c @@ -70,6 +70,100 @@ raised for division by zero and mod by zero. #include "clinic/mathmodule.c.h" +#if defined(_MSC_VER) && _MSC_VER < 1300 +# define PY_MATH_ULONG_LONG unsigned __int64 +# define PY_MATH_LONG_LONG __int64 +# define PY_MATH_ULLONG_MAX ((unsigned __int64)0xffffffffffffffffI64) +# define PY_MATH_LLONG_MAX ((__int64)0x7fffffffffffffffI64) + +static double +m_asinh(double x) +{ + if (x < 0.0) + return -m_asinh(-x); + if (x > 1.3407807929942596e154) + return log(x) + log(2.0); + return log(x + sqrt(x * x + 1.0)); +} + +static double +m_acosh(double x) +{ + if (x < 1.0) { + errno = EDOM; + return Py_NAN; + } + if (x > 1.3407807929942596e154) { + return log(x) + log(2.0); + } + return log(x + sqrt((x - 1.0) * (x + 1.0))); +} + +static double +m_atanh(double x) +{ + double a, u, t, r; + + if (Py_IS_NAN(x)) + return x; + + a = fabs(x); + if (a >= 1.0) { + errno = EDOM; + return Py_NAN; + } + if (a < 3.7252902984619140625e-9) /* 2**-28 */ + return x; + + u = 2.0 * a / (1.0 - a); + t = 1.0 + u; + r = 0.5 * log(t) * (u / (t - 1.0)); + return x < 0.0 ? -r : r; +} + +static double +m_cbrt(double x) +{ + double ax; + + if (Py_IS_NAN(x)) + return x; + if (x == 0.0) + return x; + if (Py_IS_INFINITY(x)) + return x; + ax = fabs(x); + ax = exp(log(ax) / 3.0); + return x < 0.0 ? -ax : ax; +} + +static double +m_expm1(double x) +{ + if (fabs(x) < 1e-5) + return x + 0.5 * x * x; + return exp(x) - 1.0; +} + +static double +m_exp2(double x) +{ + if (Py_IS_NAN(x)) + return x; + return exp(x * log(2.0)); +} + +#else +# define PY_MATH_ULONG_LONG unsigned long long +# define PY_MATH_LONG_LONG long long +# define PY_MATH_ULLONG_MAX ULLONG_MAX +# define PY_MATH_LLONG_MAX LLONG_MAX +# define m_atanh atanh +# define m_cbrt cbrt +# define m_expm1 expm1 +# define m_exp2 exp2 +#endif + /*[clinic input] module math [clinic start generated code]*/ @@ -841,7 +935,7 @@ m_log10(double x) static PyObject * math_gcd(PyObject *module, PyObject * const *args, Py_ssize_t nargs) { - PyObject *res, *x; + PyObject *res, *x, *one; Py_ssize_t i; if (nargs == 0) { @@ -856,7 +950,7 @@ math_gcd(PyObject *module, PyObject * const *args, Py_ssize_t nargs) return res; } - PyObject *one = _PyLong_GetOne(); // borrowed ref + one = _PyLong_GetOne(); // borrowed ref for (i = 1; i < nargs; i++) { x = _PyNumber_Index(args[i]); if (x == NULL) { @@ -916,7 +1010,7 @@ long_lcm(PyObject *a, PyObject *b) static PyObject * math_lcm(PyObject *module, PyObject * const *args, Py_ssize_t nargs) { - PyObject *res, *x; + PyObject *res, *x, *zero; Py_ssize_t i; if (nargs == 0) { @@ -931,7 +1025,7 @@ math_lcm(PyObject *module, PyObject * const *args, Py_ssize_t nargs) return res; } - PyObject *zero = _PyLong_GetZero(); // borrowed ref + zero = _PyLong_GetZero(); // borrowed ref for (i = 1; i < nargs; i++) { x = PyNumber_Index(args[i]); if (x == NULL) { @@ -1175,14 +1269,14 @@ FUNC1(acos, acos, 0, "acos($module, x, /)\n--\n\n" "Return the arc cosine (measured in radians) of x.\n\n" "The result is between 0 and pi.") -FUNC1(acosh, acosh, 0, +FUNC1(acosh, m_acosh, 0, "acosh($module, x, /)\n--\n\n" "Return the inverse hyperbolic cosine of x.") FUNC1(asin, asin, 0, "asin($module, x, /)\n--\n\n" "Return the arc sine (measured in radians) of x.\n\n" "The result is between -pi/2 and pi/2.") -FUNC1(asinh, asinh, 0, +FUNC1(asinh, m_asinh, 0, "asinh($module, x, /)\n--\n\n" "Return the inverse hyperbolic sine of x.") FUNC1(atan, atan, 0, @@ -1193,10 +1287,10 @@ FUNC2(atan2, m_atan2, "atan2($module, y, x, /)\n--\n\n" "Return the arc tangent (measured in radians) of y/x.\n\n" "Unlike atan(y/x), the signs of both x and y are considered.") -FUNC1(atanh, atanh, 0, +FUNC1(atanh, m_atanh, 0, "atanh($module, x, /)\n--\n\n" "Return the inverse hyperbolic tangent of x.") -FUNC1(cbrt, cbrt, 0, +FUNC1(cbrt, m_cbrt, 0, "cbrt($module, x, /)\n--\n\n" "Return the cube root of x.") @@ -1216,6 +1310,7 @@ math_ceil(PyObject *module, PyObject *number) /*[clinic end generated code: output=6c3b8a78bc201c67 input=2725352806399cab]*/ { _Py_IDENTIFIER(__ceil__); + double x; if (!PyFloat_CheckExact(number)) { PyObject *method = _PyObject_LookupSpecialId(number, &PyId___ceil__); @@ -1227,7 +1322,7 @@ math_ceil(PyObject *module, PyObject *number) if (PyErr_Occurred()) return NULL; } - double x = PyFloat_AsDouble(number); + x = PyFloat_AsDouble(number); if (x == -1.0 && PyErr_Occurred()) return NULL; @@ -1254,10 +1349,10 @@ FUNC1A(erfc, m_erfc, FUNC1(exp, exp, 1, "exp($module, x, /)\n--\n\n" "Return e raised to the power of x.") -FUNC1(exp2, exp2, 1, +FUNC1(exp2, m_exp2, 1, "exp2($module, x, /)\n--\n\n" "Return 2 raised to the power of x.") -FUNC1(expm1, expm1, 1, +FUNC1(expm1, m_expm1, 1, "expm1($module, x, /)\n--\n\n" "Return exp(x)-1.\n\n" "This function avoids the loss of precision involved in the direct " @@ -1779,6 +1874,7 @@ math_isqrt(PyObject *module, PyObject *n) /*[clinic end generated code: output=35a6f7f980beab26 input=5b6e7ae4fa6c43d6]*/ { int a_too_large, c_bit_length; + int s; size_t c, d; uint64_t m; uint32_t u; @@ -1847,7 +1943,7 @@ math_isqrt(PyObject *module, PyObject *n) goto error; } - for (int s = c_bit_length - 6; s >= 0; --s) { + for (s = c_bit_length - 6; s >= 0; --s) { PyObject *q; size_t e = d; @@ -3082,14 +3178,17 @@ _check_long_mult_overflow(long a, long b) { long longprod = (long)((unsigned long)a * b); double doubleprod = (double)a * (double)b; double doubled_longprod = (double)longprod; + double diff; + double absdiff; + double absprod; if (doubled_longprod == doubleprod) { return 0; } - const double diff = doubled_longprod - doubleprod; - const double absdiff = diff >= 0.0 ? diff : -diff; - const double absprod = doubleprod >= 0.0 ? doubleprod : -doubleprod; + diff = doubled_longprod - doubleprod; + absdiff = diff >= 0.0 ? diff : -diff; + absprod = doubleprod >= 0.0 ? doubleprod : -doubleprod; if (32.0 * absdiff <= absprod) { return 0; @@ -3380,8 +3479,16 @@ static const uint8_t factorial_trailing_zeros[] = { /* Calculate C(n, k) for n in the 63-bit range. */ static PyObject * -perm_comb_small(unsigned long long n, unsigned long long k, int iscomb) +perm_comb_small(PY_MATH_ULONG_LONG n, PY_MATH_ULONG_LONG k, int iscomb) { + PY_MATH_ULONG_LONG result, i, j; + uint64_t comb_odd_part, perm_odd_part; + int shift; + PyObject *a, *b; + static const PY_MATH_ULONG_LONG fast_comb_limits2[] = { + 0, PY_MATH_ULLONG_MAX, (PY_MATH_ULONG_LONG)4294967296I64, 3329022, 102570, 13467, 3612, 1449, // 0-7 + 746, 453, 308, 227, 178, 147, // 8-13 + }; if (k == 0) { return PyLong_FromLong(1); } @@ -3410,26 +3517,22 @@ perm_comb_small(unsigned long long n, unsigned long long k, int iscomb) calculated efficiently via arithmetic modulo 2**64, using three lookups and two uint64_t multiplications. */ - uint64_t comb_odd_part = reduced_factorial_odd_part[n] - * inverted_factorial_odd_part[k] - * inverted_factorial_odd_part[n - k]; - int shift = factorial_trailing_zeros[n] - - factorial_trailing_zeros[k] - - factorial_trailing_zeros[n - k]; + comb_odd_part = reduced_factorial_odd_part[n] + * inverted_factorial_odd_part[k] + * inverted_factorial_odd_part[n - k]; + shift = factorial_trailing_zeros[n] + - factorial_trailing_zeros[k] + - factorial_trailing_zeros[n - k]; return PyLong_FromUnsignedLongLong(comb_odd_part << shift); } /* Maps k to the maximal n so that 2*k-1 <= n <= 127 and C(n, k)*k * fits into a long long (which is at least 64 bit). Only contains * items larger than in fast_comb_limits1. */ - static const unsigned long long fast_comb_limits2[] = { - 0, ULLONG_MAX, 4294967296ULL, 3329022, 102570, 13467, 3612, 1449, // 0-7 - 746, 453, 308, 227, 178, 147, // 8-13 - }; if (k < Py_ARRAY_LENGTH(fast_comb_limits2) && n <= fast_comb_limits2[k]) { /* C(n, k) = C(n, k-1) * (n-k+1) / k */ - unsigned long long result = n; - for (unsigned long long i = 1; i < k;) { + result = n; + for (i = 1; i < k;) { result *= --n; result /= ++i; } @@ -3439,8 +3542,8 @@ perm_comb_small(unsigned long long n, unsigned long long k, int iscomb) else { /* Maps k to the maximal n so that k <= n and P(n, k) * fits into a long long (which is at least 64 bit). */ - static const unsigned long long fast_perm_limits[] = { - 0, ULLONG_MAX, 4294967296ULL, 2642246, 65537, 7133, 1627, 568, // 0-7 + static const PY_MATH_ULONG_LONG fast_perm_limits[] = { + 0, PY_MATH_ULLONG_MAX, (PY_MATH_ULONG_LONG)4294967296I64, 2642246, 65537, 7133, 1627, 568, // 0-7 259, 142, 88, 61, 45, 36, 30, 26, // 8-15 24, 22, 21, 20, 20, // 16-20 }; @@ -3455,8 +3558,8 @@ perm_comb_small(unsigned long long n, unsigned long long k, int iscomb) } /* P(n, k) = P(n, k-1) * (n-k+1) */ - unsigned long long result = n; - for (unsigned long long i = 1; i < k;) { + result = n; + for (i = 1; i < k;) { result *= --n; ++i; } @@ -3469,8 +3572,7 @@ perm_comb_small(unsigned long long n, unsigned long long k, int iscomb) * P(n, k) = P(n, j) * P(n-j, k-j) * C(n, k) = C(n, j) * C(n-j, k-j) // C(k, j) */ - unsigned long long j = k / 2; - PyObject *a, *b; + j = k / 2; a = perm_comb_small(n, j, iscomb); if (a == NULL) { return NULL; @@ -3501,8 +3603,10 @@ perm_comb_small(unsigned long long n, unsigned long long k, int iscomb) * Karatsuba multiplication. */ static PyObject * -perm_comb(PyObject *n, unsigned long long k, int iscomb) +perm_comb(PyObject *n, PY_MATH_ULONG_LONG k, int iscomb) { + PY_MATH_ULONG_LONG j; + PyObject *a, *b, *t; if (k == 0) { return PyLong_FromLong(1); } @@ -3513,13 +3617,12 @@ perm_comb(PyObject *n, unsigned long long k, int iscomb) /* P(n, k) = P(n, j) * P(n-j, k-j) */ /* C(n, k) = C(n, j) * C(n-j, k-j) // C(k, j) */ - unsigned long long j = k / 2; - PyObject *a, *b; + j = k / 2; a = perm_comb(n, j, iscomb); if (a == NULL) { return NULL; } - PyObject *t = PyLong_FromUnsignedLongLong(j); + t = PyLong_FromUnsignedLongLong(j); if (t == NULL) { goto error; } @@ -3575,7 +3678,7 @@ math_perm_impl(PyObject *module, PyObject *n, PyObject *k) { PyObject *result = NULL; int overflow, cmp; - long long ki, ni; + PY_MATH_LONG_LONG ki, ni; if (k == Py_None) { return math_factorial(module, n); @@ -3616,7 +3719,7 @@ math_perm_impl(PyObject *module, PyObject *n, PyObject *k) if (overflow > 0) { PyErr_Format(PyExc_OverflowError, "k must not exceed %lld", - LLONG_MAX); + PY_MATH_LLONG_MAX); goto error; } assert(ki >= 0); @@ -3625,11 +3728,11 @@ math_perm_impl(PyObject *module, PyObject *n, PyObject *k) assert(overflow >= 0 && !PyErr_Occurred()); if (!overflow && ki > 1) { assert(ni >= 0); - result = perm_comb_small((unsigned long long)ni, - (unsigned long long)ki, 0); + result = perm_comb_small((PY_MATH_ULONG_LONG)ni, + (PY_MATH_ULONG_LONG)ki, 0); } else { - result = perm_comb(n, (unsigned long long)ki, 0); + result = perm_comb(n, (PY_MATH_ULONG_LONG)ki, 0); } done: @@ -3670,7 +3773,7 @@ math_comb_impl(PyObject *module, PyObject *n, PyObject *k) { PyObject *result = NULL, *temp; int overflow, cmp; - long long ki, ni; + PY_MATH_LONG_LONG ki, ni; n = PyNumber_Index(n); if (n == NULL) { @@ -3708,8 +3811,8 @@ math_comb_impl(PyObject *module, PyObject *n, PyObject *k) ki = Py_MIN(ki, ni - ki); if (ki > 1) { - result = perm_comb_small((unsigned long long)ni, - (unsigned long long)ki, 1); + result = perm_comb_small((PY_MATH_ULONG_LONG)ni, + (PY_MATH_ULONG_LONG)ki, 1); goto done; } /* For k == 1 just return the original n in perm_comb(). */ @@ -3741,13 +3844,13 @@ math_comb_impl(PyObject *module, PyObject *n, PyObject *k) if (overflow) { PyErr_Format(PyExc_OverflowError, "min(n - k, k) must not exceed %lld", - LLONG_MAX); + PY_MATH_LLONG_MAX); goto error; } assert(ki >= 0); } - result = perm_comb(n, (unsigned long long)ki, 1); + result = perm_comb(n, (PY_MATH_ULONG_LONG)ki, 1); done: Py_DECREF(n); @@ -3805,6 +3908,8 @@ static double math_ulp_impl(PyObject *module, double x) /*[clinic end generated code: output=f5207867a9384dd4 input=31f9bfbbe373fcaa]*/ { + double inf; + double x2; if (Py_IS_NAN(x)) { return x; } @@ -3812,8 +3917,8 @@ math_ulp_impl(PyObject *module, double x) if (Py_IS_INFINITY(x)) { return x; } - double inf = m_inf(); - double x2 = nextafter(x, inf); + inf = m_inf(); + x2 = nextafter(x, inf); if (Py_IS_INFINITY(x2)) { /* special case: x is the largest positive representable float */ x2 = nextafter(x, -inf); @@ -3916,11 +4021,11 @@ PyDoc_STRVAR(module_doc, static struct PyModuleDef mathmodule = { PyModuleDef_HEAD_INIT, - .m_name = "math", - .m_doc = module_doc, - .m_size = 0, - .m_methods = math_methods, - .m_slots = math_slots, + "math", + module_doc, + 0, + math_methods, + math_slots }; PyMODINIT_FUNC diff --git a/PC/pyconfig.h b/PC/pyconfig.h index 959b851..6d8ce84 100644 --- a/PC/pyconfig.h +++ b/PC/pyconfig.h @@ -256,6 +256,19 @@ typedef int pid_t; # define PY_ULLONG_MAX _UI64_MAX #endif +/* Spelling of 64 bit integer literal suffixes. MSVC before Visual C++ .NET + (_MSC_VER < 1300, i.e. Visual C++ 6.0 and earlier) rejects the C99 LL/ULL + suffixes and spells them i64/ui64 instead. */ +#ifndef PY_LL +# if defined(_MSC_VER) && _MSC_VER < 1300 +# define PY_LL(x) x##i64 +# define PY_ULL(x) x##ui64 +# else +# define PY_LL(x) x##LL +# define PY_ULL(x) x##ULL +# endif +#endif + /* For Windows the Python core is in a DLL by default. Test Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ #if !defined(MS_NO_COREDLL) && !defined(Py_NO_ENABLE_SHARED) diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c index 9248e97..4abd5d4 100644 --- a/Python/pylifecycle.c +++ b/Python/pylifecycle.c @@ -88,8 +88,14 @@ _Py_COMP_DIAG_IGNORE_DEPR_DECLS #if defined(MS_WINDOWS) +# if defined(_MSC_VER) && _MSC_VER < 1300 +/* VC6 does not support #pragma section plus __declspec(allocate()). + Use its older data_seg spelling for this initialized object instead. */ +# pragma data_seg("PyRuntime") +# else #pragma section("PyRuntime", read, write) __declspec(allocate("PyRuntime")) +# endif #elif defined(__APPLE__) @@ -103,10 +109,20 @@ _PyRuntimeState _PyRuntime #if defined(__linux__) && (defined(__GNUC__) || defined(__clang__)) __attribute__ ((section (".PyRuntime"))) #endif +#if defined(_MSC_VER) && _MSC_VER < 1300 +; +#else = _PyRuntimeState_INIT; +#endif +#if defined(MS_WINDOWS) && defined(_MSC_VER) && _MSC_VER < 1300 +# pragma data_seg() +#endif _Py_COMP_DIAG_POP static int runtime_initialized = 0; +#if defined(_MSC_VER) && _MSC_VER < 1300 +static int runtime_static_initialized = 0; +#endif PyStatus _PyRuntime_Initialize(void) @@ -117,6 +133,12 @@ _PyRuntime_Initialize(void) every Py_Initialize() call, but doing so breaks the runtime. This is because the runtime state is not properly finalized currently. */ +#if defined(_MSC_VER) && _MSC_VER < 1300 + if (!runtime_static_initialized) { + _PyRuntimeState_InitStaticDefaults(&_PyRuntime); + runtime_static_initialized = 1; + } +#endif if (runtime_initialized) { return _PyStatus_OK(); } @@ -175,10 +197,16 @@ Py_IsInitialized(void) static int init_importlib(PyThreadState *tstate, PyObject *sysmod) { + PyInterpreterState *interp; + int verbose; + PyObject *importlib; + PyObject *imp_mod; + PyObject *value; + assert(!_PyErr_Occurred(tstate)); - PyInterpreterState *interp = tstate->interp; - int verbose = _PyInterpreterState_GetConfig(interp)->verbose; + interp = tstate->interp; + verbose = _PyInterpreterState_GetConfig(interp)->verbose; // Import _importlib through its frozen version, _frozen_importlib. if (verbose) { @@ -187,7 +215,7 @@ init_importlib(PyThreadState *tstate, PyObject *sysmod) if (PyImport_ImportFrozenModule("_frozen_importlib") <= 0) { return -1; } - PyObject *importlib = PyImport_AddModule("_frozen_importlib"); // borrowed + importlib = PyImport_AddModule("_frozen_importlib"); // borrowed if (importlib == NULL) { return -1; } @@ -197,7 +225,7 @@ init_importlib(PyThreadState *tstate, PyObject *sysmod) if (verbose) { PySys_FormatStderr("import _imp # builtin\n"); } - PyObject *imp_mod = _PyImport_BootstrapImp(tstate); + imp_mod = _PyImport_BootstrapImp(tstate); if (imp_mod == NULL) { return -1; } @@ -207,8 +235,8 @@ init_importlib(PyThreadState *tstate, PyObject *sysmod) } // Install importlib as the implementation of import - PyObject *value = PyObject_CallMethod(importlib, "_install", - "OO", sysmod, imp_mod); + value = PyObject_CallMethod(importlib, "_install", + "OO", sysmod, imp_mod); Py_DECREF(imp_mod); if (value == NULL) { return -1; @@ -464,9 +492,10 @@ static int interpreter_update_config(PyThreadState *tstate, int only_update_path_config) { const PyConfig *config = &tstate->interp->config; + PyStatus status; if (!only_update_path_config) { - PyStatus status = _PyConfig_Write(config, tstate->interp->runtime); + status = _PyConfig_Write(config, tstate->interp->runtime); if (_PyStatus_EXCEPTION(status)) { _PyErr_SetFromPyStatus(status); return -1; @@ -474,7 +503,7 @@ interpreter_update_config(PyThreadState *tstate, int only_update_path_config) } if (_Py_IsMainInterpreter(tstate->interp)) { - PyStatus status = _PyPathConfig_UpdateGlobal(config); + status = _PyPathConfig_UpdateGlobal(config); if (_PyStatus_EXCEPTION(status)) { _PyErr_SetFromPyStatus(status); return -1; @@ -494,10 +523,11 @@ _PyInterpreterState_SetConfig(const PyConfig *src_config) { PyThreadState *tstate = _PyThreadState_GET(); int res = -1; - PyConfig config; + PyStatus status; + PyConfig_InitPythonConfig(&config); - PyStatus status = _PyConfig_Copy(&config, src_config); + status = _PyConfig_Copy(&config, src_config); if (_PyStatus_EXCEPTION(status)) { _PyErr_SetFromPyStatus(status); goto done; @@ -542,12 +572,13 @@ pyinit_core_reconfigure(_PyRuntimeState *runtime, { PyStatus status; PyThreadState *tstate = _PyThreadState_GET(); + PyInterpreterState *interp; if (!tstate) { return _PyStatus_ERR("failed to read thread state"); } *tstate_p = tstate; - PyInterpreterState *interp = tstate->interp; + interp = tstate->interp; if (interp == NULL) { return _PyStatus_ERR("can't make main interpreter"); } @@ -577,11 +608,13 @@ static PyStatus pycore_init_runtime(_PyRuntimeState *runtime, const PyConfig *config) { + PyStatus status; + if (runtime->initialized) { return _PyStatus_ERR("main interpreter already initialized"); } - PyStatus status = _PyConfig_Write(config, runtime); + status = _PyConfig_Write(config, runtime); if (_PyStatus_EXCEPTION(status)) { return status; } @@ -640,13 +673,17 @@ pycore_create_interpreter(_PyRuntimeState *runtime, const PyConfig *config, PyThreadState **tstate_p) { + PyStatus status; + PyInterpreterState *interp; + PyThreadState *tstate; + /* Auto-thread-state API */ - PyStatus status = _PyGILState_Init(runtime); + status = _PyGILState_Init(runtime); if (_PyStatus_EXCEPTION(status)) { return status; } - PyInterpreterState *interp = PyInterpreterState_New(); + interp = PyInterpreterState_New(); if (interp == NULL) { return _PyStatus_ERR("can't make main interpreter"); } @@ -657,7 +694,7 @@ pycore_create_interpreter(_PyRuntimeState *runtime, return status; } - PyThreadState *tstate = PyThreadState_New(interp); + tstate = PyThreadState_New(interp); if (tstate == NULL) { return _PyStatus_ERR("can't make first thread"); } @@ -762,8 +799,14 @@ static PyStatus pycore_init_builtins(PyThreadState *tstate) { PyInterpreterState *interp = tstate->interp; - - PyObject *bimod = _PyBuiltin_Init(interp); + PyObject *bimod; + PyObject *builtins_dict; + PyObject *isinstance; + PyObject *len; + PyObject *list_append; + PyObject *import_func; + + bimod = _PyBuiltin_Init(interp); if (bimod == NULL) { goto error; } @@ -772,20 +815,20 @@ pycore_init_builtins(PyThreadState *tstate) goto error; } - PyObject *builtins_dict = PyModule_GetDict(bimod); + builtins_dict = PyModule_GetDict(bimod); if (builtins_dict == NULL) { goto error; } Py_INCREF(builtins_dict); interp->builtins = builtins_dict; - PyObject *isinstance = PyDict_GetItem(builtins_dict, &_Py_ID(isinstance)); + isinstance = PyDict_GetItem(builtins_dict, &_Py_ID(isinstance)); assert(isinstance); interp->callable_cache.isinstance = isinstance; - PyObject *len = PyDict_GetItem(builtins_dict, &_Py_ID(len)); + len = PyDict_GetItem(builtins_dict, &_Py_ID(len)); assert(len); interp->callable_cache.len = len; - PyObject *list_append = _PyType_Lookup(&PyList_Type, &_Py_ID(append)); + list_append = _PyType_Lookup(&PyList_Type, &_Py_ID(append)); assert(list_append); interp->callable_cache.list_append = list_append; @@ -800,8 +843,8 @@ pycore_init_builtins(PyThreadState *tstate) Py_DECREF(bimod); // Get the __import__ function - PyObject *import_func = _PyDict_GetItemStringWithError(interp->builtins, - "__import__"); + import_func = _PyDict_GetItemStringWithError(interp->builtins, + "__import__"); if (import_func == NULL) { goto error; } @@ -822,6 +865,7 @@ pycore_interp_init(PyThreadState *tstate) PyInterpreterState *interp = tstate->interp; PyStatus status; PyObject *sysmod = NULL; + const PyConfig *config; // Create singletons before the first PyType_Ready() call, since // PyType_Ready() uses singletons like the Unicode empty string (tp_doc) @@ -866,7 +910,7 @@ pycore_interp_init(PyThreadState *tstate) goto done; } - const PyConfig *config = _PyInterpreterState_GetConfig(interp); + config = _PyInterpreterState_GetConfig(interp); if (config->_install_importlib) { /* This call sets up builtin and frozen import support */ if (init_importlib(tstate, sysmod) < 0) { @@ -886,12 +930,14 @@ pyinit_config(_PyRuntimeState *runtime, PyThreadState **tstate_p, const PyConfig *config) { - PyStatus status = pycore_init_runtime(runtime, config); + PyStatus status; + PyThreadState *tstate; + + status = pycore_init_runtime(runtime, config); if (_PyStatus_EXCEPTION(status)) { return status; } - PyThreadState *tstate; status = pycore_create_interpreter(runtime, config, &tstate); if (_PyStatus_EXCEPTION(status)) { return status; @@ -913,6 +959,8 @@ PyStatus _Py_PreInitializeFromPyArgv(const PyPreConfig *src_config, const _PyArgv *args) { PyStatus status; + _PyRuntimeState *runtime; + PyPreConfig config; if (src_config == NULL) { return _PyStatus_ERR("preinitialization config is NULL"); @@ -922,7 +970,7 @@ _Py_PreInitializeFromPyArgv(const PyPreConfig *src_config, const _PyArgv *args) if (_PyStatus_EXCEPTION(status)) { return status; } - _PyRuntimeState *runtime = &_PyRuntime; + runtime = &_PyRuntime; if (runtime->preinitialized) { /* If it's already configured: ignored the new configuration */ @@ -933,8 +981,6 @@ _Py_PreInitializeFromPyArgv(const PyPreConfig *src_config, const _PyArgv *args) at exit on success. */ runtime->preinitializing = 1; - PyPreConfig config; - status = _PyPreConfig_InitFromPreConfig(&config, src_config); if (_PyStatus_EXCEPTION(status)) { return status; @@ -959,7 +1005,11 @@ _Py_PreInitializeFromPyArgv(const PyPreConfig *src_config, const _PyArgv *args) PyStatus Py_PreInitializeFromBytesArgs(const PyPreConfig *src_config, Py_ssize_t argc, char **argv) { - _PyArgv args = {.use_bytes_argv = 1, .argc = argc, .bytes_argv = argv}; + _PyArgv args; + + args.use_bytes_argv = 1; + args.argc = argc; + args.bytes_argv = argv; return _Py_PreInitializeFromPyArgv(src_config, &args); } @@ -967,7 +1017,11 @@ Py_PreInitializeFromBytesArgs(const PyPreConfig *src_config, Py_ssize_t argc, ch PyStatus Py_PreInitializeFromArgs(const PyPreConfig *src_config, Py_ssize_t argc, wchar_t **argv) { - _PyArgv args = {.use_bytes_argv = 0, .argc = argc, .wchar_argv = argv}; + _PyArgv args; + + args.use_bytes_argv = 0; + args.argc = argc; + args.wchar_argv = argv; return _Py_PreInitializeFromPyArgv(src_config, &args); } @@ -983,31 +1037,33 @@ PyStatus _Py_PreInitializeFromConfig(const PyConfig *config, const _PyArgv *args) { + PyStatus status; + _PyRuntimeState *runtime; + PyPreConfig preconfig; + _PyArgv config_args; + assert(config != NULL); - PyStatus status = _PyRuntime_Initialize(); + status = _PyRuntime_Initialize(); if (_PyStatus_EXCEPTION(status)) { return status; } - _PyRuntimeState *runtime = &_PyRuntime; + runtime = &_PyRuntime; if (runtime->preinitialized) { /* Already initialized: do nothing */ return _PyStatus_OK(); } - PyPreConfig preconfig; - _PyPreConfig_InitFromConfig(&preconfig, config); if (!config->parse_argv) { return Py_PreInitialize(&preconfig); } else if (args == NULL) { - _PyArgv config_args = { - .use_bytes_argv = 0, - .argc = config->argv.length, - .wchar_argv = config->argv.items}; + config_args.use_bytes_argv = 0; + config_args.argc = config->argv.length; + config_args.wchar_argv = config->argv.items; return _Py_PreInitializeFromPyArgv(&preconfig, &config_args); } else { @@ -1039,13 +1095,13 @@ pyinit_core(_PyRuntimeState *runtime, PyThreadState **tstate_p) { PyStatus status; + PyConfig config; status = _Py_PreInitializeFromConfig(src_config, NULL); if (_PyStatus_EXCEPTION(status)) { return status; } - PyConfig config; PyConfig_InitPythonConfig(&config); status = _PyConfig_Copy(&config, src_config); @@ -1093,14 +1149,13 @@ static PyStatus init_interp_main(PyThreadState *tstate) { extern void _PyThread_debug_deprecation(void); - - assert(!_PyErr_Occurred(tstate)); - PyStatus status; int is_main_interp = _Py_IsMainInterpreter(tstate->interp); PyInterpreterState *interp = tstate->interp; const PyConfig *config = _PyInterpreterState_GetConfig(interp); + assert(!_PyErr_Occurred(tstate)); + if (!config->_install_importlib) { /* Special mode for freeze_importlib: run with no import system * @@ -1218,7 +1273,10 @@ init_interp_main(PyThreadState *tstate) static PyStatus pyinit_main(PyThreadState *tstate) { - PyInterpreterState *interp = tstate->interp; + PyInterpreterState *interp; + PyStatus status; + + interp = tstate->interp; if (!interp->runtime->core_initialized) { return _PyStatus_ERR("runtime core not initialized"); } @@ -1227,7 +1285,7 @@ pyinit_main(PyThreadState *tstate) return pyinit_main_reconfigure(tstate); } - PyStatus status = init_interp_main(tstate); + status = init_interp_main(tstate); if (_PyStatus_EXCEPTION(status)) { return status; } @@ -1238,19 +1296,21 @@ pyinit_main(PyThreadState *tstate) PyStatus Py_InitializeFromConfig(const PyConfig *config) { + PyStatus status; + _PyRuntimeState *runtime; + PyThreadState *tstate; + if (config == NULL) { return _PyStatus_ERR("initialization config is NULL"); } - PyStatus status; - status = _PyRuntime_Initialize(); if (_PyStatus_EXCEPTION(status)) { return status; } - _PyRuntimeState *runtime = &_PyRuntime; + runtime = &_PyRuntime; - PyThreadState *tstate = NULL; + tstate = NULL; status = pyinit_core(runtime, config, &tstate); if (_PyStatus_EXCEPTION(status)) { return status; @@ -1272,19 +1332,20 @@ void Py_InitializeEx(int install_sigs) { PyStatus status; + _PyRuntimeState *runtime; + PyConfig config; status = _PyRuntime_Initialize(); if (_PyStatus_EXCEPTION(status)) { Py_ExitStatusException(status); } - _PyRuntimeState *runtime = &_PyRuntime; + runtime = &_PyRuntime; if (runtime->initialized) { /* bpo-33932: Calling Py_Initialize() twice does nothing. */ return; } - PyConfig config; _PyConfig_InitCompatConfig(&config); config.install_signal_handlers = install_sigs; @@ -1302,20 +1363,24 @@ Py_Initialize(void) Py_InitializeEx(1); } - PyStatus _Py_InitializeMain(void) { - PyStatus status = _PyRuntime_Initialize(); + PyStatus status; + _PyRuntimeState *runtime; + PyThreadState *tstate; + + status = _PyRuntime_Initialize(); if (_PyStatus_EXCEPTION(status)) { return status; } - _PyRuntimeState *runtime = &_PyRuntime; - PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime); + runtime = &_PyRuntime; + tstate = _PyRuntimeState_GetThreadState(runtime); return pyinit_main(tstate); } + static void finalize_modules_delete_special(PyThreadState *tstate, int verbose) { @@ -1336,6 +1401,9 @@ finalize_modules_delete_special(PyThreadState *tstate, int verbose) }; PyInterpreterState *interp = tstate->interp; + const char * const *p; + PyObject *value; + if (verbose) { PySys_WriteStderr("# clear builtins._\n"); } @@ -1343,8 +1411,8 @@ finalize_modules_delete_special(PyThreadState *tstate, int verbose) PyErr_WriteUnraisable(NULL); } - const char * const *p; - for (p = sys_deletes; *p != NULL; p++) { + p = sys_deletes; + for (; *p != NULL; p++) { if (verbose) { PySys_WriteStderr("# clear sys.%s\n", *p); } @@ -1358,8 +1426,8 @@ finalize_modules_delete_special(PyThreadState *tstate, int verbose) if (verbose) { PySys_WriteStderr("# restore sys.%s\n", name); } - PyObject *value = _PyDict_GetItemStringWithError(interp->sysdict, - orig_name); + value = _PyDict_GetItemStringWithError(interp->sysdict, + orig_name); if (value == NULL) { if (_PyErr_Occurred(tstate)) { PyErr_WriteUnraisable(NULL); @@ -1479,16 +1547,22 @@ static void finalize_modules_clear_weaklist(PyInterpreterState *interp, PyObject *weaklist, int verbose) { + Py_ssize_t i; + PyObject *tup; + PyObject *name; + PyObject *mod; + PyObject *dict; + // First clear modules imported later - for (Py_ssize_t i = PyList_GET_SIZE(weaklist) - 1; i >= 0; i--) { - PyObject *tup = PyList_GET_ITEM(weaklist, i); - PyObject *name = PyTuple_GET_ITEM(tup, 0); - PyObject *mod = PyWeakref_GET_OBJECT(PyTuple_GET_ITEM(tup, 1)); + for (i = PyList_GET_SIZE(weaklist) - 1; i >= 0; i--) { + tup = PyList_GET_ITEM(weaklist, i); + name = PyTuple_GET_ITEM(tup, 0); + mod = PyWeakref_GET_OBJECT(PyTuple_GET_ITEM(tup, 1)); if (mod == Py_None) { continue; } assert(PyModule_Check(mod)); - PyObject *dict = PyModule_GetDict(mod); + dict = PyModule_GetDict(mod); if (dict == interp->builtins || dict == interp->sysdict) { continue; } @@ -1525,11 +1599,14 @@ finalize_modules(PyThreadState *tstate) { PyInterpreterState *interp = tstate->interp; PyObject *modules = interp->modules; + int verbose; + PyObject *weaklist; + if (modules == NULL) { // Already done return; } - int verbose = _PyInterpreterState_GetConfig(interp)->verbose; + verbose = _PyInterpreterState_GetConfig(interp)->verbose; // Delete some special builtins._ and sys attributes first. These are // common places where user values hide and people complain when their @@ -1547,7 +1624,7 @@ finalize_modules(PyThreadState *tstate) // modules when they are removed from sys.modules. The name is used // for diagnosis messages (in verbose mode), while the weakref helps // detect those modules which have been held alive. - PyObject *weaklist = finalize_remove_modules(modules, verbose); + weaklist = finalize_remove_modules(modules, verbose); // Clear the modules dict finalize_clear_modules_dict(modules); @@ -1751,14 +1828,26 @@ int Py_FinalizeEx(void) { int status = 0; - _PyRuntimeState *runtime = &_PyRuntime; + PyThreadState *tstate; +#ifdef Py_REF_DEBUG + int show_ref_count; +#endif +#ifdef Py_TRACE_REFS + int dump_refs; + wchar_t *dump_refs_file; + FILE *dump_refs_fp; +#endif +#ifdef WITH_PYMALLOC + int malloc_stats; +#endif + if (!runtime->initialized) { return status; } /* Get current thread state and interpreter pointer */ - PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime); + tstate = _PyRuntimeState_GetThreadState(runtime); // Wrap up existing "threading"-module-created, non-daemon threads. wait_for_thread_shutdown(tstate); @@ -1781,14 +1870,14 @@ Py_FinalizeEx(void) /* Copy the core config, PyInterpreterState_Delete() free the core config memory */ #ifdef Py_REF_DEBUG - int show_ref_count = tstate->interp->config.show_ref_count; + show_ref_count = tstate->interp->config.show_ref_count; #endif #ifdef Py_TRACE_REFS - int dump_refs = tstate->interp->config.dump_refs; - wchar_t *dump_refs_file = tstate->interp->config.dump_refs_file; + dump_refs = tstate->interp->config.dump_refs; + dump_refs_file = tstate->interp->config.dump_refs_file; #endif #ifdef WITH_PYMALLOC - int malloc_stats = tstate->interp->config.malloc_stats; + malloc_stats = tstate->interp->config.malloc_stats; #endif /* Remaining daemon threads will automatically exit @@ -1879,7 +1968,7 @@ Py_FinalizeEx(void) * up later. */ - FILE *dump_refs_fp = NULL; + dump_refs_fp = NULL; if (dump_refs_file != NULL) { dump_refs_fp = _Py_wfopen(dump_refs_file, L"w"); if (dump_refs_fp == NULL) { @@ -1956,12 +2045,17 @@ static PyStatus new_interpreter(PyThreadState **tstate_p, int isolated_subinterpreter) { PyStatus status; + _PyRuntimeState *runtime; + PyInterpreterState *interp; + PyThreadState *tstate; + PyThreadState *save_tstate; + const PyConfig *config; status = _PyRuntime_Initialize(); if (_PyStatus_EXCEPTION(status)) { return status; } - _PyRuntimeState *runtime = &_PyRuntime; + runtime = &_PyRuntime; if (!runtime->initialized) { return _PyStatus_ERR("Py_Initialize must be called first"); @@ -1971,23 +2065,22 @@ new_interpreter(PyThreadState **tstate_p, int isolated_subinterpreter) interpreters: disable PyGILState_Check(). */ runtime->gilstate.check_enabled = 0; - PyInterpreterState *interp = PyInterpreterState_New(); + interp = PyInterpreterState_New(); if (interp == NULL) { *tstate_p = NULL; return _PyStatus_OK(); } - PyThreadState *tstate = PyThreadState_New(interp); + tstate = PyThreadState_New(interp); if (tstate == NULL) { PyInterpreterState_Delete(interp); *tstate_p = NULL; return _PyStatus_OK(); } - PyThreadState *save_tstate = PyThreadState_Swap(tstate); + save_tstate = PyThreadState_Swap(tstate); /* Copy the current interpreter config into the new interpreter */ - const PyConfig *config; if (save_tstate != NULL) { config = _PyInterpreterState_GetConfig(save_tstate->interp); } @@ -2099,7 +2192,7 @@ Py_EndInterpreter(PyThreadState *tstate) static PyStatus add_main_module(PyInterpreterState *interp) { - PyObject *m, *d, *loader, *ann_dict; + PyObject *m, *d, *loader, *ann_dict, *bimod, *loader_obj; m = PyImport_AddModule("__main__"); if (m == NULL) return _PyStatus_ERR("can't create __main__ module"); @@ -2116,7 +2209,7 @@ add_main_module(PyInterpreterState *interp) if (PyErr_Occurred()) { return _PyStatus_ERR("Failed to test __main__.__builtins__"); } - PyObject *bimod = PyImport_ImportModule("builtins"); + bimod = PyImport_ImportModule("builtins"); if (bimod == NULL) { return _PyStatus_ERR("Failed to retrieve builtins module"); } @@ -2137,15 +2230,15 @@ add_main_module(PyInterpreterState *interp) if (PyErr_Occurred()) { return _PyStatus_ERR("Failed to test __main__.__loader__"); } - PyObject *loader = PyObject_GetAttrString(interp->importlib, - "BuiltinImporter"); - if (loader == NULL) { + loader_obj = PyObject_GetAttrString(interp->importlib, + "BuiltinImporter"); + if (loader_obj == NULL) { return _PyStatus_ERR("Failed to retrieve BuiltinImporter"); } - if (PyDict_SetItemString(d, "__loader__", loader) < 0) { + if (PyDict_SetItemString(d, "__loader__", loader_obj) < 0) { return _PyStatus_ERR("Failed to initialize __main__.__loader__"); } - Py_DECREF(loader); + Py_DECREF(loader_obj); } return _PyStatus_OK(); } @@ -2185,6 +2278,18 @@ is_valid_fd(int fd) Only use dup() on Linux where dup() is enough to detect invalid FD (bpo-32849). */ +#if defined(F_GETFD) && ( \ + defined(__linux__) || \ + defined(__APPLE__) || \ + defined(__wasm__)) +#elif defined(__linux__) + int fd2; +#elif defined(MS_WINDOWS) + HANDLE hfile; +#else + struct stat st; +#endif + if (fd < 0) { return 0; } @@ -2194,20 +2299,18 @@ is_valid_fd(int fd) defined(__wasm__)) return fcntl(fd, F_GETFD) >= 0; #elif defined(__linux__) - int fd2 = dup(fd); + fd2 = dup(fd); if (fd2 >= 0) { close(fd2); } return (fd2 >= 0); #elif defined(MS_WINDOWS) - HANDLE hfile; _Py_BEGIN_SUPPRESS_IPH hfile = (HANDLE)_get_osfhandle(fd); _Py_END_SUPPRESS_IPH return (hfile != INVALID_HANDLE_VALUE && GetFileType(hfile) != FILE_TYPE_UNKNOWN); #else - struct stat st; return (fstat(fd, &st) == 0); #endif } @@ -2219,6 +2322,7 @@ create_stdio(const PyConfig *config, PyObject* io, const wchar_t* encoding, const wchar_t* errors) { PyObject *buf = NULL, *stream = NULL, *text = NULL, *raw = NULL, *res; + PyObject *encoding_str, *errors_str; const char* mode; const char* newline; PyObject *line_buffering, *write_through; @@ -2297,13 +2401,13 @@ create_stdio(const PyConfig *config, PyObject* io, newline = "\n"; #endif - PyObject *encoding_str = PyUnicode_FromWideChar(encoding, -1); + encoding_str = PyUnicode_FromWideChar(encoding, -1); if (encoding_str == NULL) { Py_CLEAR(buf); goto error; } - PyObject *errors_str = PyUnicode_FromWideChar(errors, -1); + errors_str = PyUnicode_FromWideChar(errors, -1); if (errors_str == NULL) { Py_CLEAR(buf); Py_CLEAR(encoding_str); @@ -2590,8 +2694,10 @@ fatal_output_debug(const char *msg) static void fatal_error_dump_runtime(int fd, _PyRuntimeState *runtime) { + PyThreadState *finalizing; + PUTS(fd, "Python runtime state: "); - PyThreadState *finalizing = _PyRuntimeState_GetFinalizing(runtime); + finalizing = _PyRuntimeState_GetFinalizing(runtime); if (finalizing) { PUTS(fd, "finalizing (tstate=0x"); _Py_DumpHexadecimal(fd, (uintptr_t)finalizing, sizeof(finalizing) * 2); @@ -2640,21 +2746,25 @@ fatal_error_exit(int status) void _Py_DumpExtensionModules(int fd, PyInterpreterState *interp) { + PyObject *modules; + Py_ssize_t pos; + PyObject *key, *value; + PyObject *stdlib_module_names; + int header; + Py_ssize_t count; + if (interp == NULL) { return; } - PyObject *modules = interp->modules; + modules = interp->modules; if (modules == NULL || !PyDict_Check(modules)) { return; } - Py_ssize_t pos; - PyObject *key, *value; - // Avoid PyDict_GetItemString() which calls PyUnicode_FromString(), // memory cannot be allocated on the heap in a signal handler. // Iterate on the dict instead. - PyObject *stdlib_module_names = NULL; + stdlib_module_names = NULL; if (interp->sysdict != NULL) { pos = 0; while (PyDict_Next(interp->sysdict, &pos, &key, &value)) { @@ -2672,8 +2782,8 @@ _Py_DumpExtensionModules(int fd, PyInterpreterState *interp) } // List extensions - int header = 1; - Py_ssize_t count = 0; + header = 1; + count = 0; pos = 0; while (PyDict_Next(modules, &pos, &key, &value)) { if (!PyUnicode_Check(key)) { @@ -2730,6 +2840,11 @@ fatal_error(int fd, int header, const char *prefix, const char *msg, int status) { static int reentrant = 0; + _PyRuntimeState *runtime; + PyThreadState *tstate; + PyInterpreterState *interp; + PyThreadState *tss_tstate; + int has_tstate_and_gil; if (reentrant) { /* Py_FatalError() caused a second fatal error. @@ -2753,7 +2868,7 @@ fatal_error(int fd, int header, const char *prefix, const char *msg, PUTS(fd, "\n"); } - _PyRuntimeState *runtime = &_PyRuntime; + runtime = &_PyRuntime; fatal_error_dump_runtime(fd, runtime); /* Check if the current thread has a Python thread state @@ -2764,16 +2879,16 @@ fatal_error(int fd, int header, const char *prefix, const char *msg, tss_tstate != tstate if the current Python thread does not hold the GIL. */ - PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime); - PyInterpreterState *interp = NULL; - PyThreadState *tss_tstate = PyGILState_GetThisThreadState(); + tstate = _PyRuntimeState_GetThreadState(runtime); + interp = NULL; + tss_tstate = PyGILState_GetThisThreadState(); if (tstate != NULL) { interp = tstate->interp; } else if (tss_tstate != NULL) { interp = tss_tstate->interp; } - int has_tstate_and_gil = (tss_tstate != NULL && tss_tstate == tstate); + has_tstate_and_gil = (tss_tstate != NULL && tss_tstate == tstate); if (has_tstate_and_gil) { /* If an exception is set, print the exception with its traceback */ @@ -2828,21 +2943,24 @@ void _Py_NO_RETURN _Py_FatalErrorFormat(const char *func, const char *format, ...) { static int reentrant = 0; + FILE *stream; + int fd; + va_list vargs; + if (reentrant) { /* _Py_FatalErrorFormat() caused a second fatal error */ fatal_error_exit(-1); } reentrant = 1; - FILE *stream = stderr; - const int fd = fileno(stream); + stream = stderr; + fd = fileno(stream); PUTS(fd, "Fatal Python error: "); if (func) { PUTS(fd, func); PUTS(fd, ": "); } - va_list vargs; #ifdef HAVE_STDARG_PROTOTYPES va_start(vargs, format); #else @@ -2921,10 +3039,12 @@ int Py_AtExit(void (*func)(void)) static void call_ll_exitfuncs(_PyRuntimeState *runtime) { + void (*exitfunc)(void); + while (runtime->nexitfuncs > 0) { /* pop last function from the list */ runtime->nexitfuncs--; - void (*exitfunc)(void) = runtime->exitfuncs[runtime->nexitfuncs]; + exitfunc = runtime->exitfuncs[runtime->nexitfuncs]; runtime->exitfuncs[runtime->nexitfuncs] = NULL; exitfunc(); diff --git a/Python/pystate.c b/Python/pystate.c index a451166..f26d2c2 100644 --- a/Python/pystate.c +++ b/Python/pystate.c @@ -50,9 +50,1127 @@ static void _PyThreadState_Delete(PyThreadState *tstate, int check_current); /* Suppress deprecation warning for PyBytesObject.ob_shash */ _Py_COMP_DIAG_PUSH _Py_COMP_DIAG_IGNORE_DEPR_DECLS +#if defined(_MSC_VER) && _MSC_VER < 1300 +/* We use an explicit field-by-field initializer on VC6, which cannot parse + the C99 designated initializer used by _PyRuntimeState_INIT. */ + +static void +init_immortal_object(PyObject *op, PyTypeObject *type) +{ +#ifdef Py_TRACE_REFS + op->_ob_next = NULL; + op->_ob_prev = NULL; +#endif + op->ob_refcnt = 999999999; + op->ob_type = type; +} + +static void +init_immortal_varobject(PyVarObject *op, PyTypeObject *type, Py_ssize_t size) +{ + init_immortal_object(&op->ob_base, type); + op->ob_size = size; +} + +static void +init_ascii_object(PyASCIIObject *ascii, uint8_t *data, + const char *literal, int is_ascii) +{ + size_t len = strlen(literal); + init_immortal_object(&ascii->ob_base, &PyUnicode_Type); + ascii->length = (Py_ssize_t)len; + ascii->hash = -1; + ascii->state.interned = 0; + ascii->state.kind = 1; + ascii->state.compact = 1; + ascii->state.ascii = is_ascii; + ascii->state.ready = 1; + ascii->wstr = NULL; + memcpy(data, literal, len + 1); +} + +static void +init_latin1_object(PyCompactUnicodeObject *latin1, uint8_t *data, + unsigned char ch) +{ + char literal[2]; + literal[0] = (char)ch; + literal[1] = '\0'; + init_ascii_object(&latin1->_base, data, literal, 0); + latin1->utf8_length = 0; + latin1->utf8 = NULL; + latin1->wstr_length = 0; +} + +static void +init_static_threadstate(PyThreadState *tstate) +{ + tstate->_static = 1; + tstate->recursion_limit = Py_DEFAULT_RECURSION_LIMIT; + tstate->context_ver = 1; +} + +static void +init_static_interpreter(PyInterpreterState *interp) +{ + interp->_static = 1; + interp->id_refcount = -1; +#ifdef HAVE_DLOPEN + interp->dlopenflags = _Py_DLOPEN_FLAGS; +#endif + interp->ceval.recursion_limit = Py_DEFAULT_RECURSION_LIMIT; + interp->gc.enabled = 1; + interp->gc.generations[0].threshold = 700; + interp->gc.generations[1].threshold = 10; + interp->gc.generations[2].threshold = 10; + init_static_threadstate(&interp->_initial_thread); +} + +static void +init_small_int(PyLongObject *op, int value) +{ + int size = 0; + int digit_value = value; + if (value < 0) { + size = -1; + digit_value = -value; + } + else if (value > 0) { + size = 1; + } + init_immortal_varobject(&op->ob_base, &PyLong_Type, size); + op->ob_digit[0] = (digit)digit_value; +} + +static void +init_static_global_objects(struct _Py_global_objects *objects) +{ + int i; + + for (i = 0; i < _PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS; i++) { + init_small_int(&objects->singletons.small_ints[i], + i - _PY_NSMALLNEGINTS); + } + + init_immortal_varobject(&objects->singletons.bytes_empty.ob_base, + &PyBytes_Type, 0); + objects->singletons.bytes_empty.ob_shash = -1; + objects->singletons.bytes_empty.ob_sval[0] = '\0'; + + for (i = 0; i < 256; i++) { + init_immortal_varobject(&objects->singletons.bytes_characters[i].ob.ob_base, + &PyBytes_Type, 1); + objects->singletons.bytes_characters[i].ob.ob_shash = -1; + objects->singletons.bytes_characters[i].ob.ob_sval[0] = (char)i; + objects->singletons.bytes_characters[i].eos = '\0'; + } + init_ascii_object(&objects->singletons.strings.literals._anon_dictcomp._ascii, + objects->singletons.strings.literals._anon_dictcomp._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._anon_genexpr._ascii, + objects->singletons.strings.literals._anon_genexpr._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._anon_lambda._ascii, + objects->singletons.strings.literals._anon_lambda._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._anon_listcomp._ascii, + objects->singletons.strings.literals._anon_listcomp._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._anon_module._ascii, + objects->singletons.strings.literals._anon_module._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._anon_setcomp._ascii, + objects->singletons.strings.literals._anon_setcomp._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._anon_string._ascii, + objects->singletons.strings.literals._anon_string._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._anon_unknown._ascii, + objects->singletons.strings.literals._anon_unknown._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._close_br._ascii, + objects->singletons.strings.literals._close_br._data, + "}", 1); + init_ascii_object(&objects->singletons.strings.literals._comma_sep._ascii, + objects->singletons.strings.literals._comma_sep._data, + ", ", 1); + init_ascii_object(&objects->singletons.strings.literals._dbl_close_br._ascii, + objects->singletons.strings.literals._dbl_close_br._data, + "}}", 1); + init_ascii_object(&objects->singletons.strings.literals._dbl_open_br._ascii, + objects->singletons.strings.literals._dbl_open_br._data, + "{{", 1); + init_ascii_object(&objects->singletons.strings.literals._dbl_percent._ascii, + objects->singletons.strings.literals._dbl_percent._data, + "%%", 1); + init_ascii_object(&objects->singletons.strings.literals._dot._ascii, + objects->singletons.strings.literals._dot._data, + ".", 1); + init_ascii_object(&objects->singletons.strings.literals._dot_locals._ascii, + objects->singletons.strings.literals._dot_locals._data, + ".", 1); + init_ascii_object(&objects->singletons.strings.literals._empty._ascii, + objects->singletons.strings.literals._empty._data, + "", 1); + init_ascii_object(&objects->singletons.strings.literals._list_err._ascii, + objects->singletons.strings.literals._list_err._data, + "list index out of range", 1); + init_ascii_object(&objects->singletons.strings.literals._newline._ascii, + objects->singletons.strings.literals._newline._data, + "\n", 1); + init_ascii_object(&objects->singletons.strings.literals._open_br._ascii, + objects->singletons.strings.literals._open_br._data, + "{", 1); + init_ascii_object(&objects->singletons.strings.literals._percent._ascii, + objects->singletons.strings.literals._percent._data, + "%", 1); + init_ascii_object(&objects->singletons.strings.literals._utf_8._ascii, + objects->singletons.strings.literals._utf_8._data, + "utf-8", 1); + init_ascii_object(&objects->singletons.strings.identifiers._False._ascii, + objects->singletons.strings.identifiers._False._data, + "False", 1); + init_ascii_object(&objects->singletons.strings.identifiers._Py_Repr._ascii, + objects->singletons.strings.identifiers._Py_Repr._data, + "Py_Repr", 1); + init_ascii_object(&objects->singletons.strings.identifiers._TextIOWrapper._ascii, + objects->singletons.strings.identifiers._TextIOWrapper._data, + "TextIOWrapper", 1); + init_ascii_object(&objects->singletons.strings.identifiers._True._ascii, + objects->singletons.strings.identifiers._True._data, + "True", 1); + init_ascii_object(&objects->singletons.strings.identifiers._WarningMessage._ascii, + objects->singletons.strings.identifiers._WarningMessage._data, + "WarningMessage", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__._ascii, + objects->singletons.strings.identifiers.__._data, + "_", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___IOBase_closed._ascii, + objects->singletons.strings.identifiers.___IOBase_closed._data, + "__IOBase_closed", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___abc_tpflags__._ascii, + objects->singletons.strings.identifiers.___abc_tpflags__._data, + "__abc_tpflags__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___abs__._ascii, + objects->singletons.strings.identifiers.___abs__._data, + "__abs__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___abstractmethods__._ascii, + objects->singletons.strings.identifiers.___abstractmethods__._data, + "__abstractmethods__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___add__._ascii, + objects->singletons.strings.identifiers.___add__._data, + "__add__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___aenter__._ascii, + objects->singletons.strings.identifiers.___aenter__._data, + "__aenter__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___aexit__._ascii, + objects->singletons.strings.identifiers.___aexit__._data, + "__aexit__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___aiter__._ascii, + objects->singletons.strings.identifiers.___aiter__._data, + "__aiter__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___all__._ascii, + objects->singletons.strings.identifiers.___all__._data, + "__all__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___and__._ascii, + objects->singletons.strings.identifiers.___and__._data, + "__and__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___anext__._ascii, + objects->singletons.strings.identifiers.___anext__._data, + "__anext__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___annotations__._ascii, + objects->singletons.strings.identifiers.___annotations__._data, + "__annotations__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___args__._ascii, + objects->singletons.strings.identifiers.___args__._data, + "__args__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___await__._ascii, + objects->singletons.strings.identifiers.___await__._data, + "__await__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___bases__._ascii, + objects->singletons.strings.identifiers.___bases__._data, + "__bases__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___bool__._ascii, + objects->singletons.strings.identifiers.___bool__._data, + "__bool__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___build_class__._ascii, + objects->singletons.strings.identifiers.___build_class__._data, + "__build_class__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___builtins__._ascii, + objects->singletons.strings.identifiers.___builtins__._data, + "__builtins__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___bytes__._ascii, + objects->singletons.strings.identifiers.___bytes__._data, + "__bytes__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___call__._ascii, + objects->singletons.strings.identifiers.___call__._data, + "__call__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___cantrace__._ascii, + objects->singletons.strings.identifiers.___cantrace__._data, + "__cantrace__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___class__._ascii, + objects->singletons.strings.identifiers.___class__._data, + "__class__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___class_getitem__._ascii, + objects->singletons.strings.identifiers.___class_getitem__._data, + "__class_getitem__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___classcell__._ascii, + objects->singletons.strings.identifiers.___classcell__._data, + "__classcell__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___complex__._ascii, + objects->singletons.strings.identifiers.___complex__._data, + "__complex__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___contains__._ascii, + objects->singletons.strings.identifiers.___contains__._data, + "__contains__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___copy__._ascii, + objects->singletons.strings.identifiers.___copy__._data, + "__copy__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___del__._ascii, + objects->singletons.strings.identifiers.___del__._data, + "__del__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___delattr__._ascii, + objects->singletons.strings.identifiers.___delattr__._data, + "__delattr__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___delete__._ascii, + objects->singletons.strings.identifiers.___delete__._data, + "__delete__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___delitem__._ascii, + objects->singletons.strings.identifiers.___delitem__._data, + "__delitem__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___dict__._ascii, + objects->singletons.strings.identifiers.___dict__._data, + "__dict__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___dir__._ascii, + objects->singletons.strings.identifiers.___dir__._data, + "__dir__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___divmod__._ascii, + objects->singletons.strings.identifiers.___divmod__._data, + "__divmod__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___doc__._ascii, + objects->singletons.strings.identifiers.___doc__._data, + "__doc__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___enter__._ascii, + objects->singletons.strings.identifiers.___enter__._data, + "__enter__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___eq__._ascii, + objects->singletons.strings.identifiers.___eq__._data, + "__eq__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___exit__._ascii, + objects->singletons.strings.identifiers.___exit__._data, + "__exit__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___file__._ascii, + objects->singletons.strings.identifiers.___file__._data, + "__file__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___float__._ascii, + objects->singletons.strings.identifiers.___float__._data, + "__float__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___floordiv__._ascii, + objects->singletons.strings.identifiers.___floordiv__._data, + "__floordiv__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___format__._ascii, + objects->singletons.strings.identifiers.___format__._data, + "__format__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___fspath__._ascii, + objects->singletons.strings.identifiers.___fspath__._data, + "__fspath__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ge__._ascii, + objects->singletons.strings.identifiers.___ge__._data, + "__ge__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___get__._ascii, + objects->singletons.strings.identifiers.___get__._data, + "__get__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___getattr__._ascii, + objects->singletons.strings.identifiers.___getattr__._data, + "__getattr__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___getattribute__._ascii, + objects->singletons.strings.identifiers.___getattribute__._data, + "__getattribute__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___getinitargs__._ascii, + objects->singletons.strings.identifiers.___getinitargs__._data, + "__getinitargs__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___getitem__._ascii, + objects->singletons.strings.identifiers.___getitem__._data, + "__getitem__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___getnewargs__._ascii, + objects->singletons.strings.identifiers.___getnewargs__._data, + "__getnewargs__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___getnewargs_ex__._ascii, + objects->singletons.strings.identifiers.___getnewargs_ex__._data, + "__getnewargs_ex__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___getstate__._ascii, + objects->singletons.strings.identifiers.___getstate__._data, + "__getstate__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___gt__._ascii, + objects->singletons.strings.identifiers.___gt__._data, + "__gt__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___hash__._ascii, + objects->singletons.strings.identifiers.___hash__._data, + "__hash__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___iadd__._ascii, + objects->singletons.strings.identifiers.___iadd__._data, + "__iadd__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___iand__._ascii, + objects->singletons.strings.identifiers.___iand__._data, + "__iand__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ifloordiv__._ascii, + objects->singletons.strings.identifiers.___ifloordiv__._data, + "__ifloordiv__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ilshift__._ascii, + objects->singletons.strings.identifiers.___ilshift__._data, + "__ilshift__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___imatmul__._ascii, + objects->singletons.strings.identifiers.___imatmul__._data, + "__imatmul__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___imod__._ascii, + objects->singletons.strings.identifiers.___imod__._data, + "__imod__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___import__._ascii, + objects->singletons.strings.identifiers.___import__._data, + "__import__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___imul__._ascii, + objects->singletons.strings.identifiers.___imul__._data, + "__imul__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___index__._ascii, + objects->singletons.strings.identifiers.___index__._data, + "__index__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___init__._ascii, + objects->singletons.strings.identifiers.___init__._data, + "__init__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___init_subclass__._ascii, + objects->singletons.strings.identifiers.___init_subclass__._data, + "__init_subclass__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___instancecheck__._ascii, + objects->singletons.strings.identifiers.___instancecheck__._data, + "__instancecheck__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___int__._ascii, + objects->singletons.strings.identifiers.___int__._data, + "__int__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___invert__._ascii, + objects->singletons.strings.identifiers.___invert__._data, + "__invert__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ior__._ascii, + objects->singletons.strings.identifiers.___ior__._data, + "__ior__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ipow__._ascii, + objects->singletons.strings.identifiers.___ipow__._data, + "__ipow__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___irshift__._ascii, + objects->singletons.strings.identifiers.___irshift__._data, + "__irshift__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___isabstractmethod__._ascii, + objects->singletons.strings.identifiers.___isabstractmethod__._data, + "__isabstractmethod__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___isub__._ascii, + objects->singletons.strings.identifiers.___isub__._data, + "__isub__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___iter__._ascii, + objects->singletons.strings.identifiers.___iter__._data, + "__iter__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___itruediv__._ascii, + objects->singletons.strings.identifiers.___itruediv__._data, + "__itruediv__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ixor__._ascii, + objects->singletons.strings.identifiers.___ixor__._data, + "__ixor__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___le__._ascii, + objects->singletons.strings.identifiers.___le__._data, + "__le__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___len__._ascii, + objects->singletons.strings.identifiers.___len__._data, + "__len__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___length_hint__._ascii, + objects->singletons.strings.identifiers.___length_hint__._data, + "__length_hint__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___lltrace__._ascii, + objects->singletons.strings.identifiers.___lltrace__._data, + "__lltrace__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___loader__._ascii, + objects->singletons.strings.identifiers.___loader__._data, + "__loader__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___lshift__._ascii, + objects->singletons.strings.identifiers.___lshift__._data, + "__lshift__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___lt__._ascii, + objects->singletons.strings.identifiers.___lt__._data, + "__lt__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___main__._ascii, + objects->singletons.strings.identifiers.___main__._data, + "__main__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___matmul__._ascii, + objects->singletons.strings.identifiers.___matmul__._data, + "__matmul__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___missing__._ascii, + objects->singletons.strings.identifiers.___missing__._data, + "__missing__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___mod__._ascii, + objects->singletons.strings.identifiers.___mod__._data, + "__mod__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___module__._ascii, + objects->singletons.strings.identifiers.___module__._data, + "__module__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___mro_entries__._ascii, + objects->singletons.strings.identifiers.___mro_entries__._data, + "__mro_entries__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___mul__._ascii, + objects->singletons.strings.identifiers.___mul__._data, + "__mul__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___name__._ascii, + objects->singletons.strings.identifiers.___name__._data, + "__name__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ne__._ascii, + objects->singletons.strings.identifiers.___ne__._data, + "__ne__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___neg__._ascii, + objects->singletons.strings.identifiers.___neg__._data, + "__neg__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___new__._ascii, + objects->singletons.strings.identifiers.___new__._data, + "__new__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___newobj__._ascii, + objects->singletons.strings.identifiers.___newobj__._data, + "__newobj__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___newobj_ex__._ascii, + objects->singletons.strings.identifiers.___newobj_ex__._data, + "__newobj_ex__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___next__._ascii, + objects->singletons.strings.identifiers.___next__._data, + "__next__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___notes__._ascii, + objects->singletons.strings.identifiers.___notes__._data, + "__notes__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___or__._ascii, + objects->singletons.strings.identifiers.___or__._data, + "__or__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___orig_class__._ascii, + objects->singletons.strings.identifiers.___orig_class__._data, + "__orig_class__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___origin__._ascii, + objects->singletons.strings.identifiers.___origin__._data, + "__origin__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___package__._ascii, + objects->singletons.strings.identifiers.___package__._data, + "__package__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___parameters__._ascii, + objects->singletons.strings.identifiers.___parameters__._data, + "__parameters__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___path__._ascii, + objects->singletons.strings.identifiers.___path__._data, + "__path__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___pos__._ascii, + objects->singletons.strings.identifiers.___pos__._data, + "__pos__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___pow__._ascii, + objects->singletons.strings.identifiers.___pow__._data, + "__pow__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___prepare__._ascii, + objects->singletons.strings.identifiers.___prepare__._data, + "__prepare__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___qualname__._ascii, + objects->singletons.strings.identifiers.___qualname__._data, + "__qualname__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___radd__._ascii, + objects->singletons.strings.identifiers.___radd__._data, + "__radd__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rand__._ascii, + objects->singletons.strings.identifiers.___rand__._data, + "__rand__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rdivmod__._ascii, + objects->singletons.strings.identifiers.___rdivmod__._data, + "__rdivmod__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___reduce__._ascii, + objects->singletons.strings.identifiers.___reduce__._data, + "__reduce__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___reduce_ex__._ascii, + objects->singletons.strings.identifiers.___reduce_ex__._data, + "__reduce_ex__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___repr__._ascii, + objects->singletons.strings.identifiers.___repr__._data, + "__repr__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___reversed__._ascii, + objects->singletons.strings.identifiers.___reversed__._data, + "__reversed__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rfloordiv__._ascii, + objects->singletons.strings.identifiers.___rfloordiv__._data, + "__rfloordiv__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rlshift__._ascii, + objects->singletons.strings.identifiers.___rlshift__._data, + "__rlshift__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rmatmul__._ascii, + objects->singletons.strings.identifiers.___rmatmul__._data, + "__rmatmul__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rmod__._ascii, + objects->singletons.strings.identifiers.___rmod__._data, + "__rmod__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rmul__._ascii, + objects->singletons.strings.identifiers.___rmul__._data, + "__rmul__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___ror__._ascii, + objects->singletons.strings.identifiers.___ror__._data, + "__ror__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___round__._ascii, + objects->singletons.strings.identifiers.___round__._data, + "__round__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rpow__._ascii, + objects->singletons.strings.identifiers.___rpow__._data, + "__rpow__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rrshift__._ascii, + objects->singletons.strings.identifiers.___rrshift__._data, + "__rrshift__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rshift__._ascii, + objects->singletons.strings.identifiers.___rshift__._data, + "__rshift__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rsub__._ascii, + objects->singletons.strings.identifiers.___rsub__._data, + "__rsub__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rtruediv__._ascii, + objects->singletons.strings.identifiers.___rtruediv__._data, + "__rtruediv__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___rxor__._ascii, + objects->singletons.strings.identifiers.___rxor__._data, + "__rxor__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___set__._ascii, + objects->singletons.strings.identifiers.___set__._data, + "__set__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___set_name__._ascii, + objects->singletons.strings.identifiers.___set_name__._data, + "__set_name__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___setattr__._ascii, + objects->singletons.strings.identifiers.___setattr__._data, + "__setattr__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___setitem__._ascii, + objects->singletons.strings.identifiers.___setitem__._data, + "__setitem__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___setstate__._ascii, + objects->singletons.strings.identifiers.___setstate__._data, + "__setstate__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___sizeof__._ascii, + objects->singletons.strings.identifiers.___sizeof__._data, + "__sizeof__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___slotnames__._ascii, + objects->singletons.strings.identifiers.___slotnames__._data, + "__slotnames__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___slots__._ascii, + objects->singletons.strings.identifiers.___slots__._data, + "__slots__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___spec__._ascii, + objects->singletons.strings.identifiers.___spec__._data, + "__spec__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___str__._ascii, + objects->singletons.strings.identifiers.___str__._data, + "__str__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___sub__._ascii, + objects->singletons.strings.identifiers.___sub__._data, + "__sub__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___subclasscheck__._ascii, + objects->singletons.strings.identifiers.___subclasscheck__._data, + "__subclasscheck__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___subclasshook__._ascii, + objects->singletons.strings.identifiers.___subclasshook__._data, + "__subclasshook__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___truediv__._ascii, + objects->singletons.strings.identifiers.___truediv__._data, + "__truediv__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___trunc__._ascii, + objects->singletons.strings.identifiers.___trunc__._data, + "__trunc__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___typing_is_unpacked_typevartuple__._ascii, + objects->singletons.strings.identifiers.___typing_is_unpacked_typevartuple__._data, + "__typing_is_unpacked_typevartuple__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___typing_prepare_subst__._ascii, + objects->singletons.strings.identifiers.___typing_prepare_subst__._data, + "__typing_prepare_subst__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___typing_subst__._ascii, + objects->singletons.strings.identifiers.___typing_subst__._data, + "__typing_subst__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___typing_unpacked_tuple_args__._ascii, + objects->singletons.strings.identifiers.___typing_unpacked_tuple_args__._data, + "__typing_unpacked_tuple_args__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___warningregistry__._ascii, + objects->singletons.strings.identifiers.___warningregistry__._data, + "__warningregistry__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___weakref__._ascii, + objects->singletons.strings.identifiers.___weakref__._data, + "__weakref__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.___xor__._ascii, + objects->singletons.strings.identifiers.___xor__._data, + "__xor__", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__abc_impl._ascii, + objects->singletons.strings.identifiers.__abc_impl._data, + "_abc_impl", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__annotation._ascii, + objects->singletons.strings.identifiers.__annotation._data, + "_annotation", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__blksize._ascii, + objects->singletons.strings.identifiers.__blksize._data, + "_blksize", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__bootstrap._ascii, + objects->singletons.strings.identifiers.__bootstrap._data, + "_bootstrap", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__dealloc_warn._ascii, + objects->singletons.strings.identifiers.__dealloc_warn._data, + "_dealloc_warn", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__finalizing._ascii, + objects->singletons.strings.identifiers.__finalizing._data, + "_finalizing", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__find_and_load._ascii, + objects->singletons.strings.identifiers.__find_and_load._data, + "_find_and_load", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__fix_up_module._ascii, + objects->singletons.strings.identifiers.__fix_up_module._data, + "_fix_up_module", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__get_sourcefile._ascii, + objects->singletons.strings.identifiers.__get_sourcefile._data, + "_get_sourcefile", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__handle_fromlist._ascii, + objects->singletons.strings.identifiers.__handle_fromlist._data, + "_handle_fromlist", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__initializing._ascii, + objects->singletons.strings.identifiers.__initializing._data, + "_initializing", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__is_text_encoding._ascii, + objects->singletons.strings.identifiers.__is_text_encoding._data, + "_is_text_encoding", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__lock_unlock_module._ascii, + objects->singletons.strings.identifiers.__lock_unlock_module._data, + "_lock_unlock_module", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__showwarnmsg._ascii, + objects->singletons.strings.identifiers.__showwarnmsg._data, + "_showwarnmsg", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__shutdown._ascii, + objects->singletons.strings.identifiers.__shutdown._data, + "_shutdown", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__slotnames._ascii, + objects->singletons.strings.identifiers.__slotnames._data, + "_slotnames", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__strptime_time._ascii, + objects->singletons.strings.identifiers.__strptime_time._data, + "_strptime_time", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__uninitialized_submodules._ascii, + objects->singletons.strings.identifiers.__uninitialized_submodules._data, + "_uninitialized_submodules", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__warn_unawaited_coroutine._ascii, + objects->singletons.strings.identifiers.__warn_unawaited_coroutine._data, + "_warn_unawaited_coroutine", 1); + init_ascii_object(&objects->singletons.strings.identifiers.__xoptions._ascii, + objects->singletons.strings.identifiers.__xoptions._data, + "_xoptions", 1); + init_ascii_object(&objects->singletons.strings.identifiers._add._ascii, + objects->singletons.strings.identifiers._add._data, + "add", 1); + init_ascii_object(&objects->singletons.strings.identifiers._append._ascii, + objects->singletons.strings.identifiers._append._data, + "append", 1); + init_ascii_object(&objects->singletons.strings.identifiers._big._ascii, + objects->singletons.strings.identifiers._big._data, + "big", 1); + init_ascii_object(&objects->singletons.strings.identifiers._buffer._ascii, + objects->singletons.strings.identifiers._buffer._data, + "buffer", 1); + init_ascii_object(&objects->singletons.strings.identifiers._builtins._ascii, + objects->singletons.strings.identifiers._builtins._data, + "builtins", 1); + init_ascii_object(&objects->singletons.strings.identifiers._c_call._ascii, + objects->singletons.strings.identifiers._c_call._data, + "c_call", 1); + init_ascii_object(&objects->singletons.strings.identifiers._c_exception._ascii, + objects->singletons.strings.identifiers._c_exception._data, + "c_exception", 1); + init_ascii_object(&objects->singletons.strings.identifiers._c_return._ascii, + objects->singletons.strings.identifiers._c_return._data, + "c_return", 1); + init_ascii_object(&objects->singletons.strings.identifiers._call._ascii, + objects->singletons.strings.identifiers._call._data, + "call", 1); + init_ascii_object(&objects->singletons.strings.identifiers._clear._ascii, + objects->singletons.strings.identifiers._clear._data, + "clear", 1); + init_ascii_object(&objects->singletons.strings.identifiers._close._ascii, + objects->singletons.strings.identifiers._close._data, + "close", 1); + init_ascii_object(&objects->singletons.strings.identifiers._closed._ascii, + objects->singletons.strings.identifiers._closed._data, + "closed", 1); + init_ascii_object(&objects->singletons.strings.identifiers._code._ascii, + objects->singletons.strings.identifiers._code._data, + "code", 1); + init_ascii_object(&objects->singletons.strings.identifiers._copy._ascii, + objects->singletons.strings.identifiers._copy._data, + "copy", 1); + init_ascii_object(&objects->singletons.strings.identifiers._copyreg._ascii, + objects->singletons.strings.identifiers._copyreg._data, + "copyreg", 1); + init_ascii_object(&objects->singletons.strings.identifiers._decode._ascii, + objects->singletons.strings.identifiers._decode._data, + "decode", 1); + init_ascii_object(&objects->singletons.strings.identifiers._default._ascii, + objects->singletons.strings.identifiers._default._data, + "default", 1); + init_ascii_object(&objects->singletons.strings.identifiers._defaultaction._ascii, + objects->singletons.strings.identifiers._defaultaction._data, + "defaultaction", 1); + init_ascii_object(&objects->singletons.strings.identifiers._dictcomp._ascii, + objects->singletons.strings.identifiers._dictcomp._data, + "dictcomp", 1); + init_ascii_object(&objects->singletons.strings.identifiers._difference_update._ascii, + objects->singletons.strings.identifiers._difference_update._data, + "difference_update", 1); + init_ascii_object(&objects->singletons.strings.identifiers._dispatch_table._ascii, + objects->singletons.strings.identifiers._dispatch_table._data, + "dispatch_table", 1); + init_ascii_object(&objects->singletons.strings.identifiers._displayhook._ascii, + objects->singletons.strings.identifiers._displayhook._data, + "displayhook", 1); + init_ascii_object(&objects->singletons.strings.identifiers._enable._ascii, + objects->singletons.strings.identifiers._enable._data, + "enable", 1); + init_ascii_object(&objects->singletons.strings.identifiers._encode._ascii, + objects->singletons.strings.identifiers._encode._data, + "encode", 1); + init_ascii_object(&objects->singletons.strings.identifiers._encoding._ascii, + objects->singletons.strings.identifiers._encoding._data, + "encoding", 1); + init_ascii_object(&objects->singletons.strings.identifiers._end_lineno._ascii, + objects->singletons.strings.identifiers._end_lineno._data, + "end_lineno", 1); + init_ascii_object(&objects->singletons.strings.identifiers._end_offset._ascii, + objects->singletons.strings.identifiers._end_offset._data, + "end_offset", 1); + init_ascii_object(&objects->singletons.strings.identifiers._errors._ascii, + objects->singletons.strings.identifiers._errors._data, + "errors", 1); + init_ascii_object(&objects->singletons.strings.identifiers._excepthook._ascii, + objects->singletons.strings.identifiers._excepthook._data, + "excepthook", 1); + init_ascii_object(&objects->singletons.strings.identifiers._exception._ascii, + objects->singletons.strings.identifiers._exception._data, + "exception", 1); + init_ascii_object(&objects->singletons.strings.identifiers._extend._ascii, + objects->singletons.strings.identifiers._extend._data, + "extend", 1); + init_ascii_object(&objects->singletons.strings.identifiers._filename._ascii, + objects->singletons.strings.identifiers._filename._data, + "filename", 1); + init_ascii_object(&objects->singletons.strings.identifiers._fileno._ascii, + objects->singletons.strings.identifiers._fileno._data, + "fileno", 1); + init_ascii_object(&objects->singletons.strings.identifiers._fillvalue._ascii, + objects->singletons.strings.identifiers._fillvalue._data, + "fillvalue", 1); + init_ascii_object(&objects->singletons.strings.identifiers._filters._ascii, + objects->singletons.strings.identifiers._filters._data, + "filters", 1); + init_ascii_object(&objects->singletons.strings.identifiers._find_class._ascii, + objects->singletons.strings.identifiers._find_class._data, + "find_class", 1); + init_ascii_object(&objects->singletons.strings.identifiers._flush._ascii, + objects->singletons.strings.identifiers._flush._data, + "flush", 1); + init_ascii_object(&objects->singletons.strings.identifiers._genexpr._ascii, + objects->singletons.strings.identifiers._genexpr._data, + "genexpr", 1); + init_ascii_object(&objects->singletons.strings.identifiers._get._ascii, + objects->singletons.strings.identifiers._get._data, + "get", 1); + init_ascii_object(&objects->singletons.strings.identifiers._get_source._ascii, + objects->singletons.strings.identifiers._get_source._data, + "get_source", 1); + init_ascii_object(&objects->singletons.strings.identifiers._getattr._ascii, + objects->singletons.strings.identifiers._getattr._data, + "getattr", 1); + init_ascii_object(&objects->singletons.strings.identifiers._getstate._ascii, + objects->singletons.strings.identifiers._getstate._data, + "getstate", 1); + init_ascii_object(&objects->singletons.strings.identifiers._ignore._ascii, + objects->singletons.strings.identifiers._ignore._data, + "ignore", 1); + init_ascii_object(&objects->singletons.strings.identifiers._importlib._ascii, + objects->singletons.strings.identifiers._importlib._data, + "importlib", 1); + init_ascii_object(&objects->singletons.strings.identifiers._inf._ascii, + objects->singletons.strings.identifiers._inf._data, + "inf", 1); + init_ascii_object(&objects->singletons.strings.identifiers._intersection._ascii, + objects->singletons.strings.identifiers._intersection._data, + "intersection", 1); + init_ascii_object(&objects->singletons.strings.identifiers._isatty._ascii, + objects->singletons.strings.identifiers._isatty._data, + "isatty", 1); + init_ascii_object(&objects->singletons.strings.identifiers._isinstance._ascii, + objects->singletons.strings.identifiers._isinstance._data, + "isinstance", 1); + init_ascii_object(&objects->singletons.strings.identifiers._items._ascii, + objects->singletons.strings.identifiers._items._data, + "items", 1); + init_ascii_object(&objects->singletons.strings.identifiers._iter._ascii, + objects->singletons.strings.identifiers._iter._data, + "iter", 1); + init_ascii_object(&objects->singletons.strings.identifiers._join._ascii, + objects->singletons.strings.identifiers._join._data, + "join", 1); + init_ascii_object(&objects->singletons.strings.identifiers._keys._ascii, + objects->singletons.strings.identifiers._keys._data, + "keys", 1); + init_ascii_object(&objects->singletons.strings.identifiers._lambda._ascii, + objects->singletons.strings.identifiers._lambda._data, + "lambda", 1); + init_ascii_object(&objects->singletons.strings.identifiers._last_traceback._ascii, + objects->singletons.strings.identifiers._last_traceback._data, + "last_traceback", 1); + init_ascii_object(&objects->singletons.strings.identifiers._last_type._ascii, + objects->singletons.strings.identifiers._last_type._data, + "last_type", 1); + init_ascii_object(&objects->singletons.strings.identifiers._last_value._ascii, + objects->singletons.strings.identifiers._last_value._data, + "last_value", 1); + init_ascii_object(&objects->singletons.strings.identifiers._latin1._ascii, + objects->singletons.strings.identifiers._latin1._data, + "latin1", 1); + init_ascii_object(&objects->singletons.strings.identifiers._len._ascii, + objects->singletons.strings.identifiers._len._data, + "len", 1); + init_ascii_object(&objects->singletons.strings.identifiers._line._ascii, + objects->singletons.strings.identifiers._line._data, + "line", 1); + init_ascii_object(&objects->singletons.strings.identifiers._lineno._ascii, + objects->singletons.strings.identifiers._lineno._data, + "lineno", 1); + init_ascii_object(&objects->singletons.strings.identifiers._listcomp._ascii, + objects->singletons.strings.identifiers._listcomp._data, + "listcomp", 1); + init_ascii_object(&objects->singletons.strings.identifiers._little._ascii, + objects->singletons.strings.identifiers._little._data, + "little", 1); + init_ascii_object(&objects->singletons.strings.identifiers._locale._ascii, + objects->singletons.strings.identifiers._locale._data, + "locale", 1); + init_ascii_object(&objects->singletons.strings.identifiers._match._ascii, + objects->singletons.strings.identifiers._match._data, + "match", 1); + init_ascii_object(&objects->singletons.strings.identifiers._metaclass._ascii, + objects->singletons.strings.identifiers._metaclass._data, + "metaclass", 1); + init_ascii_object(&objects->singletons.strings.identifiers._mode._ascii, + objects->singletons.strings.identifiers._mode._data, + "mode", 1); + init_ascii_object(&objects->singletons.strings.identifiers._modules._ascii, + objects->singletons.strings.identifiers._modules._data, + "modules", 1); + init_ascii_object(&objects->singletons.strings.identifiers._mro._ascii, + objects->singletons.strings.identifiers._mro._data, + "mro", 1); + init_ascii_object(&objects->singletons.strings.identifiers._msg._ascii, + objects->singletons.strings.identifiers._msg._data, + "msg", 1); + init_ascii_object(&objects->singletons.strings.identifiers._n_fields._ascii, + objects->singletons.strings.identifiers._n_fields._data, + "n_fields", 1); + init_ascii_object(&objects->singletons.strings.identifiers._n_sequence_fields._ascii, + objects->singletons.strings.identifiers._n_sequence_fields._data, + "n_sequence_fields", 1); + init_ascii_object(&objects->singletons.strings.identifiers._n_unnamed_fields._ascii, + objects->singletons.strings.identifiers._n_unnamed_fields._data, + "n_unnamed_fields", 1); + init_ascii_object(&objects->singletons.strings.identifiers._name._ascii, + objects->singletons.strings.identifiers._name._data, + "name", 1); + init_ascii_object(&objects->singletons.strings.identifiers._newlines._ascii, + objects->singletons.strings.identifiers._newlines._data, + "newlines", 1); + init_ascii_object(&objects->singletons.strings.identifiers._next._ascii, + objects->singletons.strings.identifiers._next._data, + "next", 1); + init_ascii_object(&objects->singletons.strings.identifiers._obj._ascii, + objects->singletons.strings.identifiers._obj._data, + "obj", 1); + init_ascii_object(&objects->singletons.strings.identifiers._offset._ascii, + objects->singletons.strings.identifiers._offset._data, + "offset", 1); + init_ascii_object(&objects->singletons.strings.identifiers._onceregistry._ascii, + objects->singletons.strings.identifiers._onceregistry._data, + "onceregistry", 1); + init_ascii_object(&objects->singletons.strings.identifiers._opcode._ascii, + objects->singletons.strings.identifiers._opcode._data, + "opcode", 1); + init_ascii_object(&objects->singletons.strings.identifiers._open._ascii, + objects->singletons.strings.identifiers._open._data, + "open", 1); + init_ascii_object(&objects->singletons.strings.identifiers._parent._ascii, + objects->singletons.strings.identifiers._parent._data, + "parent", 1); + init_ascii_object(&objects->singletons.strings.identifiers._partial._ascii, + objects->singletons.strings.identifiers._partial._data, + "partial", 1); + init_ascii_object(&objects->singletons.strings.identifiers._path._ascii, + objects->singletons.strings.identifiers._path._data, + "path", 1); + init_ascii_object(&objects->singletons.strings.identifiers._peek._ascii, + objects->singletons.strings.identifiers._peek._data, + "peek", 1); + init_ascii_object(&objects->singletons.strings.identifiers._persistent_id._ascii, + objects->singletons.strings.identifiers._persistent_id._data, + "persistent_id", 1); + init_ascii_object(&objects->singletons.strings.identifiers._persistent_load._ascii, + objects->singletons.strings.identifiers._persistent_load._data, + "persistent_load", 1); + init_ascii_object(&objects->singletons.strings.identifiers._print_file_and_line._ascii, + objects->singletons.strings.identifiers._print_file_and_line._data, + "print_file_and_line", 1); + init_ascii_object(&objects->singletons.strings.identifiers._ps1._ascii, + objects->singletons.strings.identifiers._ps1._data, + "ps1", 1); + init_ascii_object(&objects->singletons.strings.identifiers._ps2._ascii, + objects->singletons.strings.identifiers._ps2._data, + "ps2", 1); + init_ascii_object(&objects->singletons.strings.identifiers._raw._ascii, + objects->singletons.strings.identifiers._raw._data, + "raw", 1); + init_ascii_object(&objects->singletons.strings.identifiers._read._ascii, + objects->singletons.strings.identifiers._read._data, + "read", 1); + init_ascii_object(&objects->singletons.strings.identifiers._read1._ascii, + objects->singletons.strings.identifiers._read1._data, + "read1", 1); + init_ascii_object(&objects->singletons.strings.identifiers._readable._ascii, + objects->singletons.strings.identifiers._readable._data, + "readable", 1); + init_ascii_object(&objects->singletons.strings.identifiers._readall._ascii, + objects->singletons.strings.identifiers._readall._data, + "readall", 1); + init_ascii_object(&objects->singletons.strings.identifiers._readinto._ascii, + objects->singletons.strings.identifiers._readinto._data, + "readinto", 1); + init_ascii_object(&objects->singletons.strings.identifiers._readinto1._ascii, + objects->singletons.strings.identifiers._readinto1._data, + "readinto1", 1); + init_ascii_object(&objects->singletons.strings.identifiers._readline._ascii, + objects->singletons.strings.identifiers._readline._data, + "readline", 1); + init_ascii_object(&objects->singletons.strings.identifiers._reducer_override._ascii, + objects->singletons.strings.identifiers._reducer_override._data, + "reducer_override", 1); + init_ascii_object(&objects->singletons.strings.identifiers._reload._ascii, + objects->singletons.strings.identifiers._reload._data, + "reload", 1); + init_ascii_object(&objects->singletons.strings.identifiers._replace._ascii, + objects->singletons.strings.identifiers._replace._data, + "replace", 1); + init_ascii_object(&objects->singletons.strings.identifiers._reset._ascii, + objects->singletons.strings.identifiers._reset._data, + "reset", 1); + init_ascii_object(&objects->singletons.strings.identifiers._return._ascii, + objects->singletons.strings.identifiers._return._data, + "return", 1); + init_ascii_object(&objects->singletons.strings.identifiers._reversed._ascii, + objects->singletons.strings.identifiers._reversed._data, + "reversed", 1); + init_ascii_object(&objects->singletons.strings.identifiers._seek._ascii, + objects->singletons.strings.identifiers._seek._data, + "seek", 1); + init_ascii_object(&objects->singletons.strings.identifiers._seekable._ascii, + objects->singletons.strings.identifiers._seekable._data, + "seekable", 1); + init_ascii_object(&objects->singletons.strings.identifiers._send._ascii, + objects->singletons.strings.identifiers._send._data, + "send", 1); + init_ascii_object(&objects->singletons.strings.identifiers._setcomp._ascii, + objects->singletons.strings.identifiers._setcomp._data, + "setcomp", 1); + init_ascii_object(&objects->singletons.strings.identifiers._setstate._ascii, + objects->singletons.strings.identifiers._setstate._data, + "setstate", 1); + init_ascii_object(&objects->singletons.strings.identifiers._sort._ascii, + objects->singletons.strings.identifiers._sort._data, + "sort", 1); + init_ascii_object(&objects->singletons.strings.identifiers._stderr._ascii, + objects->singletons.strings.identifiers._stderr._data, + "stderr", 1); + init_ascii_object(&objects->singletons.strings.identifiers._stdin._ascii, + objects->singletons.strings.identifiers._stdin._data, + "stdin", 1); + init_ascii_object(&objects->singletons.strings.identifiers._stdout._ascii, + objects->singletons.strings.identifiers._stdout._data, + "stdout", 1); + init_ascii_object(&objects->singletons.strings.identifiers._strict._ascii, + objects->singletons.strings.identifiers._strict._data, + "strict", 1); + init_ascii_object(&objects->singletons.strings.identifiers._symmetric_difference_update._ascii, + objects->singletons.strings.identifiers._symmetric_difference_update._data, + "symmetric_difference_update", 1); + init_ascii_object(&objects->singletons.strings.identifiers._tell._ascii, + objects->singletons.strings.identifiers._tell._data, + "tell", 1); + init_ascii_object(&objects->singletons.strings.identifiers._text._ascii, + objects->singletons.strings.identifiers._text._data, + "text", 1); + init_ascii_object(&objects->singletons.strings.identifiers._threading._ascii, + objects->singletons.strings.identifiers._threading._data, + "threading", 1); + init_ascii_object(&objects->singletons.strings.identifiers._throw._ascii, + objects->singletons.strings.identifiers._throw._data, + "throw", 1); + init_ascii_object(&objects->singletons.strings.identifiers._top._ascii, + objects->singletons.strings.identifiers._top._data, + "top", 1); + init_ascii_object(&objects->singletons.strings.identifiers._truncate._ascii, + objects->singletons.strings.identifiers._truncate._data, + "truncate", 1); + init_ascii_object(&objects->singletons.strings.identifiers._unraisablehook._ascii, + objects->singletons.strings.identifiers._unraisablehook._data, + "unraisablehook", 1); + init_ascii_object(&objects->singletons.strings.identifiers._values._ascii, + objects->singletons.strings.identifiers._values._data, + "values", 1); + init_ascii_object(&objects->singletons.strings.identifiers._version._ascii, + objects->singletons.strings.identifiers._version._data, + "version", 1); + init_ascii_object(&objects->singletons.strings.identifiers._warnings._ascii, + objects->singletons.strings.identifiers._warnings._data, + "warnings", 1); + init_ascii_object(&objects->singletons.strings.identifiers._warnoptions._ascii, + objects->singletons.strings.identifiers._warnoptions._data, + "warnoptions", 1); + init_ascii_object(&objects->singletons.strings.identifiers._writable._ascii, + objects->singletons.strings.identifiers._writable._data, + "writable", 1); + init_ascii_object(&objects->singletons.strings.identifiers._write._ascii, + objects->singletons.strings.identifiers._write._data, + "write", 1); + init_ascii_object(&objects->singletons.strings.identifiers._zipimporter._ascii, + objects->singletons.strings.identifiers._zipimporter._data, + "zipimporter", 1); + + for (i = 0; i < 128; i++) { + char literal[2]; + literal[0] = (char)i; + literal[1] = '\0'; + init_ascii_object(&objects->singletons.strings.ascii[i]._ascii, + objects->singletons.strings.ascii[i]._data, + literal, 1); + init_latin1_object(&objects->singletons.strings.latin1[i]._latin1, + objects->singletons.strings.latin1[i]._data, + (unsigned char)(i + 128)); + } + + init_immortal_varobject(&objects->singletons.tuple_empty.ob_base, + &PyTuple_Type, 0); +} + +void +_PyRuntimeState_InitStaticDefaults(_PyRuntimeState *runtime) +{ + memset(runtime, 0, sizeof(*runtime)); + runtime->gilstate.check_enabled = 1; + runtime->interpreters.next_id = -1; + init_static_global_objects(&runtime->global_objects); + init_static_interpreter(&runtime->_main_interpreter); +} + +#else /* We use "initial" if the runtime gets re-used (e.g. Py_Finalize() followed by Py_Initialize(). */ static const _PyRuntimeState initial = _PyRuntimeState_INIT; +#endif _Py_COMP_DIAG_POP static int @@ -62,20 +1180,23 @@ alloc_for_runtime(PyThread_type_lock *plock1, PyThread_type_lock *plock2, /* Force default allocator, since _PyRuntimeState_Fini() must use the same allocator than this function. */ PyMemAllocatorEx old_alloc; + PyThread_type_lock lock1; + PyThread_type_lock lock2; + PyThread_type_lock lock3; _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc); - PyThread_type_lock lock1 = PyThread_allocate_lock(); + lock1 = PyThread_allocate_lock(); if (lock1 == NULL) { return -1; } - PyThread_type_lock lock2 = PyThread_allocate_lock(); + lock2 = PyThread_allocate_lock(); if (lock2 == NULL) { PyThread_free_lock(lock1); return -1; } - PyThread_type_lock lock3 = PyThread_allocate_lock(); + lock3 = PyThread_allocate_lock(); if (lock3 == NULL) { PyThread_free_lock(lock1); PyThread_free_lock(lock2); @@ -149,7 +1270,11 @@ _PyRuntimeState_Init(_PyRuntimeState *runtime) if (runtime->_initialized) { // Py_Initialize() must be running again. // Reset to _PyRuntimeState_INIT. +#if defined(_MSC_VER) && _MSC_VER < 1300 + _PyRuntimeState_InitStaticDefaults(runtime); +#else memcpy(runtime, &initial, sizeof(*runtime)); +#endif } init_runtime(runtime, open_code_hook, open_code_userdata, audit_hook_head, unicode_next_index, lock1, lock2, lock3); @@ -302,15 +1427,21 @@ PyInterpreterState * PyInterpreterState_New(void) { PyInterpreterState *interp; - PyThreadState *tstate = _PyThreadState_GET(); + PyThreadState *tstate; + PyThread_type_lock pending_lock; + _PyRuntimeState *runtime; + struct pyinterpreters *interpreters; + int64_t id; + PyInterpreterState *old_head; /* tstate is NULL when Py_InitializeFromConfig() calls PyInterpreterState_New() to create the main interpreter. */ + tstate = _PyThreadState_GET(); if (_PySys_Audit(tstate, "cpython.PyInterpreterState_New", NULL) < 0) { return NULL; } - PyThread_type_lock pending_lock = PyThread_allocate_lock(); + pending_lock = PyThread_allocate_lock(); if (pending_lock == NULL) { if (tstate != NULL) { _PyErr_NoMemory(tstate); @@ -319,8 +1450,8 @@ PyInterpreterState_New(void) } /* Don't get runtime from tstate since tstate can be NULL. */ - _PyRuntimeState *runtime = &_PyRuntime; - struct pyinterpreters *interpreters = &runtime->interpreters; + runtime = &_PyRuntime; + interpreters = &runtime->interpreters; /* We completely serialize creation of multiple interpreters, since it simplifies things here and blocking concurrent calls isn't a problem. @@ -328,11 +1459,11 @@ PyInterpreterState_New(void) after the main interpreter is created. */ HEAD_LOCK(runtime); - int64_t id = interpreters->next_id; + id = interpreters->next_id; interpreters->next_id += 1; // Allocate the interpreter and add it to the runtime state. - PyInterpreterState *old_head = interpreters->head; + old_head = interpreters->head; if (old_head == NULL) { // We are creating the main interpreter. assert(interpreters->main == NULL); @@ -354,8 +1485,13 @@ PyInterpreterState_New(void) goto error; } // Set to _PyInterpreterState_INIT. +#if defined(_MSC_VER) && _MSC_VER < 1300 + memset(interp, 0, sizeof(*interp)); + init_static_interpreter(interp); +#else memcpy(interp, &initial._main_interpreter, sizeof(*interp)); +#endif // We need to adjust any fields that are different from the initial // interpreter (as defined in _PyInterpreterState_INIT): interp->_static = false; @@ -391,6 +1527,7 @@ static void interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate) { _PyRuntimeState *runtime = interp->runtime; + PyThreadState *p; if (_PySys_Audit(tstate, "cpython.PyInterpreterState_Clear", NULL) < 0) { _PyErr_Clear(tstate); @@ -398,7 +1535,7 @@ interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate) // Clear the current/main thread state last. HEAD_LOCK(runtime); - PyThreadState *p = interp->threads.head; + p = interp->threads.head; HEAD_UNLOCK(runtime); while (p != NULL) { // See https://github.com/python/cpython/issues/102126 @@ -490,6 +1627,7 @@ PyInterpreterState_Delete(PyInterpreterState *interp) { _PyRuntimeState *runtime = interp->runtime; struct pyinterpreters *interpreters = &runtime->interpreters; + PyInterpreterState **p; zapthreads(interp, 0); _PyEval_FiniState(&interp->ceval); @@ -498,7 +1636,6 @@ PyInterpreterState_Delete(PyInterpreterState *interp) _PyThreadState_Swap(&runtime->gilstate, NULL); HEAD_LOCK(runtime); - PyInterpreterState **p; for (p = &interpreters->head; ; p = &(*p)->next) { if (*p == NULL) { Py_FatalError("NULL interpreter"); @@ -577,9 +1714,12 @@ _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime) PyInterpreterState * PyInterpreterState_Get(void) { - PyThreadState *tstate = _PyThreadState_GET(); + PyThreadState *tstate; + PyInterpreterState *interp; + + tstate = _PyThreadState_GET(); _Py_EnsureTstateNotNULL(tstate); - PyInterpreterState *interp = tstate->interp; + interp = tstate->interp; if (interp == NULL) { Py_FatalError("no current interpreter"); } @@ -667,20 +1807,25 @@ _PyInterpreterState_IDIncref(PyInterpreterState *interp) void _PyInterpreterState_IDDecref(PyInterpreterState *interp) { + struct _gilstate_runtime_state *gilstate; + int64_t refcount; + PyThreadState *tstate; + PyThreadState *save_tstate; + assert(interp->id_mutex != NULL); - struct _gilstate_runtime_state *gilstate = &_PyRuntime.gilstate; + gilstate = &_PyRuntime.gilstate; PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK); assert(interp->id_refcount != 0); interp->id_refcount -= 1; - int64_t refcount = interp->id_refcount; + refcount = interp->id_refcount; PyThread_release_lock(interp->id_mutex); if (refcount == 0 && interp->requires_idref) { // XXX Using the "head" thread isn't strictly correct. - PyThreadState *tstate = PyInterpreterState_ThreadHead(interp); + tstate = PyInterpreterState_ThreadHead(interp); // XXX Possible GILState issues? - PyThreadState *save_tstate = _PyThreadState_Swap(gilstate, tstate); + save_tstate = _PyThreadState_Swap(gilstate, tstate); Py_EndInterpreter(tstate); _PyThreadState_Swap(gilstate, save_tstate); } @@ -727,8 +1872,10 @@ PyInterpreterState_GetDict(PyInterpreterState *interp) static _PyStackChunk* allocate_chunk(int size_in_bytes, _PyStackChunk* previous) { + _PyStackChunk *res; + assert(size_in_bytes % sizeof(PyObject **) == 0); - _PyStackChunk *res = _PyObject_VirtualAlloc(size_in_bytes); + res = _PyObject_VirtualAlloc(size_in_bytes); if (res == NULL) { return NULL; } @@ -807,12 +1954,15 @@ new_threadstate(PyInterpreterState *interp) { PyThreadState *tstate; _PyRuntimeState *runtime = interp->runtime; + PyThreadState *new_tstate; + int used_newtstate; + uint64_t id; + PyThreadState *old_head; // We don't need to allocate a thread state for the main interpreter // (the common case), but doing it later for the other case revealed a // reentrancy problem (deadlock). So for now we always allocate before // taking the interpreters lock. See GH-96071. - PyThreadState *new_tstate = alloc_threadstate(); - int used_newtstate; + new_tstate = alloc_threadstate(); if (new_tstate == NULL) { return NULL; } @@ -820,10 +1970,10 @@ new_threadstate(PyInterpreterState *interp) HEAD_LOCK(runtime); interp->threads.next_unique_id += 1; - uint64_t id = interp->threads.next_unique_id; + id = interp->threads.next_unique_id; // Allocate the thread state and add it to the interpreter. - PyThreadState *old_head = interp->threads.head; + old_head = interp->threads.head; if (old_head == NULL) { // It's the interpreter's initial thread state. assert(id == 1); @@ -838,9 +1988,14 @@ new_threadstate(PyInterpreterState *interp) used_newtstate = 1; tstate = new_tstate; // Set to _PyThreadState_INIT. +#if defined(_MSC_VER) && _MSC_VER < 1300 + memset(tstate, 0, sizeof(*tstate)); + init_static_threadstate(tstate); +#else memcpy(tstate, &initial._main_interpreter._initial_thread, sizeof(*tstate)); +#endif // We need to adjust any fields that are different from the initial // thread (as defined in _PyThreadState_INIT): tstate->_static = false; @@ -911,6 +2066,8 @@ PyState_FindModule(PyModuleDef* module) int _PyState_AddModule(PyThreadState *tstate, PyObject* module, PyModuleDef* def) { + PyInterpreterState *interp; + if (!def) { assert(_PyErr_Occurred(tstate)); return -1; @@ -922,7 +2079,7 @@ _PyState_AddModule(PyThreadState *tstate, PyObject* module, PyModuleDef* def) return -1; } - PyInterpreterState *interp = tstate->interp; + interp = tstate->interp; if (!interp->modules_by_index) { interp->modules_by_index = PyList_New(0); if (!interp->modules_by_index) { @@ -944,14 +2101,18 @@ _PyState_AddModule(PyThreadState *tstate, PyObject* module, PyModuleDef* def) int PyState_AddModule(PyObject* module, PyModuleDef* def) { + PyThreadState *tstate; + PyInterpreterState *interp; + Py_ssize_t index; + if (!def) { Py_FatalError("module definition is NULL"); return -1; } - PyThreadState *tstate = _PyThreadState_GET(); - PyInterpreterState *interp = tstate->interp; - Py_ssize_t index = def->m_base.m_index; + tstate = _PyThreadState_GET(); + interp = tstate->interp; + index = def->m_base.m_index; if (interp->modules_by_index && index < PyList_GET_SIZE(interp->modules_by_index) && module == PyList_GET_ITEM(interp->modules_by_index, index)) @@ -965,8 +2126,12 @@ PyState_AddModule(PyObject* module, PyModuleDef* def) int PyState_RemoveModule(PyModuleDef* def) { - PyThreadState *tstate = _PyThreadState_GET(); - PyInterpreterState *interp = tstate->interp; + PyThreadState *tstate; + PyInterpreterState *interp; + Py_ssize_t index; + + tstate = _PyThreadState_GET(); + interp = tstate->interp; if (def->m_slots) { _PyErr_SetString(tstate, @@ -975,7 +2140,7 @@ PyState_RemoveModule(PyModuleDef* def) return -1; } - Py_ssize_t index = def->m_base.m_index; + index = def->m_base.m_index; if (index == 0) { Py_FatalError("invalid module index"); } @@ -994,16 +2159,18 @@ PyState_RemoveModule(PyModuleDef* def) void _PyInterpreterState_ClearModules(PyInterpreterState *interp) { + Py_ssize_t i; + if (!interp->modules_by_index) { return; } - Py_ssize_t i; for (i = 0; i < PyList_GET_SIZE(interp->modules_by_index); i++) { PyObject *m = PyList_GET_ITEM(interp->modules_by_index, i); if (PyModule_Check(m)) { + PyModuleDef *md; /* cleanup the saved copy of module dicts */ - PyModuleDef *md = PyModule_GetDef(m); + md = PyModule_GetDef(m); if (md) { Py_CLEAR(md->m_base.m_copy); } @@ -1074,12 +2241,16 @@ static void tstate_delete_common(PyThreadState *tstate, struct _gilstate_runtime_state *gilstate) { + PyInterpreterState *interp; + _PyRuntimeState *runtime; + _PyStackChunk *chunk; + _Py_EnsureTstateNotNULL(tstate); - PyInterpreterState *interp = tstate->interp; + interp = tstate->interp; if (interp == NULL) { Py_FatalError("NULL interpreter"); } - _PyRuntimeState *runtime = interp->runtime; + runtime = interp->runtime; HEAD_LOCK(runtime); if (tstate->prev) { @@ -1098,7 +2269,7 @@ tstate_delete_common(PyThreadState *tstate, { PyThread_tss_set(&gilstate->autoTSSkey, NULL); } - _PyStackChunk *chunk = tstate->datastack_chunk; + chunk = tstate->datastack_chunk; tstate->datastack_chunk = NULL; while (chunk != NULL) { _PyStackChunk *prev = chunk->previous; @@ -1131,8 +2302,10 @@ PyThreadState_Delete(PyThreadState *tstate) void _PyThreadState_DeleteCurrent(PyThreadState *tstate) { + struct _gilstate_runtime_state *gilstate; + _Py_EnsureTstateNotNULL(tstate); - struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate; + gilstate = &tstate->interp->runtime->gilstate; tstate_delete_common(tstate, gilstate); _PyRuntimeGILState_SetThreadState(gilstate, NULL); _PyEval_ReleaseLock(tstate); @@ -1159,12 +2332,14 @@ void _PyThreadState_DeleteExcept(_PyRuntimeState *runtime, PyThreadState *tstate) { PyInterpreterState *interp = tstate->interp; + PyThreadState *list; + PyThreadState *p, *next; HEAD_LOCK(runtime); /* Remove all thread states, except tstate, from the linked list of thread states. This will allow calling PyThreadState_Clear() without holding the lock. */ - PyThreadState *list = interp->threads.head; + list = interp->threads.head; if (list == tstate) { list = tstate->next; } @@ -1181,7 +2356,6 @@ _PyThreadState_DeleteExcept(_PyRuntimeState *runtime, PyThreadState *tstate) /* Clear and deallocate all stale thread states. Even if this executes Python code, we should be safe since it executes in the current thread, not one of the stale threads. */ - PyThreadState *p, *next; for (p = list; p; p = next) { next = p->next; PyThreadState_Clear(p); @@ -1279,15 +2453,18 @@ PyThreadState_GetInterpreter(PyThreadState *tstate) PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate) { + _PyInterpreterFrame *f; + PyFrameObject *frame; + assert(tstate != NULL); - _PyInterpreterFrame *f = tstate->cframe->current_frame; + f = tstate->cframe->current_frame; while (f && _PyFrame_IsIncomplete(f)) { f = f->previous; } if (f == NULL) { return NULL; } - PyFrameObject *frame = _PyFrame_GetFrameObject(f); + frame = _PyFrame_GetFrameObject(f); if (frame == NULL) { PyErr_Clear(); } @@ -1317,6 +2494,7 @@ PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc) { _PyRuntimeState *runtime = &_PyRuntime; PyInterpreterState *interp = _PyRuntimeState_GetThreadState(runtime)->interp; + PyThreadState *tstate; /* Although the GIL is held, a few C API functions can be called * without the GIL held, and in particular some that create and @@ -1325,7 +2503,9 @@ PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc) * head_mutex for the duration. */ HEAD_LOCK(runtime); - for (PyThreadState *tstate = interp->threads.head; tstate != NULL; tstate = tstate->next) { + for (tstate = interp->threads.head; tstate != NULL; tstate = tstate->next) { + PyObject *old_exc; + if (tstate->thread_id != id) { continue; } @@ -1337,7 +2517,7 @@ PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc) * deadlock, we need to release head_mutex before * the decref. */ - PyObject *old_exc = tstate->async_exc; + old_exc = tstate->async_exc; Py_XINCREF(exc); tstate->async_exc = exc; HEAD_UNLOCK(runtime); @@ -1389,17 +2569,22 @@ PyObject * _PyThread_CurrentFrames(void) { PyThreadState *tstate = _PyThreadState_GET(); + PyObject *result; + int gc_was_enabled; + _PyRuntimeState *runtime; + PyInterpreterState *i; + if (_PySys_Audit(tstate, "sys._current_frames", NULL) < 0) { return NULL; } - PyObject *result = PyDict_New(); + result = PyDict_New(); if (result == NULL) { return NULL; } // gh-106883: Disable the GC as this can cause the interpreter to deadlock - int gc_was_enabled = PyGC_Disable(); + gc_was_enabled = PyGC_Disable(); /* for i in all interpreters: * for t in all of i's thread states: @@ -1407,29 +2592,33 @@ _PyThread_CurrentFrames(void) * Because these lists can mutate even when the GIL is held, we * need to grab head_mutex for the duration. */ - _PyRuntimeState *runtime = tstate->interp->runtime; + runtime = tstate->interp->runtime; HEAD_LOCK(runtime); - PyInterpreterState *i; for (i = runtime->interpreters.head; i != NULL; i = i->next) { PyThreadState *t; for (t = i->threads.head; t != NULL; t = t->next) { - _PyInterpreterFrame *frame = t->cframe->current_frame; + _PyInterpreterFrame *frame; + PyObject *id; + PyObject *frameobj; + int stat; + + frame = t->cframe->current_frame; while (frame && _PyFrame_IsIncomplete(frame)) { frame = frame->previous; } if (frame == NULL) { continue; } - PyObject *id = PyLong_FromUnsignedLong(t->thread_id); + id = PyLong_FromUnsignedLong(t->thread_id); if (id == NULL) { goto fail; } - PyObject *frameobj = (PyObject *)_PyFrame_GetFrameObject(frame); + frameobj = (PyObject *)_PyFrame_GetFrameObject(frame); if (frameobj == NULL) { Py_DECREF(id); goto fail; } - int stat = PyDict_SetItem(result, id, frameobj); + stat = PyDict_SetItem(result, id, frameobj); Py_DECREF(id); if (stat < 0) { goto fail; @@ -1456,6 +2645,10 @@ PyObject * _PyThread_CurrentExceptions(void) { PyThreadState *tstate = _PyThreadState_GET(); + PyObject *result; + int gc_was_enabled; + _PyRuntimeState *runtime; + PyInterpreterState *i; _Py_EnsureTstateNotNULL(tstate); @@ -1463,13 +2656,13 @@ _PyThread_CurrentExceptions(void) return NULL; } - PyObject *result = PyDict_New(); + result = PyDict_New(); if (result == NULL) { return NULL; } // gh-106883: Disable the GC as this can cause the interpreter to deadlock - int gc_was_enabled = PyGC_Disable(); + gc_was_enabled = PyGC_Disable(); /* for i in all interpreters: * for t in all of i's thread states: @@ -1477,26 +2670,30 @@ _PyThread_CurrentExceptions(void) * Because these lists can mutate even when the GIL is held, we * need to grab head_mutex for the duration. */ - _PyRuntimeState *runtime = tstate->interp->runtime; + runtime = tstate->interp->runtime; HEAD_LOCK(runtime); - PyInterpreterState *i; for (i = runtime->interpreters.head; i != NULL; i = i->next) { PyThreadState *t; for (t = i->threads.head; t != NULL; t = t->next) { - _PyErr_StackItem *err_info = _PyErr_GetTopmostException(t); + _PyErr_StackItem *err_info; + PyObject *id; + PyObject *exc_info; + int stat; + + err_info = _PyErr_GetTopmostException(t); if (err_info == NULL) { continue; } - PyObject *id = PyLong_FromUnsignedLong(t->thread_id); + id = PyLong_FromUnsignedLong(t->thread_id); if (id == NULL) { goto fail; } - PyObject *exc_info = _PyErr_StackItemToExcInfoTuple(err_info); + exc_info = _PyErr_StackItemToExcInfoTuple(err_info); if (exc_info == NULL) { Py_DECREF(id); goto fail; } - int stat = PyDict_SetItem(result, id, exc_info); + stat = PyDict_SetItem(result, id, exc_info); Py_DECREF(id); Py_DECREF(exc_info); if (stat < 0) { @@ -1559,6 +2756,8 @@ _PyGILState_Init(_PyRuntimeState *runtime) PyStatus _PyGILState_SetTstate(PyThreadState *tstate) { + struct _gilstate_runtime_state *gilstate; + if (!_Py_IsMainInterpreter(tstate->interp)) { /* Currently, PyGILState is shared by all interpreters. The main * interpreter is responsible to initialize it. */ @@ -1569,7 +2768,7 @@ _PyGILState_SetTstate(PyThreadState *tstate) assert(tstate != NULL); assert(tstate->interp != NULL); - struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate; + gilstate = &tstate->interp->runtime->gilstate; gilstate->autoInterpreterState = tstate->interp; assert(PyThread_tss_get(&gilstate->autoTSSkey) == NULL); @@ -1676,6 +2875,7 @@ int PyGILState_Check(void) { struct _gilstate_runtime_state *gilstate = &_PyRuntime.gilstate; + PyThreadState *tstate; if (!gilstate->check_enabled) { return 1; } @@ -1684,7 +2884,7 @@ PyGILState_Check(void) return 1; } - PyThreadState *tstate = _PyRuntimeGILState_GetThreadState(gilstate); + tstate = _PyRuntimeGILState_GetThreadState(gilstate); if (tstate == NULL) { return 0; } @@ -1697,6 +2897,8 @@ PyGILState_Ensure(void) { _PyRuntimeState *runtime = &_PyRuntime; struct _gilstate_runtime_state *gilstate = &runtime->gilstate; + PyThreadState *tcur; + int current; /* Note that we do not auto-init Python here - apart from potential races with 2 threads auto-initializing, pep-311 @@ -1708,8 +2910,7 @@ PyGILState_Ensure(void) assert(_PyEval_ThreadsInitialized(runtime)); assert(gilstate->autoInterpreterState); - PyThreadState *tcur = (PyThreadState *)PyThread_tss_get(&gilstate->autoTSSkey); - int current; + tcur = (PyThreadState *)PyThread_tss_get(&gilstate->autoTSSkey); if (tcur == NULL) { /* Create a new Python thread state for this thread */ tcur = PyThreadState_New(gilstate->autoInterpreterState); @@ -1841,24 +3042,27 @@ int _PyObject_GetCrossInterpreterData(PyObject *obj, _PyCrossInterpreterData *data) { PyThreadState *tstate = _PyThreadState_GET(); + PyInterpreterState *interp; + crossinterpdatafunc getdata; + int res; #ifdef Py_DEBUG // The caller must hold the GIL _Py_EnsureTstateNotNULL(tstate); #endif - PyInterpreterState *interp = tstate->interp; + interp = tstate->interp; // Reset data before re-populating. - *data = (_PyCrossInterpreterData){0}; + memset(data, 0, sizeof(*data)); data->free = PyMem_RawFree; // Set a default that may be overridden. // Call the "getdata" func for the object. Py_INCREF(obj); - crossinterpdatafunc getdata = _lookup_getdata(obj); + getdata = _lookup_getdata(obj); if (getdata == NULL) { Py_DECREF(obj); return -1; } - int res = getdata(obj, data); + res = getdata(obj, data); Py_DECREF(obj); if (res != 0) { return -1; @@ -1912,13 +3116,16 @@ _call_in_interpreter(struct _gilstate_runtime_state *gilstate, void _PyCrossInterpreterData_Release(_PyCrossInterpreterData *data) { + PyInterpreterState *interp; + struct _gilstate_runtime_state *gilstate; + if (data->data == NULL && data->obj == NULL) { // Nothing to release! return; } // Switch to the original interpreter. - PyInterpreterState *interp = _PyInterpreterState_LookUpID(data->interp); + interp = _PyInterpreterState_LookUpID(data->interp); if (interp == NULL) { // The interpreter was already destroyed. if (data->free != NULL) { @@ -1928,7 +3135,7 @@ _PyCrossInterpreterData_Release(_PyCrossInterpreterData *data) } // "Release" the data and/or the object. - struct _gilstate_runtime_state *gilstate = &_PyRuntime.gilstate; + gilstate = &_PyRuntime.gilstate; _call_in_interpreter(gilstate, interp, _release_xidata, data); } @@ -1966,6 +3173,9 @@ int _PyCrossInterpreterData_RegisterClass(PyTypeObject *cls, crossinterpdatafunc getdata) { + struct _xidregistry *xidregistry; + int res; + if (!PyType_Check(cls)) { PyErr_Format(PyExc_ValueError, "only classes may be registered"); return -1; @@ -1978,12 +3188,12 @@ _PyCrossInterpreterData_RegisterClass(PyTypeObject *cls, // Make sure the class isn't ever deallocated. Py_INCREF((PyObject *)cls); - struct _xidregistry *xidregistry = &_PyRuntime.xidregistry ; + xidregistry = &_PyRuntime.xidregistry; PyThread_acquire_lock(xidregistry->mutex, WAIT_LOCK); if (xidregistry->head == NULL) { _register_builtins_for_crossinterpreter_data(xidregistry); } - int res = _register_xidata(xidregistry, cls, getdata); + res = _register_xidata(xidregistry, cls, getdata); PyThread_release_lock(xidregistry->mutex); return res; } @@ -1995,11 +3205,13 @@ _PyCrossInterpreterData_RegisterClass(PyTypeObject *cls, crossinterpdatafunc _PyCrossInterpreterData_Lookup(PyObject *obj) { - struct _xidregistry *xidregistry = &_PyRuntime.xidregistry ; + struct _xidregistry *xidregistry = &_PyRuntime.xidregistry; PyObject *cls = PyObject_Type(obj); crossinterpdatafunc getdata = NULL; + struct _xidregitem *cur; + PyThread_acquire_lock(xidregistry->mutex, WAIT_LOCK); - struct _xidregitem *cur = xidregistry->head; + cur = xidregistry->head; if (cur == NULL) { _register_builtins_for_crossinterpreter_data(xidregistry); cur = xidregistry->head; @@ -2189,8 +3401,10 @@ _PyInterpreterState_GetConfigCopy(PyConfig *config) const PyConfig* _Py_GetConfig(void) { + PyThreadState *tstate; + assert(PyGILState_Check()); - PyThreadState *tstate = _PyThreadState_GET(); + tstate = _PyThreadState_GET(); return _PyInterpreterState_GetConfig(tstate->interp); } @@ -2200,10 +3414,13 @@ static PyObject ** push_chunk(PyThreadState *tstate, int size) { int allocate_size = DATA_STACK_CHUNK_SIZE; + _PyStackChunk *new; + PyObject **res; + while (allocate_size < (int)sizeof(PyObject*)*(size + MINIMUM_OVERHEAD)) { allocate_size *= 2; } - _PyStackChunk *new = allocate_chunk(allocate_size, tstate->datastack_chunk); + new = allocate_chunk(allocate_size, tstate->datastack_chunk); if (new == NULL) { return NULL; } @@ -2216,7 +3433,7 @@ push_chunk(PyThreadState *tstate, int size) // When new is the "root" chunk (i.e. new->previous == NULL), we can keep // _PyThreadState_PopFrame from freeing it later by "skipping" over the // first element: - PyObject **res = &new->data[new->previous == NULL]; + res = &new->data[new->previous == NULL]; tstate->datastack_top = res + size; return res; } @@ -2239,8 +3456,10 @@ _PyThreadState_BumpFramePointerSlow(PyThreadState *tstate, size_t size) void _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame * frame) { + PyObject **base; + assert(tstate->datastack_chunk); - PyObject **base = (PyObject **)frame; + base = (PyObject **)frame; if (base == &tstate->datastack_chunk->data[0]) { _PyStackChunk *chunk = tstate->datastack_chunk; _PyStackChunk *previous = chunk->previous;