70쫏 nB20333333333"?6"R "Qe撖B;f݆ l~poWw7 Y3Qq`0 @Fi, rFQ2c!CC3 dUƹBec), Py_None, PyDateTimeAPI->DateTimeType) #define PyDateTime_FromDateAndTimeAndFold(year, month, day, hour, min, sec, usec, fold) \ PyDateTimeAPI->DateTime_FromDateAndTimeAndFold((year), (month), (day), (hour), \ (min), (sec), (usec), Py_None, (fold), PyDateTimeAPI->DateTimeType) #define PyTime_FromTime(hour, minute, second, usecond) \ PyDateTimeAPI->Time_FromTime((hour), (minute), (se \ unsigned char data[_PyDateTime_DATETIME_DATASIZE]; typedef struct { _PyDateTime_DATETIMEHEAD } _PyDateTime_BaseDateTime; /* hastzinfo false */ typedef struct { _PyDateTime_DATETIMEHEAD unsigned char fold; PyObject *tzinfo; } PyDateTime_DateTime; /* hastzinfo true */ /* Apply for date and datetime instances. */ // o is a pointer to a time or a datetime object. #define _PyDateTime_HAS_TZINFO(o) (((_PyDateTime_BaseTZInfo *)(o))->hastzinfo) #define PyDateTime_GET_YEAR(o) ((((PyDateT_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *, PyObject *); #endif /* Export the old function so that the existing API remains available: */ PyAPI_FUNC(void) PyErr_BadInternalCall(void); PyAPI_FUNC(void) _PyErr_BadInternalCall(const char *filename, int lineno); /* Mask the old API with a call to the new API for code compiled under Python 2.0: */ #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) /* Function to create a new exception */ PyAPI_FUNC(PyObject *) PyErr_NewException( cI_DATA(PyObject *) PyExc_NotADirectoryError; PyAPI_DATA(PyObject *) PyExc_PermissionError; PyAPI_DATA(PyObject *) PyExc_ProcessLookupError; PyAPI_DATA(PyObject *) PyExc_TimeoutError; #endif /* Compatibility aliases */ PyAPI_DATA(PyObject *) PyExc_EnvironmentError; PyAPI_DATA(PyObject *) PyExc_IOError; #ifdef MS_WINDOWS PyAPI_DATA(PyObject *) PyExc_WindowsError; #endif /* Predefined warning categories */ PyAPI_DATA(PyObject *) PyExc_Warning; PyAPI_DATA(PyObject *) PyExc_UserWarning; PyAPI_DATA(PyObject *) PyExc_DeprecationWarninge "cpython/import.h" # undef Py_CPYTHON_IMPORT_H #endif #ifdef __cplusplus } #endif #endif /* !Py_IMPORT_H */ /* Set object interface */ #ifndef Py_SETOBJECT_H #define Py_SETOBJECT_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PySet_Type; PyAPI_DATA(PyTypeObject) PyFrozenSet_Type; PyAPI_DATA(PyTypeObject) PySetIter_Type; PyAPI_FUNC(PyObject *) PySet_New(PyObject *); PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *); PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key); PyAPI_FUNC(int) PySet_Clear(PyObjets the input string as ISO-8859-1 if it contains non-ASCII characters. This function does not raise exceptions. */ PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString( PyObject *left, const char *right /* ASCII-encoded string */ ); /* Rich compare two strings and return one of the following: - NULL in case an exception was raised - Py_True or Py_False for successful comparisons - Py_NotImplemented in case the type combination is unknown Possible values for op: Py_GT, Py_GE, Py_EQ, Py_ng Unicode objects and strings on input (we refer to them as strings in the descriptions) and return Unicode objects or integers as appropriate. */ /* Concat two strings giving a new Unicode string. */ PyAPI_FUNC(PyObject*) PyUnicode_Concat( PyObject *left, /* Left string */ PyObject *right /* Right string */ ); /* Concat two strings and put the result in *pleft (sets *pleft to NULL on error) */ PyAPI_FUNC(void) PyUnicode_Append( PyObject **pleft, /* Pointer to left str-------------------------------- */ #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 /* Decode a string from the current locale encoding. The decoder is strict if *surrogateescape* is equal to zero, otherwise it uses the 'surrogateescape' error handler (PEP 383) to escape undecodable bytes. If a byte sequence can be decoded as a surrogate character and *surrogateescape* is not equal to zero, the byte sequence is escaped using the 'surrogateescape' error handler instead of being decoded. *str* must end /* Decodes length bytes from a UTF-16 encoded buffer string and returns the corresponding Unicode object. errors (if non-NULL) defines the error handling. It defaults to "strict". If byteorder is non-NULL, the decoder starts decoding using the given byte order: *byteorder == -1: little endian *byteorder == 0: native order *byteorder == 1: big endian In native mode, the first two bytes of the stream are checked for a BOM mark. If found, the BOM mark is analysed, the byte order adjusted andCATED. The only supported standard encoding is rot13. Use PyCodec_Decode() to decode with rot13 and non-standard codecs that decode from str to str. */ Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode( PyObject *unicode, /* Unicode object */ const char *encoding, /* encoding */ const char *errors /* error handling */ ); /* Encodes a Unicode object and returns the result as Python object. This API is DEPRECATED. It is superseded by PyUnicode_AsEncodedString() va_list vargs ); PyAPI_FUNC(PyObject *) PyUnicode_FromFormat( const char *format, /* ASCII-encoded string */ ... ); PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **); PyAPI_FUNC(PyObject *) PyUnicode_InternFromString( const char *u /* UTF-8 encoded string */ ); /* --- wchar_t support for platforms which support it --------------------- */ #ifdef HAVE_WCHAR_H /* Create a Unicode Object from the wchar_t buffer w of the given size. The buffer is copied into the new object. */sed in advertising or publicity pertaining to * distribution of the software without specific, written prior * permission. * * SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUhe data will be copied into the array in C-style (last dimension varies the fastest). If fort is 'A', then it does not matter and the copy will be made in whatever way is more efficient. */ PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); /* Copy the data from the src buffer to the buffer of destination. */ PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort); /*Fill the strides array with byte-strides of a contiguous (Fortran-style if fort is 'F' or C-style otherwise) array of th* * memory layout on 32 bit systems * cccccccc cccccccc cccccccc uc * ppppssss ........ ........ fnv -- two Py_hash_t * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t (*) * ........ ........ ssss.... djbx33a -- 16 bytes padding + one Py_hash_t * ........ ........ eeee.... pyexpat XML hash salt * * (*) The siphash member may not be available on 32 bit platforms without * an unsigned int64 data type. */ #ifndef Py_LIMITED_API typedef union { /* ensure 24 bytes */ unsigned char uc[24]; /* tH_COEXIST 0x0040 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030a0000 # define METH_FASTCALL 0x0080 #endif /* This bit is preserved for Stackless Python */ #ifdef STACKLESS # define METH_STACKLESS 0x0100 #else # define METH_STACKLESS 0x0000 #endif /* METH_METHOD means the function stores an * additional reference to the class that defines it; * both self and class are passed to it. * It uses PyCMethodObject instead of PyCFunctionObject. * May not be combined with METH_NOARGS, METH_O, METH_CLASS or METH_STATICva_list /* Type PyBytesObject represents a byte string. An extra zero byte is reserved at the end to ensure it is zero-terminated, but a size is present so strings with null bytes in them can be represented. This is an immutable object type. There are functions to create new bytes objects, to test an object for bytes-ness, and to get the byte string value. The latter function returns a null pointer if the object is not of the proper type. There is a variant that takes an explicit size as well as a variant that assumes a zero-t/* !Py_FILEOBJECT_H */ // Entry point of the Python C API. // C extensions should only #include , and not include directly // the other Python header files included by . #ifndef Py_PYTHON_H #define Py_PYTHON_H // Since this is a "meta-include" file, no #ifdef __cplusplus / extern "C" { // Include Python header files #include "patchlevel.h" #include "pyconfig.h" #include "pymacconfig.h" #if defined(__sgi) && !defined(_SGI_MP_SOURCE) # define _SGI_MP_SOURCE #endif // stdlib.h, stdio.h, errno.h and string.h hndif #else # ifndef WORDS_BIGENDIAN /* # undef WORDS_BIGENDIAN */ # endif #endif /* Define if arithmetic is subject to x87-style double rounding issue */ /* #undef X87_DOUBLE_ROUNDING */ /* Define on OpenBSD to activate all library features */ /* #undef _BSD_SOURCE */ /* Define on Darwin to activate all library features */ #define _DARWIN_C_SOURCE 1 /* This must be set to 64 on some systems to enable large file support. */ #define _FILE_OFFSET_BITS 64 /* Define to include mbstate_t for mbrtowc */ /* #undef _INCLUDE__STDC_A1_SPENBSD_SOURCE # define _OPENBSD_SOURCE 1 #endif /* Define to 1 if needed for POSIX-compatible behavior. */ #ifndef _POSIX_SOURCE /* # undef _POSIX_SOURCE */ #endif /* Define to 2 if needed for POSIX-compatible behavior. */ #ifndef _POSIX_1_SOURCE /* # undef _POSIX_1_SOURCE */ #endif /* Enable POSIX-compatible threading on Solaris. */ #ifndef _POSIX_PTHREAD_SEMANTICS # define _POSIX_PTHREAD_SEMANTICS 1 #endif /* Enable extensions specified by ISO/IEC TS 18661-5:2014. */ #ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ # define __STDCeclared in . */ /* #undef MAJOR_IN_MKDEV */ /* Define to 1 if `major', `minor', and `makedev' are declared in . */ #define MAJOR_IN_SYSMACROS 1 /* Define if mvwdelch in curses.h is an expression. */ #define MVWDELCH_IS_EXPRESSION 1 /* Define to the address where bug reports for this package should be sent. */ /* #undef PACKAGE_BUGREPORT */ /* Define to the full name of this package. */ /* #undef PACKAGE_NAME */ /* Define to the full name and version of this package. */ /* #undef PACKAGE_STRING */ /E_SYS_STAT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_SYSCALL_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_SYSMACROS_H 1 /* Define to 1 if you have the header file. */ /* #undef HAVE_SYS_SYS_DOMAIN_H */ /* Define to 1 if you have the header file. */ /* #undef HAVE_SYS_TERMIO_H */ /* Define to 1 if you have the header file. */ #define HAVE_SYS_TIMES_H 1 /* Define to 1 if you have the hee the `sem_open' function. */ #define HAVE_SEM_OPEN 1 /* Define to 1 if you have the `sem_timedwait' function. */ #define HAVE_SEM_TIMEDWAIT 1 /* Define to 1 if you have the `sem_unlink' function. */ #define HAVE_SEM_UNLINK 1 /* Define to 1 if you have the `sendfile' function. */ #define HAVE_SENDFILE 1 /* Define if you have the 'sendto' function. */ #define HAVE_SENDTO 1 /* Define to 1 if you have the `setegid' function. */ #define HAVE_SETEGID 1 /* Define to 1 if you have the `seteuid' function. */ #define HAVE_SETEUID 1 /ve the 'recvfrom' function. */ #define HAVE_RECVFROM 1 /* Define to 1 if you have the `renameat' function. */ #define HAVE_RENAMEAT 1 /* Define if readline supports append_history */ /* #undef HAVE_RL_APPEND_HISTORY */ /* Define if you can turn off readline's signal handling. */ /* #undef HAVE_RL_CATCH_SIGNAL */ /* Define if readline supports rl_compdisp_func_t */ /* #undef HAVE_RL_COMPDISP_FUNC_T */ /* Define if you have readline 2.2 */ /* #undef HAVE_RL_COMPLETION_APPEND_CHARACTER */ /* Define if you have readline 4.0 */ /* have the `mremap' function. */ #define HAVE_MREMAP 1 /* Define to 1 if you have the `nanosleep' function. */ #define HAVE_NANOSLEEP 1 /* Define to 1 if you have the `ncursesw' library. */ /* #undef HAVE_NCURSESW */ /* Define to 1 if you have the header file. */ #define HAVE_NCURSES_H 1 /* Define to 1 if you have the header file. */ /* #undef HAVE_NDBM_H */ /* Define to 1 if you have the header file, and it defines `DIR'. */ /* #undef HAVE_NDIR_H */ /* Define to 1 if you have the h`getgrnam_r' function. */ #define HAVE_GETGRNAM_R 1 /* Define to 1 if you have the `getgrouplist' function. */ #define HAVE_GETGROUPLIST 1 /* Define to 1 if you have the `getgroups' function. */ #define HAVE_GETGROUPS 1 /* Define if you have the 'gethostbyaddr' function. */ #define HAVE_GETHOSTBYADDR 1 /* Define to 1 if you have the `gethostbyname' function. */ #define HAVE_GETHOSTBYNAME 1 /* Define this if you have some version of gethostbyname_r() */ #define HAVE_GETHOSTBYNAME_R 1 /* Define this if you have the 3-arg versioyou have the `dup3' function. */ #define HAVE_DUP3 1 /* Define if you have the '_dyld_shared_cache_contains_path' function. */ /* #undef HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH */ /* Defined when any dynamic module loading is enabled. */ #define HAVE_DYNAMIC_LOADING 1 /* Define to 1 if you have the header file. */ /* #undef HAVE_EDITLINE_READLINE_H */ /* Define to 1 if you have the header file. */ #define HAVE_ENDIAN_H 1 /* Define if you have the 'epoll_create' function. */ #define HAVE_EPOLL 1 /CURSES_RESIZE_TERM 1 /* Define if you have the 'syncok' function. */ #define HAVE_CURSES_SYNCOK 1 /* Define if you have the 'typeahead' function. */ #define HAVE_CURSES_TYPEAHEAD 1 /* Define if you have the 'use_env' function. */ #define HAVE_CURSES_USE_ENV 1 /* Define if you have the 'wchgat' function. */ #define HAVE_CURSES_WCHGAT 1 /* Define to 1 if you have the header file. */ /* #undef HAVE_DB_H */ /* Define to 1 if you have the declaration of `RTLD_DEEPBIND', and to 0 if you don't. */ #define HAVE_DECL_RTLD_DE. */ #define ALIGNOF_LONG 8 /* The normal alignment of `max_align_t', in bytes. */ #define ALIGNOF_MAX_ALIGN_T 16 /* The normal alignment of `size_t', in bytes. */ #define ALIGNOF_SIZE_T 8 /* Alternative SOABI used in debug build to load C extensions built in release mode */ /* #undef ALT_SOABI */ /* The Android API level. */ /* #undef ANDROID_API_LEVEL */ /* Define if C doubles are 64-bit IEEE 754 binary format, stored in ARM mixed-endian order (byte order 45670123) */ /* #undef DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754 */ /*access the members of this list, and PySequence_Fast_GET_SIZE to get its length. Returns NULL on failure. If the object does not support iteration, raises a TypeError exception with 'm' as the message text. */ PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m); /* Return the size of the sequence 'o', assuming that 'o' was returned by PySequence_Fast and is not NULL. */ #define PySequence_Fast_GET_SIZE(o) \ (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o)) /* Return the 'i'-th element oReturns the result of multiplying o1 by o2, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 *= o2. */ PyAPI_FUNC(PyObject *) PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 /* This is the equivalent of the Python expression: o1 @= o2. */ PyAPI_FUNC(PyObject *) PyNumber_InPlaceMatrixMultiply(PyObject *o1, PyObject *o2); #endif /* Returns the result of dividing o1 by o2 giving an integral result, possibly in-pla Takes an iterator object and calls its tp_iternext slot, returning the next value. If the iterator is exhausted, this returns NULL without setting an exception. NULL with an exception means an error occurred. */ PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 /* Takes generator, coroutine or iterator object and sends the value into it. Returns: - PYGEN_RETURN (0) if generator has returned. 'result' parameter is filled with return value - P char *key); /* Delete the mapping for the object 'key' from the object 'o'. Returns -1 on failure. This is the equivalent of the Python statement: del o[key]. */ PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key); /* === Old Buffer API ============================================ */ /* FIXME: usage of these should all be replaced in Python itself but for backwards compatibility we will implement them. Their usage without a corresponding "unlock" mechanism may create issues (but they would already be mkvalue-style format string. The format may be NULL, indicating that no arguments are provided. Returns the result of the call on success, or NULL on failure. This is the equivalent of the Python expression: callable(arg1, arg2, ...). */ PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable, const char *format, ...); /* Call the method named 'name' of object 'obj' with a variable number of C arguments. The C arguments are described by a mkvalue format strytes); XML_Bool (*SetAllocTrackerMaximumAmplification)( XML_Parser parser, float maxAmplificationFactor); /* always add new stuff to the end! */ }; /* Abstract Object Interface (many thanks to Jim Fulton) */ #ifndef Py_ABSTRACTOBJECT_H #define Py_ABSTRACTOBJECT_H #ifdef __cplusplus extern "C" { #endif /* === Object Protocol ================================================== */ /* Implemented elsewhere: int PyObject_Print(PyObject *o, FILE *fp, int flags); Print an object 'o' on file 'fp'. Returns -1 on on systems with DTrace, is auto-generated to include `PyDTrace_{PROBE}` and `PyDTrace_{PROBE}_ENABLED()` macros for every probe defined in pydtrace.d. Calling these functions must be guarded by a `PyDTrace_{PROBE}_ENABLED()` check to minimize performance impact when probing is off. For example: if (PyDTrace_FUNCTION_ENTRY_ENABLED()) PyDTrace_FUNCTION_ENTRY(f); */ #else /* Without DTrace, compile to nothing. */ static inline void PyDTrace_LINE(const char *arg0, const char *arg1, int arg2) {} statiis is an immutable type. C code can change the tuple items (but not their number), and even use tuples as general-purpose arrays of object references, but in general only brand new tuples should be mutated, not ones that might already have been exposed to Python code. *** WARNING *** PyTuple_SetItem does not increment the new item's reference count, but does decrement the reference count of the item it replaces, if not nil. It does *decrement* the reference count if it is *not* inserted in the tuple. Similarly, PyTuple_GetItem dl Libs: -L${libdir} -lpython3.12 Cflags: -I${includedir}/python3.12 # See: man pkg-config prefix=/usr exec_prefix=${prefix} libdir=${exec_prefix}/lib includedir=${prefix}/include Name: Python Description: Build a C extension for Python Requires: Version: 3.12 Libs.private: -ldl Libs: -L${libdir} Cflags: -I${includedir}/python3.12 /* System module interface */ #ifndef Py_SYSMODULE_H #define Py_SYSMODULE_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(PyObject *) PySys_GetObject(const char *); PyAPI_FUNC(int) PySys_SetObjPy_get___phello___spam_toplevel_Py_get_frozen_only_toplevel_Py_Deepfreeze_Fini_Py_Deepfreeze_Init_Py_next_func_version_Py_Get_Getpath_CodeObject_Py_M__getpath_PyConfig_InitPathConfigPyImport_FrozenModules_PyImport_FrozenAliases_PyImport_FrozenTest_PyImport_FrozenStdlib_PyImport_FrozenBootstrap_Py_M____hello___Py_M____phello___Py_M____phello___ham_Py_M____phello___ham_eggs_Py_M____phello___spam_Py_M__frozen_only_Py_M__abc_Py_M__codecs_Py_M__io_Py_M___collections_abc_Py_M___sitebuiltins_Py_M__genericpath_Py_MnitWarnOptions_PySys_ReadPreinitXOptionsPySys_ResetWarnOptionsPySys_AddWarnOptionUnicodePySys_AddWarnOptionPySys_HasWarnOptionsPySys_AddXOptionPySys_GetXOptions_PySys_UpdateConfig_PySys_Create_PySys_ImplName_PySys_ImplCacheTag_PySys_FiniTypesPySys_SetPathPySys_SetArgvExPySys_SetArgvPySys_WriteStdoutPySys_WriteStderr_PySys_ClearAttrString_PySys_ClearAuditHooksPySys_FormatStdoutPySys_FormatStderrPyThread_init_thread_PyThread_cond_init_PyThread_cond_afterPyThread_start_new_threadPyThread_get_thread_identPyTh_InitFromPreConfig_PyPreConfig_InitFromConfig_PyPreConfig_AsDict_PyPreConfig_GetConfig_Py_GetEnv_Py_str_to_int_Py_get_env_flag_Py_get_xoption_PyPreCmdline_Read_PyPreConfig_Read_PyPreConfig_Write_PyArena_New_PyArena_Free_PyArena_Malloc_PyArena_AddPyObject_Py_ctype_toupper_Py_ctype_tolower_Py_ctype_tablePyFPE_dummyPyFPE_counter_Py_HashSecret_Py_HashPointerRaw_Py_HashPointer_Py_HashDouble_Py_HashBytes_PyHash_FiniPyHash_GetFuncDef_Py_KeyedHash_PyRuntime_PyRuntime_Initialize_PyRuntime_Finalize_Py_IsFinaliz_PyArg_ParseStackAndKeywords_SizeT_PyArg_VaParseTupleAndKeywordsFast_PyArg_VaParseTupleAndKeywordsFast_SizeTPyArg_ValidateKeywordArguments_PyArg_UnpackKeywords_PyArg_UnpackKeywordsWithVararg_PyArg_CheckPositionalPyArg_UnpackTuple_PyArg_UnpackStack_PyArg_NoKeywords_PyArg_NoPositional_PyArg_NoKwnames_PyArg_FiniPy_GetCompilerPy_GetCopyrightPy_GetPlatform_Py_InitVersionPy_GetVersionPy_Version_PyEval_SetSwitchInterval_PyEval_GetSwitchInterval_PyEval_ThreadsInitializedPyEval_ThreadsInitialized_PyEval_FiniGILPyEvaldec_IncrementalDecoderPyCodec_StreamWriter_PyCodec_LookupTextEncoding_PyCodec_EncodeText_PyCodec_DecodeTextPyCodec_IncrementalEncoderPyCodec_EncoderPyCodec_EncodePyCodec_StreamReaderPyCodec_LookupErrorPyCodec_StrictErrorsPyCodec_IgnoreErrorsPyCodec_ReplaceErrorsPyCodec_XMLCharRefReplaceErrorsPyCodec_BackslashReplaceErrorsPy_hexdigitsPyCodec_NameReplaceErrors_PyOpcode_Jump_PyOpcode_Deopt_PyCompile_InstrSize_PyOpcode_Caches_PyCompile_EnsureArrayLargeEnough_PyAST_CompilePyCompile_OpcodeStackEffectWithJumpPyCompe_GenericAllocPyType_GenericNewPyType_IsSubtypePySuper_TypePyType_GetFlagsPyType_SUPPORTS_WEAKREFS_PyType_CalculateMetaclassPyType_GetNamePyType_GetQualNamePyType_GetSlotPyType_GetModulePyType_GetModuleStatePyType_GetModuleByDefPyObject_GetTypeDataPyType_GetTypeDataSizePyObject_GetItemData_PyStaticType_Dealloc_Py_BaseObject_RichCompare_PyObject_GetState_PyType_AddMethodPyType_ReadyPyType_FromMetaclassPyType_FromModuleAndSpecPyType_FromSpecWithBasesPyType_FromSpec_PyType_Lookup_PyObject_LookupSpecial_PyObjer_GetBufferPyPickleBuffer_ReleasePyLongRangeIter_TypePyRangeIter_TypePyRange_TypePyFrozenSet_TypePySet_TypePySetIter_TypePySet_NewPyFrozenSet_NewPySet_SizePySet_ClearPySet_ContainsPySet_DiscardPySet_Add_PySet_NextEntryPySet_Pop_PySet_Update_PySet_DummyPySlice_Type_Py_EllipsisObject_PySlice_FiniPySlice_New_PyBuildSlice_ConsumeRefs_PySlice_FromIndicesPySlice_GetIndicesPySlice_UnpackPySlice_AdjustIndicesPySlice_GetIndicesEx_PySlice_GetLongIndicesPyEllipsis_TypePyStructSequence_NewPyStructSequence_SetItPyExc_NotImplementedErrorPyExc_RecursionErrorPyExc_RuntimeErrorPyExc_EOFErrorPyExc_ConnectionErrorPyExc_ModuleNotFoundErrorPyExc_ImportErrorPyExc_KeyboardInterruptPyExc_SystemExitPyExc_GeneratorExitPyExc_StopIterationPyExc_StopAsyncIterationPyExc_BaseException_Py_GenericAliasIterTypePy_GenericAliasType_Py_make_parameters_Py_subs_parametersPy_GenericAliasPyCoro_TypePyAsyncGen_Type_PyCoroWrapper_Type_PyAsyncGenAThrow_Type_PyAsyncGenASend_TypePyGen_GetCode_PyGen_yf_PyGen_SetStopIterationValue_PyGen_Finalizenstable_Code_SetExtra_PyCode_GetVarnamesPyCode_GetVarnames_PyCode_GetCellvarsPyCode_GetCellvars_PyCode_GetFreevarsPyCode_GetFreevars_PyCode_GetCodePyCode_GetCode_PyCode_ConstantKey_PyStaticCode_Fini_PyStaticCode_Init_Py_MakeShimCodePyComplex_Type_Py_c_sum_Py_c_diff_Py_c_neg_Py_c_prod_Py_c_quot_Py_c_pow_Py_c_absPyComplex_FromCComplexPyComplex_FromDoublesPyComplex_RealAsDoublePyComplex_ImagAsDoublePyComplex_AsCComplex_PyMethodWrapper_TypePyDictProxy_TypePyProperty_TypePyDescr_NewMethodPyMethodDescr_TypesPyBuffer_GetPointerPyBuffer_SizeFromFormatPyBuffer_FromContiguousPyBuffer_FillContiguousStridesPyBuffer_FillInfoPyBuffer_ReleasePyObject_CheckReadBufferPyObject_AsReadBufferPyObject_AsWriteBufferPyObject_CopyDataPyObject_AsCharBufferPyObject_FormatPyNumber_CheckPyNumber_OrPyNumber_XorPyNumber_AndPyNumber_LshiftPyNumber_RshiftPyNumber_SubtractPyNumber_DivmodPyNumber_AddPyNumber_MatrixMultiplyPyNumber_FloorDividePyNumber_TrueDividePyNumber_RemainderPyNumber_Power_PyNumber_PowerNoModPyNumber_InPlaceOrPyNu(((f J J#~'****1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i"1i">1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1>1B*B*B*B*B*B*B*B*B*B*B*B*B*N6N6N6N6N6N6N6N6N6N6N6N6N6N6N6N6N6R[FR[FR[jjjjIfIfIfbbbbbbbbbb...............W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:W:OOOOOOOOOOOOOOO;;;first block b = PyBytes_FromStringAndSize(NULL, init_size); if (b == NULL) { PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); return -1; } // create the list buffer->list = PyList_New(1); if (buffer->list == NULL) { Py_DECREF(b); return -1; } PyList_SET_ITEM(buffer->list, 0, b); // set variables buffer->allocated = init_size; buffer->max_length = -1; *next_out = PyBytes_AS_STRING(b); return init_size; } /* Grow the buffer. The avail_out f the buffer, -1 for unlimited length. On success, return allocated size (>=0) On failure, return -1 */ static inline Py_ssize_t _BlocksOutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, const Py_ssize_t max_length, void **next_out) { PyObject *b; Py_ssize_t block_size; // ensure .list was set to NULL assert(buffer->list == NULL); // get block size if (0 <= max_length && max_length < BUFFER_BLOCK_SIZE[0]) { block_size = max_l _PyType_GetModuleState(PyTypeObject *type) { assert(PyType_Check(type)); assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); PyHeapTypeObject *et = (PyHeapTypeObject *)type; assert(et->ht_module); PyModuleObject *mod = (PyModuleObject *)(et->ht_module); assert(mod != NULL); return mod->md_state; } extern int _PyStaticType_InitBuiltin(PyInterpreterState *, PyTypeObject *type); extern static_builtin_state * _PyStaticType_GetState(PyInterpreterState *, PyTypeObject *); extern void _PyStaticType_ClearWeakRefs(Plude #endif #ifndef MS_WINDOWS /* register() is useless on Windows, because only SIGSEGV, SIGABRT and SIGILL can be handled by the process, and these signals can only be used with enable(), not using register() */ # define FAULTHANDLER_USER #endif #ifdef HAVE_SIGACTION /* Using an alternative stack requires sigaltstack() and sigaction() SA_ONSTACK */ # ifdef HAVE_SIGALTSTACK # define FAULTHANDLER_USE_ALT_STACK # endif typedef struct sigaction _Py_sighandler_t; #else typedef PyOS_sighandler_t _. WASM's indirect_call has strict * function signature checks. Argument count, types, and return type must * match. * * Third party code unintentionally rely on problematic fpcasts. The call * trampoline mitigates common occurrences of bad fpcasts on Emscripten. */ #if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE) #define _PyCFunction_TrampolineCall(meth, self, args) \ _PyCFunctionWithKeywords_TrampolineCall( \ (*(PyCFunctionWithKeywords)(void(*)(void))(meth)), (self), (args), NULL) extern PyObject* _PyCFLISTPTR_FROM_OFFSET(): Py_ssize_t offset = Py_TYPE(op)->tp_weaklistoffset; return (PyObject **)((char *)op + offset); } /* This is a special case of _PyObject_GET_WEAKREFS_LISTPTR(). * Only the most fundamental lookup path is used. * Consequently, static types should not be used. * * For static builtin types the returned pointer will always point * to a NULL tp_weaklist. This is fine for any deallocation cases, * since static types are never deallocated and static builtin types * are only finalized at the end of rutalRefcountError("Expected a positive remaining refcount"); } #endif } #ifdef Py_REF_DEBUG # undef _Py_DEC_REFTOTAL #endif PyAPI_FUNC(int) _PyType_CheckConsistency(PyTypeObject *type); PyAPI_FUNC(int) _PyDict_CheckConsistency(PyObject *mp, int check_content); /* Update the Python traceback of an object. This function must be called when a memory block is reused from a free list. Internal function called by _Py_NewReference(). */ extern int _PyTraceMalloc_NewReference(PyObject *op); // Fast inlined version of PyTypeg_InitImportConfig(PyConfig *config); extern PyStatus _PyConfig_Read(PyConfig *config, int compute_path_config); extern PyStatus _PyConfig_Write(const PyConfig *config, struct pyruntimestate *runtime); extern PyStatus _PyConfig_SetPyArgv( PyConfig *config, const _PyArgv *args); PyAPI_FUNC(PyObject*) _PyConfig_AsDict(const PyConfig *config); PyAPI_FUNC(int) _PyConfig_FromDict(PyConfig *config, PyObject *dict); extern void _Py_DumpPathConfig(PyThreadState *tstate); PyAPI_FUNC(PyObject*) _Py_Get_Getpath_CodeObject(void)UMP_IF_FALSE] = "INSTRUMENTED_POP_JUMP_IF_FALSE", [INSTRUMENTED_POP_JUMP_IF_TRUE] = "INSTRUMENTED_POP_JUMP_IF_TRUE", [INSTRUMENTED_END_FOR] = "INSTRUMENTED_END_FOR", [INSTRUMENTED_END_SEND] = "INSTRUMENTED_END_SEND", [INSTRUMENTED_INSTRUCTION] = "INSTRUMENTED_INSTRUCTION", [INSTRUMENTED_LINE] = "INSTRUMENTED_LINE", [255] = "<255>", [SETUP_FINALLY] = "SETUP_FINALLY", [SETUP_CLEANUP] = "SETUP_CLEANUP", [SETUP_WITH] = "SETUP_WITH", [POP_BLOCK] = "POP_BLOCK", [JUMP] = "JUMP", [JUMP_NO_INTY] = "COPY", [RETURN_CONST] = "RETURN_CONST", [BINARY_OP] = "BINARY_OP", [SEND] = "SEND", [LOAD_FAST] = "LOAD_FAST", [STORE_FAST] = "STORE_FAST", [DELETE_FAST] = "DELETE_FAST", [LOAD_FAST_CHECK] = "LOAD_FAST_CHECK", [POP_JUMP_IF_NOT_NONE] = "POP_JUMP_IF_NOT_NONE", [POP_JUMP_IF_NONE] = "POP_JUMP_IF_NONE", [RAISE_VARARGS] = "RAISE_VARARGS", [GET_AWAITABLE] = "GET_AWAITABLE", [MAKE_FUNCTION] = "MAKE_FUNCTION", [BUILD_SLICE] = "BUILD_SLICE", [JUMP_BACKWARD_NO_INTERRUPT] = "JUMP_BACR] = "STORE_SUBSCR", [DELETE_SUBSCR] = "DELETE_SUBSCR", [FOR_ITER_LIST] = "FOR_ITER_LIST", [FOR_ITER_TUPLE] = "FOR_ITER_TUPLE", [FOR_ITER_RANGE] = "FOR_ITER_RANGE", [FOR_ITER_GEN] = "FOR_ITER_GEN", [LOAD_SUPER_ATTR_ATTR] = "LOAD_SUPER_ATTR_ATTR", [LOAD_SUPER_ATTR_METHOD] = "LOAD_SUPER_ATTR_METHOD", [GET_ITER] = "GET_ITER", [GET_YIELD_FROM_ITER] = "GET_YIELD_FROM_ITER", [LOAD_ATTR_CLASS] = "LOAD_ATTR_CLASS", [LOAD_BUILD_CLASS] = "LOAD_BUILD_CLASS", [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] [BUILD_MAP] = BUILD_MAP, [BUILD_SET] = BUILD_SET, [BUILD_SLICE] = BUILD_SLICE, [BUILD_STRING] = BUILD_STRING, [BUILD_TUPLE] = BUILD_TUPLE, [CACHE] = CACHE, [CALL] = CALL, [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, [CALL_BUILTIN_CLASS] = CALL, [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, [CALL_NO_KW_BUILTIN_FAST] = CAL, [STORE_SUBSCR] = 1, [UNPACK_SEQUENCE] = 1, [FOR_ITER] = 1, [STORE_ATTR] = 4, [LOAD_ATTR] = 9, [COMPARE_OP] = 1, [LOAD_GLOBAL] = 4, [BINARY_OP] = 1, [SEND] = 1, [LOAD_SUPER_ATTR] = 1, [CALL] = 3, }; const uint8_t _PyOpcode_Deopt[256] = { [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, [BEFORE_WITH] = BEFORE_WITH, [BINARY_OP] = BINARY_OP, [BINARY_OP_ADD_FLOAT] = BINARY_OP, [BINARY_OP_ADD_INT] = BINARY_OP, [BINARY_OP_ADD_UNICODE] = BINARY_OP, [BINARY_OP_INPLACE_ADD_UNarations needed to // use the two macros below. // * _Py_SET_53BIT_PRECISION_START: store original FPU settings, and // set FPU to 53-bit precision/round-half-to-even // * _Py_SET_53BIT_PRECISION_END: restore original FPU settings // // The macros are designed to be used within a single C function: see // Python/pystrtod.c for an example of their use. // Get and set x87 control word for gcc/x86 #ifdef HAVE_GCC_ASM_FOR_X87 #define HAVE_PY_SET_53BIT_PRECISION 1 // Functions defined in Python/pymath.c extern unsigned short _Py_ /* runtime lifecycle */ extern PyStatus _PyTuple_InitGlobalObjects(PyInterpreterState *); extern void _PyTuple_Fini(PyInterpreterState *); /* other API */ // PyTuple_MAXSAVESIZE - largest tuple to save on free list // PyTuple_MAXFREELIST - maximum number of tuples of each size to save #if defined(PyTuple_MAXSAVESIZE) && PyTuple_MAXSAVESIZE <= 0 // A build indicated that tuple freelists should not be used. # define PyTuple_NFREELISTS 0 # undef PyTuple_MAXSAVESIZE # undef PyTuple_MAXFREELIST #elif !defined(WITH_FREELISad of adding a new _Py_atomic_ulong. */ _Py_atomic_address _finalizing_id; /* The value to use for sys.path[0] in new subinterpreters. Normally this would be part of the PyConfig struct. However, we cannot add it there in 3.12 since that's an ABI change. */ wchar_t *sys_path_0; /* The following fields are here to avoid allocation during init. The data is exposed through _PyRuntimeState pointer fields. These fields should not be accessed directly outside of init. All other _PyRun--------- The fields above this line are declared as early as possible to facilitate out-of-process observability tools. */ // XXX Remove this field once we have a tp_* slot. struct _xidregistry xidregistry; struct _pymem_allocators allocators; struct _obmalloc_global_state obmalloc; struct pyhash_runtime_state pyhash_state; struct _time_runtime_state time; struct _pythread_runtime_state threads; struct _signals_runtime_state signals; /* Used for the thread state bound to the cu PyGC_Head *gc = _Py_AS_GC(op); _PyGCHead_SET_FINALIZED(gc); } /* GC runtime state */ /* If we change this, we need to change the default value in the signature of gc.collect. */ #define NUM_GENERATIONS 3 /* NOTE: about untracking of mutable objects. Certain types of container cannot participate in a reference cycle, and so do not need to be tracked by the garbage collector. Untracking these objects reduces the cost of garbage collections. However, determining which objects may be untracked is not free object is in generation which is GCed currently. */ #define _PyGC_PREV_MASK_COLLECTING (2) /* The (N-2) most significant bits contain the real address. */ #define _PyGC_PREV_SHIFT (2) #define _PyGC_PREV_MASK (((uintptr_t) -1) << _PyGC_PREV_SHIFT) // Lowest bit of _gc_next is used for flags only in GC. // But it is always 0 for normal code. static inline PyGC_Head* _PyGCHead_NEXT(PyGC_Head *gc) { uintptr_t next = gc->_gc_next; return _Py_CAST(PyGC_Head*, next); } static inline void _PyGCHead_SET_NEXT(Pcode_flags, int nlocals, int nparams, int firstlineno); int _PyCfg_Stackdepth(_PyCfgBasicblock *entryblock, int code_flags); void _PyCfg_ConvertPseudoOps(_PyCfgBasicblock *entryblock); int _PyCfg_ResolveJumps(_PyCfgBuilder *g); static inline int basicblock_nofallthrough(const _PyCfgBasicblock *b) { _PyCfgInstruction *last = _PyCfg_BasicblockLastInstr(b); return (last && (IS_SCOPE_EXIT_OPCODE(last->i_opcode) || IS_UNCONDITIONAL_JUMP_OPCODE(last->i_opcode))); } #define BB_NO_FALLTHROUGH(B) (basicblnt override_multi_interp_extensions_check; #ifdef HAVE_DLOPEN int dlopenflags; #endif PyObject *import_func; /* The global import lock. */ struct { PyThread_type_lock mutex; unsigned long thread; int level; } lock; /* diagnostic info in PyImport_ImportModuleLevelObject() */ struct { int import_level; _PyTime_t accumulated; int header; } find_and_load; }; #ifdef HAVE_DLOPEN # include # if HAVE_DECL_RTLD_NOW # define _Py_DLOPEN_FLAGS RTLD_table.h" // _Py_hashtable_t #include "pycore_time.h" // _PyTime_t struct _import_runtime_state { /* The builtin modules (defined in config.c). */ struct _inittab *inittab; /* The most recent value assigned to a PyModuleDef.m_base.m_index. This is incremented each time PyModuleDef_Init() is called, which is just about every time an extension module is imported. See PyInterpreterState.modules_by_index for more info. */ Py_ssize_t last_module_index; struct { /* A lock to arena size: 14 -> MAP_BOT_BITS 18 -> ideal aligned arena ---- 32 */ #if SIZEOF_VOID_P == 8 /* number of bits in a pointer */ #define POINTER_BITS 64 /* High bits of memory addresses that will be ignored when indexing into the * radix tree. Setting this to zero is the safe default. For most 64-bit * machines, setting this to 16 would be safe. The kernel would not give * user-space virtual memory addresses that have significant information in * those high bits. The main advantage to setting IGNORE_BITS pools list, via its nextpool member. The prevpool member has no meaning in this case. Empty pools have no inherent size class: the next time a malloc finds an empty list in usedpools[], it takes the first pool off of freepools. If the size class needed happens to be the same as the size class the pool last had, some pool initialization can be skipped. Block Management Blocks within pools are again carved out as needed. pool->freeblock points to the start of a singly-linked list of free blocks within the polid nextoffset */ }; typedef struct pool_header *poolp; /* Record keeping for arenas. */ struct arena_object { /* The address of the arena, as returned by malloc. Note that 0 * will never be returned by a successful malloc, and is used * here to mark an arena_object that doesn't correspond to an * allocated arena. */ uintptr_t address; /* Pool-aligned pointer to the next pool to be carved off. */ pymem_block* pool_address; /* The number of available pools in the arena: free pools +. */ /* #undef WITH_MEMORY_LIMITS */ /* disable mem limit checks */ /*==========================================================================*/ /* * Allocation strategy abstract: * * For small requests, the allocator sub-allocates blocks of memory. * Requests greater than SMALL_REQUEST_THRESHOLD bytes are routed to the * system's allocator. * * Small requests are grouped in size classes spaced 8 bytes apart, due * to the required valid alignment of the returned address. Requests of * a particular size is actually used (layer +2), It is called for every object allocation and deallocation (PyObject_New/Del), unless the object-specific allocators implement a proprietary allocation scheme (ex.: ints use a simple free list). This is also the place where the cyclic garbage collector operates selectively on container objects. Object-specific allocators _____ ______ ______ ________ [ int ] [ dict ] [ list ] ... [ string ] Python core | +3 | <----- Object-specific memory -----> | <-- Non-TORING_PROFILER_ID 2 #define PY_MONITORING_OPTIMIZER_ID 5 /* Internal IDs used to suuport sys.setprofile() and sys.settrace() */ #define PY_MONITORING_SYS_PROFILE_ID 6 #define PY_MONITORING_SYS_TRACE_ID 7 PyObject *_PyMonitoring_RegisterCallback(int tool_id, int event_id, PyObject *obj); int _PyMonitoring_SetEvents(int tool_id, _PyMonitoringEventSet events); extern int _Py_call_instrumentation(PyThreadState *tstate, int event, _PyInterpreterFrame *frame, _Py_CODEUNIT *instr); extern int _Py_call_instrumentation_line(PyThrmport annotations' is active. // Annotation blocks cannot bind names and are not evaluated. AnnotationBlock, // Used for generics and type aliases. These work mostly like functions // (see PEP 695 for details). The three different blocks function identically; // they are different enum entries only so that error messages can be more // precise. TypeVarBoundBlock, TypeAliasBlock, TypeParamBlock } _Py_block_ty; typedef enum _comprehension_type { NoComprehension = 0, ListComprehension = 1, Dictict_WatchCallback watchers[DICT_MAX_WATCHERS]; }; #define _dict_state_INIT \ { \ .next_keys_version = 2, \ } #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_DICT_STATE_H */ #ifndef Py_INTERNAL_PYMEM_INIT_H #define Py_INTERNAL_PYMEM_INIT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "pycore_pymem.h" /********************************/ /* the allocators' initializers */ extern void * _PyMem_RawMalloc(void *, size_t); exteffset, PyArena *arena); alias_ty _PyAST_alias(identifier name, identifier asname, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); withitem_ty _PyAST_withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena); match_case_ty _PyAST_match_case(pattern_ty pattern, expr_ty guard, asdl_stmt_seq * body, PyArena *arena); pattern_ty _PyAST_MatchValue(expr_ty value, int int col_offset, int end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno end_col_offset, PyArena *arena); stmt_ty _PyAST_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); stmt_ty _PyAST_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body, asdl_stmt_seq * orelse, string type_comment, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); stmt_ty _PyAST_AsyncFor(exp asdl_identifier_seq *names; } Nonlocal; struct { expr_ty value; } Expr; } v; int lineno; int col_offset; int end_lineno; int end_col_offset; }; enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, Lambda_kind=5, IfExp_kind=6, Dict_kind=7, Set_kind=8, ListComp_kind=9, SetComp_kind=10, DictComp_kind=11, GeneratorExp_kind=12, Await_kind=13, Yield_kind=14, YieldFrom_kind=15, Comkind=20, Import_kind=21, ImportFrom_kind=22, Global_kind=23, Nonlocal_kind=24, Expr_kind=25, Pass_kind=26, Break_kind=27, Continue_kind=28}; struct _stmt { enum _stmt_kind kind; union { struct { identifier name; arguments_ty args; asdl_stmt_seq *body; asdl_expr_seq *decorator_list; expr_ty returns; string type_comment; asdl_type_param_seq *type_params; } FunctionDef; _ASDL_SEQ_HEAD stmt_ty typed_elements[1]; } asdl_stmt_seq; asdl_stmt_seq *_Py_asdl_stmt_seq_new(Py_ssize_t size, PyArena *arena); typedef struct { _ASDL_SEQ_HEAD expr_ty typed_elements[1]; } asdl_expr_seq; asdl_expr_seq *_Py_asdl_expr_seq_new(Py_ssize_t size, PyArena *arena); typedef struct { _ASDL_SEQ_HEAD comprehension_ty typed_elements[1]; } asdl_comprehension_seq; asdl_comprehension_seq *_Py_asdl_comprehension_seq_new(Py_ssize_t size, PyArena *arenat(PyList_Check(op)), _Py_CAST(PyListObject*, (op))) // Macros and static inline functions, trading safety for speed static inline Py_ssize_t PyList_GET_SIZE(PyObject *op) { PyListObject *list = _PyList_CAST(op); return Py_SIZE(list); } #define PyList_GET_SIZE(op) PyList_GET_SIZE(_PyObject_CAST(op)) #define PyList_GET_ITEM(op, index) (_PyList_CAST(op)->ob_item[(index)]) static inline void PyList_SET_ITEM(PyObject *op, Py_ssize_t index, PyObject *value) { PyListObject *list = _PyList_CAST(op); list->ob_item[index]ocator is run directly without further ado. But if the counter gets large, it instead adds p to a list of objects to be deallocated later, skips the body of the deallocator, and resumes execution after the END macro. The tp_dealloc routine then returns without deallocating anything (and so unbounded call-stack depth is avoided). When the call stack finishes unwinding again, code generated by the END macro notices this, and calls another routine to deallocate all the objects that may have been added to the list of deferred dealloEAR "the obvious" code can be deadly: * * Py_DECREF(dst); * dst = src; * * The safe way is: * * Py_SETREF(dst, src); * * That arranges to set `dst` to `src` _before_ decref'ing, so that any code * triggered as a side-effect of `dst` getting torn down no longer believes * `dst` points to a valid object. * * Temporary variables are used to only evalutate macro arguments once and so * avoid the duplication of side effects. _Py_TYPEOF() or memcpy() is used to * avoid a miscompilation caused by type punning. item can be called // with two positional arguments and no keyword arguments, and has neither // *args nor **kwargs (as required by BINARY_SUBSCR_GETITEM): PyObject *getitem; uint32_t getitem_version; }; /* The *real* layout of a type object when allocated on the heap */ typedef struct _heaptypeobject { /* Note: there's a dependency on the order of these members in slotptr() in typeobject.c . */ PyTypeObject ht_type; PyAsyncMethods as_async; PyNumberMethods as_number; PyMappingMethodsue_divide; binaryfunc nb_inplace_floor_divide; binaryfunc nb_inplace_true_divide; unaryfunc nb_index; binaryfunc nb_matrix_multiply; binaryfunc nb_inplace_matrix_multiply; } PyNumberMethods; typedef struct { lenfunc sq_length; binaryfunc sq_concat; ssizeargfunc sq_repeat; ssizeargfunc sq_item; void *was_sq_slice; ssizeobjargproc sq_ass_item; void *was_sq_ass_slice; objobjproc sq_contains; binaryfunc sq_inplace_concat; ssizeargfunc sq_inplace_repeat; } PySequenceMethodsatus) Py_PreInitializeFromArgs( const PyPreConfig *src_config, Py_ssize_t argc, wchar_t **argv); PyAPI_FUNC(int) _Py_IsCoreInitialized(void); /* Initialization and finalization */ PyAPI_FUNC(PyStatus) Py_InitializeFromConfig( const PyConfig *config); PyAPI_FUNC(PyStatus) _Py_InitializeMain(void); PyAPI_FUNC(int) Py_RunMain(void); PyAPI_FUNC(void) _Py_NO_RETURN Py_ExitStatusException(PyStatus err); /* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */ PyAPI_FUNC(void) _Py_RestoreSignalsct_CheckExact(op) Py_IS_TYPE((op), &PyODict_Type) #define PyODict_SIZE(op) PyDict_GET_SIZE((op)) PyAPI_FUNC(PyObject *) PyODict_New(void); PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item); PyAPI_FUNC(int) PyODict_DelItem(PyObject *od, PyObject *key); /* wrappers around PyDict* functions */ #define PyODict_GetItem(od, key) PyDict_GetItem(_PyObject_CAST(od), (key)) #define PyODict_GetItemWithError(od, key) \ PyDict_GetItemWithError(_PyObject_CAST(od), (key)) #define PyODict_Contains(od, key) PyDict_CNC(PyObject *) _PyLong_Lshift(PyObject *, size_t); PyAPI_FUNC(int) PyUnstable_Long_IsCompact(const PyLongObject* op); PyAPI_FUNC(Py_ssize_t) PyUnstable_Long_CompactValue(const PyLongObject* op); #ifndef Py_CPYTHON_PYTHONRUN_H # error "this header file must not be included directly" #endif PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *); PyAPI_FUNC(int) _PyRun_SimpleFileObject( FILE *fp, PyObject *filename, int closeit, PyCompilerFlags *flags); PyAPI_FUNC(int) PyRun_AnyFileExFlags( F) bytes[0] is the MSB and bytes[n-1] the LSB. If is_signed is 0/false, view the bytes as a non-negative integer. If is_signed is 1/true, view the bytes as a 2's-complement integer, non-negative if bit 0x80 of the MSB is clear, negative if set. Error returns: + Return NULL with the appropriate exception set if there's not enough memory to create the Python int. */ PyAPI_FUNC(PyObject *) _PyLong_FromByteArray( const unsigned char* bytes, size_t n, int little_endian, int is_signed); /* _PyLong_AsByteArr void *wrapped, PyObject *kwds); struct wrapperbase { const char *name; int offset; void *function; wrapperfunc wrapper; const char *doc; int flags; PyObject *name_strobj; }; /* Flags for above struct */ #define PyWrapperFlag_KEYWORDS 1 /* wrapper function takes keyword args */ /* Various kinds of descriptor objects */ typedef struct { PyObject_HEAD PyTypeObject *d_type; PyObject *d_name; PyObject *d_qualname; } PyDescrObject; #define PyDescr_COMMON PyDescrObject d_common #defiI_FUNC(double) PyFloat_Unpack8(const char *p, int le); #ifndef Py_CPYTHON_PTRHEAD_STUBS_H #define Py_CPYTHON_PTRHEAD_STUBS_H #if !defined(HAVE_PTHREAD_STUBS) # error "this header file requires stubbed pthreads." #endif #ifndef _POSIX_THREADS # define _POSIX_THREADS 1 #endif /* Minimal pthread stubs for CPython. * * The stubs implement the minimum pthread API for CPython. * - pthread_create() fails. * - pthread_exit() calls exit(0). * - pthread_key_*() functions implement minimal TSS without destructor. * - all other funcxid_newobjectfunc)(_PyCrossInterpreterData *); typedef void (*xid_freefunc)(void *); struct _xid { // data is the cross-interpreter-safe derivation of a Python object // (see _PyObject_GetCrossInterpreterData). It will be NULL if the // new_object func (below) encodes the data. void *data; // obj is the Python object from which the data was derived. This // is non-NULL only if the data remains bound to the object in some // way, such that the object must be "released" (via a decref) when // the da See https://bugs.python.org/issue45953#msg412046. /* The thread's exception stack entry. (Always the last entry.) */ _PyErr_StackItem exc_state; /* The bottom-most frame on the stack. */ _PyCFrame root_cframe; }; /* WASI has limited call stack. Python's recursion limit depends on code layout, optimization, and WASI runtime. Wasmtime can handle about 700 recursions, sometimes less. 500 is a more conservative limit. */ #ifdef Py_DEBUG # if defined(__wasi__) # define C_RECURSION_LIMIT 150 # else # dhunk { struct _stack_chunk *previous; size_t size; size_t top; PyObject * data[1]; /* Variable sized */ } _PyStackChunk; struct _py_trashcan { int delete_nesting; PyObject *delete_later; }; struct _ts { /* See Python/ceval.c for comments explaining most fields */ PyThreadState *prev; PyThreadState *next; PyInterpreterState *interp; struct { /* Has been initialized to a safe state. In order to be effective, this must be set to 0 during or right after alloobject storage; 2) the initialization of the Python specific fields in this storage with PyObject_{Init, InitVar}. PyObject * YourObject_New(...) { PyObject *op; op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct)); if (op == NULL) { return PyErr_NoMemory(); } PyObject_Init(op, &YourTypeStruct); op->ob_field = value; ... return op; } Note that in C++, the use of the new operator usually implies that the 1st step is perint) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, struct _PyInterpreterFrame *f, int exc); PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds); PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void); PyAPI_FUNC(int) _PyEval_MakePendingCalls(PyThreadState *); PyAPI_FUNC(Py_ssize_t) PyUnstable_Eval_RequestCodeExtraIndex(freefunc); // Old name -- remove when this API changes: _Py_DEPRECATED_EXTERNALLY(3.12) static inline Py_ssize_t _PyE the dictionary is modified */ #ifdef Py_BUILD_CORE uint64_t ma_version_tag; #else Py_DEPRECATED(3.12) uint64_t ma_version_tag; #endif PyDictKeysObject *ma_keys; /* If ma_values is NULL, the table is "combined": keys and values are stored in ma_keys. If ma_values is not NULL, the table is split: keys are stored in ma_keys and values are stored in ma_values */ PyDictValues *ma_values; } PyDictObject; PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key, yObject *) _PyFunction_Vectorcall( PyObject *func, PyObject *const *stack, size_t nargsf, PyObject *kwnames); #define _PyFunction_CAST(func) \ (assert(PyFunction_Check(func)), _Py_CAST(PyFunctionObject*, func)) /* Static inline functions for direct access to these values. Type checks are *not* done, so use with care. */ static inline PyObject* PyFunction_GET_CODE(PyObject *func) { return _PyFunction_CAST(func)->func_code; } #define PyFunction_GET_CODE(func) PyFunction_GET_CODE(_PyObject_CAST(func)) sta PyObject *note); PyAPI_FUNC(PyObject*) PyUnstable_Exc_PrepReraiseStar( PyObject *orig, PyObject *excs); /* In signalmodule.c */ int PySignal_SetWakeupFd(int fd); PyAPI_FUNC(int) _PyErr_CheckSignals(void); /* Support for adding program text to SyntaxErrors */ PyAPI_FUNC(void) PyErr_SyntaxLocationObject( PyObject *filename, int lineno, int col_offset); PyAPI_FUNC(void) PyErr_RangedSyntaxLocationObject( PyObject *filename, int lineno, int col_offset, int end_lineno, int end_col_offoid) PyPreConfig_InitIsolatedConfig(PyPreConfig *config); /* --- PyConfig ---------------------------------------------- */ /* This structure is best documented in the Doc/c-api/init_config.rst file. */ typedef struct PyConfig { int _config_init; /* _PyConfigInitEnum value */ int isolated; int use_environment; int dev_mode; int install_signal_handlers; int use_hash_seed; unsigned long hash_seed; int faulthandler; int tracemalloc; int perf_profiling; int import_time; int code_d_ReleaseLock(PyInterpreterState *interp); PyAPI_FUNC(int) _PyImport_FixupBuiltin( PyObject *mod, const char *name, /* UTF-8 encoded string */ PyObject *modules ); PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *, PyObject *, PyObject *); struct _inittab { const char *name; /* ASCII encoded string */ PyObject* (*initfunc)(void); }; // This is not used after Py_Initialize() is called. PyAPI_DATA(struct _inittab *) PyImporicode_IsAlpha( Py_UCS4 ch /* Unicode character */ ); // Helper array used by Py_UNICODE_ISSPACE(). PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[]; // Since splitting on whitespace is an important use case, and // whitespace in most situations is solely ASCII whitespace, we // optimize for the common case by using a quick look-up table // _Py_ascii_whitespace (see below) with an inlined check. static inline int Py_UNICODE_ISSPACE(Py_UCS4 ch) { if (ch < 128) { return _Py_ascii_whitespace[ch]; } Py_ssize_t *consumed, /* bytes consumed */ const char **first_invalid_escape /* on return, points to first invalid escaped char in string. */ ); /* --- Raw-Unicode-Escape Codecs ---------------------------------------------- */ /* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */ PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful( const char *string, /* Unicode-Escape encodmat the object based on the format_spec, as defined in PEP 3101 (Advanced String Formatting). */ PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter( _PyUnicodeWriter *writer, PyObject *obj, PyObject *format_spec, Py_ssize_t start, Py_ssize_t end); /* --- Manage the default encoding ---------------------------------------- */ /* Returns a pointer to the default encoding (UTF-8) of the Unicode object unicode. Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation in the unicodeobjectndData( int kind, const void *buffer, Py_ssize_t size); /* Create a new string from a buffer of ASCII characters. WARNING: Don't check if the string contains any non-ASCII character. */ PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII( const char *buffer, Py_ssize_t size); /* Compute the maximum character of the substring unicode[start:end]. Return 127 for an empty string. */ PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar ( PyObject *unicode, Py_ssize_t start, Py_ssize_t end); /* --- _PyUnicodeWriter CAST(Py_UCS2, value); } else { assert(kind == PyUnicode_4BYTE_KIND); assert(value <= 0x10ffffU); _Py_STATIC_CAST(Py_UCS4*, data)[index] = value; } } #define PyUnicode_WRITE(kind, data, index, value) \ PyUnicode_WRITE(_Py_STATIC_CAST(int, kind), _Py_CAST(void*, data), \ (index), _Py_STATIC_CAST(Py_UCS4, value)) /* Read a code point from the string's canonical representation. No checks or ready calls are performed. */ static inline Py_UCS4 PyUnicode_READ(int kind, /* UTF-8 representation (null-terminated) */ } PyCompactUnicodeObject; /* Object format for Unicode subclasses. */ typedef struct { PyCompactUnicodeObject _base; union { void *any; Py_UCS1 *latin1; Py_UCS2 *ucs2; Py_UCS4 *ucs4; } data; /* Canonical, smallest-form Unicode buffer */ } PyUnicodeObject; PyAPI_FUNC(int) _PyUnicode_CheckConsistency( PyObject *op, int check_content); #define _PyASCIIObject_CAST(op) \ (assert(PyUnicode_Check(op)), \ _Py_CAture. state.ascii and state.compact are set, and the data immediately follow the structure. utf8_length can be found in the length field; the utf8 pointer is equal to the data pointer. */ typedef struct { /* There are 4 forms of Unicode strings: - compact ascii: * structure = PyASCIIObject * test: PyUnicode_IS_COMPACT_ASCII(op) * kind = PyUnicode_1BYTE_KIND * compact = 1 * ascii = 1 * (length is the length of the utf8) * (data starts just after the st{ /* bytes, bytearray or NULL (when the small buffer is used) */ PyObject *buffer; /* Number of allocated size. */ Py_ssize_t allocated; /* Minimum number of allocated bytes, incremented by _PyBytesWriter_Prepare() */ Py_ssize_t min_size; /* If non-zero, use a bytearray instead of a bytes object for buffer. */ int use_bytearray; /* If non-zero, overallocate the buffer (default: 0). This flag must be zero if use_bytearray is non-zero. */ int overallocate; /* Stack bufferyObject *) PyFile_OpenCodeObject(PyObject *path); PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData); PyAPI_FUNC(int) _PyLong_FileDescriptor_Converter(PyObject *, void *); #ifndef Py_LIMITED_API #ifndef Py_CONTEXT_H #define Py_CONTEXT_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyContext_Type; typedef struct _pycontextobject PyContext; PyAPI_DATA(PyTypeObject) PyContextVar_Type; typedef struct _pycontextvarobject PyContextVar; PyAPI_DATA(PyTypeObject) PyContextToken_Type; _clock_info_t *info); /* Get the time of a monotonic clock, i.e. a clock that cannot go backwards. The clock is not affected by system clock updates. The reference point of the returned value is undefined, so that only the difference between the results of consecutive calls is valid. If the internal clock fails, silently ignore the error and return 0. On integer overflow, silently ignore the overflow and clamp the clock to [_PyTime_MIN; _PyTime_MAX]. Use _PyTime_GetMonotonicClockWithInfo() to check for failuyTime_round_t round); /* Convert a number of milliseconds (Python float or int, 10^-3) to a timestamp. Raise an exception and return -1 on error, return 0 on success. */ PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round); /* Convert a timestamp to a number of seconds as a C double. */ PyAPI_FUNC(double) _PyTime_AsSecondsDouble(_PyTime_t t); /* Convert timestamp to a number of milliseconds (10^-3 seconds). */ PyAPI_FUNC(_PyTime_t) _PyTime_AsMilliseconds(_PyTime_t t, _VER) struct timeval; #endif /* _PyTime_t: Python timestamp with subsecond precision. It can be used to store a duration, and so indirectly a date (related to another date, like UNIX epoch). */ typedef int64_t _PyTime_t; // _PyTime_MIN nanoseconds is around -292.3 years #define _PyTime_MIN INT64_MIN // _PyTime_MAX nanoseconds is around +292.3 years #define _PyTime_MAX INT64_MAX #define _SIZEOF_PYTIME_T 8 typedef enum { /* Round towards minus infinity (-inf). For example, used to read a clock. */ _PyTime_ROUND_ = _PyUnicode_FromId(name); /* borrowed */ if (!oname) { return _Py_NULL; } return PyObject_VectorcallMethod(oname, args, nargsf, kwnames); } static inline PyObject * _PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name) { size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET; return _PyObject_VectorcallMethodId(name, &self, nargsf, _Py_NULL); } static inline PyObject * _PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg) { PyObject *args[2] = {self, arg}; int flags; /* state flags */ Py_ssize_t exports; /* number of buffer re-exports */ Py_buffer view; /* private copy of the exporter's view */ PyObject *weakreflist; Py_ssize_t ob_array[1]; /* shape, strides, suboffsets */ } PyMemoryViewObject; #define _PyMemoryView_CAST(op) _Py_CAST(PyMemoryViewObject*, op) /* Get a pointer to the memoryview's private copy of the exporter's buffer. */ static inline Py_buffer* PyMemoryView_GET_BUFFER(PyObject *op) { return (&_Preter callback that will be invoked for code object * lifecycle events. * * Returns a handle that may be passed to PyCode_ClearWatcher on success, * or -1 and sets an error if no more handles are available. */ PyAPI_FUNC(int) PyCode_AddWatcher(PyCode_WatchCallback callback); /* * Clear the watcher associated with the watcher_id handle. * * Returns 0 on success or -1 if no watcher exists for the provided id. */ PyAPI_FUNC(int) PyCode_ClearWatcher(int watcher_id); /* for internal use only */ struct _opaque { int computnotified for line events for the matching code unit */ uint8_t *line_tools; /* Information to support instruction events */ /* The underlying instructions, which can themselves be instrumented */ uint8_t *per_instruction_opcodes; /* The tools that are to be notified for instruction events for the matching code unit */ uint8_t *per_instruction_tools; } _PyCoMonitoringData; // To avoid repeating ourselves in deepfreeze.py, all PyCodeObject members are // defined in this macro: #define _PyCode_DEF(SIZE) { uint8_t tools[_PY_MONITORING_UNGROUPED_EVENTS]; } _Py_GlobalMonitors; /* Each instruction in a code object is a fixed-width value, * currently 2 bytes: 1-byte opcode + 1-byte oparg. The EXTENDED_ARG * opcode allows for larger values but the current limit is 3 uses * of EXTENDED_ARG (see Python/compile.c), for a maximum * 32-bit value. This aligns with the note in Python/compile.c * (compiler_addop_i_line) indicating that the max oparg value is * 2**32 - 1, rather than INT_MAX. */ typedef union { uint16_t cache; PyObject_VAR_HEAD /* ob_item contains space for 'ob_size' elements. Items must normally not be NULL, except during construction when the tuple is not yet visible outside the function that builds it. */ PyObject *ob_item[1]; } PyTupleObject; PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *); /* Cast argument to PyTupleObject* type. */ #define _PyTuple_CAST(op) \ (assert(PyTuple_Check(op)), _Py_CAST(PyTupleObject*, (op))) // Macros and staticbject *cell; assert(PyCell_Check(op)); cell = _Py_CAST(PyCellObject*, op); cell->ob_ref = value; } #define PyCell_SET(op, value) PyCell_SET(_PyObject_CAST(op), (value)) #ifdef __cplusplus } #endif #endif /* !Py_TUPLEOBJECT_H */ #endif /* Py_LIMITED_API */ #ifndef Py_CPYTHON_SYSMODULE_H # error "this header file must not be included directly" #endif PyAPI_FUNC(PyObject *) _PySys_GetAttr(PyThreadState *tstate, PyObject *name); PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); typect(op) PyType_CheckExact(_PyObject_CAST(op)) #endif #ifdef __cplusplus } #endif #endif // !Py_OBJECT_H /* Limited C API of PyFrame API * * Include "frameobject.h" to get the PyFrameObject structure. */ #ifndef Py_PYFRAME_H #define Py_PYFRAME_H #ifdef __cplusplus extern "C" { #endif /* Return the line of code the frame is currently executing. */ PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *); PyAPI_FUNC(PyCodeObject *) PyFrame_GetCode(PyFrameObject *frame); #ifndef Py_LIMITED_API # define Py_CPYTHON_PYFRAME_H # ifined type which can be used in contexts where NULL (nil) is not suitable (since NULL often means 'error'). Don't forget to apply Py_INCREF() when returning this value!!! */ PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */ #define Py_None (&_Py_NoneStruct) // Test if an object is the None singleton, the same as "x is None" in Python. PyAPI_FUNC(int) Py_IsNone(PyObject *x); #define Py_IsNone(x) Py_Is((x), Py_None) /* Macro for returning Py_None from a function */ #define Py_RETURN_NONE return Py_None /* Py_NotIine Py_CLEAR(op) \ do { \ PyObject **_tmp_op_ptr = _Py_CAST(PyObject**, &(op)); \ PyObject *_tmp_old_op = (*_tmp_op_ptr); \ if (_tmp_old_op != NULL) { \ PyObject *_null_ptr = _Py_NULL; \ memcpy(_tmp_op_ptr, &_null_ptr, sizeof(PyObject*)); \ Py_DECREF(_tmp_old_op); \ } \ } while (0) #endif /* Function to use in case the object pointer can be NULL: */ static inline void Py_XINCREF(PyObject *op) { if (op != _Py_NULL) { Py_INCREF(op); } } #if S_HAVE_VERSION_TAG (1UL << 18) /* The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement reference counts. Py_DECREF calls the object's deallocator function when the refcount falls to 0; for objects that don't contain references to other objects or heap memory this can be the standard function free(). Both macros can be used wherever a void expression is allowed. The argument must not be a NULL pointer. If it may be NULL, use Py_XINCREF/Py_XDECREF instead. The macro _Py_NewReference(op) initialize refoptional feature; these flags remain of course.) Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value. Code can use PyType_HasFeature(type_ob, flag_value) to test whether the given type object has a specified feature. */ #ifndef Py_LIMITED_API /* Track types initialized using _PyStaticType_InitBuiltin(). */ #define _Py_TPFLAGS_STATIC_BUILTIN (1 << 1) /* Placement of weakref pointers are managed by the VM, not by the type. * The VM will automatically set tp_weaklistoffset. */ #define Py_TPFLAGS_MANAGED_WEAKy_LIMITED_API+0 >= 0x030c0000 // 3.12 typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames); #endif typedef struct{ int slot; /* slot id, see below */ void *pfunc; /* function pointer */ } PyType_Slot; typedef struct{ const char* name; int basicsize; int itemsize; unsigned int flags; PyType_Slot *slots; /* terminated by slot==0. */ } PyType_Spec; PyAPI_FUNC(PyObject*) PyType_FromSpec(PyType_Spec*); #if !dject *op) { #if SIZEOF_VOID_P > 4 return _Py_CAST(PY_INT32_T, op->ob_refcnt) < 0; #else return op->ob_refcnt == _Py_IMMORTAL_REFCNT; #endif } #define _Py_IsImmortal(op) _Py_IsImmortal(_PyObject_CAST(op)) static inline int Py_IS_TYPE(PyObject *ob, PyTypeObject *type) { return Py_TYPE(ob) == type; } #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 # define Py_IS_TYPE(ob, type) Py_IS_TYPE(_PyObject_CAST(ob), (type)) #endif static inline void Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) { // This immoing on the specializations for the underlying system. Proper deallocation of immortal instances requires distinguishing between statically allocated immortal instances vs those promoted by the runtime to be immortal. The latter should be the only instances that require cleanup during runtime finalization. */ #if SIZEOF_VOID_P > 4 /* In 64+ bit systems, an object will be marked as immortal by setting all of the lower 32 bits of the reference count field, which is equal to: 0xFFFFFFFF Using the lower 32 bits makes the value backwaFUNC(void) Py_EndInterpreter(PyThreadState *); /* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level * exit functions. */ PyAPI_FUNC(int) Py_AtExit(void (*func)(void)); PyAPI_FUNC(void) _Py_NO_RETURN Py_Exit(int); /* Bootstrap __main__ (defined in Modules/main.c) */ PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv); PyAPI_FUNC(int) Py_BytesMain(int argc, char **argv); /* In pathconfig.c */ Py_DEPRECATED(3.11) PyAPI_FUNC(void) Py_SetProgramName(const wchar_t *); PyAPI_FUNC(wchar_t *) Py_GetProgramName(void); PyReturns 1/0 depending on whether there is a registered codec for the given encoding. */ PyAPI_FUNC(int) PyCodec_KnownEncoding( const char *encoding ); /* Generic codec based encoding API. object is passed through the encoder function found for the given encoding using the error handling method defined by errors. errors may be NULL to use the default method defined for the codec. Raises a LookupError in case no encoder can be found. */ PyAPI_FUNC(PyObject *) PyCodec_Encode( PyObject *objec 0x03050000 /* New in 3.5 */ PyAPI_FUNC(int) PyModule_SetDocString(PyObject *, const char *); PyAPI_FUNC(int) PyModule_AddFunctions(PyObject *, PyMethodDef *); PyAPI_FUNC(int) PyModule_ExecDef(PyObject *module, PyModuleDef *def); #endif #define Py_CLEANUP_SUPPORTED 0x20000 #define PYTHON_API_VERSION 1013 #define PYTHON_API_STRING "1013" /* The API version is maintained (independently from the Python version) so we can detect mismatches between the interpreter and dynamically loaded modules. These are diagnosed by an error rg_VaParseTupleAndKeywords_SizeT #define Py_BuildValue _Py_BuildValue_SizeT #define Py_VaBuildValue _Py_VaBuildValue_SizeT #endif /* Due to a glitch in 3.2, the _SizeT versions weren't exported from the DLL. */ #if !defined(PY_SSIZE_T_CLEAN) || !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(int) PyArg_Parse(PyObject *, const char *, ...); PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...); PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *, of(char [1 - 2*!(cond)]) - 1) #define Py_BUILD_ASSERT(cond) do { \ (void)Py_BUILD_ASSERT_EXPR(cond); \ } while(0) /* Get the number of elements in a visible array This does not work on pointers, or arrays declared as [], or function parameters. With correct compiler support, such usage will cause a build error (see Py_BUILD_ASSERT_EXPR). Written by Rusty Russell, public domain, http://ccodearchive.net/ Requires at GCC 3.1+ */ #if (defined(__GNUC__) && !defined(__STRICT_ANSI__) && \ (((C(unsigned long long) PyLong_AsUnsignedLongLongMask(PyObject *); PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject *, int *); PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int); /* These aren't really part of the int object, but they're handy. The functions are in Python/mystrtoul.c. */ PyAPI_FUNC(unsigned long) PyOS_strtoul(const char *, char **, int); PyAPI_FUNC(long) PyOS_strtol(const char *, char **, int); #ifndef Py_LIMITED_API # define Py_CPYTHON_LONGOBJECT_H # include "cpython/longobject. fall back to the PyThread_tss_*() API, or ignore. # undef HAVE_THREAD_LOCAL # endif # endif #endif /* Check that ALT_SOABI is consistent with Py_TRACE_REFS: ./configure --with-trace-refs should must be used to define Py_TRACE_REFS */ #if defined(ALT_SOABI) && defined(Py_TRACE_REFS) # error "Py_TRACE_REFS ABI is not compatible with release and debug ABI" #endif #if defined(__ANDROID__) || defined(__VXWORKS__) // Use UTF-8 as the locale encoding, ignore the LC_CTYPE locale. // See _Py_GetLocaleEncoding(), PyUnicA # define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE #endif #ifndef PyMODINIT_FUNC # if defined(__cplusplus) # define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* # else /* __cplusplus */ # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* # endif /* __cplusplus */ #endif /* limits.h constants that may be missing */ #ifndef INT_MAX #define INT_MAX 2147483647 #endif #ifndef LONG_MAX #if SIZEOF_LONG == 4 #define LONG_MAX 0X7FFFFFFFL #elif SIZEOF_LONG == 8 #defition inlining when building in debug mode. // // Marking blindly a static inline function with Py_ALWAYS_INLINE can result in // worse performances (due to increased code size for example). The compiler is // usually smarter than the developer for the cost/benefit analysis. // // If Python is built in debug mode (if the Py_DEBUG macro is defined), the // Py_ALWAYS_INLINE macro does nothing. // // It must be specified before the function return type. Usage: // // static inline Py_ALWAYS_INLINE int random(void) { return 4; } #if IDE, NARROW) _Py_STATIC_CAST(NARROW, (VALUE)) #endif /* Py_DEPRECATED(version) * Declare a variable, type, or function deprecated. * The macro must be placed before the declaration. * Usage: * Py_DEPRECATED(3.3) extern int old_var; * Py_DEPRECATED(3.4) typedef int T1; * Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void); */ #if defined(__GNUC__) \ && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__)) #elif defined(_MSC_VER) #endif #if defined(Py_BUILD_CORE_MODULE) && !defined(Py_BUILD_CORE) # define Py_BUILD_CORE #endif /************************************************************************** Symbols and macros to supply platform-independent interfaces to basic C language & library operations whose spellings vary across platforms. Please try to make documentation here as clear as possible: by definition, the stuff here is trying to illuminate C's darkest corners. Config #defines referenced here: SIGNED_RIGHT_SHIFT_ZERO_FILLS Meaning: To be deAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size); PyAPI_FUNC(void) PyMem_Free(void *ptr); /* * Type-oriented memory interface * ============================== * * Allocate memory for n objects of the given type. Returns a new pointer * or NULL if the request was too large or memory allocation failed. Use * these macros rather than doing the multiplication yourself so that proper * overflow checking is always done. */ #define PyMem_New(type, n) \ ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ptr); /* Get the traceback where a memory block was allocated. Return a tuple of (filename: str, lineno: int) tuples. Return None if the tracemalloc module is disabled or if the memory block is not tracked by tracemalloc. Raise an exception and return NULL on error. */ PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback( unsigned int domain, uintptr_t ptr); /* Return non-zero if tracemalloc is tracing */ PyAPI_FUNC(int) _PyTraceMalloc_IsTracing(void); /* Clear the tracemalloc traces */ PyAPI_FUNC(void) _PyTr; uint64_t type_cache_dunder_misses; uint64_t type_cache_collisions; } ObjectStats; typedef struct _stats { OpcodeStats opcode_stats[256]; CallStats call_stats; ObjectStats object_stats; } PyStats; PyAPI_DATA(PyStats) _py_stats_struct; PyAPI_DATA(PyStats *) _py_stats; extern void _Py_StatsClear(void); extern void _Py_PrintSpecializationStats(int to_file); #ifdef _PY_INTERPRETER #define _Py_INCREF_STAT_INC() do { if (_py_stats) _py_stats->object_stats.interpreter_increfs++; } while (0) #define _Py_DECREF_STFUNC(PyFrameObject*) PyThreadState_GetFrame(PyThreadState *tstate); PyAPI_FUNC(uint64_t) PyThreadState_GetID(PyThreadState *tstate); #endif typedef enum {PyGILState_LOCKED, PyGILState_UNLOCKED} PyGILState_STATE; /* Ensure that the current thread is ready to call the Python C API, regardless of the current state of Python, or of its thread lock. This may be called as many times as desired by a thread so long as each call is matched with a call to PyGILState_Release(). In general, other thread-state APIs returns immediately even when the lock can't be acquired. If microseconds > 0, the call waits up to the specified duration. If microseconds < 0, the call waits until success (or abnormal failure) microseconds must be less than PY_TIMEOUT_MAX. Behaviour otherwise is undefined. If intr_flag is true and the acquire is interrupted by a signal, then the call will return PY_LOCK_INTR. The caller may reattempt to acquire the lock. */ PyAPI_FUNC(PyLockStatus) PyThread_acquire_lock_timed(PyThread_type_lock, define SIZEOF_PTHREAD_T 4 # endif # if defined(__LP64__) /* MacOSX 10.4 (the first release to support 64-bit code * at all) only supports 64-bit in the UNIX layer. * Therefore suppress the toolbox-glue in 64-bit mode. */ /* In 64-bit mode setpgrp always has no arguments, in 32-bit * mode that depends on the compilation environment */ # undef SETPGRP_HAVE_ARG # endif #ifdef __BIG_ENDIAN__ #define WORDS_BIGENDIAN 1 #define DOUBLE_IS_BIG_ENDIAN_IEEE754 #else #definisited. * Garbage collection is disabled during operation. Explicitly running a * collection in the callback may lead to undefined behaviour e.g. visiting the * same objects multiple times or not at all. */ typedef int (*gcvisitobjects_t)(PyObject*, void*); PyAPI_FUNC(void) PyUnstable_GC_VisitObjects(gcvisitobjects_t callback, void* arg); #endif /* Test if a type has a GC head */ #define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC) PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t); #definointer are filled in; the rest of the bytes of the object are *undefined*! The resulting expression type is 'type *'. The size of the object is determined by the tp_basicsize field of the type object. - PyObject_NewVar(type, typeobj, n) is similar but allocates a variable-size object with room for n items. In addition to the refcount and type pointer fields, this also fills in the ob_size field. - PyObject_Free(op) releases the memory allocated for an object. It does not run a destructor -- it only frees ttateEnableRaceDetection(const char *file, int line, int enable); void AnnotateNoOp(const char *file, int line, const volatile void *arg); void AnnotateFlushState(const char *file, int line); /* Return non-zero value if running under valgrind. If "valgrind.h" is included into dynamic_annotations.c, the regular valgrind mechanism will be used. See http://valgrind.org/docs/manual/manual-core-adv.html about RUNNING_ON_VALGRIND and other valgrind "client requests". The file "valgrind.h" may be obtained by d */ #define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() /* empty */ #define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() /* empty */ #define _Py_ANNOTATE_IGNORE_SYNC_END() /* empty */ #define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) /* empty */ #define _Py_ANNOTATE_NO_OP(arg) /* empty */ #define _Py_ANNOTATE_FLUSH_STATE() /* empty */ #endif /* DYNAMIC_ANNOTATIONS_ENABLED */ /* Use the macros above rather than using these functions directly. */ #ifdef __cplusplus extern "C" { #endif void AnnotateRWLockCreate(const char *file, int line, _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \ AnnotateBenignRaceSized(__FILE__, __LINE__, address, size, description) /* Request the analysis tool to ignore all reads in the current thread until _Py_ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey reads, while still checking other reads and all writes. See also _Py_ANNOTATE_UNPROTECTED_READ. */ #define _Py_ANNOTATE_IGNORE_READS_BEGIN() \ AnnotateIgnoreReadsBegin(__FILE__, __LINE__) /* Stop ignoring reads. */ #dType *MyQueue::Get() { MutexLock lock(&mu_); Type *e = GetElementFromMyQueue(); _Py_ANNOTATE_HAPPENS_AFTER(e); return e; } Note: when possible, please use the existing reference counting and message queue implementations instead of inventing new ones. */ /* Report that wait on the condition variable at address "cv" has succeeded and the lock at address "lock" is held. */ #define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) \ AnnotateCondVarWait(__FILE__, __LINE__, cv, lock) /* CK_THREADS if (...premature_exit...) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } Py_UNBLOCK_THREADS For convenience, that the value of 'errno' is restored across Py_END_ALLOW_THREADS and Py_BLOCK_THREADS. WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND Py_END_ALLOW_THREADS!!! Note that not yet all candidates have been converted to use this mechanism! */ PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void); PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *); Py_DEunction * and PyEval_CallMethod are deprecated. Since they are officially part of the * stable ABI (PEP 384), they must be kept for backward compatibility. * PyObject_Call(), PyObject_CallFunction() and PyObject_CallMethod() are * recommended to call a callable object. */ Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords( PyObject *callable, PyObject *args, PyObject *kwargs); /* Deprecated since PyEval_CallObjectWithKeywords is deprecated */ #define PyEval_CallObject(callable, arg) \ PyE 80 #define LOAD_ATTR_METHOD_NO_DICT 81 #define LOAD_ATTR_METHOD_WITH_VALUES 82 #define LOAD_CONST__LOAD_FAST 84 #define LOAD_FAST__LOAD_CONST 86 #define LOAD_FAST__LOAD_FAST 88 #define LOAD_GLOBAL_BUILTIN 111 #define LOAD_GLOBAL_MODULE 112 #define STORE_ATTR_INSTANCE_VALUE 113 #define STORE_ATTR_SLOT 148 #define STORE_ATTR_WITH_HINT 153 #define STORE_FAST__e LOAD_FROM_DICT_OR_DEREF 176 #define MIN_INSTRUMENTED_OPCODE 237 #define INSTRUMENTED_LOAD_SUPER_ATTR 237 #define INSTRUMENTED_POP_JUMP_IF_NONE 238 #define INSTRUMENTED_POP_JUMP_IF_NOT_NONE 239 #define INSTRUMENTED_RESUME 240 #define INSTRUMENTED_CALL 241 #define INSTRUMENTED_RETURN_VALUE 242 #define INSTRUMENTED_YIELD_VALUE 243 #define INSTRUMENTED_CALL_FUNCTION_EX 244 #define INSTRUMENTED_JUMP_FORWARDefine LOAD_BUILD_CLASS 71 #define LOAD_ASSERTION_ERROR 74 #define RETURN_GENERATOR 75 #define RETURN_VALUE 83 #define SETUP_ANNOTATIONS 85 #define LOAD_LOCALS 87 #define POP_EXCEPT 89 #define HAVE_ARGUMENT 90 #define STORE_NAME 90 #define DELETE_NAME 91 #define UNPACK_SEQUENCE t, int, PyObject*, int, PyTypeObject*); PyObject *(*Time_FromTimeAndFold)(int, int, int, int, PyObject*, int, PyTypeObject*); } PyDateTime_CAPI; #define PyDateTime_CAPSULE_NAME "datetime.datetime_CAPI" /* This block is only used as part of the public API and should not be * included in _datetimemodule.c, which does not use the C API capsule. * See bpo-35081 for more details. * */ #ifndef _PY_DATETIME_IMPL /* Define global variable for the C API and a macro for setting it. */ static PyDateTime_CAPI *PyDateTimeAPI when getting at the hastzinfo member of objects * starting with _PyTZINFO_HEAD. */ typedef struct { _PyTZINFO_HEAD } _PyDateTime_BaseTZInfo; /* All time objects are of PyDateTime_TimeType, but that can be allocated * in two ways, with or without a tzinfo member. Without is the same as * tzinfo == None, but consumes less memory. _PyDateTime_BaseTime is an * internal struct used to allocate the right amount of space for the * "without" case. */ #define _PyDateTime_TIMEHEAD \ _PyTZINFO_HEAD \ unsg */ int lineno, int col_offset); PyAPI_FUNC(PyObject *) PyErr_ProgramText( const char *filename, /* decoded from the filesystem encoding */ int lineno); /* The following functions are used to create and modify unicode exceptions from C */ /* create a UnicodeDecodeError object */ PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create( const char *encoding, /* UTF-8 encoded string */ const char *object, Py_ssize_t length, Py_ssize_t start, Py_ssize_t end, const char *reason PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)) #define PyExceptionInstance_Check(x) \ PyType_FastSubclass(Py_TYPE(x), Py_TPFLAGS_BASE_EXC_SUBCLASS) PyAPI_FUNC(const char *) PyExceptionClass_Name(PyObject *); #define PyExceptionInstance_Class(x) _PyObject_CAST(Py_TYPE(x)) #define _PyBaseExceptionGroup_Check(x) \ PyObject_TypeCheck((x), (PyTypeObject *)PyExc_BaseExceptionGroup) /* Predefined exceptions */ PyAPI_DATA(PyObject *) PyExc_BaseException; PyAPIe PySet_Check(ob) \ (Py_IS_TYPE((ob), &PySet_Type) || \ PyType_IsSubtype(Py_TYPE(ob), &PySet_Type)) #ifndef Py_LIMITED_API # define Py_CPYTHON_SETOBJECT_H # include "cpython/setobject.h" # undef Py_CPYTHON_SETOBJECT_H #endif #ifdef __cplusplus } #endif #endif /* !Py_SETOBJECT_H */ #ifndef Py_ERRORS_H #define Py_ERRORS_H #ifdef __cplusplus extern "C" { #endif #include // va_list /* Error handling definitions */ PyAPI_FUNC(void) PyErr_SetNone(PyObject *); PyAPI_FUNC(void) PyErr_SetObject(PyObj) PyOS_AfterFork_Parent(void); PyAPI_FUNC(void) PyOS_AfterFork_Child(void); #endif #endif /* Deprecated, please use PyOS_AfterFork_Child() instead */ Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void); #ifndef Py_LIMITED_API PyAPI_FUNC(int) _PyOS_IsMainThread(void); #ifdef MS_WINDOWS /* windows.h is not included by Python.h so use void* instead of HANDLE */ PyAPI_FUNC(void*) _PyOS_SigintEvent(void); #endif #endif /* !Py_LIMITED_API */ #ifdef __cplusplus } #endif #endif /* !Py_INTRCHECK_H */ /* Module definition and import occur at the given separator. At most maxsplit splits will be done. But unlike PyUnicode_Split PyUnicode_RSplit splits from the end of the string. If negative, no limit is set. Separators are not included in the resulting list. */ PyAPI_FUNC(PyObject*) PyUnicode_RSplit( PyObject *s, /* String to split */ PyObject *sep, /* String separator */ Py_ssize_t maxsplit /* Maxsplit count */ ); /* Translate a string by applying a character mapping table to it and return); /* --- Character Map Codecs ----------------------------------------------- This codec uses mappings to encode and decode characters. Decoding mappings must map byte ordinals (integers in the range from 0 to 255) to Unicode strings, integers (which are then interpreted as Unicode ordinals) or None. Unmapped data bytes (ones which cause a LookupError) as well as mapped to None, 0xFFFE or '\ufffe' are treated as "undefined mapping" and cause an error. Encoding mappings must map Unicode ordinal integers toyteorder is set to the current byte order at the end of input data. If byteorder is NULL, the codec starts in native order mode. */ PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32( const char *string, /* UTF-32 encoded string */ Py_ssize_t length, /* size of string */ const char *errors, /* error handling */ int *byteorder /* pointer to byteorder to use 0=native;-1=LE,1=BE; updated on exit */ ); PyAP Py_ssize_t size /* size of buffer */ ); /* Convert the Unicode object to a wide character string. The output string always ends with a nul character. If size is not NULL, write the number of wide characters (excluding the null character) into *size. Returns a buffer allocated by PyMem_Malloc() (use PyMem_Free() to free it) on success. On error, returns NULL, *size is undefined and raises a MemoryError. */ PyAPI_FUNC(wchar_t*) PyUnicode_AsWideCharString( PyObject *unicode, /* Unicodding to the given encoding and error handler. The encoding and error handler can be NULL to have the interface use UTF-8 and "strict". All other objects (including Unicode objects) raise an exception. The API returns NULL in case of an error. The caller is responsible for decref'ing the returned objects. */ PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject( PyObject *obj, /* Object */ const char *encoding, /* encoding */ const char *errors /* error handling */ ); /* Co--- Internal Unicode Format -------------------------------------------- */ /* Python 3.x requires unicode */ #define Py_USING_UNICODE #ifndef SIZEOF_WCHAR_T #error Must define SIZEOF_WCHAR_T #endif #define Py_UNICODE_SIZE SIZEOF_WCHAR_T /* If wchar_t can be used for UCS-4 storage, set Py_UNICODE_WIDE. Otherwise, Unicode strings are stored as UCS-2 (with limited support for UTF-16) */ #if Py_UNICODE_SIZE >= 4 #define Py_UNICODE_WIDE #endif /* Set these flags if the platform has "wchar.h" and the wchar_t type is a 16-e must not be changed in any way, as it would * break the ABI. * */ typedef struct { void *buf; PyObject *obj; /* owned reference */ Py_ssize_t len; Py_ssize_t itemsize; /* This is Py_ssize_t so it can be pointed to by strides in simple case.*/ int readonly; int ndim; char *format; Py_ssize_t *shape; Py_ssize_t *strides; Py_ssize_t *suboffsets; void *internal; } Py_buffer; typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); typedef void (* uint64_t k1; } siphash; /* a different (!) Py_hash_t for small string optimization */ struct { unsigned char padding[16]; Py_hash_t suffix; } djbx33a; struct { unsigned char padding[16]; Py_hash_t hashsalt; } expat; } _Py_HashSecret_t; PyAPI_DATA(_Py_HashSecret_t) _Py_HashSecret; #ifdef Py_DEBUG PyAPI_DATA(int) _Py_HashSecret_Initialized; #endif /* hash function definition */ typedef struct { Py_hash_t (*const hash)(const void *, Py_ssize_t); const char *name; PyObject *); struct PyMethodDef { const char *ml_name; /* The name of the built-in function/method */ PyCFunction ml_meth; /* The C function that implements it */ int ml_flags; /* Combination of METH_xxx flags, which mostly describe the args expected by the C func */ const char *ml_doc; /* The __doc__ attribute, or NULL */ }; /* PyCFunction_New is declared as a function for stable ABI (declaration is * needed for e.g. GCC with -fvisibility=hidden), but redefinedze_t) PyBytes_Size(PyObject *); PyAPI_FUNC(char *) PyBytes_AsString(PyObject *); PyAPI_FUNC(PyObject *) PyBytes_Repr(PyObject *, int); PyAPI_FUNC(void) PyBytes_Concat(PyObject **, PyObject *); PyAPI_FUNC(void) PyBytes_ConcatAndDel(PyObject **, PyObject *); PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t, const char *, Py_ssize_t, const char *); /* Provides access to the internal data buffer and size of a bytes object. Pa= 0x03060000 Py_DEPRECATED(3.12) PyAPI_DATA(const char *) Py_FileSystemDefaultEncodeErrors; #endif Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_HasFileSystemDefaultEncoding; #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 Py_DEPRECATED(3.12) PyAPI_DATA(int) Py_UTF8Mode; #endif /* A routine to check if a file descriptor can be select()-ed. */ #ifdef _MSC_VER /* On Windows, any socket fd can be select()-ed, no matter how high */ #define _PyIsSelectable_fd(FD) (1) #else #define _PyIsSelectable_fd(FD) ((unsigned */ /* #undef socklen_t */ /* Define to `int' if doesn't define. */ /* #undef uid_t */ /* Define the macros needed if on a UnixWare 7.x system. */ #if defined(__USLC__) && defined(__SCO_VERSION__) #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */ #endif #endif /*Py_PYCONFIG_H*/ /* Do not renumber the file; these numbers are part of the stable ABI. */ #define Py_bf_getbuffer 1 #define Py_bf_releasebuffer 2 #define Py_mp_ass_subscript 3 #define Py_mp_length 4 #define Py_mp_subscript 5 #define Py_nb_absole -r' without the dot. */ /* #undef Py_SUNOS_VERSION */ /* Define if you want to enable tracing references for debugging purpose */ /* #undef Py_TRACE_REFS */ /* assume C89 semantics that RETSIGTYPE is always void */ #define RETSIGTYPE void /* Define if setpgrp() must be called as setpgrp(0, 0). */ /* #undef SETPGRP_HAVE_ARG */ /* Define if i>>j for signed int i does not extend the sign bit when i < 0 */ /* #undef SIGNED_RIGHT_SHIFT_ZERO_FILLS */ /* The size of `double', as computed by sizeof. */ #define SIZEOF_DOUBLE 8 /* ThACKAGE_URL */ /* Define to the version of this package. */ /* #undef PACKAGE_VERSION */ /* Define if POSIX semaphores aren't enabled on your system */ /* #undef POSIX_SEMAPHORES_NOT_ENABLED */ /* Define if pthread_key_t is compatible with int. */ #define PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT 1 /* Defined if PTHREAD_SCOPE_SYSTEM supported. */ #define PTHREAD_SYSTEM_SCHED_SUPPORTED 1 /* Define as the preferred size in bits of long digits */ /* #undef PYLONG_BITS_IN_DIGIT */ /* enabled builtin hash modules */ #define PY_BUILTIN_Hruct stat'. */ #define HAVE_STRUCT_STAT_ST_RDEV 1 /* Define to 1 if `tm_zone' is a member of `struct tm'. */ #define HAVE_STRUCT_TM_TM_ZONE 1 /* Define if you have the 'symlink' function. */ #define HAVE_SYMLINK 1 /* Define to 1 if you have the `symlinkat' function. */ #define HAVE_SYMLINKAT 1 /* Define to 1 if you have the `sync' function. */ #define HAVE_SYNC 1 /* Define to 1 if you have the `sysconf' function. */ #define HAVE_SYSCONF 1 /* Define to 1 if you have the header file. */ #define HAVE_SYSEXITS_H 1 /efine if you have struct stat.st_mtimensec */ /* #undef HAVE_STAT_TV_NSEC2 */ /* Define to 1 if you have the header file. */ #define HAVE_STDINT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STDIO_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STDLIB_H 1 /* Has stdatomic.h with atomic_int and atomic_uintptr_t */ #define HAVE_STD_ATOMIC 1 /* Define to 1 if you have the `strftime' function. */ #define HAVE_STRFTIME 1 /* Define to 1 if you have the herocess.h> header file. */ /* #undef HAVE_PROCESS_H */ /* Define if your compiler supports function prototype */ #define HAVE_PROTOTYPES 1 /* Define to 1 if you have the `pthread_condattr_setclock' function. */ #define HAVE_PTHREAD_CONDATTR_SETCLOCK 1 /* Defined for Solaris 2.6 bug in pthread header. */ /* #undef HAVE_PTHREAD_DESTRUCTOR */ /* Define to 1 if you have the `pthread_getcpuclockid' function. */ #define HAVE_PTHREAD_GETCPUCLOCKID 1 /* Define to 1 if you have the header file. */ #define HAVE_PTHREAD_H 1 /enable this mode. (For Solaris and Linux, the necessary defines are already defined.) */ /* #undef HAVE_LARGEFILE_SUPPORT */ /* Define to 1 if you have the 'lchflags' function. */ /* #undef HAVE_LCHFLAGS */ /* Define to 1 if you have the `lchmod' function. */ /* #undef HAVE_LCHMOD */ /* Define to 1 if you have the `lchown' function. */ #define HAVE_LCHOWN 1 /* Define to 1 if you want to build _blake2 module with libb2 */ /* #undef HAVE_LIBB2 */ /* Define to 1 if you have the `db' library (-ldb). */ /* #undef HAVE_LIBDB */ f HAVE_IPA_PURE_CONST_BUG */ /* Define to 1 if you have the `kill' function. */ #define HAVE_KILL 1 /* Define to 1 if you have the `killpg' function. */ #define HAVE_KILLPG 1 /* Define if you have the 'kqueue' function. */ /* #undef HAVE_KQUEUE */ /* Define to 1 if you have the header file. */ #define HAVE_LANGINFO_H 1 /* Defined to enable large file support when an off_t is bigger than a long and long long is at least as big as an off_t. You may need to add some flags for configuration and compilation to enUTIMES 1 /* Define to 1 if you have the `futimesat' function. */ #define HAVE_FUTIMESAT 1 /* Define to 1 if you have the `gai_strerror' function. */ #define HAVE_GAI_STRERROR 1 /* Define if we can use gcc inline assembler to get and set mc68881 fpcr */ /* #undef HAVE_GCC_ASM_FOR_MC68881 */ /* Define if we can use x64 gcc inline assembler */ #define HAVE_GCC_ASM_FOR_X64 1 /* Define if we can use gcc inline assembler to get and set x87 control word */ #define HAVE_GCC_ASM_FOR_X87 1 /* Define if your compiler provides __uint1 0) does not return the number of wide chars that would be converted. */ /* #undef HAVE_BROKEN_MBSTOWCS */ /* Define if nice() returns success/failure instead of the new priority. */ #define HAVE_BROKEN_NICE 1 /* Define if the system reports an invalid PIPE_BUF value. */ /* #undef HAVE_BROKEN_PIPE_BUF */ /* Define if poll() sets errno on invalid file descriptors. */ /* #undef HAVE_BROKEN_POLL */ /* Define if the Posix semaphores do not work on your system */ /* #undef HAVE_BROKEN_POSIX_SEMAPHORES */ /* Define if pthread_sig0). */ /* #undef GETPGRP_HAVE_ARG */ /* Define if you have the 'accept' function. */ #define HAVE_ACCEPT 1 /* Define to 1 if you have the `accept4' function. */ #define HAVE_ACCEPT4 1 /* Define to 1 if you have the `acosh' function. */ #define HAVE_ACOSH 1 /* struct addrinfo (netdb.h) */ #define HAVE_ADDRINFO 1 /* Define to 1 if you have the `alarm' function. */ #define HAVE_ALARM 1 /* Define if aligned memory access is required */ /* #undef HAVE_ALIGNED_REQUIRED */ /* Define to 1 if you have the header file. */ #*value); /* For source-level backwards compatibility */ #define PySequence_In PySequence_Contains /* Return the first index for which o[i] == value. On error, return -1. This is equivalent to the Python expression: o.index(value). */ PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject *o, PyObject *value); /* --- In-place versions of some of the above Sequence functions --- */ /* Append sequence 'o2' to sequence 'o1', in-place when possible. Return the resulting object, which could be 'o1', or NULL on failure. This is an index integer (has the nb_index slot of the tp_as_number structure filled in), and 0 otherwise. */ PyAPI_FUNC(int) PyIndex_Check(PyObject *); /* Returns the object 'o' converted to a Python int, or NULL with an exception raised on failure. */ PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o); /* Returns the object 'o' converted to Py_ssize_t by going through PyNumber_Index() first. If an overflow error occurs while converting the int to Py_ssize_t, then the second argument 'exc' is the error-type to returnyielded value. */ PyAPI_FUNC(PySendResult) PyIter_Send(PyObject *, PyObject *, PyObject **); #endif /* === Number Protocol ================================================== */ /* Returns 1 if the object 'o' provides numeric protocols, and 0 otherwise. This function always succeeds. */ PyAPI_FUNC(int) PyNumber_Check(PyObject *o); /* Returns the result of adding o1 and o2, or NULL on failure. This is the equivalent of the Python expression: o1 + o2. */ PyAPI_FUNC(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2); /* arbitrary object which must support the (writable, single segment) buffer interface and returns a pointer to a writable memory location in buffer of size 'buffer_len'. Return 0 on success. buffer and buffer_len are only set in case no error occurs. Otherwise, -1 is returned and an exception set. */ Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj, void **buffer, Py_ssize_t *buffer_len); /* === New Buffer API ========yObject* values, terminated by NULL. Returns the result of the call on success, or NULL on failure. This is the equivalent of the Python expression: obj.name(*args). */ PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs( PyObject *obj, PyObject *name, ...); /* Given a vectorcall nargsf argument, return the actual number of arguments. * (For use outside the limited API, this is re-defined as a static inline * function in cpython/abstract.h) */ PyAPI_FUNC(Py_ssize_t) PyVectorcall_NARGS(size_t nargsf); /* Cct_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v); Set the value of the attribute named attr_name, for object 'o', to the value 'v'. an exception and return -1 on failure; return 0 on success. This is the equivalent of the Python statement o.attr_name=v. */ /* Implemented as a macro: int PyObject_DelAttrString(PyObject *o, const char *attr_name); Delete attribute named attr_name, for object o. Returns -1 on failure. This is the equivalent of the Python statement: del o.attr_name. */ #define PyObjeeak references objects for Python. */ #ifndef Py_WEAKREFOBJECT_H #define Py_WEAKREFOBJECT_H #ifdef __cplusplus extern "C" { #endif typedef struct _PyWeakReference PyWeakReference; PyAPI_DATA(PyTypeObject) _PyWeakref_RefType; PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType; PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType; #define PyWeakref_CheckRef(op) PyObject_TypeCheck((op), &_PyWeakref_RefType) #define PyWeakref_CheckRefExact(op) \ Py_IS_TYPE((op), &_PyWeakref_RefType) #define PyWeakref_CheckProxy(op) \ (PI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *); PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...); #ifndef Py_LIMITED_API # define Py_CPYTHON_TUPLEOBJECT_H # include "cpython/tupleobject.h" # undef Py_CPYTHON_TUPLEOBJECT_H #endif #ifdef __cplusplus } #endif #endif /* !Py_TUPLEOBJECT_H */ #ifndef Py_EXPORTS_H #define Py_EXPORTS_H #if defined(_WIN32) || defined(__CYGWIN__) #if defined(Py_ENABLE_SHARED) #define Py_IMPORTE object interface */ #ifndef Py_MODULEOBJECT_H #define Py_MODULEOBJECT_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyModule_Type; #define PyModule_Check(op) PyObject_TypeCheck((op), &PyModule_Type) #define PyModule_CheckExact(op) Py_IS_TYPE((op), &PyModule_Type) #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject *) PyModule_NewObject( PyObject *name ); #endif PyAPI_FUNC(PyObject *) PyModule_New( const char *name /* UTF-8 encoded string */ ); PyAPI__importlib__bootstrap_external_Py_M__zipimport// 354 ` action_helpers.o/ bytearrayobject.o/ genericaliasobject.o/ interpreteridobject.o/ namespaceobject.o/ picklebufobject.o/ asm_trampoline.o/ Python-tokenize.o/ dynamic_annotations.o/ instrumentation.o/ legacy_tracing.o/ bootstrap_hash.o/ formatter_unicode.o/ perf_trampoline.o/ _collectionsmodule.o/ itertoolsmodule.o/ _functoolsmodule.o/ symtablemodule.o/ getbuildinfo.o/ 1788987766 0 0 100644 6352 ` ELFPyRun_FileExFlagsPy_CompileStringObjectPy_CompileStringExFlags_Py_SourceAsStringPyRun_AnyFilePyRun_AnyFileExPyRun_AnyFileFlagsPyRun_FilePyRun_FileExPyRun_FileFlagsPyRun_SimpleFilePyRun_SimpleFileExPyRun_StringPyRun_SimpleStringPy_CompileStringPy_CompileStringFlagsPyRun_InteractiveOnePyRun_InteractiveLoop_PyTime_Add_PyTime_MulDiv_PyLong_AsTime_t_PyLong_FromTime_t_PyTime_ObjectToTime_t_PyTime_ObjectToTimespec_PyTime_ObjectToTimeval_PyTime_FromSeconds_PyTime_FromNanoseconds_PyTime_FromMicrosecondsClamp_PyTirpreterFromConfig_Py_IsInterpreterFinalizing_Py_DumpExtensionModulesPy_FatalError_Py_FatalErrorFuncPy_EndInterpreter_Py_FatalErrorFormat_Py_FatalRefcountErrorFuncPy_ExitStatusExceptionPy_InitializeExPy_InitializePy_NewInterpreterPy_AtExitPy_ExitPy_FdIsInteractive_Py_FdIsInteractivePyOS_getsigPyOS_setsig_PyOS_mystrnicmp_hack_Py_get_387controlword_Py_set_387controlword_Py_tss_tstate_PyThreadState_GetCurrent_PyRuntimeState_Fini_PyRuntimeState_Init_PyRuntimeState_ReInitThreads_PyInterpreterState_EnablePyInterImport_GetModuleAttrString_PyImport_InitExternalPyInit__imp_PyImport_LoadDynamicModuleWithSpecPy_GETENVPy_IgnoreEnvironmentFlagPyStatus_OkPyStatus_ErrorPyStatus_NoMemoryPyStatus_ExitPyStatus_IsErrorPyStatus_IsExitPyStatus_Exception_PyErr_SetFromPyStatus_PyWideStringList_Clear_PyWideStringList_CopyPyWideStringList_InsertPyWideStringList_Append_PyWideStringList_Extend_PyWideStringList_AsListPy_SetStandardStreamEncoding_Py_ClearStandardStreamEncoding_Py_ClearArgcArgvPy_GetArgcArgvPyConfig_Clear_PyConfig_InitCotPyErr_WarnExplicitFormat_PyErr_WarnUnawaitedCoroutine_PyWarnings_Init_PyWarnings_Fini_PyAST_Fini_Py_asdl_mod_seq_new_Py_asdl_stmt_seq_new_Py_asdl_expr_seq_new_Py_asdl_comprehension_seq_new_Py_asdl_excepthandler_seq_new_Py_asdl_arguments_seq_new_Py_asdl_arg_seq_new_Py_asdl_keyword_seq_new_Py_asdl_alias_seq_new_Py_asdl_withitem_seq_new_Py_asdl_match_case_seq_new_Py_asdl_pattern_seq_new_Py_asdl_type_ignore_seq_new_Py_asdl_type_param_seq_new_PyAST_Module_PyAST_Interactive_PyAST_Expression_PyAST_FunctionType_PyAyUnicode_CheckConsistencyPyUnicode_NewPyUnicode_Type_PyUnicode_FastCopyCharactersPyUnicode_CopyCharactersPyUnicode_ResizePyUnicode_FromWideChar_PyUnicode_FromASCIIPyUnicode_FromKindAndData_PyUnicode_FindMaxChar_PyUnicode_CopyPyUnicode_AsUCS4PyUnicode_AsUCS4CopyPyUnicode_AsWideCharPyUnicode_AsWideCharString_PyUnicode_WideCharString_Converter_PyUnicode_WideCharString_Opt_ConverterPyUnicode_FromOrdinalPyUnicode_FromObjectPyUnicode_Concat_Py_normalize_encodingPyUnicode_EncodeLocalePyUnicode_DecodeLocaleAndSizePyUSpec_IsInitializing_Py_module_getattro_PyModuleSpec_IsUninitializedSubmodule_Py_module_getattro_impl_PyNamespace_Type_PyNamespace_New_Py_NoneStruct_Py_NotImplementedStructPy_IncRef_Py_IncRefPyObject_CallFinalizer_Py_BreakPoint_PyObject_IsFreedPyObject_HashNotImplementedPyObject_Hash_PyObject_ComputedDictPointer_PyObject_GetDictPtrPyObject_SelfIter_PyObject_NextNotImplementedPyObject_IsTruePyObject_NotPyCallable_Check_PyObject_InitState_PyTypes_InitTypes_PyTypes_FiniTypes_Py_NewReference_PyObject_NewVarPyOction_SetClosurePyFunction_GetAnnotationsPyFunction_SetAnnotations_Py_set_function_type_paramsPyClassMethod_NewPyClassMethod_TypePyStaticMethod_NewPyStaticMethod_Type_PyInterpreterID_Type_PyInterpreterID_New_PyInterpreterState_GetIDObject_PyInterpreterID_LookUpPySeqIter_NewPySeqIter_TypePyCallIter_NewPyCallIter_TypePyAnextAwaitable_New_PyAnextAwaitable_TypePyListRevIter_TypePyListIter_TypePyList_Type_PyList_ClearFreeList_PyList_Fini_PyList_DebugMallocStatsPyList_NewPyList_SizePyList_GetItemPyList_SetItemPyExc_AttributeErrorPyExc_BlockingIOErrorPyExc_OSErrorPyException_GetTracebackPyException_SetTracebackPyException_GetCausePyException_SetCausePyException_GetContextPyException_SetContextPyException_GetArgsPyException_SetArgsPyExceptionClass_Name_PyExc_CreateExceptionGroup_PyExc_PrepReraiseStarPyUnstable_Exc_PrepReraiseStarPyUnicodeEncodeError_GetEncodingPyUnicodeDecodeError_GetEncodingPyUnicodeEncodeError_GetObjectPyUnicodeDecodeError_GetObjectPyUnicodeTranslateError_GetObjectPyUnicodeEncodeError_GetStartPyUniapping_SetItemStringPyMapping_HasKeyStringPyMapping_HasKeyPyObject_IsInstancePyObject_IsSubclass_PyObject_RealIsInstance_PyObject_RealIsSubclassPyIter_CheckPyObject_GetIterPySequence_FastPyMapping_KeysPyMapping_ItemsPyMapping_ValuesPyAIter_CheckPyObject_GetAIterPyIter_NextPySequence_Tuple_PySequence_IterSearchPySequence_CountPySequence_ContainsPySequence_InPySequence_IndexPyIter_Send_Py_FreeCharPArray_PySequence_BytesToCharpArray_Py_TrueStructPyBool_FromLong_Py_FalseStructPyBool_Type_Py_bytes_isspace_Pc2c2c2_Py_gitversion_Py_gitidentifierPy_GetBuildInfo_PyToken_OneChar_PyToken_TwoChars_PyToken_ThreeChars_PyParser_TokenNames_PyPegen_interactive_exit_PyPegen_byte_offset_to_character_offset_line_PyPegen_byte_offset_to_character_offset_raw_PyPegen_calculate_display_width_PyPegen_byte_offset_to_character_offset_PyPegen_insert_memo_PyPegen_update_memo_PyPegen_fill_token_PyPegen_is_memoized_PyPegen_lookahead_with_name_PyPegen_lookahead_with_string_PyPegen_lookahead_with_int_PyPegen_lookahead_PyPegen_expect_toke 1788987776 0 0 0 62752 ` ?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z{{{{{{{HZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZHZ