Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-02-27 15:07
📄 Python.h // Entry point of the Python C API. // C extensions should only #include <Python.h>, and not include directly // the other Python header files included by <Python.h>. #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 headers are not used by Python // headers, but kept for backward compatibility. They are excluded from the // limited C API of Python 3.11. #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # include <stdlib.h> # include <stdio.h> // FILE* # include <errno.h> // errno # include <string.h> // memcpy() #endif #ifndef MS_WINDOWS # include <unistd.h> #endif #ifdef HAVE_STDDEF_H # include <stddef.h> // size_t #endif #include <assert.h> // assert() #include <wchar.h> // wchar_t #include "pyport.h" #include "pymacro.h" #include "pymath.h" #include "pymem.h" #include "pytypedefs.h" #include "pybuffer.h" #include "object.h" #include "objimpl.h" #include "typeslots.h" #include "pyhash.h" #include "cpython/pydebug.h" #include "bytearrayobject.h" #include "bytesobject.h" #include "unicodeobject.h" #include "cpython/code.h" #include "cpython/initconfig.h" #include "pystate.h" #include "pyerrors.h" #include "longobject.h" #include "cpython/longintrepr.h" #include "boolobject.h" #include "floatobject.h" #include "complexobject.h" #include "rangeobject.h" #include "memoryobject.h" #include "tupleobject.h" #include "listobject.h" #include "dictobject.h" #include "cpython/odictobject.h" #include "enumobject.h" #include "setobject.h" #include "methodobject.h" #include "moduleobject.h" #include "cpython/funcobject.h" #include "cpython/classobject.h" #include "fileobject.h" #include "pycapsule.h" #include "pyframe.h" #include "traceback.h" #include "sliceobject.h" #include "cpython/cellobject.h" #include "iterobject.h" #include "cpython/genobject.h" #include "descrobject.h" #include "genericaliasobject.h" #include "warnings.h" #include "weakrefobject.h" #include "structseq.h" #include "cpython/picklebufobject.h" #include "cpython/pytime.h" #include "codecs.h" #include "pythread.h" #include "cpython/context.h" #include "modsupport.h" #include "compile.h" #include "pythonrun.h" #include "pylifecycle.h" #include "ceval.h" #include "sysmodule.h" #include "osmodule.h" #include "intrcheck.h" #include "import.h" #include "abstract.h" #include "bltinmodule.h" #include "cpython/pyctype.h" #include "pystrtod.h" #include "pystrcmp.h" #include "fileutils.h" #include "cpython/pyfpe.h" #include "tracemalloc.h" #endif /* !Py_PYTHON_H */	2.79 KB	2025-10-09 16:16
📄 abstract.h /* 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 error. The flags argument is used to enable certain printing options. The only option currently supported is Py_Print_RAW. (What should be said about Py_Print_RAW?). / / Implemented elsewhere: int PyObject_HasAttrString(PyObject o, const char attr_name); Returns 1 if object 'o' has the attribute attr_name, and 0 otherwise. This is equivalent to the Python expression: hasattr(o,attr_name). This function always succeeds. / / Implemented elsewhere: PyObject* PyObject_GetAttrString(PyObject o, const char attr_name); Retrieve an attributed named attr_name form object o. Returns the attribute value on success, or NULL on failure. This is the equivalent of the Python expression: o.attr_name. / / Implemented elsewhere: int PyObject_HasAttr(PyObject o, PyObject attr_name); Returns 1 if o has the attribute attr_name, and 0 otherwise. This is equivalent to the Python expression: hasattr(o,attr_name). This function always succeeds. / / Implemented elsewhere: PyObject* PyObject_GetAttr(PyObject o, PyObject attr_name); Retrieve an attributed named 'attr_name' form object 'o'. Returns the attribute value on success, or NULL on failure. This is the equivalent of the Python expression: o.attr_name. / / Implemented elsewhere: int PyObject_SetAttrString(PyObject o, const char attr_name, PyObject v); Set the value of the attribute named attr_name, for object 'o', to the value 'v'. Raise an exception and return -1 on failure; return 0 on success. This is the equivalent of the Python statement o.attr_name=v. / /* Implemented elsewhere: int PyObject_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 PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A), NULL) / Implemented as a macro: int PyObject_DelAttr(PyObject o, PyObject 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 PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A), NULL) / Implemented elsewhere: PyObject PyObject_Repr(PyObject o); Compute the string representation of object 'o'. Returns the string representation on success, NULL on failure. This is the equivalent of the Python expression: repr(o). Called by the repr() built-in function. / / Implemented elsewhere: PyObject PyObject_Str(PyObject o); Compute the string representation of object, o. Returns the string representation on success, NULL on failure. This is the equivalent of the Python expression: str(o). Called by the str() and print() built-in functions. / / Declared elsewhere PyAPI_FUNC(int) PyCallable_Check(PyObject o); Determine if the object, o, is callable. Return 1 if the object is callable and 0 otherwise. This function always succeeds. / #ifdef PY_SSIZE_T_CLEAN # define PyObject_CallFunction _PyObject_CallFunction_SizeT # define PyObject_CallMethod _PyObject_CallMethod_SizeT #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03090000 /* Call a callable Python object without any arguments / PyAPI_FUNC(PyObject ) PyObject_CallNoArgs(PyObject func); #endif / Call a callable Python object 'callable' with arguments given by the tuple 'args' and keywords arguments given by the dictionary 'kwargs'. 'args' must not be NULL, use an empty tuple if no arguments are needed. If no named arguments are needed, 'kwargs' can be NULL. This is the equivalent of the Python expression: callable(args, kwargs). / PyAPI_FUNC(PyObject ) PyObject_Call(PyObject callable, PyObject args, PyObject kwargs); /* Call a callable Python object 'callable', with arguments given by the tuple 'args'. If no arguments are needed, then 'args' can be NULL. Returns the result of the call on success, or NULL on failure. This is the equivalent of the Python expression: callable(args). / PyAPI_FUNC(PyObject ) PyObject_CallObject(PyObject callable, PyObject args); / Call a callable Python object, callable, with a variable number of C arguments. The C arguments are described using a 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 string. The format can 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: obj.name(arg1, arg2, ...). / PyAPI_FUNC(PyObject ) PyObject_CallMethod(PyObject obj, const char name, const char format, ...); PyAPI_FUNC(PyObject ) _PyObject_CallFunction_SizeT(PyObject callable, const char format, ...); PyAPI_FUNC(PyObject ) _PyObject_CallMethod_SizeT(PyObject obj, const char name, const char format, ...); /* Call a callable Python object 'callable' with a variable number of C arguments. The C arguments are provided as PyObject* values, terminated by a NULL. 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_CallFunctionObjArgs(PyObject callable, ...); / Call the method named 'name' of object 'obj' with a variable number of C arguments. The C arguments are provided as PyObject* 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, ...); / Implemented elsewhere: Py_hash_t PyObject_Hash(PyObject o); Compute and return the hash, hash_value, of an object, o. On failure, return -1. This is the equivalent of the Python expression: hash(o). / /* Implemented elsewhere: int PyObject_IsTrue(PyObject o); Returns 1 if the object, o, is considered to be true, 0 if o is considered to be false and -1 on failure. This is equivalent to the Python expression: not not o. / /* Implemented elsewhere: int PyObject_Not(PyObject o); Returns 0 if the object, o, is considered to be true, 1 if o is considered to be false and -1 on failure. This is equivalent to the Python expression: not o. / /* Get the type of an object. On success, returns a type object corresponding to the object type of object 'o'. On failure, returns NULL. This is equivalent to the Python expression: type(o) / PyAPI_FUNC(PyObject ) PyObject_Type(PyObject o); / Return the size of object 'o'. If the object 'o' provides both sequence and mapping protocols, the sequence size is returned. On error, -1 is returned. This is the equivalent to the Python expression: len(o) / PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject o); /* For DLL compatibility / #undef PyObject_Length PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject o); #define PyObject_Length PyObject_Size /* Return element of 'o' corresponding to the object 'key'. Return NULL on failure. This is the equivalent of the Python expression: o[key] / PyAPI_FUNC(PyObject ) PyObject_GetItem(PyObject o, PyObject key); /* Map the object 'key' to the value 'v' into 'o'. Raise an exception and return -1 on failure; return 0 on success. This is the equivalent of the Python statement: o[key]=v. / PyAPI_FUNC(int) PyObject_SetItem(PyObject o, PyObject key, PyObject v); /* Remove the mapping for the string 'key' from the object 'o'. Returns -1 on failure. This is equivalent to the Python statement: del o[key]. / PyAPI_FUNC(int) PyObject_DelItemString(PyObject o, const 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 there). / / Takes an arbitrary object which must support the (character, single segment) buffer interface and returns a pointer to a read-only memory location usable as character based input for subsequent processing. 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_AsCharBuffer(PyObject obj, const char *buffer, Py_ssize_t buffer_len); /* Checks whether an arbitrary object supports the (character, single segment) buffer interface. Returns 1 on success, 0 on failure. / Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject obj); /* Same as PyObject_AsCharBuffer() except that this API expects (readable, single segment) buffer interface and returns a pointer to a read-only memory location which can contain arbitrary data. 0 is returned 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_AsReadBuffer(PyObject obj, const void *buffer, Py_ssize_t buffer_len); /* Takes an 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 ============================================ / / Takes an arbitrary object and returns the result of calling obj.__format__(format_spec). / PyAPI_FUNC(PyObject ) PyObject_Format(PyObject obj, PyObject format_spec); /* ==== Iterators ================================================ / / Takes an object and returns an iterator for it. This is typically a new iterator but if the argument is an iterator, this returns itself. / PyAPI_FUNC(PyObject ) PyObject_GetIter(PyObject ); / Takes an AsyncIterable object and returns an AsyncIterator for it. This is typically a new iterator but if the argument is an AsyncIterator, this returns itself. / PyAPI_FUNC(PyObject ) PyObject_GetAIter(PyObject ); / Returns non-zero if the object 'obj' provides iterator protocols, and 0 otherwise. This function always succeeds. / PyAPI_FUNC(int) PyIter_Check(PyObject ); /* Returns non-zero if the object 'obj' provides AsyncIterator protocols, and 0 otherwise. This function always succeeds. / PyAPI_FUNC(int) PyAIter_Check(PyObject ); /* 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 - PYGEN_ERROR (-1) if exception was raised. 'result' parameter is NULL - PYGEN_NEXT (1) if generator has yielded. 'result' parameter is filled with yielded 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); /* Returns the result of subtracting o2 from o1, or NULL on failure. This is the equivalent of the Python expression: o1 - o2. / PyAPI_FUNC(PyObject ) PyNumber_Subtract(PyObject o1, PyObject o2); /* Returns the result of multiplying o1 and o2, or NULL on failure. This is the equivalent of the Python expression: o1 * o2. / PyAPI_FUNC(PyObject ) PyNumber_Multiply(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_MatrixMultiply(PyObject o1, PyObject o2); #endif /* Returns the result of dividing o1 by o2 giving an integral result, or NULL on failure. This is the equivalent of the Python expression: o1 // o2. / PyAPI_FUNC(PyObject ) PyNumber_FloorDivide(PyObject o1, PyObject o2); /* Returns the result of dividing o1 by o2 giving a float result, or NULL on failure. This is the equivalent of the Python expression: o1 / o2. / PyAPI_FUNC(PyObject ) PyNumber_TrueDivide(PyObject o1, PyObject o2); /* Returns the remainder of dividing o1 by o2, or NULL on failure. This is the equivalent of the Python expression: o1 % o2. / PyAPI_FUNC(PyObject ) PyNumber_Remainder(PyObject o1, PyObject o2); /* See the built-in function divmod. Returns NULL on failure. This is the equivalent of the Python expression: divmod(o1, o2). / PyAPI_FUNC(PyObject ) PyNumber_Divmod(PyObject o1, PyObject o2); /* See the built-in function pow. Returns NULL on failure. This is the equivalent of the Python expression: pow(o1, o2, o3), where o3 is optional. / PyAPI_FUNC(PyObject ) PyNumber_Power(PyObject o1, PyObject o2, PyObject o3); / Returns the negation of o on success, or NULL on failure. This is the equivalent of the Python expression: -o. / PyAPI_FUNC(PyObject ) PyNumber_Negative(PyObject o); / Returns the positive of o on success, or NULL on failure. This is the equivalent of the Python expression: +o. / PyAPI_FUNC(PyObject ) PyNumber_Positive(PyObject o); / Returns the absolute value of 'o', or NULL on failure. This is the equivalent of the Python expression: abs(o). / PyAPI_FUNC(PyObject ) PyNumber_Absolute(PyObject o); / Returns the bitwise negation of 'o' on success, or NULL on failure. This is the equivalent of the Python expression: ~o. / PyAPI_FUNC(PyObject ) PyNumber_Invert(PyObject o); / Returns the result of left shifting o1 by o2 on success, or NULL on failure. This is the equivalent of the Python expression: o1 << o2. / PyAPI_FUNC(PyObject ) PyNumber_Lshift(PyObject o1, PyObject o2); /* Returns the result of right shifting o1 by o2 on success, or NULL on failure. This is the equivalent of the Python expression: o1 >> o2. / PyAPI_FUNC(PyObject ) PyNumber_Rshift(PyObject o1, PyObject o2); /* Returns the result of bitwise and of o1 and o2 on success, or NULL on failure. This is the equivalent of the Python expression: o1 & o2. / PyAPI_FUNC(PyObject ) PyNumber_And(PyObject o1, PyObject o2); /* Returns the bitwise exclusive or of o1 by o2 on success, or NULL on failure. This is the equivalent of the Python expression: o1 ^ o2. / PyAPI_FUNC(PyObject ) PyNumber_Xor(PyObject o1, PyObject o2); /* Returns the result of bitwise or on o1 and o2 on success, or NULL on failure. This is the equivalent of the Python expression: o1 \| o2. / PyAPI_FUNC(PyObject ) PyNumber_Or(PyObject o1, PyObject o2); /* Returns 1 if obj 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 return. If it is NULL, then the overflow error is cleared and the value is clipped. / PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject o, PyObject exc); / Returns the object 'o' converted to an integer object on success, or NULL on failure. This is the equivalent of the Python expression: int(o). / PyAPI_FUNC(PyObject ) PyNumber_Long(PyObject o); / Returns the object 'o' converted to a float object on success, or NULL on failure. This is the equivalent of the Python expression: float(o). / PyAPI_FUNC(PyObject ) PyNumber_Float(PyObject o); / --- In-place variants of (some of) the above number protocol functions -- / / Returns the result of adding o2 to o1, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 += o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceAdd(PyObject o1, PyObject o2); /* Returns the result of subtracting o2 from o1, possibly in-place or NULL on failure. This is the equivalent of the Python expression: o1 -= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceSubtract(PyObject o1, PyObject o2); /* Returns 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-place, or NULL on failure. This is the equivalent of the Python expression: o1 /= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceFloorDivide(PyObject o1, PyObject o2); /* Returns the result of dividing o1 by o2 giving a float result, possibly in-place, or null on failure. This is the equivalent of the Python expression: o1 /= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceTrueDivide(PyObject o1, PyObject o2); /* Returns the remainder of dividing o1 by o2, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 %= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceRemainder(PyObject o1, PyObject o2); /* Returns the result of raising o1 to the power of o2, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 *= o2, or o1 = pow(o1, o2, o3) if o3 is present. / PyAPI_FUNC(PyObject ) PyNumber_InPlacePower(PyObject o1, PyObject o2, PyObject o3); /* Returns the result of left shifting o1 by o2, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 <<= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceLshift(PyObject o1, PyObject o2); /* Returns the result of right shifting o1 by o2, possibly in-place or NULL on failure. This is the equivalent of the Python expression: o1 >>= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceRshift(PyObject o1, PyObject o2); /* Returns the result of bitwise and of o1 and o2, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 &= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceAnd(PyObject o1, PyObject o2); /* Returns the bitwise exclusive or of o1 by o2, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 ^= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceXor(PyObject o1, PyObject o2); /* Returns the result of bitwise or of o1 and o2, possibly in-place, or NULL on failure. This is the equivalent of the Python expression: o1 \|= o2. / PyAPI_FUNC(PyObject ) PyNumber_InPlaceOr(PyObject o1, PyObject o2); /* Returns the integer n converted to a string with a base, with a base marker of 0b, 0o or 0x prefixed if applicable. If n is not an int object, it is converted with PyNumber_Index first. / PyAPI_FUNC(PyObject ) PyNumber_ToBase(PyObject n, int base); / === Sequence protocol ================================================ / / Return 1 if the object provides sequence protocol, and zero otherwise. This function always succeeds. / PyAPI_FUNC(int) PySequence_Check(PyObject o); /* Return the size of sequence object o, or -1 on failure. / PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject o); /* For DLL compatibility / #undef PySequence_Length PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject o); #define PySequence_Length PySequence_Size /* Return the concatenation of o1 and o2 on success, and NULL on failure. This is the equivalent of the Python expression: o1 + o2. / PyAPI_FUNC(PyObject ) PySequence_Concat(PyObject o1, PyObject o2); /* Return the result of repeating sequence object 'o' 'count' times, or NULL on failure. This is the equivalent of the Python expression: o * count. / PyAPI_FUNC(PyObject ) PySequence_Repeat(PyObject o, Py_ssize_t count); / Return the ith element of o, or NULL on failure. This is the equivalent of the Python expression: o[i]. / PyAPI_FUNC(PyObject ) PySequence_GetItem(PyObject o, Py_ssize_t i); / Return the slice of sequence object o between i1 and i2, or NULL on failure. This is the equivalent of the Python expression: o[i1:i2]. / PyAPI_FUNC(PyObject ) PySequence_GetSlice(PyObject o, Py_ssize_t i1, Py_ssize_t i2); / Assign object 'v' to the ith element of the sequence 'o'. Raise an exception and return -1 on failure; return 0 on success. This is the equivalent of the Python statement o[i] = v. / PyAPI_FUNC(int) PySequence_SetItem(PyObject o, Py_ssize_t i, PyObject v); / Delete the 'i'-th element of the sequence 'v'. Returns -1 on failure. This is the equivalent of the Python statement: del o[i]. / PyAPI_FUNC(int) PySequence_DelItem(PyObject o, Py_ssize_t i); /* Assign the sequence object 'v' to the slice in sequence object 'o', from 'i1' to 'i2'. Returns -1 on failure. This is the equivalent of the Python statement: o[i1:i2] = v. / PyAPI_FUNC(int) PySequence_SetSlice(PyObject o, Py_ssize_t i1, Py_ssize_t i2, PyObject v); / Delete the slice in sequence object 'o' from 'i1' to 'i2'. Returns -1 on failure. This is the equivalent of the Python statement: del o[i1:i2]. / PyAPI_FUNC(int) PySequence_DelSlice(PyObject o, Py_ssize_t i1, Py_ssize_t i2); /* Returns the sequence 'o' as a tuple on success, and NULL on failure. This is equivalent to the Python expression: tuple(o). / PyAPI_FUNC(PyObject ) PySequence_Tuple(PyObject o); / Returns the sequence 'o' as a list on success, and NULL on failure. This is equivalent to the Python expression: list(o) / PyAPI_FUNC(PyObject ) PySequence_List(PyObject o); / Return the sequence 'o' as a list, unless it's already a tuple or list. Use PySequence_Fast_GET_ITEM to 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 of the sequence 'o', assuming that o was returned by PySequence_Fast, and that i is within bounds. / #define PySequence_Fast_GET_ITEM(o, i)\ (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i)) / Return a pointer to the underlying item array for an object returned by PySequence_Fast / #define PySequence_Fast_ITEMS(sf) \ (PyList_Check(sf) ? ((PyListObject )(sf))->ob_item \ : ((PyTupleObject )(sf))->ob_item) / Return the number of occurrences on value on 'o', that is, return the number of keys for which o[key] == value. On failure, return -1. This is equivalent to the Python expression: o.count(value). / PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject o, PyObject value); / Return 1 if 'ob' is in the sequence 'seq'; 0 if 'ob' is not in the sequence 'seq'; -1 on error. Use __contains__ if possible, else _PySequence_IterSearch(). / PyAPI_FUNC(int) PySequence_Contains(PyObject seq, PyObject ob); / For DLL-level backwards compatibility / #undef PySequence_In / Determine if the sequence 'o' contains 'value'. If an item in 'o' is equal to 'value', return 1, otherwise return 0. On error, return -1. This is equivalent to the Python expression: value in o. / PyAPI_FUNC(int) PySequence_In(PyObject o, PyObject 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 the equivalent of the Python expression: o1 += o2. / PyAPI_FUNC(PyObject ) PySequence_InPlaceConcat(PyObject o1, PyObject o2); /* Repeat sequence 'o' by 'count', in-place when possible. Return the resulting object, which could be 'o', or NULL on failure. This is the equivalent of the Python expression: o1 = count. / PyAPI_FUNC(PyObject ) PySequence_InPlaceRepeat(PyObject o, Py_ssize_t count); /* === Mapping protocol ================================================= / / Return 1 if the object provides mapping protocol, and 0 otherwise. This function always succeeds. / PyAPI_FUNC(int) PyMapping_Check(PyObject o); /* Returns the number of keys in mapping object 'o' on success, and -1 on failure. This is equivalent to the Python expression: len(o). / PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject o); /* For DLL compatibility / #undef PyMapping_Length PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject o); #define PyMapping_Length PyMapping_Size /* Implemented as a macro: int PyMapping_DelItemString(PyObject o, const char key); Remove the mapping for the string 'key' from the mapping 'o'. Returns -1 on failure. This is equivalent to the Python statement: del o[key]. / #define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K)) / Implemented as a macro: int PyMapping_DelItem(PyObject o, PyObject key); Remove the mapping for the object 'key' from the mapping object 'o'. Returns -1 on failure. This is equivalent to the Python statement: del o[key]. / #define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K)) / On success, return 1 if the mapping object 'o' has the key 'key', and 0 otherwise. This is equivalent to the Python expression: key in o. This function always succeeds. / PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject o, const char key); / Return 1 if the mapping object has the key 'key', and 0 otherwise. This is equivalent to the Python expression: key in o. This function always succeeds. / PyAPI_FUNC(int) PyMapping_HasKey(PyObject o, PyObject key); / On success, return a list or tuple of the keys in mapping object 'o'. On failure, return NULL. / PyAPI_FUNC(PyObject ) PyMapping_Keys(PyObject o); / On success, return a list or tuple of the values in mapping object 'o'. On failure, return NULL. / PyAPI_FUNC(PyObject ) PyMapping_Values(PyObject o); / On success, return a list or tuple of the items in mapping object 'o', where each item is a tuple containing a key-value pair. On failure, return NULL. / PyAPI_FUNC(PyObject ) PyMapping_Items(PyObject o); / Return element of 'o' corresponding to the string 'key' or NULL on failure. This is the equivalent of the Python expression: o[key]. / PyAPI_FUNC(PyObject ) PyMapping_GetItemString(PyObject o, const char key); /* Map the string 'key' to the value 'v' in the mapping 'o'. Returns -1 on failure. This is the equivalent of the Python statement: o[key]=v. / PyAPI_FUNC(int) PyMapping_SetItemString(PyObject o, const char key, PyObject value); /* isinstance(object, typeorclass) / PyAPI_FUNC(int) PyObject_IsInstance(PyObject object, PyObject typeorclass); / issubclass(object, typeorclass) / PyAPI_FUNC(int) PyObject_IsSubclass(PyObject object, PyObject typeorclass); #ifndef Py_LIMITED_API # define Py_CPYTHON_ABSTRACTOBJECT_H # include "cpython/abstract.h" # undef Py_CPYTHON_ABSTRACTOBJECT_H #endif #ifdef __cplusplus } #endif #endif / Py_ABSTRACTOBJECT_H */	30.67 KB	2025-10-09 16:16
📄 bltinmodule.h #ifndef Py_BLTINMODULE_H #define Py_BLTINMODULE_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyFilter_Type; PyAPI_DATA(PyTypeObject) PyMap_Type; PyAPI_DATA(PyTypeObject) PyZip_Type; #ifdef __cplusplus } #endif #endif /* !Py_BLTINMODULE_H */	264 B	2025-10-09 16:16
📄 boolobject.h /* Boolean object interface / #ifndef Py_BOOLOBJECT_H #define Py_BOOLOBJECT_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyBool_Type; #define PyBool_Check(x) Py_IS_TYPE(x, &PyBool_Type) / Py_False and Py_True are the only two bools in existence. Don't forget to apply Py_INCREF() when returning either!!! / / Don't use these directly / PyAPI_DATA(PyLongObject) _Py_FalseStruct; PyAPI_DATA(PyLongObject) _Py_TrueStruct; / Use these macros / #define Py_False ((PyObject ) &_Py_FalseStruct) #define Py_True ((PyObject ) &_Py_TrueStruct) // Test if an object is the True singleton, the same as "x is True" in Python. PyAPI_FUNC(int) Py_IsTrue(PyObject x); #define Py_IsTrue(x) Py_Is((x), Py_True) // Test if an object is the False singleton, the same as "x is False" in Python. PyAPI_FUNC(int) Py_IsFalse(PyObject x); #define Py_IsFalse(x) Py_Is((x), Py_False) / Macros for returning Py_True or Py_False, respectively / #define Py_RETURN_TRUE return Py_NewRef(Py_True) #define Py_RETURN_FALSE return Py_NewRef(Py_False) / Function to return a bool from a C long / PyAPI_FUNC(PyObject ) PyBool_FromLong(long); #ifdef __cplusplus } #endif #endif /* !Py_BOOLOBJECT_H */	1.18 KB	2025-10-09 16:16
📄 bytearrayobject.h /* ByteArray object interface / #ifndef Py_BYTEARRAYOBJECT_H #define Py_BYTEARRAYOBJECT_H #ifdef __cplusplus extern "C" { #endif / Type PyByteArrayObject represents a mutable array of bytes. * The Python API is that of a sequence; * the bytes are mapped to ints in [0, 256). * Bytes are not characters; they may be used to encode characters. * The only way to go between bytes and str/unicode is via encoding * and decoding. * For the convenience of C programmers, the bytes type is considered * to contain a char pointer, not an unsigned char pointer. / / Type object / PyAPI_DATA(PyTypeObject) PyByteArray_Type; PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type; / Type check macros / #define PyByteArray_Check(self) PyObject_TypeCheck(self, &PyByteArray_Type) #define PyByteArray_CheckExact(self) Py_IS_TYPE(self, &PyByteArray_Type) / Direct API functions / PyAPI_FUNC(PyObject ) PyByteArray_FromObject(PyObject ); PyAPI_FUNC(PyObject ) PyByteArray_Concat(PyObject , PyObject ); PyAPI_FUNC(PyObject ) PyByteArray_FromStringAndSize(const char , Py_ssize_t); PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject ); PyAPI_FUNC(char ) PyByteArray_AsString(PyObject ); PyAPI_FUNC(int) PyByteArray_Resize(PyObject , Py_ssize_t); #ifndef Py_LIMITED_API # define Py_CPYTHON_BYTEARRAYOBJECT_H # include "cpython/bytearrayobject.h" # undef Py_CPYTHON_BYTEARRAYOBJECT_H #endif #ifdef __cplusplus } #endif #endif /* !Py_BYTEARRAYOBJECT_H */	1.43 KB	2025-10-09 16:16
📄 bytesobject.h /* Bytes object interface / #ifndef Py_BYTESOBJECT_H #define Py_BYTESOBJECT_H #ifdef __cplusplus extern "C" { #endif #include <stdarg.h> // va_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-terminated string. Note that none of the functions should be applied to NULL pointer. / PyAPI_DATA(PyTypeObject) PyBytes_Type; PyAPI_DATA(PyTypeObject) PyBytesIter_Type; #define PyBytes_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_BYTES_SUBCLASS) #define PyBytes_CheckExact(op) Py_IS_TYPE(op, &PyBytes_Type) PyAPI_FUNC(PyObject ) PyBytes_FromStringAndSize(const char , Py_ssize_t); PyAPI_FUNC(PyObject ) PyBytes_FromString(const char ); PyAPI_FUNC(PyObject ) PyBytes_FromObject(PyObject ); PyAPI_FUNC(PyObject ) PyBytes_FromFormatV(const char, va_list) Py_GCC_ATTRIBUTE((format(printf, 1, 0))); PyAPI_FUNC(PyObject ) PyBytes_FromFormat(const char, ...) Py_GCC_ATTRIBUTE((format(printf, 1, 2))); PyAPI_FUNC(Py_ssize_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. Passing NULL as len parameter will force the string buffer to be 0-terminated (passing a string with embedded NUL characters will cause an exception). / PyAPI_FUNC(int) PyBytes_AsStringAndSize( PyObject obj, /* bytes object / char s, / pointer to buffer variable / Py_ssize_t len /* pointer to length variable or NULL / ); #ifndef Py_LIMITED_API # define Py_CPYTHON_BYTESOBJECT_H # include "cpython/bytesobject.h" # undef Py_CPYTHON_BYTESOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_BYTESOBJECT_H */	2.56 KB	2025-10-09 16:16
📄 ceval.h /* Interface to random parts in ceval.c / #ifndef Py_CEVAL_H #define Py_CEVAL_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(PyObject ) PyEval_EvalCode(PyObject , PyObject , PyObject ); PyAPI_FUNC(PyObject ) PyEval_EvalCodeEx(PyObject co, PyObject globals, PyObject locals, PyObject const args, int argc, PyObject const kwds, int kwdc, PyObject const defs, int defc, PyObject kwdefs, PyObject closure); / PyEval_CallObjectWithKeywords(), PyEval_CallObject(), PyEval_CallFunction * 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) \ PyEval_CallObjectWithKeywords(callable, arg, (PyObject )NULL) Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject ) PyEval_CallFunction( PyObject callable, const char format, ...); Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject ) PyEval_CallMethod( PyObject obj, const char name, const char format, ...); PyAPI_FUNC(PyObject ) PyEval_GetBuiltins(void); PyAPI_FUNC(PyObject ) PyEval_GetGlobals(void); PyAPI_FUNC(PyObject ) PyEval_GetLocals(void); PyAPI_FUNC(PyFrameObject ) PyEval_GetFrame(void); PyAPI_FUNC(int) Py_AddPendingCall(int (func)(void ), void arg); PyAPI_FUNC(int) Py_MakePendingCalls(void); /* Protection against deeply nested recursive calls In Python 3.0, this protection has two levels: * normal anti-recursion protection is triggered when the recursion level exceeds the current recursion limit. It raises a RecursionError, and sets the "overflowed" flag in the thread state structure. This flag temporarily disables the normal protection; this allows cleanup code to potentially outgrow the recursion limit while processing the RecursionError. * "last chance" anti-recursion protection is triggered when the recursion level exceeds "current recursion limit + 50". By construction, this protection can only be triggered when the "overflowed" flag is set. It means the cleanup code has itself gone into an infinite loop, or the RecursionError has been mistakingly ignored. When this protection is triggered, the interpreter aborts with a Fatal Error. In addition, the "overflowed" flag is automatically reset when the recursion level drops below "current recursion limit - 50". This heuristic is meant to ensure that the normal anti-recursion protection doesn't get disabled too long. Please note: this scheme has its own limitations. See: http://mail.python.org/pipermail/python-dev/2008-August/082106.html for some observations. / PyAPI_FUNC(void) Py_SetRecursionLimit(int); PyAPI_FUNC(int) Py_GetRecursionLimit(void); PyAPI_FUNC(int) Py_EnterRecursiveCall(const char where); PyAPI_FUNC(void) Py_LeaveRecursiveCall(void); PyAPI_FUNC(const char ) PyEval_GetFuncName(PyObject ); PyAPI_FUNC(const char ) PyEval_GetFuncDesc(PyObject ); PyAPI_FUNC(PyObject ) PyEval_EvalFrame(PyFrameObject ); PyAPI_FUNC(PyObject ) PyEval_EvalFrameEx(PyFrameObject f, int exc); /* Interface for threads. A module that plans to do a blocking system call (or something else that lasts a long time and doesn't touch Python data) can allow other threads to run as follows: ...preparations here... Py_BEGIN_ALLOW_THREADS ...blocking system call here... Py_END_ALLOW_THREADS ...interpret result here... The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a {}-surrounded block. To leave the block in the middle (e.g., with return), you must insert a line containing Py_BLOCK_THREADS before the return, e.g. if (...premature_exit...) { Py_BLOCK_THREADS PyErr_SetFromErrno(PyExc_OSError); return NULL; } An alternative is: Py_BLOCK_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_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void); Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void); / PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI. * They will be removed from this header file in the future version. * But they will be remained in ABI until Python 4.0. / Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void); Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void); PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState tstate); PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState tstate); #define Py_BEGIN_ALLOW_THREADS { \ PyThreadState _save; \ _save = PyEval_SaveThread(); #define Py_BLOCK_THREADS PyEval_RestoreThread(_save); #define Py_UNBLOCK_THREADS _save = PyEval_SaveThread(); #define Py_END_ALLOW_THREADS PyEval_RestoreThread(_save); \ } /* Masks and values used by FORMAT_VALUE opcode. / #define FVC_MASK 0x3 #define FVC_NONE 0x0 #define FVC_STR 0x1 #define FVC_REPR 0x2 #define FVC_ASCII 0x3 #define FVS_MASK 0x4 #define FVS_HAVE_SPEC 0x4 #ifndef Py_LIMITED_API # define Py_CPYTHON_CEVAL_H # include "cpython/ceval.h" # undef Py_CPYTHON_CEVAL_H #endif #ifdef __cplusplus } #endif #endif / !Py_CEVAL_H */	6.11 KB	2025-10-09 16:16
📄 codecs.h #ifndef Py_CODECREGISTRY_H #define Py_CODECREGISTRY_H #ifdef __cplusplus extern "C" { #endif /* ------------------------------------------------------------------------ Python Codec Registry and support functions Written by Marc-Andre Lemburg (mal@lemburg.com). Copyright (c) Corporation for National Research Initiatives. ------------------------------------------------------------------------ / / Register a new codec search function. As side effect, this tries to load the encodings package, if not yet done, to make sure that it is always first in the list of search functions. The search_function's refcount is incremented by this function. / PyAPI_FUNC(int) PyCodec_Register( PyObject search_function ); /* Unregister a codec search function and clear the registry's cache. If the search function is not registered, do nothing. Return 0 on success. Raise an exception and return -1 on error. / PyAPI_FUNC(int) PyCodec_Unregister( PyObject search_function ); /* Codec registry lookup API. Looks up the given encoding and returns a CodecInfo object with function attributes which implement the different aspects of processing the encoding. The encoding string is looked up converted to all lower-case characters. This makes encodings looked up through this mechanism effectively case-insensitive. If no codec is found, a KeyError is set and NULL returned. As side effect, this tries to load the encodings package, if not yet done. This is part of the lazy load strategy for the encodings package. / #ifndef Py_LIMITED_API PyAPI_FUNC(PyObject ) _PyCodec_Lookup( const char encoding ); PyAPI_FUNC(int) _PyCodec_Forget( const char encoding ); #endif /* Codec registry encoding check API. Returns 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 object, const char encoding, const char errors ); / Generic codec based decoding API. object is passed through the decoder 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_Decode( PyObject object, const char encoding, const char errors ); #ifndef Py_LIMITED_API / Text codec specific encoding and decoding API. Checks the encoding against a list of codecs which do not implement a str<->bytes encoding before attempting the operation. Please note that these APIs are internal and should not be used in Python C extensions. XXX (ncoghlan): should we make these, or something like them, public in Python 3.5+? / PyAPI_FUNC(PyObject ) _PyCodec_LookupTextEncoding( const char encoding, const char alternate_command ); PyAPI_FUNC(PyObject ) _PyCodec_EncodeText( PyObject object, const char encoding, const char errors ); PyAPI_FUNC(PyObject ) _PyCodec_DecodeText( PyObject object, const char encoding, const char errors ); /* These two aren't actually text encoding specific, but _io.TextIOWrapper * is the only current API consumer. / PyAPI_FUNC(PyObject ) _PyCodecInfo_GetIncrementalDecoder( PyObject codec_info, const char errors ); PyAPI_FUNC(PyObject ) _PyCodecInfo_GetIncrementalEncoder( PyObject codec_info, const char errors ); #endif / --- Codec Lookup APIs -------------------------------------------------- All APIs return a codec object with incremented refcount and are based on _PyCodec_Lookup(). The same comments w/r to the encoding name also apply to these APIs. / / Get an encoder function for the given encoding. / PyAPI_FUNC(PyObject ) PyCodec_Encoder( const char encoding ); / Get a decoder function for the given encoding. / PyAPI_FUNC(PyObject ) PyCodec_Decoder( const char encoding ); / Get an IncrementalEncoder object for the given encoding. / PyAPI_FUNC(PyObject ) PyCodec_IncrementalEncoder( const char encoding, const char errors ); /* Get an IncrementalDecoder object function for the given encoding. / PyAPI_FUNC(PyObject ) PyCodec_IncrementalDecoder( const char encoding, const char errors ); /* Get a StreamReader factory function for the given encoding. / PyAPI_FUNC(PyObject ) PyCodec_StreamReader( const char encoding, PyObject stream, const char errors ); / Get a StreamWriter factory function for the given encoding. / PyAPI_FUNC(PyObject ) PyCodec_StreamWriter( const char encoding, PyObject stream, const char errors ); / Unicode encoding error handling callback registry API / / Register the error handling callback function error under the given name. This function will be called by the codec when it encounters unencodable characters/undecodable bytes and doesn't know the callback name, when name is specified as the error parameter in the call to the encode/decode function. Return 0 on success, -1 on error / PyAPI_FUNC(int) PyCodec_RegisterError(const char name, PyObject error); / Lookup the error handling callback function registered under the given name. As a special case NULL can be passed, in which case the error handling callback for "strict" will be returned. / PyAPI_FUNC(PyObject ) PyCodec_LookupError(const char name); / raise exc as an exception / PyAPI_FUNC(PyObject ) PyCodec_StrictErrors(PyObject exc); / ignore the unicode error, skipping the faulty input / PyAPI_FUNC(PyObject ) PyCodec_IgnoreErrors(PyObject exc); / replace the unicode encode error with ? or U+FFFD / PyAPI_FUNC(PyObject ) PyCodec_ReplaceErrors(PyObject exc); / replace the unicode encode error with XML character references / PyAPI_FUNC(PyObject ) PyCodec_XMLCharRefReplaceErrors(PyObject exc); / replace the unicode encode error with backslash escapes (\x, \u and \U) / PyAPI_FUNC(PyObject ) PyCodec_BackslashReplaceErrors(PyObject exc); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 / replace the unicode encode error with backslash escapes (\N, \x, \u and \U) / PyAPI_FUNC(PyObject ) PyCodec_NameReplaceErrors(PyObject exc); #endif #ifndef Py_LIMITED_API PyAPI_DATA(const char ) Py_hexdigits; #endif #ifdef __cplusplus } #endif #endif /* !Py_CODECREGISTRY_H */	6.91 KB	2025-10-09 16:16
📄 compile.h #ifndef Py_COMPILE_H #define Py_COMPILE_H #ifdef __cplusplus extern "C" { #endif /* These definitions must match corresponding definitions in graminit.h. / #define Py_single_input 256 #define Py_file_input 257 #define Py_eval_input 258 #define Py_func_type_input 345 / This doesn't need to match anything / #define Py_fstring_input 800 #ifndef Py_LIMITED_API # define Py_CPYTHON_COMPILE_H # include "cpython/compile.h" # undef Py_CPYTHON_COMPILE_H #endif #ifdef __cplusplus } #endif #endif / !Py_COMPILE_H */	520 B	2025-10-09 16:16
📄 complexobject.h /* Complex number structure / #ifndef Py_COMPLEXOBJECT_H #define Py_COMPLEXOBJECT_H #ifdef __cplusplus extern "C" { #endif / Complex object interface / PyAPI_DATA(PyTypeObject) PyComplex_Type; #define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type) #define PyComplex_CheckExact(op) Py_IS_TYPE(op, &PyComplex_Type) PyAPI_FUNC(PyObject ) PyComplex_FromDoubles(double real, double imag); PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject op); PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject op); #ifndef Py_LIMITED_API # define Py_CPYTHON_COMPLEXOBJECT_H # include "cpython/complexobject.h" # undef Py_CPYTHON_COMPLEXOBJECT_H #endif #ifdef __cplusplus } #endif #endif /* !Py_COMPLEXOBJECT_H */	724 B	2025-10-09 16:16
📁 cpython	-	2026-03-21 15:51
📄 datetime.h /* datetime.h / #ifndef Py_LIMITED_API #ifndef DATETIME_H #define DATETIME_H #ifdef __cplusplus extern "C" { #endif / Fields are packed into successive bytes, each viewed as unsigned and * big-endian, unless otherwise noted: * * byte offset * 0 year 2 bytes, 1-9999 * 2 month 1 byte, 1-12 * 3 day 1 byte, 1-31 * 4 hour 1 byte, 0-23 * 5 minute 1 byte, 0-59 * 6 second 1 byte, 0-59 * 7 usecond 3 bytes, 0-999999 * 10 / / # of bytes for year, month, and day. / #define _PyDateTime_DATE_DATASIZE 4 / # of bytes for hour, minute, second, and usecond. / #define _PyDateTime_TIME_DATASIZE 6 / # of bytes for year, month, day, hour, minute, second, and usecond. / #define _PyDateTime_DATETIME_DATASIZE 10 typedef struct { PyObject_HEAD Py_hash_t hashcode; / -1 when unknown / int days; / -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS / int seconds; / 0 <= seconds < 243600 is invariant / int microseconds; /* 0 <= microseconds < 1000000 is invariant / } PyDateTime_Delta; typedef struct { PyObject_HEAD / a pure abstract base class / } PyDateTime_TZInfo; / The datetime and time types have hashcodes, and an optional tzinfo member, * present if and only if hastzinfo is true. / #define _PyTZINFO_HEAD \ PyObject_HEAD \ Py_hash_t hashcode; \ char hastzinfo; / boolean flag / / No _PyDateTime_BaseTZInfo is allocated; it's just to have something * convenient to cast to, 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 \ unsigned char data[_PyDateTime_TIME_DATASIZE]; typedef struct { _PyDateTime_TIMEHEAD } _PyDateTime_BaseTime; / hastzinfo false / typedef struct { _PyDateTime_TIMEHEAD unsigned char fold; PyObject tzinfo; } PyDateTime_Time; /* hastzinfo true / / All datetime objects are of PyDateTime_DateTimeType, but that can be * allocated in two ways too, just like for time objects above. In addition, * the plain date type is a base class for datetime, so it must also have * a hastzinfo member (although it's unused there). / typedef struct { _PyTZINFO_HEAD unsigned char data[_PyDateTime_DATE_DATASIZE]; } PyDateTime_Date; #define _PyDateTime_DATETIMEHEAD \ _PyTZINFO_HEAD \ 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) ((((PyDateTime_Date)o)->data[0] << 8) \| \ ((PyDateTime_Date)o)->data[1]) #define PyDateTime_GET_MONTH(o) (((PyDateTime_Date)o)->data[2]) #define PyDateTime_GET_DAY(o) (((PyDateTime_Date)o)->data[3]) #define PyDateTime_DATE_GET_HOUR(o) (((PyDateTime_DateTime)o)->data[4]) #define PyDateTime_DATE_GET_MINUTE(o) (((PyDateTime_DateTime)o)->data[5]) #define PyDateTime_DATE_GET_SECOND(o) (((PyDateTime_DateTime)o)->data[6]) #define PyDateTime_DATE_GET_MICROSECOND(o) \ ((((PyDateTime_DateTime)o)->data[7] << 16) \| \ (((PyDateTime_DateTime)o)->data[8] << 8) \| \ ((PyDateTime_DateTime)o)->data[9]) #define PyDateTime_DATE_GET_FOLD(o) (((PyDateTime_DateTime)o)->fold) #define PyDateTime_DATE_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ ((PyDateTime_DateTime )(o))->tzinfo : Py_None) /* Apply for time instances. / #define PyDateTime_TIME_GET_HOUR(o) (((PyDateTime_Time)o)->data[0]) #define PyDateTime_TIME_GET_MINUTE(o) (((PyDateTime_Time)o)->data[1]) #define PyDateTime_TIME_GET_SECOND(o) (((PyDateTime_Time)o)->data[2]) #define PyDateTime_TIME_GET_MICROSECOND(o) \ ((((PyDateTime_Time)o)->data[3] << 16) \| \ (((PyDateTime_Time)o)->data[4] << 8) \| \ ((PyDateTime_Time)o)->data[5]) #define PyDateTime_TIME_GET_FOLD(o) (((PyDateTime_Time)o)->fold) #define PyDateTime_TIME_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ ((PyDateTime_Time )(o))->tzinfo : Py_None) / Apply for time delta instances / #define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta)o)->days) #define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta)o)->seconds) #define PyDateTime_DELTA_GET_MICROSECONDS(o) \ (((PyDateTime_Delta)o)->microseconds) /* Define structure for C API. / typedef struct { / type objects / PyTypeObject DateType; PyTypeObject DateTimeType; PyTypeObject TimeType; PyTypeObject DeltaType; PyTypeObject TZInfoType; /* singletons / PyObject TimeZone_UTC; /* constructors / PyObject (Date_FromDate)(int, int, int, PyTypeObject); PyObject (DateTime_FromDateAndTime)(int, int, int, int, int, int, int, PyObject, PyTypeObject); PyObject (Time_FromTime)(int, int, int, int, PyObject, PyTypeObject); PyObject (Delta_FromDelta)(int, int, int, int, PyTypeObject); PyObject (TimeZone_FromTimeZone)(PyObject offset, PyObject name); / constructors for the DB API / PyObject (DateTime_FromTimestamp)(PyObject, PyObject, PyObject); PyObject (Date_FromTimestamp)(PyObject, PyObject); /* PEP 495 constructors / PyObject (DateTime_FromDateAndTimeAndFold)(int, int, int, int, int, int, 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 = NULL; #define PyDateTime_IMPORT \ PyDateTimeAPI = (PyDateTime_CAPI )PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0) / Macro for access to the UTC singleton / #define PyDateTime_TimeZone_UTC PyDateTimeAPI->TimeZone_UTC / Macros for type checking when not building the Python core. / #define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType) #define PyDate_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateType) #define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType) #define PyDateTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateTimeType) #define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType) #define PyTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TimeType) #define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType) #define PyDelta_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DeltaType) #define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType) #define PyTZInfo_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TZInfoType) / Macros for accessing constructors in a simplified fashion. / #define PyDate_FromDate(year, month, day) \ PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType) #define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \ PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \ min, sec, usec, 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, second, usecond, \ Py_None, PyDateTimeAPI->TimeType) #define PyTime_FromTimeAndFold(hour, minute, second, usecond, fold) \ PyDateTimeAPI->Time_FromTimeAndFold(hour, minute, second, usecond, \ Py_None, fold, PyDateTimeAPI->TimeType) #define PyDelta_FromDSU(days, seconds, useconds) \ PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \ PyDateTimeAPI->DeltaType) #define PyTimeZone_FromOffset(offset) \ PyDateTimeAPI->TimeZone_FromTimeZone(offset, NULL) #define PyTimeZone_FromOffsetAndName(offset, name) \ PyDateTimeAPI->TimeZone_FromTimeZone(offset, name) / Macros supporting the DB API. / #define PyDateTime_FromTimestamp(args) \ PyDateTimeAPI->DateTime_FromTimestamp( \ (PyObject) (PyDateTimeAPI->DateTimeType), args, NULL) #define PyDate_FromTimestamp(args) \ PyDateTimeAPI->Date_FromTimestamp( \ (PyObject) (PyDateTimeAPI->DateType), args) #endif / !defined(_PY_DATETIME_IMPL) / #ifdef __cplusplus } #endif #endif #endif / !Py_LIMITED_API */	9.41 KB	2025-10-09 16:16
📄 descrobject.h /* Descriptors / #ifndef Py_DESCROBJECT_H #define Py_DESCROBJECT_H #ifdef __cplusplus extern "C" { #endif typedef PyObject (getter)(PyObject , void ); typedef int (setter)(PyObject , PyObject , void ); struct PyGetSetDef { const char name; getter get; setter set; const char doc; void closure; }; PyAPI_DATA(PyTypeObject) PyClassMethodDescr_Type; PyAPI_DATA(PyTypeObject) PyGetSetDescr_Type; PyAPI_DATA(PyTypeObject) PyMemberDescr_Type; PyAPI_DATA(PyTypeObject) PyMethodDescr_Type; PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type; PyAPI_DATA(PyTypeObject) PyDictProxy_Type; PyAPI_DATA(PyTypeObject) PyProperty_Type; PyAPI_FUNC(PyObject ) PyDescr_NewMethod(PyTypeObject , PyMethodDef ); PyAPI_FUNC(PyObject ) PyDescr_NewClassMethod(PyTypeObject , PyMethodDef ); PyAPI_FUNC(PyObject ) PyDescr_NewMember(PyTypeObject , PyMemberDef ); PyAPI_FUNC(PyObject ) PyDescr_NewGetSet(PyTypeObject , PyGetSetDef ); PyAPI_FUNC(PyObject ) PyDictProxy_New(PyObject ); PyAPI_FUNC(PyObject ) PyWrapper_New(PyObject , PyObject ); #ifndef Py_LIMITED_API # define Py_CPYTHON_DESCROBJECT_H # include "cpython/descrobject.h" # undef Py_CPYTHON_DESCROBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_DESCROBJECT_H */	1.23 KB	2025-10-09 16:16
📄 dictobject.h #ifndef Py_DICTOBJECT_H #define Py_DICTOBJECT_H #ifdef __cplusplus extern "C" { #endif /* Dictionary object type -- mapping from hashable object to object / / The distribution includes a separate file, Objects/dictnotes.txt, describing explorations into dictionary design and optimization. It covers typical dictionary use patterns, the parameters for tuning dictionaries, and several ideas for possible optimizations. / PyAPI_DATA(PyTypeObject) PyDict_Type; #define PyDict_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS) #define PyDict_CheckExact(op) Py_IS_TYPE(op, &PyDict_Type) PyAPI_FUNC(PyObject ) PyDict_New(void); PyAPI_FUNC(PyObject ) PyDict_GetItem(PyObject mp, PyObject key); PyAPI_FUNC(PyObject ) PyDict_GetItemWithError(PyObject mp, PyObject key); PyAPI_FUNC(int) PyDict_SetItem(PyObject mp, PyObject key, PyObject item); PyAPI_FUNC(int) PyDict_DelItem(PyObject mp, PyObject key); PyAPI_FUNC(void) PyDict_Clear(PyObject mp); PyAPI_FUNC(int) PyDict_Next( PyObject mp, Py_ssize_t pos, PyObject key, PyObject value); PyAPI_FUNC(PyObject ) PyDict_Keys(PyObject mp); PyAPI_FUNC(PyObject ) PyDict_Values(PyObject mp); PyAPI_FUNC(PyObject ) PyDict_Items(PyObject mp); PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject mp); PyAPI_FUNC(PyObject ) PyDict_Copy(PyObject mp); PyAPI_FUNC(int) PyDict_Contains(PyObject mp, PyObject key); / PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). / PyAPI_FUNC(int) PyDict_Update(PyObject mp, PyObject other); / PyDict_Merge updates/merges from a mapping object (an object that supports PyMapping_Keys() and PyObject_GetItem()). If override is true, the last occurrence of a key wins, else the first. The Python dict.update(other) is equivalent to PyDict_Merge(dict, other, 1). / PyAPI_FUNC(int) PyDict_Merge(PyObject mp, PyObject other, int override); / PyDict_MergeFromSeq2 updates/merges from an iterable object producing iterable objects of length 2. If override is true, the last occurrence of a key wins, else the first. The Python dict constructor dict(seq2) is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1). / PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject d, PyObject seq2, int override); PyAPI_FUNC(PyObject ) PyDict_GetItemString(PyObject dp, const char key); PyAPI_FUNC(int) PyDict_SetItemString(PyObject dp, const char key, PyObject item); PyAPI_FUNC(int) PyDict_DelItemString(PyObject dp, const char key); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030A0000 PyAPI_FUNC(PyObject ) PyObject_GenericGetDict(PyObject , void ); #endif /* Dictionary (keys, values, items) views / PyAPI_DATA(PyTypeObject) PyDictKeys_Type; PyAPI_DATA(PyTypeObject) PyDictValues_Type; PyAPI_DATA(PyTypeObject) PyDictItems_Type; #define PyDictKeys_Check(op) PyObject_TypeCheck(op, &PyDictKeys_Type) #define PyDictValues_Check(op) PyObject_TypeCheck(op, &PyDictValues_Type) #define PyDictItems_Check(op) PyObject_TypeCheck(op, &PyDictItems_Type) / This excludes Values, since they are not sets. / # define PyDictViewSet_Check(op) \ (PyDictKeys_Check(op) \|\| PyDictItems_Check(op)) / Dictionary (key, value, items) iterators / PyAPI_DATA(PyTypeObject) PyDictIterKey_Type; PyAPI_DATA(PyTypeObject) PyDictIterValue_Type; PyAPI_DATA(PyTypeObject) PyDictIterItem_Type; PyAPI_DATA(PyTypeObject) PyDictRevIterKey_Type; PyAPI_DATA(PyTypeObject) PyDictRevIterItem_Type; PyAPI_DATA(PyTypeObject) PyDictRevIterValue_Type; #ifndef Py_LIMITED_API # define Py_CPYTHON_DICTOBJECT_H # include "cpython/dictobject.h" # undef Py_CPYTHON_DICTOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_DICTOBJECT_H */	3.76 KB	2025-10-09 16:16
📄 dynamic_annotations.h /* Copyright (c) 2008-2009, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Neither the name of Google Inc. nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * --- * Author: Kostya Serebryany * Copied to CPython by Jeffrey Yasskin, with all macros renamed to * start with _Py_ to avoid colliding with users embedding Python, and * with deprecated macros removed. / / This file defines dynamic annotations for use with dynamic analysis tool such as valgrind, PIN, etc. Dynamic annotation is a source code annotation that affects the generated code (that is, the annotation is not a comment). Each such annotation is attached to a particular instruction and/or to a particular object (address) in the program. The annotations that should be used by users are macros in all upper-case (e.g., _Py_ANNOTATE_NEW_MEMORY). Actual implementation of these macros may differ depending on the dynamic analysis tool being used. See https://code.google.com/p/data-race-test/ for more information. This file supports the following dynamic analysis tools: - None (DYNAMIC_ANNOTATIONS_ENABLED is not defined or zero). Macros are defined empty. - ThreadSanitizer, Helgrind, DRD (DYNAMIC_ANNOTATIONS_ENABLED is 1). Macros are defined as calls to non-inlinable empty functions that are intercepted by Valgrind. / #ifndef __DYNAMIC_ANNOTATIONS_H__ #define __DYNAMIC_ANNOTATIONS_H__ #ifndef DYNAMIC_ANNOTATIONS_ENABLED # define DYNAMIC_ANNOTATIONS_ENABLED 0 #endif #if DYNAMIC_ANNOTATIONS_ENABLED != 0 / ------------------------------------------------------------- Annotations useful when implementing condition variables such as CondVar, using conditional critical sections (Await/LockWhen) and when constructing user-defined synchronization mechanisms. The annotations _Py_ANNOTATE_HAPPENS_BEFORE() and _Py_ANNOTATE_HAPPENS_AFTER() can be used to define happens-before arcs in user-defined synchronization mechanisms: the race detector will infer an arc from the former to the latter when they share the same argument pointer. Example 1 (reference counting): void Unref() { _Py_ANNOTATE_HAPPENS_BEFORE(&refcount_); if (AtomicDecrementByOne(&refcount_) == 0) { _Py_ANNOTATE_HAPPENS_AFTER(&refcount_); delete this; } } Example 2 (message queue): void MyQueue::Put(Type e) { MutexLock lock(&mu_); _Py_ANNOTATE_HAPPENS_BEFORE(e); PutElementIntoMyQueue(e); } Type 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) / Report that wait on the condition variable at "cv" has succeeded. Variant w/o lock. / #define _Py_ANNOTATE_CONDVAR_WAIT(cv) \ AnnotateCondVarWait(__FILE__, __LINE__, cv, NULL) / Report that we are about to signal on the condition variable at address "cv". / #define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) \ AnnotateCondVarSignal(__FILE__, __LINE__, cv) / Report that we are about to signal_all on the condition variable at "cv". / #define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) \ AnnotateCondVarSignalAll(__FILE__, __LINE__, cv) / Annotations for user-defined synchronization mechanisms. / #define _Py_ANNOTATE_HAPPENS_BEFORE(obj) _Py_ANNOTATE_CONDVAR_SIGNAL(obj) #define _Py_ANNOTATE_HAPPENS_AFTER(obj) _Py_ANNOTATE_CONDVAR_WAIT(obj) / Report that the bytes in the range [pointer, pointer+size) are about to be published safely. The race checker will create a happens-before arc from the call _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) to subsequent accesses to this memory. Note: this annotation may not work properly if the race detector uses sampling, i.e. does not observe all memory accesses. / #define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) \ AnnotatePublishMemoryRange(__FILE__, __LINE__, pointer, size) / Instruct the tool to create a happens-before arc between mu->Unlock() and mu->Lock(). This annotation may slow down the race detector and hide real races. Normally it is used only when it would be difficult to annotate each of the mutex's critical sections individually using the annotations above. This annotation makes sense only for hybrid race detectors. For pure happens-before detectors this is a no-op. For more details see https://code.google.com/p/data-race-test/wiki/PureHappensBeforeVsHybrid . / #define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) \ AnnotateMutexIsUsedAsCondVar(__FILE__, __LINE__, mu) / ------------------------------------------------------------- Annotations useful when defining memory allocators, or when memory that was protected in one way starts to be protected in another. / / Report that a new memory at "address" of size "size" has been allocated. This might be used when the memory has been retrieved from a free list and is about to be reused, or when the locking discipline for a variable changes. / #define _Py_ANNOTATE_NEW_MEMORY(address, size) \ AnnotateNewMemory(__FILE__, __LINE__, address, size) / ------------------------------------------------------------- Annotations useful when defining FIFO queues that transfer data between threads. / / Report that the producer-consumer queue (such as ProducerConsumerQueue) at address "pcq" has been created. The _Py_ANNOTATE_PCQ_* annotations should be used only for FIFO queues. For non-FIFO queues use _Py_ANNOTATE_HAPPENS_BEFORE (for put) and _Py_ANNOTATE_HAPPENS_AFTER (for get). / #define _Py_ANNOTATE_PCQ_CREATE(pcq) \ AnnotatePCQCreate(__FILE__, __LINE__, pcq) / Report that the queue at address "pcq" is about to be destroyed. / #define _Py_ANNOTATE_PCQ_DESTROY(pcq) \ AnnotatePCQDestroy(__FILE__, __LINE__, pcq) / Report that we are about to put an element into a FIFO queue at address "pcq". / #define _Py_ANNOTATE_PCQ_PUT(pcq) \ AnnotatePCQPut(__FILE__, __LINE__, pcq) / Report that we've just got an element from a FIFO queue at address "pcq". / #define _Py_ANNOTATE_PCQ_GET(pcq) \ AnnotatePCQGet(__FILE__, __LINE__, pcq) / ------------------------------------------------------------- Annotations that suppress errors. It is usually better to express the program's synchronization using the other annotations, but these can be used when all else fails. / / Report that we may have a benign race at "pointer", with size "sizeof((pointer))". "pointer" must be a non-void pointer. Insert at the point where "pointer" has been allocated, preferably close to the point where the race happens. See also _Py_ANNOTATE_BENIGN_RACE_STATIC. / #define _Py_ANNOTATE_BENIGN_RACE(pointer, description) \ AnnotateBenignRaceSized(__FILE__, __LINE__, pointer, \ sizeof((pointer)), description) /* Same as _Py_ANNOTATE_BENIGN_RACE(address, description), but applies to the memory range [address, address+size). / #define _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. / #define _Py_ANNOTATE_IGNORE_READS_END() \ AnnotateIgnoreReadsEnd(__FILE__, __LINE__) / Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes. / #define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() \ AnnotateIgnoreWritesBegin(__FILE__, __LINE__) / Stop ignoring writes. / #define _Py_ANNOTATE_IGNORE_WRITES_END() \ AnnotateIgnoreWritesEnd(__FILE__, __LINE__) / Start ignoring all memory accesses (reads and writes). / #define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \ do {\ _Py_ANNOTATE_IGNORE_READS_BEGIN();\ _Py_ANNOTATE_IGNORE_WRITES_BEGIN();\ }while(0)\ / Stop ignoring all memory accesses. / #define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() \ do {\ _Py_ANNOTATE_IGNORE_WRITES_END();\ _Py_ANNOTATE_IGNORE_READS_END();\ }while(0)\ / Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore synchronization events: RWLOCK* and CONDVAR. / #define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() \ AnnotateIgnoreSyncBegin(__FILE__, __LINE__) /* Stop ignoring sync events. / #define _Py_ANNOTATE_IGNORE_SYNC_END() \ AnnotateIgnoreSyncEnd(__FILE__, __LINE__) / Enable (enable!=0) or disable (enable==0) race detection for all threads. This annotation could be useful if you want to skip expensive race analysis during some period of program execution, e.g. during initialization. / #define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) \ AnnotateEnableRaceDetection(__FILE__, __LINE__, enable) / ------------------------------------------------------------- Annotations useful for debugging. / / Request to trace every access to "address". / #define _Py_ANNOTATE_TRACE_MEMORY(address) \ AnnotateTraceMemory(__FILE__, __LINE__, address) / Report the current thread name to a race detector. / #define _Py_ANNOTATE_THREAD_NAME(name) \ AnnotateThreadName(__FILE__, __LINE__, name) / ------------------------------------------------------------- Annotations useful when implementing locks. They are not normally needed by modules that merely use locks. The "lock" argument is a pointer to the lock object. / / Report that a lock has been created at address "lock". / #define _Py_ANNOTATE_RWLOCK_CREATE(lock) \ AnnotateRWLockCreate(__FILE__, __LINE__, lock) / Report that the lock at address "lock" is about to be destroyed. / #define _Py_ANNOTATE_RWLOCK_DESTROY(lock) \ AnnotateRWLockDestroy(__FILE__, __LINE__, lock) / Report that the lock at address "lock" has been acquired. is_w=1 for writer lock, is_w=0 for reader lock. / #define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \ AnnotateRWLockAcquired(__FILE__, __LINE__, lock, is_w) / Report that the lock at address "lock" is about to be released. / #define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) \ AnnotateRWLockReleased(__FILE__, __LINE__, lock, is_w) / ------------------------------------------------------------- Annotations useful when implementing barriers. They are not normally needed by modules that merely use barriers. The "barrier" argument is a pointer to the barrier object. / / Report that the "barrier" has been initialized with initial "count". If 'reinitialization_allowed' is true, initialization is allowed to happen multiple times w/o calling barrier_destroy() / #define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \ AnnotateBarrierInit(__FILE__, __LINE__, barrier, count, \ reinitialization_allowed) / Report that we are about to enter barrier_wait("barrier"). / #define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \ AnnotateBarrierWaitBefore(__FILE__, __LINE__, barrier) / Report that we just exited barrier_wait("barrier"). / #define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) \ AnnotateBarrierWaitAfter(__FILE__, __LINE__, barrier) / Report that the "barrier" has been destroyed. / #define _Py_ANNOTATE_BARRIER_DESTROY(barrier) \ AnnotateBarrierDestroy(__FILE__, __LINE__, barrier) / ------------------------------------------------------------- Annotations useful for testing race detectors. / / Report that we expect a race on the variable at "address". Use only in unit tests for a race detector. / #define _Py_ANNOTATE_EXPECT_RACE(address, description) \ AnnotateExpectRace(__FILE__, __LINE__, address, description) / A no-op. Insert where you like to test the interceptors. / #define _Py_ANNOTATE_NO_OP(arg) \ AnnotateNoOp(__FILE__, __LINE__, arg) / Force the race detector to flush its state. The actual effect depends on * the implementation of the detector. / #define _Py_ANNOTATE_FLUSH_STATE() \ AnnotateFlushState(__FILE__, __LINE__) #else / DYNAMIC_ANNOTATIONS_ENABLED == 0 / #define _Py_ANNOTATE_RWLOCK_CREATE(lock) / empty / #define _Py_ANNOTATE_RWLOCK_DESTROY(lock) / empty / #define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) / empty / #define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) / empty / #define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) / / #define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) / empty / #define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) / empty / #define _Py_ANNOTATE_BARRIER_DESTROY(barrier) / empty / #define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) / empty / #define _Py_ANNOTATE_CONDVAR_WAIT(cv) / empty / #define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) / empty / #define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) / empty / #define _Py_ANNOTATE_HAPPENS_BEFORE(obj) / empty / #define _Py_ANNOTATE_HAPPENS_AFTER(obj) / empty / #define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(address, size) / empty / #define _Py_ANNOTATE_UNPUBLISH_MEMORY_RANGE(address, size) / empty / #define _Py_ANNOTATE_SWAP_MEMORY_RANGE(address, size) / empty / #define _Py_ANNOTATE_PCQ_CREATE(pcq) / empty / #define _Py_ANNOTATE_PCQ_DESTROY(pcq) / empty / #define _Py_ANNOTATE_PCQ_PUT(pcq) / empty / #define _Py_ANNOTATE_PCQ_GET(pcq) / empty / #define _Py_ANNOTATE_NEW_MEMORY(address, size) / empty / #define _Py_ANNOTATE_EXPECT_RACE(address, description) / empty / #define _Py_ANNOTATE_BENIGN_RACE(address, description) / empty / #define _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) / empty / #define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) / empty / #define _Py_ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) / empty / #define _Py_ANNOTATE_TRACE_MEMORY(arg) / empty / #define _Py_ANNOTATE_THREAD_NAME(name) / empty / #define _Py_ANNOTATE_IGNORE_READS_BEGIN() / empty / #define _Py_ANNOTATE_IGNORE_READS_END() / empty / #define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() / empty / #define _Py_ANNOTATE_IGNORE_WRITES_END() / empty / #define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() / empty / #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, const volatile void lock); void AnnotateRWLockDestroy(const char file, int line, const volatile void lock); void AnnotateRWLockAcquired(const char file, int line, const volatile void lock, long is_w); void AnnotateRWLockReleased(const char file, int line, const volatile void lock, long is_w); void AnnotateBarrierInit(const char file, int line, const volatile void barrier, long count, long reinitialization_allowed); void AnnotateBarrierWaitBefore(const char file, int line, const volatile void barrier); void AnnotateBarrierWaitAfter(const char file, int line, const volatile void barrier); void AnnotateBarrierDestroy(const char file, int line, const volatile void barrier); void AnnotateCondVarWait(const char file, int line, const volatile void cv, const volatile void lock); void AnnotateCondVarSignal(const char file, int line, const volatile void cv); void AnnotateCondVarSignalAll(const char file, int line, const volatile void cv); void AnnotatePublishMemoryRange(const char file, int line, const volatile void address, long size); void AnnotateUnpublishMemoryRange(const char file, int line, const volatile void address, long size); void AnnotatePCQCreate(const char file, int line, const volatile void pcq); void AnnotatePCQDestroy(const char file, int line, const volatile void pcq); void AnnotatePCQPut(const char file, int line, const volatile void pcq); void AnnotatePCQGet(const char file, int line, const volatile void pcq); void AnnotateNewMemory(const char file, int line, const volatile void address, long size); void AnnotateExpectRace(const char file, int line, const volatile void address, const char description); void AnnotateBenignRace(const char file, int line, const volatile void address, const char description); void AnnotateBenignRaceSized(const char file, int line, const volatile void address, long size, const char description); void AnnotateMutexIsUsedAsCondVar(const char file, int line, const volatile void mu); void AnnotateTraceMemory(const char file, int line, const volatile void arg); void AnnotateThreadName(const char file, int line, const char name); void AnnotateIgnoreReadsBegin(const char file, int line); void AnnotateIgnoreReadsEnd(const char file, int line); void AnnotateIgnoreWritesBegin(const char file, int line); void AnnotateIgnoreWritesEnd(const char file, int line); void AnnotateEnableRaceDetection(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 doing svn co svn://svn.valgrind.org/valgrind/trunk/include If for some reason you can't use "valgrind.h" or want to fake valgrind, there are two ways to make this function return non-zero: - Use environment variable: export RUNNING_ON_VALGRIND=1 - Make your tool intercept the function RunningOnValgrind() and change its return value. / int RunningOnValgrind(void); #ifdef __cplusplus } #endif #if DYNAMIC_ANNOTATIONS_ENABLED != 0 && defined(__cplusplus) / _Py_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads. Instead of doing _Py_ANNOTATE_IGNORE_READS_BEGIN(); ... = x; _Py_ANNOTATE_IGNORE_READS_END(); one can use ... = _Py_ANNOTATE_UNPROTECTED_READ(x); / template <class T> inline T _Py_ANNOTATE_UNPROTECTED_READ(const volatile T &x) { _Py_ANNOTATE_IGNORE_READS_BEGIN(); T res = x; _Py_ANNOTATE_IGNORE_READS_END(); return res; } / Apply _Py_ANNOTATE_BENIGN_RACE_SIZED to a static variable. / #define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description) \ namespace { \ class static_var ## _annotator { \ public: \ static_var ## _annotator() { \ _Py_ANNOTATE_BENIGN_RACE_SIZED(&static_var, \ sizeof(static_var), \ # static_var ": " description); \ } \ }; \ static static_var ## _annotator the ## static_var ## _annotator;\ } #else / DYNAMIC_ANNOTATIONS_ENABLED == 0 / #define _Py_ANNOTATE_UNPROTECTED_READ(x) (x) #define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description) / empty / #endif / DYNAMIC_ANNOTATIONS_ENABLED / #endif / __DYNAMIC_ANNOTATIONS_H__ */	21.94 KB	2025-10-09 16:16
📄 enumobject.h #ifndef Py_ENUMOBJECT_H #define Py_ENUMOBJECT_H /* Enumerate Object / #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyEnum_Type; PyAPI_DATA(PyTypeObject) PyReversed_Type; #ifdef __cplusplus } #endif #endif / !Py_ENUMOBJECT_H */	253 B	2025-10-09 16:16
📄 errcode.h #ifndef Py_ERRCODE_H #define Py_ERRCODE_H #ifdef __cplusplus extern "C" { #endif /* Error codes passed around between file input, tokenizer, parser and interpreter. This is necessary so we can turn them into Python exceptions at a higher level. Note that some errors have a slightly different meaning when passed from the tokenizer to the parser than when passed from the parser to the interpreter; e.g. the parser only returns E_EOF when it hits EOF immediately, and it never returns E_OK. / #define E_OK 10 / No error / #define E_EOF 11 / End Of File / #define E_INTR 12 / Interrupted / #define E_TOKEN 13 / Bad token / #define E_SYNTAX 14 / Syntax error / #define E_NOMEM 15 / Ran out of memory / #define E_DONE 16 / Parsing complete / #define E_ERROR 17 / Execution error / #define E_TABSPACE 18 / Inconsistent mixing of tabs and spaces / #define E_OVERFLOW 19 / Node had too many children / #define E_TOODEEP 20 / Too many indentation levels / #define E_DEDENT 21 / No matching outer block for dedent / #define E_DECODE 22 / Error in decoding into Unicode / #define E_EOFS 23 / EOF in triple-quoted string / #define E_EOLS 24 / EOL in single-quoted string / #define E_LINECONT 25 / Unexpected characters after a line continuation / #define E_BADSINGLE 27 / Ill-formed single statement input / #define E_INTERACT_STOP 28 / Interactive mode stopped tokenization / #define E_COLUMNOVERFLOW 29 / Column offset overflow / #ifdef __cplusplus } #endif #endif / !Py_ERRCODE_H */	1.74 KB	2025-10-09 16:16
📄 exports.h #ifndef Py_EXPORTS_H #define Py_EXPORTS_H #if defined(_WIN32) \|\| defined(__CYGWIN__) #define Py_IMPORTED_SYMBOL __declspec(dllimport) #define Py_EXPORTED_SYMBOL __declspec(dllexport) #define Py_LOCAL_SYMBOL #else /* * If we only ever used gcc >= 5, we could use __has_attribute(visibility) * as a cross-platform way to determine if visibility is supported. However, * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions * have 4 < gcc < 5. / #ifndef __has_attribute #define __has_attribute(x) 0 // Compatibility with non-clang compilers. #endif #if (defined(__GNUC__) && (__GNUC__ >= 4)) \|\|\ (defined(__clang__) && __has_attribute(visibility)) #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default"))) #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default"))) #define Py_LOCAL_SYMBOL __attribute__ ((visibility ("hidden"))) #else #define Py_IMPORTED_SYMBOL #define Py_EXPORTED_SYMBOL #define Py_LOCAL_SYMBOL #endif #endif #endif / Py_EXPORTS_H */	1.07 KB	2025-10-09 16:16
📄 fileobject.h /* File object interface (what's left of it -- see io.py) / #ifndef Py_FILEOBJECT_H #define Py_FILEOBJECT_H #ifdef __cplusplus extern "C" { #endif #define PY_STDIOTEXTMODE "b" PyAPI_FUNC(PyObject ) PyFile_FromFd(int, const char , const char , int, const char , const char , const char , int); PyAPI_FUNC(PyObject ) PyFile_GetLine(PyObject , int); PyAPI_FUNC(int) PyFile_WriteObject(PyObject , PyObject , int); PyAPI_FUNC(int) PyFile_WriteString(const char , PyObject ); PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject ); /* The default encoding used by the platform file system APIs If non-NULL, this is different than the default encoding for strings / PyAPI_DATA(const char ) Py_FileSystemDefaultEncoding; #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03060000 PyAPI_DATA(const char ) Py_FileSystemDefaultEncodeErrors; #endif PyAPI_DATA(int) Py_HasFileSystemDefaultEncoding; #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03070000 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 int)(FD) < (unsigned int)FD_SETSIZE) #endif #ifndef Py_LIMITED_API # define Py_CPYTHON_FILEOBJECT_H # include "cpython/fileobject.h" # undef Py_CPYTHON_FILEOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_FILEOBJECT_H */	1.53 KB	2025-10-09 16:16
📄 fileutils.h #ifndef Py_FILEUTILS_H #define Py_FILEUTILS_H #ifdef __cplusplus extern "C" { #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 PyAPI_FUNC(wchar_t ) Py_DecodeLocale( const char arg, size_t size); PyAPI_FUNC(char) Py_EncodeLocale( const wchar_t text, size_t error_pos); #endif #ifndef Py_LIMITED_API # define Py_CPYTHON_FILEUTILS_H # include "cpython/fileutils.h" # undef Py_CPYTHON_FILEUTILS_H #endif #ifdef __cplusplus } #endif #endif /* !Py_FILEUTILS_H */	507 B	2025-10-09 16:16
📄 floatobject.h /* Float object interface / / PyFloatObject represents a (double precision) floating point number. / #ifndef Py_FLOATOBJECT_H #define Py_FLOATOBJECT_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyFloat_Type; #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type) #define PyFloat_CheckExact(op) Py_IS_TYPE(op, &PyFloat_Type) #define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN) #define Py_RETURN_INF(sign) \ do { \ if (copysign(1., sign) == 1.) { \ return PyFloat_FromDouble(Py_HUGE_VAL); \ } \ else { \ return PyFloat_FromDouble(-Py_HUGE_VAL); \ } \ } while(0) PyAPI_FUNC(double) PyFloat_GetMax(void); PyAPI_FUNC(double) PyFloat_GetMin(void); PyAPI_FUNC(PyObject) PyFloat_GetInfo(void); /* Return Python float from string PyObject. / PyAPI_FUNC(PyObject) PyFloat_FromString(PyObject); / Return Python float from C double. / PyAPI_FUNC(PyObject) PyFloat_FromDouble(double); /* Extract C double from Python float. The macro version trades safety for speed. / PyAPI_FUNC(double) PyFloat_AsDouble(PyObject); #ifndef Py_LIMITED_API # define Py_CPYTHON_FLOATOBJECT_H # include "cpython/floatobject.h" # undef Py_CPYTHON_FLOATOBJECT_H #endif #ifdef __cplusplus } #endif #endif /* !Py_FLOATOBJECT_H */	1.49 KB	2025-10-09 16:16
📄 frameobject.h /* Frame object interface / #ifndef Py_FRAMEOBJECT_H #define Py_FRAMEOBJECT_H #ifdef __cplusplus extern "C" { #endif #include "pyframe.h" #ifndef Py_LIMITED_API # define Py_CPYTHON_FRAMEOBJECT_H # include "cpython/frameobject.h" # undef Py_CPYTHON_FRAMEOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_FRAMEOBJECT_H */	336 B	2025-10-09 16:16
📄 genericaliasobject.h // Implementation of PEP 585: support list[int] etc. #ifndef Py_GENERICALIASOBJECT_H #define Py_GENERICALIASOBJECT_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(PyObject ) Py_GenericAlias(PyObject , PyObject ); PyAPI_DATA(PyTypeObject) Py_GenericAliasType; #ifdef __cplusplus } #endif #endif / !Py_GENERICALIASOBJECT_H */	334 B	2025-10-09 16:16
📄 import.h /* Module definition and import interface / #ifndef Py_IMPORT_H #define Py_IMPORT_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(long) PyImport_GetMagicNumber(void); PyAPI_FUNC(const char ) PyImport_GetMagicTag(void); PyAPI_FUNC(PyObject ) PyImport_ExecCodeModule( const char name, /* UTF-8 encoded string / PyObject co ); PyAPI_FUNC(PyObject ) PyImport_ExecCodeModuleEx( const char name, /* UTF-8 encoded string / PyObject co, const char pathname / decoded from the filesystem encoding / ); PyAPI_FUNC(PyObject ) PyImport_ExecCodeModuleWithPathnames( const char name, / UTF-8 encoded string / PyObject co, const char pathname, / decoded from the filesystem encoding / const char cpathname /* decoded from the filesystem encoding / ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject ) PyImport_ExecCodeModuleObject( PyObject name, PyObject co, PyObject pathname, PyObject cpathname ); #endif PyAPI_FUNC(PyObject ) PyImport_GetModuleDict(void); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03070000 PyAPI_FUNC(PyObject ) PyImport_GetModule(PyObject name); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject ) PyImport_AddModuleObject( PyObject name ); #endif PyAPI_FUNC(PyObject ) PyImport_AddModule( const char name / UTF-8 encoded string / ); PyAPI_FUNC(PyObject ) PyImport_ImportModule( const char name / UTF-8 encoded string / ); PyAPI_FUNC(PyObject ) PyImport_ImportModuleNoBlock( const char name / UTF-8 encoded string / ); PyAPI_FUNC(PyObject ) PyImport_ImportModuleLevel( const char name, / UTF-8 encoded string / PyObject globals, PyObject locals, PyObject fromlist, int level ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 PyAPI_FUNC(PyObject ) PyImport_ImportModuleLevelObject( PyObject name, PyObject globals, PyObject locals, PyObject fromlist, int level ); #endif #define PyImport_ImportModuleEx(n, g, l, f) \ PyImport_ImportModuleLevel(n, g, l, f, 0) PyAPI_FUNC(PyObject ) PyImport_GetImporter(PyObject path); PyAPI_FUNC(PyObject ) PyImport_Import(PyObject name); PyAPI_FUNC(PyObject ) PyImport_ReloadModule(PyObject m); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(int) PyImport_ImportFrozenModuleObject( PyObject name ); #endif PyAPI_FUNC(int) PyImport_ImportFrozenModule( const char name / UTF-8 encoded string / ); PyAPI_FUNC(int) PyImport_AppendInittab( const char name, /* ASCII encoded string / PyObject (initfunc)(void) ); #ifndef Py_LIMITED_API # define Py_CPYTHON_IMPORT_H # include "cpython/import.h" # undef Py_CPYTHON_IMPORT_H #endif #ifdef __cplusplus } #endif #endif / !Py_IMPORT_H */	2.95 KB	2025-10-09 16:16
📁 internal	-	2026-03-21 15:51
📄 intrcheck.h #ifndef Py_INTRCHECK_H #define Py_INTRCHECK_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(int) PyOS_InterruptOccurred(void); #ifdef HAVE_FORK #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03070000 PyAPI_FUNC(void) PyOS_BeforeFork(void); PyAPI_FUNC(void) 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 */	772 B	2025-10-09 16:16
📄 iterobject.h #ifndef Py_ITEROBJECT_H #define Py_ITEROBJECT_H /* Iterators (the basic kind, over a sequence) / #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PySeqIter_Type; PyAPI_DATA(PyTypeObject) PyCallIter_Type; #ifdef Py_BUILD_CORE extern PyTypeObject _PyAnextAwaitable_Type; #endif #define PySeqIter_Check(op) Py_IS_TYPE(op, &PySeqIter_Type) PyAPI_FUNC(PyObject ) PySeqIter_New(PyObject ); #define PyCallIter_Check(op) Py_IS_TYPE(op, &PyCallIter_Type) PyAPI_FUNC(PyObject ) PyCallIter_New(PyObject , PyObject ); #ifdef __cplusplus } #endif #endif /* !Py_ITEROBJECT_H */	593 B	2025-10-09 16:16
📄 listobject.h /* List object interface Another generally useful object type is a list of object pointers. This is a mutable type: the list items can be changed, and items can be added or removed. Out-of-range indices or non-list objects are ignored. WARNING: PyList_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 list. Similarly, PyList_GetItem does not increment the returned item's reference count. / #ifndef Py_LISTOBJECT_H #define Py_LISTOBJECT_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyList_Type; PyAPI_DATA(PyTypeObject) PyListIter_Type; PyAPI_DATA(PyTypeObject) PyListRevIter_Type; #define PyList_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS) #define PyList_CheckExact(op) Py_IS_TYPE(op, &PyList_Type) PyAPI_FUNC(PyObject ) PyList_New(Py_ssize_t size); PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject ); PyAPI_FUNC(PyObject ) PyList_GetItem(PyObject , Py_ssize_t); PyAPI_FUNC(int) PyList_SetItem(PyObject , Py_ssize_t, PyObject ); PyAPI_FUNC(int) PyList_Insert(PyObject , Py_ssize_t, PyObject ); PyAPI_FUNC(int) PyList_Append(PyObject , PyObject ); PyAPI_FUNC(PyObject ) PyList_GetSlice(PyObject , Py_ssize_t, Py_ssize_t); PyAPI_FUNC(int) PyList_SetSlice(PyObject , Py_ssize_t, Py_ssize_t, PyObject ); PyAPI_FUNC(int) PyList_Sort(PyObject ); PyAPI_FUNC(int) PyList_Reverse(PyObject ); PyAPI_FUNC(PyObject ) PyList_AsTuple(PyObject ); #ifndef Py_LIMITED_API # define Py_CPYTHON_LISTOBJECT_H # include "cpython/listobject.h" # undef Py_CPYTHON_LISTOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_LISTOBJECT_H */	1.74 KB	2025-10-09 16:16
📄 longobject.h #ifndef Py_LONGOBJECT_H #define Py_LONGOBJECT_H #ifdef __cplusplus extern "C" { #endif /* Long (arbitrary precision) integer object interface / PyAPI_DATA(PyTypeObject) PyLong_Type; #define PyLong_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS) #define PyLong_CheckExact(op) Py_IS_TYPE(op, &PyLong_Type) PyAPI_FUNC(PyObject ) PyLong_FromLong(long); PyAPI_FUNC(PyObject ) PyLong_FromUnsignedLong(unsigned long); PyAPI_FUNC(PyObject ) PyLong_FromSize_t(size_t); PyAPI_FUNC(PyObject ) PyLong_FromSsize_t(Py_ssize_t); PyAPI_FUNC(PyObject ) PyLong_FromDouble(double); PyAPI_FUNC(long) PyLong_AsLong(PyObject ); PyAPI_FUNC(long) PyLong_AsLongAndOverflow(PyObject , int ); PyAPI_FUNC(Py_ssize_t) PyLong_AsSsize_t(PyObject ); PyAPI_FUNC(size_t) PyLong_AsSize_t(PyObject ); PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject ); PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject ); PyAPI_FUNC(PyObject ) PyLong_GetInfo(void); /* It may be useful in the future. I've added it in the PyInt -> PyLong cleanup to keep the extra information. [CH] / #define PyLong_AS_LONG(op) PyLong_AsLong(op) / Issue #1983: pid_t can be longer than a C long on some systems / #if !defined(SIZEOF_PID_T) \|\| SIZEOF_PID_T == SIZEOF_INT #define _Py_PARSE_PID "i" #define PyLong_FromPid PyLong_FromLong # ifndef Py_LIMITED_API # define PyLong_AsPid _PyLong_AsInt # elif SIZEOF_INT == SIZEOF_LONG # define PyLong_AsPid PyLong_AsLong # else static inline int PyLong_AsPid(PyObject obj) { int overflow; long result = PyLong_AsLongAndOverflow(obj, &overflow); if (overflow \|\| result > INT_MAX \|\| result < INT_MIN) { PyErr_SetString(PyExc_OverflowError, "Python int too large to convert to C int"); return -1; } return (int)result; } # endif #elif SIZEOF_PID_T == SIZEOF_LONG #define _Py_PARSE_PID "l" #define PyLong_FromPid PyLong_FromLong #define PyLong_AsPid PyLong_AsLong #elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG #define _Py_PARSE_PID "L" #define PyLong_FromPid PyLong_FromLongLong #define PyLong_AsPid PyLong_AsLongLong #else #error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)" #endif /* SIZEOF_PID_T / #if SIZEOF_VOID_P == SIZEOF_INT # define _Py_PARSE_INTPTR "i" # define _Py_PARSE_UINTPTR "I" #elif SIZEOF_VOID_P == SIZEOF_LONG # define _Py_PARSE_INTPTR "l" # define _Py_PARSE_UINTPTR "k" #elif defined(SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG # define _Py_PARSE_INTPTR "L" # define _Py_PARSE_UINTPTR "K" #else # error "void different in size from int, long and long long" #endif /* SIZEOF_VOID_P / PyAPI_FUNC(double) PyLong_AsDouble(PyObject ); PyAPI_FUNC(PyObject ) PyLong_FromVoidPtr(void ); PyAPI_FUNC(void ) PyLong_AsVoidPtr(PyObject ); PyAPI_FUNC(PyObject ) PyLong_FromLongLong(long long); PyAPI_FUNC(PyObject ) PyLong_FromUnsignedLongLong(unsigned long long); PyAPI_FUNC(long long) PyLong_AsLongLong(PyObject ); PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLong(PyObject ); PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLongMask(PyObject ); PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject , int ); PyAPI_FUNC(PyObject ) PyLong_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.h" # undef Py_CPYTHON_LONGOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_LONGOBJECT_H */	3.65 KB	2025-10-09 16:16
📄 marshal.h /* Interface for marshal.c / #ifndef Py_MARSHAL_H #define Py_MARSHAL_H #ifndef Py_LIMITED_API #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(PyObject ) PyMarshal_ReadObjectFromString(const char , Py_ssize_t); PyAPI_FUNC(PyObject ) PyMarshal_WriteObjectToString(PyObject , int); #define Py_MARSHAL_VERSION 4 PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE ); PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE ); PyAPI_FUNC(PyObject ) PyMarshal_ReadObjectFromFile(FILE ); PyAPI_FUNC(PyObject ) PyMarshal_ReadLastObjectFromFile(FILE ); PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE , int); PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject , FILE , int); #ifdef __cplusplus } #endif #endif /* Py_LIMITED_API / #endif / !Py_MARSHAL_H */	827 B	2025-10-09 16:16
📄 memoryobject.h /* Memory view object. In Python this is available as "memoryview". / #ifndef Py_MEMORYOBJECT_H #define Py_MEMORYOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_LIMITED_API PyAPI_DATA(PyTypeObject) _PyManagedBuffer_Type; #endif PyAPI_DATA(PyTypeObject) PyMemoryView_Type; #define PyMemoryView_Check(op) Py_IS_TYPE(op, &PyMemoryView_Type) #ifndef Py_LIMITED_API / Get a pointer to the memoryview's private copy of the exporter's buffer. / #define PyMemoryView_GET_BUFFER(op) (&((PyMemoryViewObject )(op))->view) /* Get a pointer to the exporting object (this may be NULL!). / #define PyMemoryView_GET_BASE(op) (((PyMemoryViewObject )(op))->view.obj) #endif PyAPI_FUNC(PyObject ) PyMemoryView_FromObject(PyObject base); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject ) PyMemoryView_FromMemory(char mem, Py_ssize_t size, int flags); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030b0000 PyAPI_FUNC(PyObject ) PyMemoryView_FromBuffer(const Py_buffer info); #endif PyAPI_FUNC(PyObject ) PyMemoryView_GetContiguous(PyObject base, int buffertype, char order); /* The structs are declared here so that macros can work, but they shouldn't be considered public. Don't access their fields directly, use the macros and functions instead! / #ifndef Py_LIMITED_API #define _Py_MANAGED_BUFFER_RELEASED 0x001 / access to exporter blocked / #define _Py_MANAGED_BUFFER_FREE_FORMAT 0x002 / free format / typedef struct { PyObject_HEAD int flags; / state flags / Py_ssize_t exports; / number of direct memoryview exports / Py_buffer master; / snapshot buffer obtained from the original exporter / } _PyManagedBufferObject; / memoryview state flags / #define _Py_MEMORYVIEW_RELEASED 0x001 / access to master buffer blocked / #define _Py_MEMORYVIEW_C 0x002 / C-contiguous layout / #define _Py_MEMORYVIEW_FORTRAN 0x004 / Fortran contiguous layout / #define _Py_MEMORYVIEW_SCALAR 0x008 / scalar: ndim = 0 / #define _Py_MEMORYVIEW_PIL 0x010 / PIL-style layout / typedef struct { PyObject_VAR_HEAD _PyManagedBufferObject mbuf; /* managed buffer / Py_hash_t hash; / hash value for read-only views / 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; #endif #ifdef __cplusplus } #endif #endif / !Py_MEMORYOBJECT_H */	2.74 KB	2025-10-09 16:16
📄 methodobject.h /* Method object interface / #ifndef Py_METHODOBJECT_H #define Py_METHODOBJECT_H #ifdef __cplusplus extern "C" { #endif / This is about the type 'builtin_function_or_method', not Python methods in user-defined classes. See classobject.h for the latter. / PyAPI_DATA(PyTypeObject) PyCFunction_Type; #define PyCFunction_CheckExact(op) Py_IS_TYPE(op, &PyCFunction_Type) #define PyCFunction_Check(op) PyObject_TypeCheck(op, &PyCFunction_Type) typedef PyObject (PyCFunction)(PyObject , PyObject ); typedef PyObject (_PyCFunctionFast) (PyObject , PyObject const , Py_ssize_t); typedef PyObject (PyCFunctionWithKeywords)(PyObject , PyObject , PyObject ); typedef PyObject (_PyCFunctionFastWithKeywords) (PyObject , PyObject const , Py_ssize_t, PyObject ); typedef PyObject (PyCMethod)(PyObject , PyTypeObject , PyObject const , size_t, PyObject ); // Cast an function to the PyCFunction type to use it with PyMethodDef. // // This macro can be used to prevent compiler warnings if the first parameter // uses a different pointer type than PyObject* (ex: METH_VARARGS and METH_O // calling conventions). // // The macro can also be used for METH_FASTCALL and METH_VARARGS\|METH_KEYWORDS // calling conventions to avoid compiler warnings because the function has more // than 2 parameters. The macro first casts the function to the // "void func(void)" type to prevent compiler warnings. // // If a function is declared with the METH_NOARGS calling convention, it must // have 2 parameters. Since the second parameter is unused, Py_UNUSED() can be // used to prevent a compiler warning. If the function has a single parameter, // it triggers an undefined behavior when Python calls it with 2 parameters // (bpo-33012). #define _PyCFunction_CAST(func) \ _Py_CAST(PyCFunction, _Py_CAST(void()(void), (func))) PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject ); PyAPI_FUNC(PyObject ) PyCFunction_GetSelf(PyObject ); PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject ); Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject ) PyCFunction_Call(PyObject , PyObject , 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 redefined as a macro * that calls PyCFunction_NewEx. / PyAPI_FUNC(PyObject ) PyCFunction_New(PyMethodDef , PyObject ); #define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL) /* PyCFunction_NewEx is similar: on 3.9+, this calls PyCMethod_New. / PyAPI_FUNC(PyObject ) PyCFunction_NewEx(PyMethodDef , PyObject , PyObject ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03090000 #define PyCFunction_NewEx(ML, SELF, MOD) PyCMethod_New((ML), (SELF), (MOD), NULL) PyAPI_FUNC(PyObject ) PyCMethod_New(PyMethodDef , PyObject , PyObject , PyTypeObject ); #endif /* Flag passed to newmethodobject / / #define METH_OLDARGS 0x0000 -- unsupported now / #define METH_VARARGS 0x0001 #define METH_KEYWORDS 0x0002 / METH_NOARGS and METH_O must not be combined with the flags above. / #define METH_NOARGS 0x0004 #define METH_O 0x0008 / METH_CLASS and METH_STATIC are a little different; these control the construction of methods for a class. These cannot be used for functions in modules. / #define METH_CLASS 0x0010 #define METH_STATIC 0x0020 / METH_COEXIST allows a method to be entered even though a slot has already filled the entry. When defined, the flag allows a separate method, "__contains__" for example, to coexist with a defined slot like sq_contains. / #define METH_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_STATIC. / #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03090000 #define METH_METHOD 0x0200 #endif #ifndef Py_LIMITED_API # define Py_CPYTHON_METHODOBJECT_H # include "cpython/methodobject.h" # undef Py_CPYTHON_METHODOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_METHODOBJECT_H */	4.95 KB	2025-10-09 16:16
📄 modsupport.h #ifndef Py_MODSUPPORT_H #define Py_MODSUPPORT_H #ifdef __cplusplus extern "C" { #endif /* Module support interface / #include <stdarg.h> // va_list / If PY_SSIZE_T_CLEAN is defined, each functions treats #-specifier to mean Py_ssize_t / #ifdef PY_SSIZE_T_CLEAN #define PyArg_Parse _PyArg_Parse_SizeT #define PyArg_ParseTuple _PyArg_ParseTuple_SizeT #define PyArg_ParseTupleAndKeywords _PyArg_ParseTupleAndKeywords_SizeT #define PyArg_VaParse _PyArg_VaParse_SizeT #define PyArg_VaParseTupleAndKeywords _PyArg_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 , const char , char *, ...); PyAPI_FUNC(int) PyArg_VaParse(PyObject , const char , va_list); PyAPI_FUNC(int) PyArg_VaParseTupleAndKeywords(PyObject , PyObject , const char , char *, va_list); #endif PyAPI_FUNC(int) PyArg_ValidateKeywordArguments(PyObject ); PyAPI_FUNC(int) PyArg_UnpackTuple(PyObject , const char , Py_ssize_t, Py_ssize_t, ...); PyAPI_FUNC(PyObject ) Py_BuildValue(const char , ...); PyAPI_FUNC(PyObject ) _Py_BuildValue_SizeT(const char , ...); #define ANY_VARARGS(n) (n == PY_SSIZE_T_MAX) PyAPI_FUNC(PyObject ) Py_VaBuildValue(const char , va_list); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030a0000 // Add an attribute with name 'name' and value 'obj' to the module 'mod. // On success, return 0 on success. // On error, raise an exception and return -1. PyAPI_FUNC(int) PyModule_AddObjectRef(PyObject mod, const char name, PyObject value); #endif / Py_LIMITED_API / // Similar to PyModule_AddObjectRef() but steal a reference to 'obj' // (Py_DECREF(obj)) on success (if it returns 0). PyAPI_FUNC(int) PyModule_AddObject(PyObject mod, const char , PyObject value); PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject , const char , long); PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject , const char , const char ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03090000 / New in 3.9 / PyAPI_FUNC(int) PyModule_AddType(PyObject module, PyTypeObject type); #endif / Py_LIMITED_API / #define PyModule_AddIntMacro(m, c) PyModule_AddIntConstant(m, #c, c) #define PyModule_AddStringMacro(m, c) PyModule_AddStringConstant(m, #c, c) #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 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 message but the module is still loaded (because the mismatch can only be tested after loading the module). The error message is intended to explain the core dump a few seconds later. The symbol PYTHON_API_STRING defines the same value as a string literal. * PLEASE MAKE SURE THE DEFINITIONS MATCH. * Please add a line or two to the top of this log for each API version change: 22-Feb-2006 MvL 1013 PEP 353 - long indices for sequence lengths 19-Aug-2002 GvR 1012 Changes to string object struct for interning changes, saving 3 bytes. 17-Jul-2001 GvR 1011 Descr-branch, just to be on the safe side 25-Jan-2001 FLD 1010 Parameters added to PyCode_New() and PyFrame_New(); Python 2.1a2 14-Mar-2000 GvR 1009 Unicode API added 3-Jan-1999 GvR 1007 Decided to change back! (Don't reuse 1008!) 3-Dec-1998 GvR 1008 Python 1.5.2b1 18-Jan-1997 GvR 1007 string interning and other speedups 11-Oct-1996 GvR renamed Py_Ellipses to Py_Ellipsis :-( 30-Jul-1996 GvR Slice and ellipses syntax added 23-Jul-1996 GvR For 1.4 -- better safe than sorry this time :-) 7-Nov-1995 GvR Keyword arguments (should've been done at 1.3 :-( ) 10-Jan-1995 GvR Renamed globals to new naming scheme 9-Jan-1995 GvR Initial version (incompatible with older API) / / The PYTHON_ABI_VERSION is introduced in PEP 384. For the lifetime of Python 3, it will stay at the value of 3; changes to the limited API must be performed in a strictly backwards-compatible manner. / #define PYTHON_ABI_VERSION 3 #define PYTHON_ABI_STRING "3" #ifdef Py_TRACE_REFS / When we are tracing reference counts, rename module creation functions so modules compiled with incompatible settings will generate a link-time error. / #define PyModule_Create2 PyModule_Create2TraceRefs #define PyModule_FromDefAndSpec2 PyModule_FromDefAndSpec2TraceRefs #endif PyAPI_FUNC(PyObject ) PyModule_Create2(PyModuleDef, int apiver); #ifdef Py_LIMITED_API #define PyModule_Create(module) \ PyModule_Create2(module, PYTHON_ABI_VERSION) #else #define PyModule_Create(module) \ PyModule_Create2(module, PYTHON_API_VERSION) #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 / New in 3.5 / PyAPI_FUNC(PyObject ) PyModule_FromDefAndSpec2(PyModuleDef def, PyObject spec, int module_api_version); #ifdef Py_LIMITED_API #define PyModule_FromDefAndSpec(module, spec) \ PyModule_FromDefAndSpec2(module, spec, PYTHON_ABI_VERSION) #else #define PyModule_FromDefAndSpec(module, spec) \ PyModule_FromDefAndSpec2(module, spec, PYTHON_API_VERSION) #endif /* Py_LIMITED_API / #endif / New in 3.5 / #ifndef Py_LIMITED_API # define Py_CPYTHON_MODSUPPORT_H # include "cpython/modsupport.h" # undef Py_CPYTHON_MODSUPPORT_H #endif #ifdef __cplusplus } #endif #endif / !Py_MODSUPPORT_H */	6.39 KB	2025-10-09 16:16
📄 moduleobject.h /* Module 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_FUNC(PyObject ) PyModule_GetDict(PyObject ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject ) PyModule_GetNameObject(PyObject ); #endif PyAPI_FUNC(const char ) PyModule_GetName(PyObject ); Py_DEPRECATED(3.2) PyAPI_FUNC(const char ) PyModule_GetFilename(PyObject ); PyAPI_FUNC(PyObject ) PyModule_GetFilenameObject(PyObject ); #ifndef Py_LIMITED_API PyAPI_FUNC(void) _PyModule_Clear(PyObject ); PyAPI_FUNC(void) _PyModule_ClearDict(PyObject ); PyAPI_FUNC(int) _PyModuleSpec_IsInitializing(PyObject ); #endif PyAPI_FUNC(PyModuleDef) PyModule_GetDef(PyObject); PyAPI_FUNC(void) PyModule_GetState(PyObject); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 /* New in 3.5 / PyAPI_FUNC(PyObject ) PyModuleDef_Init(PyModuleDef); PyAPI_DATA(PyTypeObject) PyModuleDef_Type; #endif typedef struct PyModuleDef_Base { PyObject_HEAD PyObject (m_init)(void); Py_ssize_t m_index; PyObject m_copy; } PyModuleDef_Base; #define PyModuleDef_HEAD_INIT { \ PyObject_HEAD_INIT(_Py_NULL) \ _Py_NULL, /* m_init / \ 0, / m_index / \ _Py_NULL, / m_copy / \ } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 / New in 3.5 / struct PyModuleDef_Slot { int slot; void value; }; #define Py_mod_create 1 #define Py_mod_exec 2 #ifndef Py_LIMITED_API #define _Py_mod_LAST_SLOT 2 #endif #endif /* New in 3.5 / struct PyModuleDef { PyModuleDef_Base m_base; const char m_name; const char* m_doc; Py_ssize_t m_size; PyMethodDef m_methods; PyModuleDef_Slot m_slots; traverseproc m_traverse; inquiry m_clear; freefunc m_free; }; // Internal C API #ifdef Py_BUILD_CORE extern int _PyModule_IsExtension(PyObject obj); #endif #ifdef __cplusplus } #endif #endif / !Py_MODULEOBJECT_H */	2.32 KB	2025-10-09 16:16
📄 object.h #ifndef Py_OBJECT_H #define Py_OBJECT_H #ifdef __cplusplus extern "C" { #endif /* Object and type object interface / / Objects are structures allocated on the heap. Special rules apply to the use of objects to ensure they are properly garbage-collected. Objects are never allocated statically or on the stack; they must be accessed through special macros and functions only. (Type objects are exceptions to the first rule; the standard types are represented by statically initialized type objects, although work on type/class unification for Python 2.2 made it possible to have heap-allocated type objects too). An object has a 'reference count' that is increased or decreased when a pointer to the object is copied or deleted; when the reference count reaches zero there are no references to the object left and it can be removed from the heap. An object has a 'type' that determines what it represents and what kind of data it contains. An object's type is fixed when it is created. Types themselves are represented as objects; an object contains a pointer to the corresponding type object. The type itself has a type pointer pointing to the object representing the type 'type', which contains a pointer to itself!. Objects do not float around in memory; once allocated an object keeps the same size and address. Objects that must hold variable-size data can contain pointers to variable-size parts of the object. Not all objects of the same type have the same size; but the size cannot change after allocation. (These restrictions are made so a reference to an object can be simply a pointer -- moving an object would require updating all the pointers, and changing an object's size would require moving it if there was another object right next to it.) Objects are always accessed through pointers of the type 'PyObject '. The type 'PyObject' is a structure that only contains the reference count and the type pointer. The actual memory allocated for an object contains other data that can only be accessed after casting the pointer to a pointer to a longer structure type. This longer type must start with the reference count and type fields; the macro PyObject_HEAD should be used for this (to accommodate for future changes). The implementation of a particular object type can cast the object pointer to the proper type and back. A standard interface exists for objects that contain an array of items whose size is determined when the object is allocated. / /* Py_DEBUG implies Py_REF_DEBUG. / #if defined(Py_DEBUG) && !defined(Py_REF_DEBUG) # define Py_REF_DEBUG #endif #if defined(Py_LIMITED_API) && defined(Py_TRACE_REFS) # error Py_LIMITED_API is incompatible with Py_TRACE_REFS #endif #ifdef Py_TRACE_REFS / Define pointers to support a doubly-linked list of all live heap objects. / #define _PyObject_HEAD_EXTRA \ PyObject _ob_next; \ PyObject _ob_prev; #define _PyObject_EXTRA_INIT _Py_NULL, _Py_NULL, #else # define _PyObject_HEAD_EXTRA # define _PyObject_EXTRA_INIT #endif / PyObject_HEAD defines the initial segment of every PyObject. / #define PyObject_HEAD PyObject ob_base; #define PyObject_HEAD_INIT(type) \ { _PyObject_EXTRA_INIT \ 1, type }, #define PyVarObject_HEAD_INIT(type, size) \ { PyObject_HEAD_INIT(type) size }, / PyObject_VAR_HEAD defines the initial segment of all variable-size * container objects. These end with a declaration of an array with 1 * element, but enough space is malloc'ed so that the array actually * has room for ob_size elements. Note that ob_size is an element count, * not necessarily a byte count. / #define PyObject_VAR_HEAD PyVarObject ob_base; #define Py_INVALID_SIZE (Py_ssize_t)-1 / Nothing is actually declared to be a PyObject, but every pointer to * a Python object can be cast to a PyObject. This is inheritance built by hand. Similarly every pointer to a variable-size Python object can, * in addition, be cast to PyVarObject. / struct _object { _PyObject_HEAD_EXTRA Py_ssize_t ob_refcnt; PyTypeObject ob_type; }; / Cast argument to PyObject* type. / #define _PyObject_CAST(op) _Py_CAST(PyObject, (op)) typedef struct { PyObject ob_base; Py_ssize_t ob_size; /* Number of items in variable part / } PyVarObject; / Cast argument to PyVarObject* type. / #define _PyVarObject_CAST(op) _Py_CAST(PyVarObject, (op)) // Test if the 'x' object is the 'y' object, the same as "x is y" in Python. PyAPI_FUNC(int) Py_Is(PyObject x, PyObject y); #define Py_Is(x, y) ((x) == (y)) static inline Py_ssize_t Py_REFCNT(PyObject ob) { return ob->ob_refcnt; } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_REFCNT(ob) Py_REFCNT(_PyObject_CAST(ob)) #endif // bpo-39573: The Py_SET_TYPE() function must be used to set an object type. static inline PyTypeObject Py_TYPE(PyObject ob) { return ob->ob_type; } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_TYPE(ob) Py_TYPE(_PyObject_CAST(ob)) #endif // bpo-39573: The Py_SET_SIZE() function must be used to set an object size. static inline Py_ssize_t Py_SIZE(PyObject ob) { PyVarObject var_ob = _PyVarObject_CAST(ob); return var_ob->ob_size; } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_SIZE(ob) Py_SIZE(_PyObject_CAST(ob)) #endif 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) { ob->ob_refcnt = refcnt; } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_SET_REFCNT(ob, refcnt) Py_SET_REFCNT(_PyObject_CAST(ob), refcnt) #endif static inline void Py_SET_TYPE(PyObject ob, PyTypeObject type) { ob->ob_type = type; } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_SET_TYPE(ob, type) Py_SET_TYPE(_PyObject_CAST(ob), type) #endif static inline void Py_SET_SIZE(PyVarObject ob, Py_ssize_t size) { ob->ob_size = size; } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_SET_SIZE(ob, size) Py_SET_SIZE(_PyVarObject_CAST(ob), size) #endif / Type objects contain a string containing the type name (to help somewhat in debugging), the allocation parameters (see PyObject_New() and PyObject_NewVar()), and methods for accessing objects of the type. Methods are optional, a nil pointer meaning that particular kind of access is not available for this type. The Py_DECREF() macro uses the tp_dealloc method without checking for a nil pointer; it should always be implemented except if the implementation can guarantee that the reference count will never reach zero (e.g., for statically allocated type objects). NB: the methods for certain type groups are now contained in separate method blocks. / typedef PyObject (unaryfunc)(PyObject ); typedef PyObject * (binaryfunc)(PyObject , PyObject ); typedef PyObject (ternaryfunc)(PyObject , PyObject , PyObject ); typedef int (inquiry)(PyObject ); typedef Py_ssize_t (lenfunc)(PyObject ); typedef PyObject (ssizeargfunc)(PyObject , Py_ssize_t); typedef PyObject (ssizessizeargfunc)(PyObject , Py_ssize_t, Py_ssize_t); typedef int(ssizeobjargproc)(PyObject , Py_ssize_t, PyObject ); typedef int(ssizessizeobjargproc)(PyObject , Py_ssize_t, Py_ssize_t, PyObject ); typedef int(objobjargproc)(PyObject , PyObject , PyObject ); typedef int (objobjproc)(PyObject , PyObject ); typedef int (visitproc)(PyObject , void ); typedef int (traverseproc)(PyObject , visitproc, void ); typedef void (freefunc)(void ); typedef void (destructor)(PyObject ); typedef PyObject (getattrfunc)(PyObject , char ); typedef PyObject (getattrofunc)(PyObject , PyObject ); typedef int (setattrfunc)(PyObject , char , PyObject ); typedef int (setattrofunc)(PyObject , PyObject , PyObject ); typedef PyObject (reprfunc)(PyObject ); typedef Py_hash_t (hashfunc)(PyObject ); typedef PyObject (richcmpfunc) (PyObject , PyObject , int); typedef PyObject (getiterfunc) (PyObject ); typedef PyObject (iternextfunc) (PyObject ); typedef PyObject (descrgetfunc) (PyObject , PyObject , PyObject ); typedef int (descrsetfunc) (PyObject , PyObject , PyObject ); typedef int (initproc)(PyObject , PyObject , PyObject ); typedef PyObject (newfunc)(PyTypeObject , PyObject , PyObject ); typedef PyObject (allocfunc)(PyTypeObject , Py_ssize_t); 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 !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject) PyType_FromSpecWithBases(PyType_Spec, PyObject); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03040000 PyAPI_FUNC(void) PyType_GetSlot(PyTypeObject, int); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03090000 PyAPI_FUNC(PyObject) PyType_FromModuleAndSpec(PyObject , PyType_Spec , PyObject ); PyAPI_FUNC(PyObject ) PyType_GetModule(PyTypeObject ); PyAPI_FUNC(void ) PyType_GetModuleState(PyTypeObject ); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030B0000 PyAPI_FUNC(PyObject ) PyType_GetName(PyTypeObject ); PyAPI_FUNC(PyObject ) PyType_GetQualName(PyTypeObject ); #endif /* Generic type check / PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject , PyTypeObject ); static inline int PyObject_TypeCheck(PyObject ob, PyTypeObject type) { return Py_IS_TYPE(ob, type) \|\| PyType_IsSubtype(Py_TYPE(ob), type); } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define PyObject_TypeCheck(ob, type) PyObject_TypeCheck(_PyObject_CAST(ob), type) #endif PyAPI_DATA(PyTypeObject) PyType_Type; / built-in 'type' / PyAPI_DATA(PyTypeObject) PyBaseObject_Type; / built-in 'object' / PyAPI_DATA(PyTypeObject) PySuper_Type; / built-in 'super' / PyAPI_FUNC(unsigned long) PyType_GetFlags(PyTypeObject); PyAPI_FUNC(int) PyType_Ready(PyTypeObject ); PyAPI_FUNC(PyObject ) PyType_GenericAlloc(PyTypeObject , Py_ssize_t); PyAPI_FUNC(PyObject ) PyType_GenericNew(PyTypeObject , PyObject , PyObject ); PyAPI_FUNC(unsigned int) PyType_ClearCache(void); PyAPI_FUNC(void) PyType_Modified(PyTypeObject ); /* Generic operations on objects / PyAPI_FUNC(PyObject ) PyObject_Repr(PyObject ); PyAPI_FUNC(PyObject ) PyObject_Str(PyObject ); PyAPI_FUNC(PyObject ) PyObject_ASCII(PyObject ); PyAPI_FUNC(PyObject ) PyObject_Bytes(PyObject ); PyAPI_FUNC(PyObject ) PyObject_RichCompare(PyObject , PyObject , int); PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject , PyObject , int); PyAPI_FUNC(PyObject ) PyObject_GetAttrString(PyObject , const char ); PyAPI_FUNC(int) PyObject_SetAttrString(PyObject , const char , PyObject ); PyAPI_FUNC(int) PyObject_HasAttrString(PyObject , const char ); PyAPI_FUNC(PyObject ) PyObject_GetAttr(PyObject , PyObject ); PyAPI_FUNC(int) PyObject_SetAttr(PyObject , PyObject , PyObject ); PyAPI_FUNC(int) PyObject_HasAttr(PyObject , PyObject ); PyAPI_FUNC(PyObject ) PyObject_SelfIter(PyObject ); PyAPI_FUNC(PyObject ) PyObject_GenericGetAttr(PyObject , PyObject ); PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject , PyObject , PyObject ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(int) PyObject_GenericSetDict(PyObject , PyObject , void ); #endif PyAPI_FUNC(Py_hash_t) PyObject_Hash(PyObject ); PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject ); PyAPI_FUNC(int) PyObject_IsTrue(PyObject ); PyAPI_FUNC(int) PyObject_Not(PyObject ); PyAPI_FUNC(int) PyCallable_Check(PyObject ); PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject ); / PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a list of strings. PyObject_Dir(NULL) is like builtins.dir(), returning the names of the current locals. In this case, if there are no current locals, NULL is returned, and PyErr_Occurred() is false. / PyAPI_FUNC(PyObject ) PyObject_Dir(PyObject ); / Pickle support. / #ifndef Py_LIMITED_API PyAPI_FUNC(PyObject ) _PyObject_GetState(PyObject ); #endif / Helpers for printing recursive container types / PyAPI_FUNC(int) Py_ReprEnter(PyObject ); PyAPI_FUNC(void) Py_ReprLeave(PyObject ); / Flag bits for printing: / #define Py_PRINT_RAW 1 / No string quotes etc. / / Type flags (tp_flags) These flags are used to change expected features and behavior for a particular type. Arbitration of the flag bit positions will need to be coordinated among all extension writers who publicly release their extensions (this will be fewer than you might expect!). Most flags were removed as of Python 3.0 to make room for new flags. (Some flags are not for backwards compatibility but to indicate the presence of an optional 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 / Placement of dict (and values) pointers are managed by the VM, not by the type. * The VM will automatically set tp_dictoffset. Should not be used for variable sized * classes, such as classes that extend tuple. / #define Py_TPFLAGS_MANAGED_DICT (1 << 4) / Set if instances of the type object are treated as sequences for pattern matching / #define Py_TPFLAGS_SEQUENCE (1 << 5) / Set if instances of the type object are treated as mappings for pattern matching / #define Py_TPFLAGS_MAPPING (1 << 6) #endif / Disallow creating instances of the type: set tp_new to NULL and don't create * the "__new__" key in the type dictionary. / #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) / Set if the type object is immutable: type attributes cannot be set nor deleted / #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) / Set if the type object is dynamically allocated / #define Py_TPFLAGS_HEAPTYPE (1UL << 9) / Set if the type allows subclassing / #define Py_TPFLAGS_BASETYPE (1UL << 10) / Set if the type implements the vectorcall protocol (PEP 590) / #ifndef Py_LIMITED_API #define Py_TPFLAGS_HAVE_VECTORCALL (1UL << 11) // Backwards compatibility alias for API that was provisional in Python 3.8 #define _Py_TPFLAGS_HAVE_VECTORCALL Py_TPFLAGS_HAVE_VECTORCALL #endif / Set if the type is 'ready' -- fully initialized / #define Py_TPFLAGS_READY (1UL << 12) / Set while the type is being 'readied', to prevent recursive ready calls / #define Py_TPFLAGS_READYING (1UL << 13) / Objects support garbage collection (see objimpl.h) / #define Py_TPFLAGS_HAVE_GC (1UL << 14) / These two bits are preserved for Stackless Python, next after this is 17 / #ifdef STACKLESS #define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3UL << 15) #else #define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0 #endif / Objects behave like an unbound method / #define Py_TPFLAGS_METHOD_DESCRIPTOR (1UL << 17) / Object has up-to-date type attribute cache / #define Py_TPFLAGS_VALID_VERSION_TAG (1UL << 19) / Type is abstract and cannot be instantiated / #define Py_TPFLAGS_IS_ABSTRACT (1UL << 20) // This undocumented flag gives certain built-ins their unique pattern-matching // behavior, which allows a single positional subpattern to match against the // subject itself (rather than a mapped attribute on it): #define _Py_TPFLAGS_MATCH_SELF (1UL << 22) / These flags are used to determine if a type is a subclass. / #define Py_TPFLAGS_LONG_SUBCLASS (1UL << 24) #define Py_TPFLAGS_LIST_SUBCLASS (1UL << 25) #define Py_TPFLAGS_TUPLE_SUBCLASS (1UL << 26) #define Py_TPFLAGS_BYTES_SUBCLASS (1UL << 27) #define Py_TPFLAGS_UNICODE_SUBCLASS (1UL << 28) #define Py_TPFLAGS_DICT_SUBCLASS (1UL << 29) #define Py_TPFLAGS_BASE_EXC_SUBCLASS (1UL << 30) #define Py_TPFLAGS_TYPE_SUBCLASS (1UL << 31) #define Py_TPFLAGS_DEFAULT ( \ Py_TPFLAGS_HAVE_STACKLESS_EXTENSION \| \ 0) / NOTE: Some of the following flags reuse lower bits (removed as part of the * Python 3.0 transition). / / The following flags are kept for compatibility; in previous * versions they indicated presence of newer tp_* fields on the * type struct. * Starting with 3.8, binary compatibility of C extensions across * feature releases of Python is not supported anymore (except when * using the stable ABI, in which all classes are created dynamically, * using the interpreter's memory layout.) * Note that older extensions using the stable ABI set these flags, * so the bits must not be repurposed. / #define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0) #define Py_TPFLAGS_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 reference counts to 1, and in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional bookkeeping appropriate to the special build. We assume that the reference count field can never overflow; this can be proven when the size of the field is the same as the pointer size, so we ignore the possibility. Provided a C int is at least 32 bits (which is implicitly assumed in many parts of this code), that's enough for about 2*31 references to an object. XXX The following became out of date in Python 2.2, but I'm not sure XXX what the full truth is now. Certainly, heap-allocated type objects XXX can and should be deallocated. Type objects should never be deallocated; the type pointer in an object is not considered to be a reference to the type object, to save complications in the deallocation function. (This is actually a decision that's up to the implementer of each new type so if you want, you can count such references to the type object.) / #ifdef Py_REF_DEBUG PyAPI_DATA(Py_ssize_t) _Py_RefTotal; PyAPI_FUNC(void) _Py_NegativeRefcount(const char filename, int lineno, PyObject op); #endif /* Py_REF_DEBUG / PyAPI_FUNC(void) _Py_Dealloc(PyObject ); /* These are provided as conveniences to Python runtime embedders, so that they can have object code that is not dependent on Python compilation flags. / PyAPI_FUNC(void) Py_IncRef(PyObject ); PyAPI_FUNC(void) Py_DecRef(PyObject ); // Similar to Py_IncRef() and Py_DecRef() but the argument must be non-NULL. // Private functions used by Py_INCREF() and Py_DECREF(). PyAPI_FUNC(void) _Py_IncRef(PyObject ); PyAPI_FUNC(void) _Py_DecRef(PyObject ); static inline void Py_INCREF(PyObject op) { #if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 // Stable ABI for Python 3.10 built in debug mode. _Py_IncRef(op); #else // Non-limited C API and limited C API for Python 3.9 and older access // directly PyObject.ob_refcnt. #ifdef Py_REF_DEBUG _Py_RefTotal++; #endif op->ob_refcnt++; #endif } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_INCREF(op) Py_INCREF(_PyObject_CAST(op)) #endif #if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 // Stable ABI for limited C API version 3.10 of Python debug build static inline void Py_DECREF(PyObject op) { _Py_DecRef(op); } #define Py_DECREF(op) Py_DECREF(_PyObject_CAST(op)) #elif defined(Py_REF_DEBUG) static inline void Py_DECREF(const char filename, int lineno, PyObject op) { _Py_RefTotal--; if (--op->ob_refcnt != 0) { if (op->ob_refcnt < 0) { _Py_NegativeRefcount(filename, lineno, op); } } else { _Py_Dealloc(op); } } #define Py_DECREF(op) Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op)) #else static inline void Py_DECREF(PyObject op) { // Non-limited C API and limited C API for Python 3.9 and older access // directly PyObject.ob_refcnt. if (--op->ob_refcnt == 0) { _Py_Dealloc(op); } } #define Py_DECREF(op) Py_DECREF(_PyObject_CAST(op)) #endif /* Safely decref `op` and set `op` to NULL, especially useful in tp_clear * and tp_dealloc implementations. * * Note that "the obvious" code can be deadly: * * Py_XDECREF(op); * op = NULL; * * Typically, `op` is something like self->containee, and `self` is done * using its `containee` member. In the code sequence above, suppose * `containee` is non-NULL with a refcount of 1. Its refcount falls to * 0 on the first line, which can trigger an arbitrary amount of code, * possibly including finalizers (like __del__ methods or weakref callbacks) * coded in Python, which in turn can release the GIL and allow other threads * to run, etc. Such code may even invoke methods of `self` again, or cause * cyclic gc to trigger, but-- oops! --self->containee still points to the * object being torn down, and it may be in an insane state while being torn * down. This has in fact been a rich historic source of miserable (rare & * hard-to-diagnose) segfaulting (and other) bugs. * * The safe way is: * * Py_CLEAR(op); * * That arranges to set `op` to NULL _before_ decref'ing, so that any code * triggered as a side-effect of `op` getting torn down no longer believes * `op` points to a valid object. * * There are cases where it's safe to use the naive code, but they're brittle. * For example, if `op` points to a Python integer, you know that destroying * one of those can't cause problems -- but in part that relies on that * Python integers aren't currently weakly referencable. Best practice is * to use Py_CLEAR() even if you can't think of a reason for why you need to. / #define Py_CLEAR(op) \ do { \ PyObject _py_tmp = _PyObject_CAST(op); \ if (_py_tmp != NULL) { \ (op) = NULL; \ Py_DECREF(_py_tmp); \ } \ } while (0) /* 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 !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_XINCREF(op) Py_XINCREF(_PyObject_CAST(op)) #endif static inline void Py_XDECREF(PyObject op) { if (op != _Py_NULL) { Py_DECREF(op); } } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_XDECREF(op) Py_XDECREF(_PyObject_CAST(op)) #endif // Create a new strong reference to an object: // increment the reference count of the object and return the object. PyAPI_FUNC(PyObject) Py_NewRef(PyObject obj); // Similar to Py_NewRef(), but the object can be NULL. PyAPI_FUNC(PyObject) Py_XNewRef(PyObject obj); static inline PyObject _Py_NewRef(PyObject obj) { Py_INCREF(obj); return obj; } static inline PyObject _Py_XNewRef(PyObject obj) { Py_XINCREF(obj); return obj; } // Py_NewRef() and Py_XNewRef() are exported as functions for the stable ABI. // Names overridden with macros by static inline functions for best // performances. #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj)) # define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj)) #else # define Py_NewRef(obj) _Py_NewRef(obj) # define Py_XNewRef(obj) _Py_XNewRef(obj) #endif / _Py_NoneStruct is an object of undefined 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_NewRef(Py_None) / Py_NotImplemented is a singleton used to signal that an operation is not implemented for a given type combination. / PyAPI_DATA(PyObject) _Py_NotImplementedStruct; / Don't use this directly / #define Py_NotImplemented (&_Py_NotImplementedStruct) / Macro for returning Py_NotImplemented from a function / #define Py_RETURN_NOTIMPLEMENTED return Py_NewRef(Py_NotImplemented) / Rich comparison opcodes / #define Py_LT 0 #define Py_LE 1 #define Py_EQ 2 #define Py_NE 3 #define Py_GT 4 #define Py_GE 5 #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030A0000 / Result of calling PyIter_Send / typedef enum { PYGEN_RETURN = 0, PYGEN_ERROR = -1, PYGEN_NEXT = 1, } PySendResult; #endif / * Macro for implementing rich comparisons * * Needs to be a macro because any C-comparable type can be used. / #define Py_RETURN_RICHCOMPARE(val1, val2, op) \ do { \ switch (op) { \ case Py_EQ: if ((val1) == (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ case Py_NE: if ((val1) != (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ case Py_LT: if ((val1) < (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ case Py_GT: if ((val1) > (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ case Py_LE: if ((val1) <= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ case Py_GE: if ((val1) >= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \ default: \ Py_UNREACHABLE(); \ } \ } while (0) / More conventions ================ Argument Checking ----------------- Functions that take objects as arguments normally don't check for nil arguments, but they do check the type of the argument, and return an error if the function doesn't apply to the type. Failure Modes ------------- Functions may fail for a variety of reasons, including running out of memory. This is communicated to the caller in two ways: an error string is set (see errors.h), and the function result differs: functions that normally return a pointer return NULL for failure, functions returning an integer return -1 (which could be a legal return value too!), and other functions return 0 for success and -1 for failure. Callers should always check for errors before using the result. If an error was set, the caller must either explicitly clear it, or pass the error on to its caller. Reference Counts ---------------- It takes a while to get used to the proper usage of reference counts. Functions that create an object set the reference count to 1; such new objects must be stored somewhere or destroyed again with Py_DECREF(). Some functions that 'store' objects, such as PyTuple_SetItem() and PyList_SetItem(), don't increment the reference count of the object, since the most frequent use is to store a fresh object. Functions that 'retrieve' objects, such as PyTuple_GetItem() and PyDict_GetItemString(), also don't increment the reference count, since most frequently the object is only looked at quickly. Thus, to retrieve an object and store it again, the caller must call Py_INCREF() explicitly. NOTE: functions that 'consume' a reference count, like PyList_SetItem(), consume the reference even if the object wasn't successfully stored, to simplify error handling. It seems attractive to make other functions that take an object as argument consume a reference count; however, this may quickly get confusing (even the current practice is already confusing). Consider it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at times. / #ifndef Py_LIMITED_API # define Py_CPYTHON_OBJECT_H # include "cpython/object.h" # undef Py_CPYTHON_OBJECT_H #endif static inline int PyType_HasFeature(PyTypeObject type, unsigned long feature) { unsigned long flags; #ifdef Py_LIMITED_API // PyTypeObject is opaque in the limited C API flags = PyType_GetFlags(type); #else flags = type->tp_flags; #endif return ((flags & feature) != 0); } #define PyType_FastSubclass(type, flag) PyType_HasFeature(type, flag) static inline int PyType_Check(PyObject op) { return PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS); } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define PyType_Check(op) PyType_Check(_PyObject_CAST(op)) #endif #define _PyType_CAST(op) \ (assert(PyType_Check(op)), _Py_CAST(PyTypeObject, (op))) static inline int PyType_CheckExact(PyObject *op) { return Py_IS_TYPE(op, &PyType_Type); } #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define PyType_CheckExact(op) PyType_CheckExact(_PyObject_CAST(op)) #endif #ifdef __cplusplus } #endif #endif // !Py_OBJECT_H	29.1 KB	2025-10-09 16:16
📄 objimpl.h /* The PyObject_ memory family: high-level object memory interfaces. See pymem.h for the low-level PyMem_ family. / #ifndef Py_OBJIMPL_H #define Py_OBJIMPL_H #include "pymem.h" #ifdef __cplusplus extern "C" { #endif / BEWARE: Each interface exports both functions and macros. Extension modules should use the functions, to ensure binary compatibility across Python versions. Because the Python implementation is free to change internal details, and the macros may (or may not) expose details for speed, if you do use the macros you must recompile your extensions with each Python release. Never mix calls to PyObject_ memory functions with calls to the platform malloc/realloc/ calloc/free, or with calls to PyMem_. / / Functions and macros for modules that implement new object types. - PyObject_New(type, typeobj) allocates memory for a new object of the given type, and initializes part of it. 'type' must be the C structure type used to represent the object, and 'typeobj' the address of the corresponding type object. Reference count and type pointer 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 the memory. PyObject_Free is identical. - PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't allocate memory. Instead of a 'type' parameter, they take a pointer to a new object (allocated by an arbitrary allocator), and initialize its object header fields. Note that objects created with PyObject_{New, NewVar} are allocated using the specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is enabled. In addition, a special debugging allocator is used if Py_DEBUG macro is also defined. In case a specific form of memory management is needed (for example, if you must use the platform malloc heap(s), or shared memory, or C++ local storage or operator new), you must first allocate the object with your custom allocator, then pass its pointer to PyObject_{Init, InitVar} for filling in its Python- specific fields: reference count, type pointer, possibly others. You should be aware that Python has no control over these objects because they don't cooperate with the Python memory manager. Such objects may not be eligible for automatic garbage collection and you have to make sure that they are released accordingly whenever their destructor gets called (cf. the specific form of memory management you're using). Unless you have specific memory management requirements, use PyObject_{New, NewVar, Del}. / /* * Raw object memory interface * =========================== / / Functions to call the same malloc/realloc/free as used by Python's object allocator. If WITH_PYMALLOC is enabled, these may differ from the platform malloc/realloc/free. The Python object allocator is designed for fast, cache-conscious allocation of many "small" objects, and with low hidden memory overhead. PyObject_Malloc(0) returns a unique non-NULL pointer if possible. PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n). PyObject_Realloc(p != NULL, 0) does not return NULL, or free the memory at p. Returned pointers must be checked for NULL explicitly; no action is performed on failure other than to return NULL (no warning it printed, no exception is set, etc). For allocating objects, use PyObject_{New, NewVar} instead whenever possible. The PyObject_{Malloc, Realloc, Free} family is exposed so that you can exploit Python's small-block allocator for non-object uses. If you must use these routines to allocate object memory, make sure the object gets initialized via PyObject_{Init, InitVar} after obtaining the raw memory. / PyAPI_FUNC(void ) PyObject_Malloc(size_t size); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 PyAPI_FUNC(void ) PyObject_Calloc(size_t nelem, size_t elsize); #endif PyAPI_FUNC(void ) PyObject_Realloc(void ptr, size_t new_size); PyAPI_FUNC(void) PyObject_Free(void ptr); // Deprecated aliases only kept for backward compatibility. // PyObject_Del and PyObject_DEL are defined with no parameter to be able to // use them as function pointers (ex: tp_free = PyObject_Del). #define PyObject_MALLOC PyObject_Malloc #define PyObject_REALLOC PyObject_Realloc #define PyObject_FREE PyObject_Free #define PyObject_Del PyObject_Free #define PyObject_DEL PyObject_Free /* * Generic object allocator interface * ================================== / / Functions / PyAPI_FUNC(PyObject ) PyObject_Init(PyObject , PyTypeObject ); PyAPI_FUNC(PyVarObject ) PyObject_InitVar(PyVarObject , PyTypeObject , Py_ssize_t); #define PyObject_INIT(op, typeobj) \ PyObject_Init(_PyObject_CAST(op), (typeobj)) #define PyObject_INIT_VAR(op, typeobj, size) \ PyObject_InitVar(_PyVarObject_CAST(op), (typeobj), (size)) PyAPI_FUNC(PyObject ) _PyObject_New(PyTypeObject ); PyAPI_FUNC(PyVarObject ) _PyObject_NewVar(PyTypeObject , Py_ssize_t); #define PyObject_New(type, typeobj) ((type )_PyObject_New(typeobj)) // Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly // PyObject_MALLOC() with _PyObject_SIZE(). #define PyObject_NEW(type, typeobj) PyObject_New(type, typeobj) #define PyObject_NewVar(type, typeobj, n) \ ( (type ) _PyObject_NewVar((typeobj), (n)) ) // Alias to PyObject_NewVar(). In Python 3.8, PyObject_NEW_VAR() called // directly PyObject_MALLOC() with _PyObject_VAR_SIZE(). #define PyObject_NEW_VAR(type, typeobj, n) PyObject_NewVar(type, typeobj, n) / * Garbage Collection Support * ========================== / / C equivalent of gc.collect(). / PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void); / C API for controlling the state of the garbage collector / PyAPI_FUNC(int) PyGC_Enable(void); PyAPI_FUNC(int) PyGC_Disable(void); PyAPI_FUNC(int) PyGC_IsEnabled(void); / 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); #define PyObject_GC_Resize(type, op, n) \ ( (type ) _PyObject_GC_Resize(_PyVarObject_CAST(op), (n)) ) PyAPI_FUNC(PyObject ) _PyObject_GC_New(PyTypeObject ); PyAPI_FUNC(PyVarObject ) _PyObject_GC_NewVar(PyTypeObject , Py_ssize_t); /* Tell the GC to track this object. * * See also private _PyObject_GC_TRACK() macro. / PyAPI_FUNC(void) PyObject_GC_Track(void ); /* Tell the GC to stop tracking this object. * * See also private _PyObject_GC_UNTRACK() macro. / PyAPI_FUNC(void) PyObject_GC_UnTrack(void ); PyAPI_FUNC(void) PyObject_GC_Del(void ); #define PyObject_GC_New(type, typeobj) \ _Py_CAST(type, _PyObject_GC_New(typeobj)) #define PyObject_GC_NewVar(type, typeobj, n) \ _Py_CAST(type, _PyObject_GC_NewVar((typeobj), (n))) PyAPI_FUNC(int) PyObject_GC_IsTracked(PyObject ); PyAPI_FUNC(int) PyObject_GC_IsFinalized(PyObject ); / Utility macro to help write tp_traverse functions. * To use this macro, the tp_traverse function must name its arguments * "visit" and "arg". This is intended to keep tp_traverse functions * looking as much alike as possible. / #define Py_VISIT(op) \ do { \ if (op) { \ int vret = visit(_PyObject_CAST(op), arg); \ if (vret) \ return vret; \ } \ } while (0) #ifndef Py_LIMITED_API # define Py_CPYTHON_OBJIMPL_H # include "cpython/objimpl.h" # undef Py_CPYTHON_OBJIMPL_H #endif #ifdef __cplusplus } #endif #endif / !Py_OBJIMPL_H */	8.23 KB	2025-10-09 16:16
📄 opcode.h // Auto-generated by Tools/scripts/generate_opcode_h.py from Lib/opcode.py #ifndef Py_OPCODE_H #define Py_OPCODE_H #ifdef __cplusplus extern "C" { #endif /* Instruction opcodes for compiled code / #define CACHE 0 #define POP_TOP 1 #define PUSH_NULL 2 #define NOP 9 #define UNARY_POSITIVE 10 #define UNARY_NEGATIVE 11 #define UNARY_NOT 12 #define UNARY_INVERT 15 #define BINARY_SUBSCR 25 #define GET_LEN 30 #define MATCH_MAPPING 31 #define MATCH_SEQUENCE 32 #define MATCH_KEYS 33 #define PUSH_EXC_INFO 35 #define CHECK_EXC_MATCH 36 #define CHECK_EG_MATCH 37 #define WITH_EXCEPT_START 49 #define GET_AITER 50 #define GET_ANEXT 51 #define BEFORE_ASYNC_WITH 52 #define BEFORE_WITH 53 #define END_ASYNC_FOR 54 #define STORE_SUBSCR 60 #define DELETE_SUBSCR 61 #define GET_ITER 68 #define GET_YIELD_FROM_ITER 69 #define PRINT_EXPR 70 #define LOAD_BUILD_CLASS 71 #define LOAD_ASSERTION_ERROR 74 #define RETURN_GENERATOR 75 #define LIST_TO_TUPLE 82 #define RETURN_VALUE 83 #define IMPORT_STAR 84 #define SETUP_ANNOTATIONS 85 #define YIELD_VALUE 86 #define ASYNC_GEN_WRAP 87 #define PREP_RERAISE_STAR 88 #define POP_EXCEPT 89 #define HAVE_ARGUMENT 90 #define STORE_NAME 90 #define DELETE_NAME 91 #define UNPACK_SEQUENCE 92 #define FOR_ITER 93 #define UNPACK_EX 94 #define STORE_ATTR 95 #define DELETE_ATTR 96 #define STORE_GLOBAL 97 #define DELETE_GLOBAL 98 #define SWAP 99 #define LOAD_CONST 100 #define LOAD_NAME 101 #define BUILD_TUPLE 102 #define BUILD_LIST 103 #define BUILD_SET 104 #define BUILD_MAP 105 #define LOAD_ATTR 106 #define COMPARE_OP 107 #define IMPORT_NAME 108 #define IMPORT_FROM 109 #define JUMP_FORWARD 110 #define JUMP_IF_FALSE_OR_POP 111 #define JUMP_IF_TRUE_OR_POP 112 #define POP_JUMP_FORWARD_IF_FALSE 114 #define POP_JUMP_FORWARD_IF_TRUE 115 #define LOAD_GLOBAL 116 #define IS_OP 117 #define CONTAINS_OP 118 #define RERAISE 119 #define COPY 120 #define BINARY_OP 122 #define SEND 123 #define LOAD_FAST 124 #define STORE_FAST 125 #define DELETE_FAST 126 #define POP_JUMP_FORWARD_IF_NOT_NONE 128 #define POP_JUMP_FORWARD_IF_NONE 129 #define RAISE_VARARGS 130 #define GET_AWAITABLE 131 #define MAKE_FUNCTION 132 #define BUILD_SLICE 133 #define JUMP_BACKWARD_NO_INTERRUPT 134 #define MAKE_CELL 135 #define LOAD_CLOSURE 136 #define LOAD_DEREF 137 #define STORE_DEREF 138 #define DELETE_DEREF 139 #define JUMP_BACKWARD 140 #define CALL_FUNCTION_EX 142 #define EXTENDED_ARG 144 #define LIST_APPEND 145 #define SET_ADD 146 #define MAP_ADD 147 #define LOAD_CLASSDEREF 148 #define COPY_FREE_VARS 149 #define RESUME 151 #define MATCH_CLASS 152 #define FORMAT_VALUE 155 #define BUILD_CONST_KEY_MAP 156 #define BUILD_STRING 157 #define LOAD_METHOD 160 #define LIST_EXTEND 162 #define SET_UPDATE 163 #define DICT_MERGE 164 #define DICT_UPDATE 165 #define PRECALL 166 #define CALL 171 #define KW_NAMES 172 #define POP_JUMP_BACKWARD_IF_NOT_NONE 173 #define POP_JUMP_BACKWARD_IF_NONE 174 #define POP_JUMP_BACKWARD_IF_FALSE 175 #define POP_JUMP_BACKWARD_IF_TRUE 176 #define BINARY_OP_ADAPTIVE 3 #define BINARY_OP_ADD_FLOAT 4 #define BINARY_OP_ADD_INT 5 #define BINARY_OP_ADD_UNICODE 6 #define BINARY_OP_INPLACE_ADD_UNICODE 7 #define BINARY_OP_MULTIPLY_FLOAT 8 #define BINARY_OP_MULTIPLY_INT 13 #define BINARY_OP_SUBTRACT_FLOAT 14 #define BINARY_OP_SUBTRACT_INT 16 #define BINARY_SUBSCR_ADAPTIVE 17 #define BINARY_SUBSCR_DICT 18 #define BINARY_SUBSCR_GETITEM 19 #define BINARY_SUBSCR_LIST_INT 20 #define BINARY_SUBSCR_TUPLE_INT 21 #define CALL_ADAPTIVE 22 #define CALL_PY_EXACT_ARGS 23 #define CALL_PY_WITH_DEFAULTS 24 #define COMPARE_OP_ADAPTIVE 26 #define COMPARE_OP_FLOAT_JUMP 27 #define COMPARE_OP_INT_JUMP 28 #define COMPARE_OP_STR_JUMP 29 #define EXTENDED_ARG_QUICK 34 #define JUMP_BACKWARD_QUICK 38 #define LOAD_ATTR_ADAPTIVE 39 #define LOAD_ATTR_INSTANCE_VALUE 40 #define LOAD_ATTR_MODULE 41 #define LOAD_ATTR_SLOT 42 #define LOAD_ATTR_WITH_HINT 43 #define LOAD_CONST__LOAD_FAST 44 #define LOAD_FAST__LOAD_CONST 45 #define LOAD_FAST__LOAD_FAST 46 #define LOAD_GLOBAL_ADAPTIVE 47 #define LOAD_GLOBAL_BUILTIN 48 #define LOAD_GLOBAL_MODULE 55 #define LOAD_METHOD_ADAPTIVE 56 #define LOAD_METHOD_CLASS 57 #define LOAD_METHOD_MODULE 58 #define LOAD_METHOD_NO_DICT 59 #define LOAD_METHOD_WITH_DICT 62 #define LOAD_METHOD_WITH_VALUES 63 #define PRECALL_ADAPTIVE 64 #define PRECALL_BOUND_METHOD 65 #define PRECALL_BUILTIN_CLASS 66 #define PRECALL_BUILTIN_FAST_WITH_KEYWORDS 67 #define PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 72 #define PRECALL_NO_KW_BUILTIN_FAST 73 #define PRECALL_NO_KW_BUILTIN_O 76 #define PRECALL_NO_KW_ISINSTANCE 77 #define PRECALL_NO_KW_LEN 78 #define PRECALL_NO_KW_LIST_APPEND 79 #define PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST 80 #define PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS 81 #define PRECALL_NO_KW_METHOD_DESCRIPTOR_O 113 #define PRECALL_NO_KW_STR_1 121 #define PRECALL_NO_KW_TUPLE_1 127 #define PRECALL_NO_KW_TYPE_1 141 #define PRECALL_PYFUNC 143 #define RESUME_QUICK 150 #define STORE_ATTR_ADAPTIVE 153 #define STORE_ATTR_INSTANCE_VALUE 154 #define STORE_ATTR_SLOT 158 #define STORE_ATTR_WITH_HINT 159 #define STORE_FAST__LOAD_FAST 161 #define STORE_FAST__STORE_FAST 167 #define STORE_SUBSCR_ADAPTIVE 168 #define STORE_SUBSCR_DICT 169 #define STORE_SUBSCR_LIST_INT 170 #define UNPACK_SEQUENCE_ADAPTIVE 177 #define UNPACK_SEQUENCE_LIST 178 #define UNPACK_SEQUENCE_TUPLE 179 #define UNPACK_SEQUENCE_TWO_TUPLE 180 #define DO_TRACING 255 #define HAS_CONST(op) (false\ \|\| ((op) == 100) \ \|\| ((op) == 172) \ ) #define NB_ADD 0 #define NB_AND 1 #define NB_FLOOR_DIVIDE 2 #define NB_LSHIFT 3 #define NB_MATRIX_MULTIPLY 4 #define NB_MULTIPLY 5 #define NB_REMAINDER 6 #define NB_OR 7 #define NB_POWER 8 #define NB_RSHIFT 9 #define NB_SUBTRACT 10 #define NB_TRUE_DIVIDE 11 #define NB_XOR 12 #define NB_INPLACE_ADD 13 #define NB_INPLACE_AND 14 #define NB_INPLACE_FLOOR_DIVIDE 15 #define NB_INPLACE_LSHIFT 16 #define NB_INPLACE_MATRIX_MULTIPLY 17 #define NB_INPLACE_MULTIPLY 18 #define NB_INPLACE_REMAINDER 19 #define NB_INPLACE_OR 20 #define NB_INPLACE_POWER 21 #define NB_INPLACE_RSHIFT 22 #define NB_INPLACE_SUBTRACT 23 #define NB_INPLACE_TRUE_DIVIDE 24 #define NB_INPLACE_XOR 25 #define HAS_ARG(op) ((op) >= HAVE_ARGUMENT) / Reserve some bytecodes for internal use in the compiler. * The value of 240 is arbitrary. / #define IS_ARTIFICIAL(op) ((op) > 240) #ifdef __cplusplus } #endif #endif / !Py_OPCODE_H */	10.92 KB	2025-10-09 16:16
📄 osdefs.h #ifndef Py_OSDEFS_H #define Py_OSDEFS_H #ifdef __cplusplus extern "C" { #endif /* Operating system dependencies / #ifdef MS_WINDOWS #define SEP L'\\' #define ALTSEP L'/' #define MAXPATHLEN 256 #define DELIM L';' #endif #ifdef __VXWORKS__ #define DELIM L';' #endif / Filename separator / #ifndef SEP #define SEP L'/' #endif / Max pathname length / #ifdef __hpux #include <sys/param.h> #include <limits.h> #ifndef PATH_MAX #define PATH_MAX MAXPATHLEN #endif #endif #ifndef MAXPATHLEN #if defined(PATH_MAX) && PATH_MAX > 1024 #define MAXPATHLEN PATH_MAX #else #define MAXPATHLEN 1024 #endif #endif / Search path entry delimiter / #ifndef DELIM #define DELIM L':' #endif #ifdef __cplusplus } #endif #endif / !Py_OSDEFS_H */	737 B	2025-10-09 16:16
📄 osmodule.h /* os module interface / #ifndef Py_OSMODULE_H #define Py_OSMODULE_H #ifdef __cplusplus extern "C" { #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03060000 PyAPI_FUNC(PyObject ) PyOS_FSPath(PyObject path); #endif #ifdef __cplusplus } #endif #endif / !Py_OSMODULE_H */	291 B	2025-10-09 16:16
📄 patchlevel.h /* Python version identification scheme. When the major or minor version changes, the VERSION variable in configure.ac must also be changed. There is also (independent) API version information in modsupport.h. / / Values for PY_RELEASE_LEVEL / #define PY_RELEASE_LEVEL_ALPHA 0xA #define PY_RELEASE_LEVEL_BETA 0xB #define PY_RELEASE_LEVEL_GAMMA 0xC / For release candidates / #define PY_RELEASE_LEVEL_FINAL 0xF / Serial should be 0 here / / Higher for patch releases / / Version parsed out into numeric values / /--start constants--/ #define PY_MAJOR_VERSION 3 #define PY_MINOR_VERSION 11 #define PY_MICRO_VERSION 14 #define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL #define PY_RELEASE_SERIAL 0 / Version as a string / #define PY_VERSION "3.11.14" /--end constants--/ / Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */ #define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) \| \ (PY_MINOR_VERSION << 16) \| \ (PY_MICRO_VERSION << 8) \| \ (PY_RELEASE_LEVEL << 4) \| \ (PY_RELEASE_SERIAL << 0))	1.27 KB	2025-10-09 16:16
📄 py_curses.h #ifndef Py_CURSES_H #define Py_CURSES_H #ifdef __APPLE__ /* On Mac OS X 10.2 [n]curses.h and stdlib.h use different guards against multiple definition of wchar_t. / #ifdef _BSD_WCHAR_T_DEFINED_ #define _WCHAR_T #endif #endif / __APPLE__ / / On FreeBSD, [n]curses.h and stdlib.h/wchar.h use different guards against multiple definition of wchar_t and wint_t. / #if defined(__FreeBSD__) && defined(_XOPEN_SOURCE_EXTENDED) # ifndef __wchar_t # define __wchar_t # endif # ifndef __wint_t # define __wint_t # endif #endif #if !defined(HAVE_CURSES_IS_PAD) && defined(WINDOW_HAS_FLAGS) / The following definition is necessary for ncurses 5.7; without it, some of [n]curses.h set NCURSES_OPAQUE to 1, and then Python can't get at the WINDOW flags field. / #define NCURSES_OPAQUE 0 #endif #ifdef HAVE_NCURSES_H #include <ncurses.h> #else #include <curses.h> #endif #ifdef HAVE_NCURSES_H / configure was checking <curses.h>, but we will use <ncurses.h>, which has some or all these features. / #if !defined(WINDOW_HAS_FLAGS) && !(NCURSES_OPAQUE+0) #define WINDOW_HAS_FLAGS 1 #endif #if !defined(HAVE_CURSES_IS_PAD) && NCURSES_VERSION_PATCH+0 >= 20090906 #define HAVE_CURSES_IS_PAD 1 #endif #ifndef MVWDELCH_IS_EXPRESSION #define MVWDELCH_IS_EXPRESSION 1 #endif #endif #ifdef __cplusplus extern "C" { #endif #define PyCurses_API_pointers 4 / Type declarations / typedef struct { PyObject_HEAD WINDOW win; char encoding; } PyCursesWindowObject; #define PyCursesWindow_Check(v) Py_IS_TYPE(v, &PyCursesWindow_Type) #define PyCurses_CAPSULE_NAME "_curses._C_API" #ifdef CURSES_MODULE / This section is used when compiling _cursesmodule.c / #else / This section is used in modules that use the _cursesmodule API / static void PyCurses_API; #define PyCursesWindow_Type (_PyType_CAST(PyCurses_API[0])) #define PyCursesSetupTermCalled {if (! ((int ()(void))PyCurses_API[1]) () ) return NULL;} #define PyCursesInitialised {if (! ((int ()(void))PyCurses_API[2]) () ) return NULL;} #define PyCursesInitialisedColor {if (! ((int ()(void))PyCurses_API[3]) () ) return NULL;} #define import_curses() \ PyCurses_API = (void )PyCapsule_Import(PyCurses_CAPSULE_NAME, 1); #endif / general error messages / static const char catchall_ERR[] = "curses function returned ERR"; static const char catchall_NULL[] = "curses function returned NULL"; #ifdef __cplusplus } #endif #endif / !defined(Py_CURSES_H) */	2.41 KB	2025-10-09 16:16
📄 pybuffer.h /* Public Py_buffer API / #ifndef Py_BUFFER_H #define Py_BUFFER_H #ifdef __cplusplus extern "C" { #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030b0000 / === New Buffer API ============================================ * Limited API and stable ABI since Python 3.11 * * Py_buffer struct layout and size is now part of the stable abi3. The * struct layout and size 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; /* Return 1 if the getbuffer function is available, otherwise return 0. / PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject obj); /* This is a C-API version of the getbuffer function call. It checks to make sure object has the required function pointer and issues the call. Returns -1 and raises an error on failure and returns 0 on success. / PyAPI_FUNC(int) PyObject_GetBuffer(PyObject obj, Py_buffer view, int flags); / Get the memory area pointed to by the indices for the buffer given. Note that view->ndim is the assumed size of indices. / PyAPI_FUNC(void ) PyBuffer_GetPointer(const Py_buffer view, const Py_ssize_t indices); /* Return the implied itemsize of the data-format area from a struct-style description. / PyAPI_FUNC(Py_ssize_t) PyBuffer_SizeFromFormat(const char format); /* Implementation in memoryobject.c / PyAPI_FUNC(int) PyBuffer_ToContiguous(void buf, const Py_buffer view, Py_ssize_t len, char order); PyAPI_FUNC(int) PyBuffer_FromContiguous(const Py_buffer view, const void buf, Py_ssize_t len, char order); / Copy len bytes of data from the contiguous chunk of memory pointed to by buf into the buffer exported by obj. Return 0 on success and return -1 and raise a PyBuffer_Error on error (i.e. the object does not have a buffer interface or it is not working). If fort is 'F', then if the object is multi-dimensional, then the data will be copied into the array in Fortran-style (first dimension varies the fastest). If fort is 'C', then the 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 the given shape with the given number of bytes per element. / PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, Py_ssize_t shape, Py_ssize_t strides, int itemsize, char fort); /* Fills in a buffer-info structure correctly for an exporter that can only share a contiguous chunk of memory of "unsigned bytes" of the given length. Returns 0 on success and -1 (with raising an error) on error. / PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer view, PyObject o, void buf, Py_ssize_t len, int readonly, int flags); /* Releases a Py_buffer obtained from getbuffer ParseTuple's "s". / PyAPI_FUNC(void) PyBuffer_Release(Py_buffer view); / Maximum number of dimensions / #define PyBUF_MAX_NDIM 64 / Flags for getting buffers / #define PyBUF_SIMPLE 0 #define PyBUF_WRITABLE 0x0001 #ifndef Py_LIMITED_API / we used to include an E, backwards compatible alias / #define PyBUF_WRITEABLE PyBUF_WRITABLE #endif #define PyBUF_FORMAT 0x0004 #define PyBUF_ND 0x0008 #define PyBUF_STRIDES (0x0010 \| PyBUF_ND) #define PyBUF_C_CONTIGUOUS (0x0020 \| PyBUF_STRIDES) #define PyBUF_F_CONTIGUOUS (0x0040 \| PyBUF_STRIDES) #define PyBUF_ANY_CONTIGUOUS (0x0080 \| PyBUF_STRIDES) #define PyBUF_INDIRECT (0x0100 \| PyBUF_STRIDES) #define PyBUF_CONTIG (PyBUF_ND \| PyBUF_WRITABLE) #define PyBUF_CONTIG_RO (PyBUF_ND) #define PyBUF_STRIDED (PyBUF_STRIDES \| PyBUF_WRITABLE) #define PyBUF_STRIDED_RO (PyBUF_STRIDES) #define PyBUF_RECORDS (PyBUF_STRIDES \| PyBUF_WRITABLE \| PyBUF_FORMAT) #define PyBUF_RECORDS_RO (PyBUF_STRIDES \| PyBUF_FORMAT) #define PyBUF_FULL (PyBUF_INDIRECT \| PyBUF_WRITABLE \| PyBUF_FORMAT) #define PyBUF_FULL_RO (PyBUF_INDIRECT \| PyBUF_FORMAT) #define PyBUF_READ 0x100 #define PyBUF_WRITE 0x200 #endif / !Py_LIMITED_API \|\| Py_LIMITED_API >= 3.11 / #ifdef __cplusplus } #endif #endif / Py_BUFFER_H */	5 KB	2025-10-09 16:16
📄 pycapsule.h /* Capsule objects let you wrap a C "void " pointer in a Python object. They're a way of passing data through the Python interpreter without creating your own custom type. Capsules are used for communication between extension modules. They provide a way for an extension module to export a C interface to other extension modules, so that extension modules can use the Python import mechanism to link to one another. For more information, please see "c-api/capsule.html" in the documentation. / #ifndef Py_CAPSULE_H #define Py_CAPSULE_H #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyCapsule_Type; typedef void (PyCapsule_Destructor)(PyObject ); #define PyCapsule_CheckExact(op) Py_IS_TYPE(op, &PyCapsule_Type) PyAPI_FUNC(PyObject ) PyCapsule_New( void pointer, const char name, PyCapsule_Destructor destructor); PyAPI_FUNC(void ) PyCapsule_GetPointer(PyObject capsule, const char name); PyAPI_FUNC(PyCapsule_Destructor) PyCapsule_GetDestructor(PyObject capsule); PyAPI_FUNC(const char ) PyCapsule_GetName(PyObject capsule); PyAPI_FUNC(void ) PyCapsule_GetContext(PyObject capsule); PyAPI_FUNC(int) PyCapsule_IsValid(PyObject capsule, const char name); PyAPI_FUNC(int) PyCapsule_SetPointer(PyObject capsule, void pointer); PyAPI_FUNC(int) PyCapsule_SetDestructor(PyObject capsule, PyCapsule_Destructor destructor); PyAPI_FUNC(int) PyCapsule_SetName(PyObject capsule, const char name); PyAPI_FUNC(int) PyCapsule_SetContext(PyObject capsule, void context); PyAPI_FUNC(void ) PyCapsule_Import( const char name, /* UTF-8 encoded string / int no_block); #ifdef __cplusplus } #endif #endif / !Py_CAPSULE_H */	1.68 KB	2025-10-09 16:16
📄 pyconfig-64.h /* pyconfig.h. Generated from pyconfig.h.in by configure. / / pyconfig.h.in. Generated from configure.ac by autoheader. / #ifndef Py_PYCONFIG_H #define Py_PYCONFIG_H / Define if building universal (internal helper macro) / / #undef AC_APPLE_UNIVERSAL_BUILD / / BUILD_GNU_TYPE + AIX_BUILDDATE are used to construct the PEP425 tag of the build system. / / #undef AIX_BUILDDATE / / Define for AIX if your compiler is a genuine IBM xlC/xlC_r and you want support for AIX C++ shared extension modules. / / #undef AIX_GENUINE_CPLUSPLUS / / The normal alignment of `long', in bytes. / #define ALIGNOF_LONG 8 / 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 / / Define if C doubles are 64-bit IEEE 754 binary format, stored with the most significant byte first / / #undef DOUBLE_IS_BIG_ENDIAN_IEEE754 / / Define if C doubles are 64-bit IEEE 754 binary format, stored with the least significant byte first / #define DOUBLE_IS_LITTLE_ENDIAN_IEEE754 1 / Define if --enable-ipv6 is specified / #define ENABLE_IPV6 1 / Define to 1 if your system stores words within floats with the most significant word first / / #undef FLOAT_WORDS_BIGENDIAN / / Define if getpgrp() must be called as getpgrp(0). / / #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 <alloca.h> header file. / #define HAVE_ALLOCA_H 1 / Define this if your time.h defines altzone. / / #undef HAVE_ALTZONE / / Define to 1 if you have the `asinh' function. / #define HAVE_ASINH 1 / Define to 1 if you have the <asm/types.h> header file. / #define HAVE_ASM_TYPES_H 1 / Define to 1 if you have the `atanh' function. / #define HAVE_ATANH 1 / Define if you have the 'bind' function. / #define HAVE_BIND 1 / Define to 1 if you have the `bind_textdomain_codeset' function. / #define HAVE_BIND_TEXTDOMAIN_CODESET 1 / Define to 1 if you have the <bluetooth/bluetooth.h> header file. / #define HAVE_BLUETOOTH_BLUETOOTH_H 1 / Define to 1 if you have the <bluetooth.h> header file. / / #undef HAVE_BLUETOOTH_H / / Define if mbstowcs(NULL, "text", 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. / / #undef HAVE_BROKEN_NICE / / 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_sigmask() does not work on your system. / / #undef HAVE_BROKEN_PTHREAD_SIGMASK / / define to 1 if your sem_getvalue is broken. / / #undef HAVE_BROKEN_SEM_GETVALUE / / Define if 'unsetenv' does not return an int. / / #undef HAVE_BROKEN_UNSETENV / / Has builtin __atomic_load_n() and __atomic_store_n() functions / #define HAVE_BUILTIN_ATOMIC 1 / Define to 1 if you have the <bzlib.h> header file. / / #undef HAVE_BZLIB_H / / Define to 1 if you have the 'chflags' function. / / #undef HAVE_CHFLAGS / / Define to 1 if you have the `chmod' function. / #define HAVE_CHMOD 1 / Define to 1 if you have the `chown' function. / #define HAVE_CHOWN 1 / Define if you have the 'chroot' function. / #define HAVE_CHROOT 1 / Define to 1 if you have the `clock' function. / #define HAVE_CLOCK 1 / Define to 1 if you have the `clock_getres' function. / #define HAVE_CLOCK_GETRES 1 / Define to 1 if you have the `clock_gettime' function. / #define HAVE_CLOCK_GETTIME 1 / Define to 1 if you have the `clock_nanosleep' function. / #define HAVE_CLOCK_NANOSLEEP 1 / Define to 1 if you have the `clock_settime' function. / #define HAVE_CLOCK_SETTIME 1 / Define to 1 if you have the `close_range' function. / #define HAVE_CLOSE_RANGE 1 / Define if the C compiler supports computed gotos. / #define HAVE_COMPUTED_GOTOS 1 / Define to 1 if you have the `confstr' function. / #define HAVE_CONFSTR 1 / Define to 1 if you have the <conio.h> header file. / / #undef HAVE_CONIO_H / / Define if you have the 'connect' function. / #define HAVE_CONNECT 1 / Define to 1 if you have the `copy_file_range' function. / #define HAVE_COPY_FILE_RANGE 1 / Define to 1 if you have the <crypt.h> header file. / #define HAVE_CRYPT_H 1 / Define if you have the crypt_r() function. / #define HAVE_CRYPT_R 1 / Define to 1 if you have the `ctermid' function. / #define HAVE_CTERMID 1 / Define if you have the 'ctermid_r' function. / / #undef HAVE_CTERMID_R / / Define if you have the 'filter' function. / #define HAVE_CURSES_FILTER 1 / Define to 1 if you have the <curses.h> header file. / #define HAVE_CURSES_H 1 / Define if you have the 'has_key' function. / #define HAVE_CURSES_HAS_KEY 1 / Define if you have the 'immedok' function. / #define HAVE_CURSES_IMMEDOK 1 / Define if you have the 'is_pad' function. / #define HAVE_CURSES_IS_PAD 1 / Define if you have the 'is_term_resized' function. / #define HAVE_CURSES_IS_TERM_RESIZED 1 / Define if you have the 'resizeterm' function. / #define HAVE_CURSES_RESIZETERM 1 / Define if you have the 'resize_term' function. / #define HAVE_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 <db.h> 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_DEEPBIND 1 / Define to 1 if you have the declaration of `RTLD_GLOBAL', and to 0 if you don't. / #define HAVE_DECL_RTLD_GLOBAL 1 / Define to 1 if you have the declaration of `RTLD_LAZY', and to 0 if you don't. / #define HAVE_DECL_RTLD_LAZY 1 / Define to 1 if you have the declaration of `RTLD_LOCAL', and to 0 if you don't. / #define HAVE_DECL_RTLD_LOCAL 1 / Define to 1 if you have the declaration of `RTLD_MEMBER', and to 0 if you don't. / #define HAVE_DECL_RTLD_MEMBER 0 / Define to 1 if you have the declaration of `RTLD_NODELETE', and to 0 if you don't. / #define HAVE_DECL_RTLD_NODELETE 1 / Define to 1 if you have the declaration of `RTLD_NOLOAD', and to 0 if you don't. / #define HAVE_DECL_RTLD_NOLOAD 1 / Define to 1 if you have the declaration of `RTLD_NOW', and to 0 if you don't. / #define HAVE_DECL_RTLD_NOW 1 / Define to 1 if you have the declaration of `tzname', and to 0 if you don't. / / #undef HAVE_DECL_TZNAME / / Define to 1 if you have the device macros. / #define HAVE_DEVICE_MACROS 1 / Define to 1 if you have the /dev/ptc device file. / / #undef HAVE_DEV_PTC / / Define to 1 if you have the /dev/ptmx device file. / #define HAVE_DEV_PTMX 1 / Define to 1 if you have the <direct.h> header file. / / #undef HAVE_DIRECT_H / / Define to 1 if the dirent structure has a d_type field / #define HAVE_DIRENT_D_TYPE 1 / Define to 1 if you have the <dirent.h> header file, and it defines `DIR'. / #define HAVE_DIRENT_H 1 / Define if you have the 'dirfd' function or macro. / #define HAVE_DIRFD 1 / Define to 1 if you have the <dlfcn.h> header file. / #define HAVE_DLFCN_H 1 / Define to 1 if you have the `dlopen' function. / #define HAVE_DLOPEN 1 / Define to 1 if you have the `dup' function. / #define HAVE_DUP 1 / Define to 1 if you have the `dup2' function. / #define HAVE_DUP2 1 / Define to 1 if you 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 <endian.h> header file. / #define HAVE_ENDIAN_H 1 / Define if you have the 'epoll_create' function. / #define HAVE_EPOLL 1 / Define if you have the 'epoll_create1' function. / #define HAVE_EPOLL_CREATE1 1 / Define to 1 if you have the `erf' function. / #define HAVE_ERF 1 / Define to 1 if you have the `erfc' function. / #define HAVE_ERFC 1 / Define to 1 if you have the <errno.h> header file. / #define HAVE_ERRNO_H 1 / Define if you have the 'eventfd' function. / #define HAVE_EVENTFD 1 / Define to 1 if you have the `execv' function. / #define HAVE_EXECV 1 / Define to 1 if you have the `explicit_bzero' function. / #define HAVE_EXPLICIT_BZERO 1 / Define to 1 if you have the `explicit_memset' function. / / #undef HAVE_EXPLICIT_MEMSET / / Define to 1 if you have the `expm1' function. / #define HAVE_EXPM1 1 / Define to 1 if you have the `faccessat' function. / #define HAVE_FACCESSAT 1 / Define if you have the 'fchdir' function. / #define HAVE_FCHDIR 1 / Define to 1 if you have the `fchmod' function. / #define HAVE_FCHMOD 1 / Define to 1 if you have the `fchmodat' function. / #define HAVE_FCHMODAT 1 / Define to 1 if you have the `fchown' function. / #define HAVE_FCHOWN 1 / Define to 1 if you have the `fchownat' function. / #define HAVE_FCHOWNAT 1 / Define to 1 if you have the <fcntl.h> header file. / #define HAVE_FCNTL_H 1 / Define if you have the 'fdatasync' function. / #define HAVE_FDATASYNC 1 / Define to 1 if you have the `fdopendir' function. / #define HAVE_FDOPENDIR 1 / Define to 1 if you have the `fdwalk' function. / / #undef HAVE_FDWALK / / Define to 1 if you have the `fexecve' function. / #define HAVE_FEXECVE 1 / Define to 1 if you have the `flock' function. / #define HAVE_FLOCK 1 / Define to 1 if you have the `fork' function. / #define HAVE_FORK 1 / Define to 1 if you have the `fork1' function. / / #undef HAVE_FORK1 / / Define to 1 if you have the `forkpty' function. / #define HAVE_FORKPTY 1 / Define to 1 if you have the `fpathconf' function. / #define HAVE_FPATHCONF 1 / Define to 1 if you have the `fseek64' function. / / #undef HAVE_FSEEK64 / / Define to 1 if you have the `fseeko' function. / #define HAVE_FSEEKO 1 / Define to 1 if you have the `fstatat' function. / #define HAVE_FSTATAT 1 / Define to 1 if you have the `fstatvfs' function. / #define HAVE_FSTATVFS 1 / Define if you have the 'fsync' function. / #define HAVE_FSYNC 1 / Define to 1 if you have the `ftell64' function. / / #undef HAVE_FTELL64 / / Define to 1 if you have the `ftello' function. / #define HAVE_FTELLO 1 / Define to 1 if you have the `ftime' function. / #define HAVE_FTIME 1 / Define to 1 if you have the `ftruncate' function. / #define HAVE_FTRUNCATE 1 / Define to 1 if you have the `futimens' function. / #define HAVE_FUTIMENS 1 / Define to 1 if you have the `futimes' function. / #define HAVE_FUTIMES 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 __uint128_t / #define HAVE_GCC_UINT128_T 1 / Define to 1 if you have the <gdbm-ndbm.h> header file. / / #undef HAVE_GDBM_DASH_NDBM_H / / Define to 1 if you have the <gdbm.h> header file. / #define HAVE_GDBM_H 1 / Define to 1 if you have the <gdbm/ndbm.h> header file. / #define HAVE_GDBM_NDBM_H 1 / Define if you have the getaddrinfo function. / #define HAVE_GETADDRINFO 1 / Define this if you have flockfile(), getc_unlocked(), and funlockfile() / #define HAVE_GETC_UNLOCKED 1 / Define to 1 if you have the `getegid' function. / #define HAVE_GETEGID 1 / Define to 1 if you have the `getentropy' function. / #define HAVE_GETENTROPY 1 / Define to 1 if you have the `geteuid' function. / #define HAVE_GETEUID 1 / Define to 1 if you have the `getgid' function. / #define HAVE_GETGID 1 / Define to 1 if you have the `getgrgid' function. / #define HAVE_GETGRGID 1 / Define to 1 if you have the `getgrgid_r' function. / #define HAVE_GETGRGID_R 1 / Define to 1 if you have the `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 version of gethostbyname_r(). / / #undef HAVE_GETHOSTBYNAME_R_3_ARG / / Define this if you have the 5-arg version of gethostbyname_r(). / / #undef HAVE_GETHOSTBYNAME_R_5_ARG / / Define this if you have the 6-arg version of gethostbyname_r(). / #define HAVE_GETHOSTBYNAME_R_6_ARG 1 / Define to 1 if you have the `gethostname' function. / #define HAVE_GETHOSTNAME 1 / Define to 1 if you have the `getitimer' function. / #define HAVE_GETITIMER 1 / Define to 1 if you have the `getloadavg' function. / #define HAVE_GETLOADAVG 1 / Define to 1 if you have the `getlogin' function. / #define HAVE_GETLOGIN 1 / Define to 1 if you have the `getnameinfo' function. / #define HAVE_GETNAMEINFO 1 / Define if you have the 'getpagesize' function. / #define HAVE_GETPAGESIZE 1 / Define if you have the 'getpeername' function. / #define HAVE_GETPEERNAME 1 / Define to 1 if you have the `getpgid' function. / #define HAVE_GETPGID 1 / Define to 1 if you have the `getpgrp' function. / #define HAVE_GETPGRP 1 / Define to 1 if you have the `getpid' function. / #define HAVE_GETPID 1 / Define to 1 if you have the `getppid' function. / #define HAVE_GETPPID 1 / Define to 1 if you have the `getpriority' function. / #define HAVE_GETPRIORITY 1 / Define if you have the 'getprotobyname' function. / #define HAVE_GETPROTOBYNAME 1 / Define to 1 if you have the `getpwent' function. / #define HAVE_GETPWENT 1 / Define to 1 if you have the `getpwnam_r' function. / #define HAVE_GETPWNAM_R 1 / Define to 1 if you have the `getpwuid' function. / #define HAVE_GETPWUID 1 / Define to 1 if you have the `getpwuid_r' function. / #define HAVE_GETPWUID_R 1 / Define to 1 if the getrandom() function is available / #define HAVE_GETRANDOM 1 / Define to 1 if the Linux getrandom() syscall is available / #define HAVE_GETRANDOM_SYSCALL 1 / Define to 1 if you have the `getresgid' function. / #define HAVE_GETRESGID 1 / Define to 1 if you have the `getresuid' function. / #define HAVE_GETRESUID 1 / Define to 1 if you have the `getrusage' function. / #define HAVE_GETRUSAGE 1 / Define if you have the 'getservbyname' function. / #define HAVE_GETSERVBYNAME 1 / Define if you have the 'getservbyport' function. / #define HAVE_GETSERVBYPORT 1 / Define to 1 if you have the `getsid' function. / #define HAVE_GETSID 1 / Define if you have the 'getsockname' function. / #define HAVE_GETSOCKNAME 1 / Define to 1 if you have the `getspent' function. / #define HAVE_GETSPENT 1 / Define to 1 if you have the `getspnam' function. / #define HAVE_GETSPNAM 1 / Define to 1 if you have the `getuid' function. / #define HAVE_GETUID 1 / Define to 1 if you have the `getwd' function. / #define HAVE_GETWD 1 / Define if glibc has incorrect _FORTIFY_SOURCE wrappers for memmove and bcopy. / #define HAVE_GLIBC_MEMMOVE_BUG 1 / Define to 1 if you have the <grp.h> header file. / #define HAVE_GRP_H 1 / Define if you have the 'hstrerror' function. / #define HAVE_HSTRERROR 1 / Define this if you have le64toh() / #define HAVE_HTOLE64 1 / Define to 1 if you have the <ieeefp.h> header file. / / #undef HAVE_IEEEFP_H / / Define to 1 if you have the `if_nameindex' function. / #define HAVE_IF_NAMEINDEX 1 / Define if you have the 'inet_aton' function. / #define HAVE_INET_ATON 1 / Define if you have the 'inet_ntoa' function. / #define HAVE_INET_NTOA 1 / Define if you have the 'inet_pton' function. / #define HAVE_INET_PTON 1 / Define to 1 if you have the `initgroups' function. / #define HAVE_INITGROUPS 1 / Define to 1 if you have the <inttypes.h> header file. / #define HAVE_INTTYPES_H 1 / Define to 1 if you have the <io.h> header file. / / #undef HAVE_IO_H / / Define if gcc has the ipa-pure-const bug. / #define HAVE_IPA_PURE_CONST_BUG 1 / 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 <langinfo.h> 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 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 / / Define to 1 if you have the `dl' library (-ldl). / #define HAVE_LIBDL 1 / Define to 1 if you have the `dld' library (-ldld). / / #undef HAVE_LIBDLD / / Define to 1 if you have the `gdbm_compat' library (-lgdbm_compat). / #define HAVE_LIBGDBM_COMPAT 1 / Define to 1 if you have the `ieee' library (-lieee). / / #undef HAVE_LIBIEEE / / Define to 1 if you have the <libintl.h> header file. / #define HAVE_LIBINTL_H 1 / Define to 1 if you have the `ndbm' library (-lndbm). / / #undef HAVE_LIBNDBM / / Define to build the readline module. / #define HAVE_LIBREADLINE 1 / Define to 1 if you have the `resolv' library (-lresolv). / / #undef HAVE_LIBRESOLV / / Define to 1 if you have the `sendfile' library (-lsendfile). / / #undef HAVE_LIBSENDFILE / / Define to 1 if you have the `sqlite3' library (-lsqlite3). / #define HAVE_LIBSQLITE3 1 / Define to 1 if you have the <libutil.h> header file. / / #undef HAVE_LIBUTIL_H / / Define if you have the 'link' function. / #define HAVE_LINK 1 / Define to 1 if you have the `linkat' function. / #define HAVE_LINKAT 1 / Define to 1 if you have the <linux/auxvec.h> header file. / #define HAVE_LINUX_AUXVEC_H 1 / Define to 1 if you have the <linux/can/bcm.h> header file. / #define HAVE_LINUX_CAN_BCM_H 1 / Define to 1 if you have the <linux/can.h> header file. / #define HAVE_LINUX_CAN_H 1 / Define to 1 if you have the <linux/can/j1939.h> header file. / #define HAVE_LINUX_CAN_J1939_H 1 / Define if compiling using Linux 3.6 or later. / #define HAVE_LINUX_CAN_RAW_FD_FRAMES 1 / Define to 1 if you have the <linux/can/raw.h> header file. / #define HAVE_LINUX_CAN_RAW_H 1 / Define if compiling using Linux 4.1 or later. / #define HAVE_LINUX_CAN_RAW_JOIN_FILTERS 1 / Define to 1 if you have the <linux/limits.h> header file. / #define HAVE_LINUX_LIMITS_H 1 / Define to 1 if you have the <linux/memfd.h> header file. / #define HAVE_LINUX_MEMFD_H 1 / Define to 1 if you have the <linux/netlink.h> header file. / #define HAVE_LINUX_NETLINK_H 1 / Define to 1 if you have the <linux/qrtr.h> header file. / #define HAVE_LINUX_QRTR_H 1 / Define to 1 if you have the <linux/random.h> header file. / #define HAVE_LINUX_RANDOM_H 1 / Define to 1 if you have the <linux/soundcard.h> header file. / #define HAVE_LINUX_SOUNDCARD_H 1 / Define to 1 if you have the <linux/tipc.h> header file. / #define HAVE_LINUX_TIPC_H 1 / Define to 1 if you have the <linux/vm_sockets.h> header file. / #define HAVE_LINUX_VM_SOCKETS_H 1 / Define to 1 if you have the <linux/wait.h> header file. / #define HAVE_LINUX_WAIT_H 1 / Define if you have the 'listen' function. / #define HAVE_LISTEN 1 / Define to 1 if you have the `lockf' function. / #define HAVE_LOCKF 1 / Define to 1 if you have the `log1p' function. / #define HAVE_LOG1P 1 / Define to 1 if you have the `log2' function. / #define HAVE_LOG2 1 / Define to 1 if you have the `login_tty' function. / #define HAVE_LOGIN_TTY 1 / Define to 1 if the system has the type `long double'. / #define HAVE_LONG_DOUBLE 1 / Define to 1 if you have the `lstat' function. / #define HAVE_LSTAT 1 / Define to 1 if you have the `lutimes' function. / #define HAVE_LUTIMES 1 / Define to 1 if you have the <lzma.h> header file. / / #undef HAVE_LZMA_H / / Define to 1 if you have the `madvise' function. / #define HAVE_MADVISE 1 / Define this if you have the makedev macro. / #define HAVE_MAKEDEV 1 / Define to 1 if you have the `mbrtowc' function. / #define HAVE_MBRTOWC 1 / Define if you have the 'memfd_create' function. / #define HAVE_MEMFD_CREATE 1 / Define to 1 if you have the <memory.h> header file. / #define HAVE_MEMORY_H 1 / Define to 1 if you have the `memrchr' function. / #define HAVE_MEMRCHR 1 / Define to 1 if you have the `mkdirat' function. / #define HAVE_MKDIRAT 1 / Define to 1 if you have the `mkfifo' function. / #define HAVE_MKFIFO 1 / Define to 1 if you have the `mkfifoat' function. / #define HAVE_MKFIFOAT 1 / Define to 1 if you have the `mknod' function. / #define HAVE_MKNOD 1 / Define to 1 if you have the `mknodat' function. / #define HAVE_MKNODAT 1 / Define to 1 if you have the `mktime' function. / #define HAVE_MKTIME 1 / Define to 1 if you have the `mmap' function. / #define HAVE_MMAP 1 / Define to 1 if you 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 <ncurses.h> header file. / #define HAVE_NCURSES_H 1 / Define to 1 if you have the <ndbm.h> header file. / #define HAVE_NDBM_H 1 / Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. / / #undef HAVE_NDIR_H / / Define to 1 if you have the <netcan/can.h> header file. / / #undef HAVE_NETCAN_CAN_H / / Define to 1 if you have the <netdb.h> header file. / #define HAVE_NETDB_H 1 / Define to 1 if you have the <netinet/in.h> header file. / #define HAVE_NETINET_IN_H 1 / Define to 1 if you have the <netpacket/packet.h> header file. / #define HAVE_NETPACKET_PACKET_H 1 / Define to 1 if you have the <net/if.h> header file. / #define HAVE_NET_IF_H 1 / Define to 1 if you have the `nice' function. / #define HAVE_NICE 1 / Define if the internal form of wchar_t in non-Unicode locales is not Unicode. / / #undef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION / / Define to 1 if you have the `openat' function. / #define HAVE_OPENAT 1 / Define to 1 if you have the `opendir' function. / #define HAVE_OPENDIR 1 / Define to 1 if you have the `openpty' function. / #define HAVE_OPENPTY 1 / Define to 1 if you have the `pathconf' function. / #define HAVE_PATHCONF 1 / Define to 1 if you have the `pause' function. / #define HAVE_PAUSE 1 / Define to 1 if you have the `pipe' function. / #define HAVE_PIPE 1 / Define to 1 if you have the `pipe2' function. / #define HAVE_PIPE2 1 / Define to 1 if you have the `plock' function. / / #undef HAVE_PLOCK / / Define to 1 if you have the `poll' function. / #define HAVE_POLL 1 / Define to 1 if you have the <poll.h> header file. / #define HAVE_POLL_H 1 / Define to 1 if you have the `posix_fadvise' function. / #define HAVE_POSIX_FADVISE 1 / Define to 1 if you have the `posix_fallocate' function. / #define HAVE_POSIX_FALLOCATE 1 / Define to 1 if you have the `posix_spawn' function. / #define HAVE_POSIX_SPAWN 1 / Define to 1 if you have the `posix_spawnp' function. / #define HAVE_POSIX_SPAWNP 1 / Define to 1 if you have the `pread' function. / #define HAVE_PREAD 1 / Define to 1 if you have the `preadv' function. / #define HAVE_PREADV 1 / Define to 1 if you have the `preadv2' function. / #define HAVE_PREADV2 1 / Define if you have the 'prlimit' function. / #define HAVE_PRLIMIT 1 / Define to 1 if you have the <process.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 <pthread.h> header file. / #define HAVE_PTHREAD_H 1 / Define to 1 if you have the `pthread_init' function. / / #undef HAVE_PTHREAD_INIT / / Define to 1 if you have the `pthread_kill' function. / #define HAVE_PTHREAD_KILL 1 / Define to 1 if you have the `pthread_sigmask' function. / #define HAVE_PTHREAD_SIGMASK 1 / Define if platform requires stubbed pthreads support / / #undef HAVE_PTHREAD_STUBS / / Define to 1 if you have the <pty.h> header file. / #define HAVE_PTY_H 1 / Define to 1 if you have the `pwrite' function. / #define HAVE_PWRITE 1 / Define to 1 if you have the `pwritev' function. / #define HAVE_PWRITEV 1 / Define to 1 if you have the `pwritev2' function. / #define HAVE_PWRITEV2 1 / Define to 1 if you have the `readlink' function. / #define HAVE_READLINK 1 / Define to 1 if you have the `readlinkat' function. / #define HAVE_READLINKAT 1 / Define to 1 if you have the `readv' function. / #define HAVE_READV 1 / Define to 1 if you have the `realpath' function. / #define HAVE_REALPATH 1 / Define if you have 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 / #define HAVE_RL_APPEND_HISTORY 1 / Define if you can turn off readline's signal handling. / #define HAVE_RL_CATCH_SIGNAL 1 / Define if readline supports rl_compdisp_func_t / #define HAVE_RL_COMPDISP_FUNC_T 1 / Define if you have readline 2.2 / #define HAVE_RL_COMPLETION_APPEND_CHARACTER 1 / Define if you have readline 4.0 / #define HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK 1 / Define if you have readline 4.2 / #define HAVE_RL_COMPLETION_MATCHES 1 / Define if you have rl_completion_suppress_append / #define HAVE_RL_COMPLETION_SUPPRESS_APPEND 1 / Define if you have readline 4.0 / #define HAVE_RL_PRE_INPUT_HOOK 1 / Define if you have readline 4.0 / #define HAVE_RL_RESIZE_TERMINAL 1 / Define to 1 if you have the <rpc/rpc.h> header file. / #define HAVE_RPC_RPC_H 1 / Define to 1 if you have the `rtpSpawn' function. / / #undef HAVE_RTPSPAWN / / Define to 1 if you have the `sched_get_priority_max' function. / #define HAVE_SCHED_GET_PRIORITY_MAX 1 / Define to 1 if you have the <sched.h> header file. / #define HAVE_SCHED_H 1 / Define to 1 if you have the `sched_rr_get_interval' function. / #define HAVE_SCHED_RR_GET_INTERVAL 1 / Define to 1 if you have the `sched_setaffinity' function. / #define HAVE_SCHED_SETAFFINITY 1 / Define to 1 if you have the `sched_setparam' function. / #define HAVE_SCHED_SETPARAM 1 / Define to 1 if you have the `sched_setscheduler' function. / #define HAVE_SCHED_SETSCHEDULER 1 / Define to 1 if you have the `sem_clockwait' function. / #define HAVE_SEM_CLOCKWAIT 1 / Define to 1 if you have the `sem_getvalue' function. / #define HAVE_SEM_GETVALUE 1 / Define to 1 if you have 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 / Define to 1 if you have the `setgid' function. / #define HAVE_SETGID 1 / Define if you have the 'setgroups' function. / #define HAVE_SETGROUPS 1 / Define to 1 if you have the `sethostname' function. / #define HAVE_SETHOSTNAME 1 / Define to 1 if you have the `setitimer' function. / #define HAVE_SETITIMER 1 / Define to 1 if you have the <setjmp.h> header file. / #define HAVE_SETJMP_H 1 / Define to 1 if you have the `setlocale' function. / #define HAVE_SETLOCALE 1 / Define to 1 if you have the `setpgid' function. / #define HAVE_SETPGID 1 / Define to 1 if you have the `setpgrp' function. / #define HAVE_SETPGRP 1 / Define to 1 if you have the `setpriority' function. / #define HAVE_SETPRIORITY 1 / Define to 1 if you have the `setregid' function. / #define HAVE_SETREGID 1 / Define to 1 if you have the `setresgid' function. / #define HAVE_SETRESGID 1 / Define to 1 if you have the `setresuid' function. / #define HAVE_SETRESUID 1 / Define to 1 if you have the `setreuid' function. / #define HAVE_SETREUID 1 / Define to 1 if you have the `setsid' function. / #define HAVE_SETSID 1 / Define if you have the 'setsockopt' function. / #define HAVE_SETSOCKOPT 1 / Define to 1 if you have the `setuid' function. / #define HAVE_SETUID 1 / Define to 1 if you have the `setvbuf' function. / #define HAVE_SETVBUF 1 / Define to 1 if you have the <shadow.h> header file. / #define HAVE_SHADOW_H 1 / Define to 1 if you have the `shm_open' function. / #define HAVE_SHM_OPEN 1 / Define to 1 if you have the `shm_unlink' function. / #define HAVE_SHM_UNLINK 1 / Define to 1 if you have the `shutdown' function. / #define HAVE_SHUTDOWN 1 / Define to 1 if you have the `sigaction' function. / #define HAVE_SIGACTION 1 / Define to 1 if you have the `sigaltstack' function. / #define HAVE_SIGALTSTACK 1 / Define to 1 if you have the `sigfillset' function. / #define HAVE_SIGFILLSET 1 / Define to 1 if `si_band' is a member of `siginfo_t'. / #define HAVE_SIGINFO_T_SI_BAND 1 / Define to 1 if you have the `siginterrupt' function. / #define HAVE_SIGINTERRUPT 1 / Define to 1 if you have the <signal.h> header file. / #define HAVE_SIGNAL_H 1 / Define to 1 if you have the `sigpending' function. / #define HAVE_SIGPENDING 1 / Define to 1 if you have the `sigrelse' function. / #define HAVE_SIGRELSE 1 / Define to 1 if you have the `sigtimedwait' function. / #define HAVE_SIGTIMEDWAIT 1 / Define to 1 if you have the `sigwait' function. / #define HAVE_SIGWAIT 1 / Define to 1 if you have the `sigwaitinfo' function. / #define HAVE_SIGWAITINFO 1 / Define to 1 if you have the `snprintf' function. / #define HAVE_SNPRINTF 1 / struct sockaddr_alg (linux/if_alg.h) / #define HAVE_SOCKADDR_ALG 1 / Define if sockaddr has sa_len member / / #undef HAVE_SOCKADDR_SA_LEN / / struct sockaddr_storage (sys/socket.h) / #define HAVE_SOCKADDR_STORAGE 1 / Define if you have the 'socket' function. / #define HAVE_SOCKET 1 / Define if you have the 'socketpair' function. / #define HAVE_SOCKETPAIR 1 / Define to 1 if you have the <spawn.h> header file. / #define HAVE_SPAWN_H 1 / Define to 1 if you have the `splice' function. / #define HAVE_SPLICE 1 / Define if your compiler provides ssize_t / #define HAVE_SSIZE_T 1 / Define to 1 if you have the `statvfs' function. / #define HAVE_STATVFS 1 / Define if you have struct stat.st_mtim.tv_nsec / #define HAVE_STAT_TV_NSEC 1 / Define if you have struct stat.st_mtimensec / / #undef HAVE_STAT_TV_NSEC2 / / Define if your compiler supports variable length function prototypes (e.g. void fprintf(FILE , char , ...);) and <stdarg.h> / #define HAVE_STDARG_PROTOTYPES 1 / Define to 1 if you have the <stdint.h> header file. / #define HAVE_STDINT_H 1 / Define to 1 if you have the <stdlib.h> 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 <strings.h> header file. / #define HAVE_STRINGS_H 1 / Define to 1 if you have the <string.h> header file. / #define HAVE_STRING_H 1 / Define to 1 if you have the `strlcpy' function. / / #undef HAVE_STRLCPY / / Define to 1 if you have the <stropts.h> header file. / / #undef HAVE_STROPTS_H / / Define to 1 if you have the `strsignal' function. / #define HAVE_STRSIGNAL 1 / Define to 1 if `pw_gecos' is a member of `struct passwd'. / #define HAVE_STRUCT_PASSWD_PW_GECOS 1 / Define to 1 if `pw_passwd' is a member of `struct passwd'. / #define HAVE_STRUCT_PASSWD_PW_PASSWD 1 / Define to 1 if `st_birthtime' is a member of `struct stat'. / / #undef HAVE_STRUCT_STAT_ST_BIRTHTIME / / Define to 1 if `st_blksize' is a member of `struct stat'. / #define HAVE_STRUCT_STAT_ST_BLKSIZE 1 / Define to 1 if `st_blocks' is a member of `struct stat'. / #define HAVE_STRUCT_STAT_ST_BLOCKS 1 / Define to 1 if `st_flags' is a member of `struct stat'. / / #undef HAVE_STRUCT_STAT_ST_FLAGS / / Define to 1 if `st_gen' is a member of `struct stat'. / / #undef HAVE_STRUCT_STAT_ST_GEN / / Define to 1 if `st_rdev' is a member of `struct 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 <sysexits.h> header file. / #define HAVE_SYSEXITS_H 1 / Define to 1 if you have the <syslog.h> header file. / #define HAVE_SYSLOG_H 1 / Define to 1 if you have the `system' function. / #define HAVE_SYSTEM 1 / Define to 1 if you have the <sys/audioio.h> header file. / / #undef HAVE_SYS_AUDIOIO_H / / Define to 1 if you have the <sys/auxv.h> header file. / #define HAVE_SYS_AUXV_H 1 / Define to 1 if you have the <sys/bsdtty.h> header file. / / #undef HAVE_SYS_BSDTTY_H / / Define to 1 if you have the <sys/devpoll.h> header file. / / #undef HAVE_SYS_DEVPOLL_H / / Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'. / / #undef HAVE_SYS_DIR_H / / Define to 1 if you have the <sys/endian.h> header file. / / #undef HAVE_SYS_ENDIAN_H / / Define to 1 if you have the <sys/epoll.h> header file. / #define HAVE_SYS_EPOLL_H 1 / Define to 1 if you have the <sys/eventfd.h> header file. / #define HAVE_SYS_EVENTFD_H 1 / Define to 1 if you have the <sys/event.h> header file. / / #undef HAVE_SYS_EVENT_H / / Define to 1 if you have the <sys/file.h> header file. / #define HAVE_SYS_FILE_H 1 / Define to 1 if you have the <sys/ioctl.h> header file. / #define HAVE_SYS_IOCTL_H 1 / Define to 1 if you have the <sys/kern_control.h> header file. / / #undef HAVE_SYS_KERN_CONTROL_H / / Define to 1 if you have the <sys/loadavg.h> header file. / / #undef HAVE_SYS_LOADAVG_H / / Define to 1 if you have the <sys/lock.h> header file. / / #undef HAVE_SYS_LOCK_H / / Define to 1 if you have the <sys/memfd.h> header file. / / #undef HAVE_SYS_MEMFD_H / / Define to 1 if you have the <sys/mkdev.h> header file. / / #undef HAVE_SYS_MKDEV_H / / Define to 1 if you have the <sys/mman.h> header file. / #define HAVE_SYS_MMAN_H 1 / Define to 1 if you have the <sys/modem.h> header file. / / #undef HAVE_SYS_MODEM_H / / Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'. / / #undef HAVE_SYS_NDIR_H / / Define to 1 if you have the <sys/param.h> header file. / #define HAVE_SYS_PARAM_H 1 / Define to 1 if you have the <sys/poll.h> header file. / #define HAVE_SYS_POLL_H 1 / Define to 1 if you have the <sys/random.h> header file. / #define HAVE_SYS_RANDOM_H 1 / Define to 1 if you have the <sys/resource.h> header file. / #define HAVE_SYS_RESOURCE_H 1 / Define to 1 if you have the <sys/select.h> header file. / #define HAVE_SYS_SELECT_H 1 / Define to 1 if you have the <sys/sendfile.h> header file. / #define HAVE_SYS_SENDFILE_H 1 / Define to 1 if you have the <sys/socket.h> header file. / #define HAVE_SYS_SOCKET_H 1 / Define to 1 if you have the <sys/soundcard.h> header file. / #define HAVE_SYS_SOUNDCARD_H 1 / Define to 1 if you have the <sys/statvfs.h> header file. / #define HAVE_SYS_STATVFS_H 1 / Define to 1 if you have the <sys/stat.h> header file. / #define HAVE_SYS_STAT_H 1 / Define to 1 if you have the <sys/syscall.h> header file. / #define HAVE_SYS_SYSCALL_H 1 / Define to 1 if you have the <sys/sysmacros.h> header file. / #define HAVE_SYS_SYSMACROS_H 1 / Define to 1 if you have the <sys/sys_domain.h> header file. / / #undef HAVE_SYS_SYS_DOMAIN_H / / Define to 1 if you have the <sys/termio.h> header file. / / #undef HAVE_SYS_TERMIO_H / / Define to 1 if you have the <sys/times.h> header file. / #define HAVE_SYS_TIMES_H 1 / Define to 1 if you have the <sys/time.h> header file. / #define HAVE_SYS_TIME_H 1 / Define to 1 if you have the <sys/types.h> header file. / #define HAVE_SYS_TYPES_H 1 / Define to 1 if you have the <sys/uio.h> header file. / #define HAVE_SYS_UIO_H 1 / Define to 1 if you have the <sys/un.h> header file. / #define HAVE_SYS_UN_H 1 / Define to 1 if you have the <sys/utsname.h> header file. / #define HAVE_SYS_UTSNAME_H 1 / Define to 1 if you have the <sys/wait.h> header file. / #define HAVE_SYS_WAIT_H 1 / Define to 1 if you have the <sys/xattr.h> header file. / #define HAVE_SYS_XATTR_H 1 / Define to 1 if you have the `tcgetpgrp' function. / #define HAVE_TCGETPGRP 1 / Define to 1 if you have the `tcsetpgrp' function. / #define HAVE_TCSETPGRP 1 / Define to 1 if you have the `tempnam' function. / #define HAVE_TEMPNAM 1 / Define to 1 if you have the <termios.h> header file. / #define HAVE_TERMIOS_H 1 / Define to 1 if you have the <term.h> header file. / #define HAVE_TERM_H 1 / Define to 1 if you have the `timegm' function. / #define HAVE_TIMEGM 1 / Define to 1 if you have the `times' function. / #define HAVE_TIMES 1 / Define to 1 if you have the `tmpfile' function. / #define HAVE_TMPFILE 1 / Define to 1 if you have the `tmpnam' function. / #define HAVE_TMPNAM 1 / Define to 1 if you have the `tmpnam_r' function. / #define HAVE_TMPNAM_R 1 / Define to 1 if your `struct tm' has `tm_zone'. Deprecated, use `HAVE_STRUCT_TM_TM_ZONE' instead. / #define HAVE_TM_ZONE 1 / Define to 1 if you have the `truncate' function. / #define HAVE_TRUNCATE 1 / Define to 1 if you have the `ttyname' function. / #define HAVE_TTYNAME 1 / Define to 1 if you don't have `tm_zone' but do have the external array `tzname'. / / #undef HAVE_TZNAME / / Define to 1 if you have the `umask' function. / #define HAVE_UMASK 1 / Define to 1 if you have the `uname' function. / #define HAVE_UNAME 1 / Define to 1 if you have the <unistd.h> header file. / #define HAVE_UNISTD_H 1 / Define to 1 if you have the `unlinkat' function. / #define HAVE_UNLINKAT 1 / Define if you have a useable wchar_t type defined in wchar.h; useable means wchar_t must be an unsigned type with at least 16 bits. (see Include/unicodeobject.h). / / #undef HAVE_USABLE_WCHAR_T / / Define to 1 if you have the <util.h> header file. / / #undef HAVE_UTIL_H / / Define to 1 if you have the `utimensat' function. / #define HAVE_UTIMENSAT 1 / Define to 1 if you have the `utimes' function. / #define HAVE_UTIMES 1 / Define to 1 if you have the <utime.h> header file. / #define HAVE_UTIME_H 1 / Define to 1 if you have the <utmp.h> header file. / #define HAVE_UTMP_H 1 / Define to 1 if you have the `uuid_create' function. / / #undef HAVE_UUID_CREATE / / Define to 1 if you have the `uuid_enc_be' function. / / #undef HAVE_UUID_ENC_BE / / Define if uuid_generate_time_safe() exists. / #define HAVE_UUID_GENERATE_TIME_SAFE 1 / Define to 1 if you have the <uuid.h> header file. / #define HAVE_UUID_H 1 / Define to 1 if you have the <uuid/uuid.h> header file. / / #undef HAVE_UUID_UUID_H / / Define to 1 if you have the `vfork' function. / #define HAVE_VFORK 1 / Define to 1 if you have the `wait' function. / #define HAVE_WAIT 1 / Define to 1 if you have the `wait3' function. / #define HAVE_WAIT3 1 / Define to 1 if you have the `wait4' function. / #define HAVE_WAIT4 1 / Define to 1 if you have the `waitid' function. / #define HAVE_WAITID 1 / Define to 1 if you have the `waitpid' function. / #define HAVE_WAITPID 1 / Define if the compiler provides a wchar.h header file. / #define HAVE_WCHAR_H 1 / Define to 1 if you have the `wcscoll' function. / #define HAVE_WCSCOLL 1 / Define to 1 if you have the `wcsftime' function. / #define HAVE_WCSFTIME 1 / Define to 1 if you have the `wcsxfrm' function. / #define HAVE_WCSXFRM 1 / Define to 1 if you have the `wmemcmp' function. / #define HAVE_WMEMCMP 1 / Define if tzset() actually switches the local timezone in a meaningful way. / #define HAVE_WORKING_TZSET 1 / Define to 1 if you have the `writev' function. / #define HAVE_WRITEV 1 / Define if the zlib library has inflateCopy / #define HAVE_ZLIB_COPY 1 / Define to 1 if you have the <zlib.h> header file. / / #undef HAVE_ZLIB_H / / Define to 1 if you have the `_getpty' function. / / #undef HAVE__GETPTY / / Define to 1 if `major', `minor', and `makedev' are declared in <mkdev.h>. / / #undef MAJOR_IN_MKDEV / / Define to 1 if `major', `minor', and `makedev' are declared in <sysmacros.h>. / #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 / / Define to the one symbol short name of this package. / / #undef PACKAGE_TARNAME / / Define to the home page for this package. / / #undef PACKAGE_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_HASHLIB_HASHES "md5,sha1,sha256,sha512,sha3,blake2" / Define if you want to coerce the C locale to a UTF-8 based locale / #define PY_COERCE_C_LOCALE 1 / Define to printf format modifier for Py_ssize_t / #define PY_FORMAT_SIZE_T "z" / Define to 1 to build the sqlite module with loadable extensions support. / #define PY_SQLITE_ENABLE_LOAD_EXTENSION 1 / Define if SQLite was compiled with the serialize API / #define PY_SQLITE_HAVE_SERIALIZE 1 / Default cipher suites list for ssl module. 1: Python's preferred selection, 2: leave OpenSSL defaults untouched, 0: custom string / #define PY_SSL_DEFAULT_CIPHERS 2 / Cipher suite string for PY_SSL_DEFAULT_CIPHERS=0 / / #undef PY_SSL_DEFAULT_CIPHER_STRING / / PEP 11 Support tier (1, 2, 3 or 0 for unsupported) / #define PY_SUPPORT_TIER 1 / Define if you want to build an interpreter with many run-time checks. / / #undef Py_DEBUG / / Defined if Python is built as a shared library. / #define Py_ENABLE_SHARED 1 / Define hash algorithm for str, bytes and memoryview. SipHash24: 1, FNV: 2, SipHash13: 3, externally defined: 0 / / #undef Py_HASH_ALGORITHM / / Define if you want to enable internal statistics gathering. / / #undef Py_STATS / / The version of SunOS/Solaris as reported by `uname -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 / The size of `float', as computed by sizeof. / #define SIZEOF_FLOAT 4 / The size of `fpos_t', as computed by sizeof. / #define SIZEOF_FPOS_T 16 / The size of `int', as computed by sizeof. / #define SIZEOF_INT 4 / The size of `long', as computed by sizeof. / #define SIZEOF_LONG 8 / The size of `long double', as computed by sizeof. / #define SIZEOF_LONG_DOUBLE 16 / The size of `long long', as computed by sizeof. / #define SIZEOF_LONG_LONG 8 / The size of `off_t', as computed by sizeof. / #define SIZEOF_OFF_T 8 / The size of `pid_t', as computed by sizeof. / #define SIZEOF_PID_T 4 / The size of `pthread_key_t', as computed by sizeof. / #define SIZEOF_PTHREAD_KEY_T 4 / The size of `pthread_t', as computed by sizeof. / #define SIZEOF_PTHREAD_T 8 / The size of `short', as computed by sizeof. / #define SIZEOF_SHORT 2 / The size of `size_t', as computed by sizeof. / #define SIZEOF_SIZE_T 8 / The size of `time_t', as computed by sizeof. / #define SIZEOF_TIME_T 8 / The size of `uintptr_t', as computed by sizeof. / #define SIZEOF_UINTPTR_T 8 / The size of `void ', as computed by sizeof. / #define SIZEOF_VOID_P 8 /* The size of `wchar_t', as computed by sizeof. / #define SIZEOF_WCHAR_T 4 / The size of `_Bool', as computed by sizeof. / #define SIZEOF__BOOL 1 / Define to 1 if you have the ANSI C header files. / #define STDC_HEADERS 1 / Define if you can safely include both <sys/select.h> and <sys/time.h> (which you can't on SCO ODT 3.0). / #define SYS_SELECT_WITH_SYS_TIME 1 / Custom thread stack size depending on chosen sanitizer runtimes. / / #undef THREAD_STACK_SIZE / / Library needed by timemodule.c: librt may be needed for clock_gettime() / / #undef TIMEMODULE_LIB / / Define to 1 if you can safely include both <sys/time.h> and <time.h>. / #define TIME_WITH_SYS_TIME 1 / Define to 1 if your <sys/time.h> declares `struct tm'. / / #undef TM_IN_SYS_TIME / / Define if you want to use computed gotos in ceval.c. / #define USE_COMPUTED_GOTOS 1 / Enable extensions on AIX 3, Interix. / #ifndef _ALL_SOURCE # define _ALL_SOURCE 1 #endif / Enable GNU extensions on systems that have them. / #ifndef _GNU_SOURCE # define _GNU_SOURCE 1 #endif / Enable threading extensions on Solaris. / #ifndef _POSIX_PTHREAD_SEMANTICS # define _POSIX_PTHREAD_SEMANTICS 1 #endif / Enable extensions on HP NonStop. / #ifndef _TANDEM_SOURCE # define _TANDEM_SOURCE 1 #endif / Enable general extensions on Solaris. / #ifndef __EXTENSIONS__ # define __EXTENSIONS__ 1 #endif / Define if WINDOW in curses.h offers a field _flags. / #define WINDOW_HAS_FLAGS 1 / Define if you want build the _decimal module using a coroutine-local rather than a thread-local context / #define WITH_DECIMAL_CONTEXTVAR 1 / Define if you want documentation strings in extension modules / #define WITH_DOC_STRINGS 1 / Define if you want to compile in DTrace support / #define WITH_DTRACE 1 / Define if you want to use the new-style (Openstep, Rhapsody, MacOS) dynamic linker (dyld) instead of the old-style (NextStep) dynamic linker (rld). Dyld is necessary to support frameworks. / / #undef WITH_DYLD / / Define to build the readline module against Editline. / / #undef WITH_EDITLINE / / Define if you want to compile in object freelists optimization / #define WITH_FREELISTS 1 / Define to 1 if libintl is needed for locale functions. / / #undef WITH_LIBINTL / / Define if you want to produce an OpenStep/Rhapsody framework (shared library plus accessory files). / / #undef WITH_NEXT_FRAMEWORK / / Define if you want to compile in Python-specific mallocs / #define WITH_PYMALLOC 1 / Define if you want pymalloc to be disabled when running under valgrind / #define WITH_VALGRIND 1 / Define WORDS_BIGENDIAN to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel). / #if defined AC_APPLE_UNIVERSAL_BUILD # if defined __BIG_ENDIAN__ # define WORDS_BIGENDIAN 1 # endif #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_SOURCE / / This must be defined on some systems to enable large file support. / #define _LARGEFILE_SOURCE 1 / This must be defined on AIX systems to enable large file support. / / #undef _LARGE_FILES / / Define to 1 if on MINIX. / / #undef _MINIX / / Define on NetBSD to activate all library features / #define _NETBSD_SOURCE 1 / Define to 2 if the system does not provide POSIX.1 features except with this defined. / / #undef _POSIX_1_SOURCE / / Define to activate features from IEEE Stds 1003.1-2008 / #define _POSIX_C_SOURCE 200809L / Define to 1 if you need to in order for `stat' and other things to work. / / #undef _POSIX_SOURCE / / Define if you have POSIX threads, and your system does not define that. / / #undef _POSIX_THREADS / / framework name / #define _PYTHONFRAMEWORK "" / Define to force use of thread-safe errno, h_errno, and other functions / #define _REENTRANT 1 / Define to 1 if you want to emulate getpid() on WASI / / #undef _WASI_EMULATED_GETPID / / Define to 1 if you want to emulate process clocks on WASI / / #undef _WASI_EMULATED_PROCESS_CLOCKS / / Define to 1 if you want to emulate signals on WASI / / #undef _WASI_EMULATED_SIGNAL / / Define to the level of X/Open that your system supports / #define _XOPEN_SOURCE 700 / Define to activate Unix95-and-earlier features / #define _XOPEN_SOURCE_EXTENDED 1 / Define on FreeBSD to activate all library features / #define __BSD_VISIBLE 1 / Define to 'long' if <time.h> doesn't define. / / #undef clock_t / / Define to empty if `const' does not conform to ANSI C. / / #undef const / / Define to `int' if <sys/types.h> doesn't define. / / #undef gid_t / / Define to `int' if <sys/types.h> does not define. / / #undef mode_t / / Define to `long int' if <sys/types.h> does not define. / / #undef off_t / / Define to `int' if <sys/types.h> does not define. / / #undef pid_t / / Define to empty if the keyword does not work. / / #undef signed / / Define to `unsigned int' if <sys/types.h> does not define. / / #undef size_t / / Define to `int' if <sys/socket.h> does not define. / / #undef socklen_t / / Define to `int' if <sys/types.h> 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*/	51.95 KB	2026-01-07 23:02
📄 pyconfig.h #include <bits/wordsize.h> #if __WORDSIZE == 32 #include "pyconfig-32.h" #elif __WORDSIZE == 64 #include "pyconfig-64.h" #else #error "Unknown word size" #endif	162 B	2026-01-07 23:15
📄 pydtrace.h /* Static DTrace probes interface / #ifndef Py_DTRACE_H #define Py_DTRACE_H #ifdef __cplusplus extern "C" { #endif #ifdef WITH_DTRACE #include "pydtrace_probes.h" / pydtrace_probes.h, on systems with DTrace, is auto-generated to include `PyDTrace_{PROBE}` and `PyDTrace_{PROBE}_ENABLED()` macros for every probe defined in pydtrace_provider.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) {} static inline void PyDTrace_FUNCTION_ENTRY(const char arg0, const char arg1, int arg2) {} static inline void PyDTrace_FUNCTION_RETURN(const char arg0, const char arg1, int arg2) {} static inline void PyDTrace_GC_START(int arg0) {} static inline void PyDTrace_GC_DONE(Py_ssize_t arg0) {} static inline void PyDTrace_INSTANCE_NEW_START(int arg0) {} static inline void PyDTrace_INSTANCE_NEW_DONE(int arg0) {} static inline void PyDTrace_INSTANCE_DELETE_START(int arg0) {} static inline void PyDTrace_INSTANCE_DELETE_DONE(int arg0) {} static inline void PyDTrace_IMPORT_FIND_LOAD_START(const char arg0) {} static inline void PyDTrace_IMPORT_FIND_LOAD_DONE(const char arg0, int arg1) {} static inline void PyDTrace_AUDIT(const char arg0, void arg1) {} static inline int PyDTrace_LINE_ENABLED(void) { return 0; } static inline int PyDTrace_FUNCTION_ENTRY_ENABLED(void) { return 0; } static inline int PyDTrace_FUNCTION_RETURN_ENABLED(void) { return 0; } static inline int PyDTrace_GC_START_ENABLED(void) { return 0; } static inline int PyDTrace_GC_DONE_ENABLED(void) { return 0; } static inline int PyDTrace_INSTANCE_NEW_START_ENABLED(void) { return 0; } static inline int PyDTrace_INSTANCE_NEW_DONE_ENABLED(void) { return 0; } static inline int PyDTrace_INSTANCE_DELETE_START_ENABLED(void) { return 0; } static inline int PyDTrace_INSTANCE_DELETE_DONE_ENABLED(void) { return 0; } static inline int PyDTrace_IMPORT_FIND_LOAD_START_ENABLED(void) { return 0; } static inline int PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED(void) { return 0; } static inline int PyDTrace_AUDIT_ENABLED(void) { return 0; } #endif / !WITH_DTRACE / #ifdef __cplusplus } #endif #endif / !Py_DTRACE_H */	2.36 KB	2025-10-09 16:16
📄 pyerrors.h #ifndef Py_ERRORS_H #define Py_ERRORS_H #ifdef __cplusplus extern "C" { #endif #include <stdarg.h> // va_list /* Error handling definitions / PyAPI_FUNC(void) PyErr_SetNone(PyObject ); PyAPI_FUNC(void) PyErr_SetObject(PyObject , PyObject ); PyAPI_FUNC(void) PyErr_SetString( PyObject exception, const char string /* decoded from utf-8 / ); PyAPI_FUNC(PyObject ) PyErr_Occurred(void); PyAPI_FUNC(void) PyErr_Clear(void); PyAPI_FUNC(void) PyErr_Fetch(PyObject , PyObject , PyObject *); PyAPI_FUNC(void) PyErr_Restore(PyObject , PyObject , PyObject ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030b0000 PyAPI_FUNC(PyObject) PyErr_GetHandledException(void); PyAPI_FUNC(void) PyErr_SetHandledException(PyObject ); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject , PyObject , PyObject *); PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject , PyObject , PyObject ); #endif /* Defined in Python/pylifecycle.c The Py_FatalError() function is replaced with a macro which logs automatically the name of the current function, unless the Py_LIMITED_API macro is defined. / PyAPI_FUNC(void) _Py_NO_RETURN Py_FatalError(const char message); /* Error testing and normalization / PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject , PyObject ); PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject ); PyAPI_FUNC(void) PyErr_NormalizeException(PyObject, PyObject, PyObject*); / Traceback manipulation (PEP 3134) / PyAPI_FUNC(int) PyException_SetTraceback(PyObject , PyObject ); PyAPI_FUNC(PyObject ) PyException_GetTraceback(PyObject ); / Cause manipulation (PEP 3134) / PyAPI_FUNC(PyObject ) PyException_GetCause(PyObject ); PyAPI_FUNC(void) PyException_SetCause(PyObject , PyObject ); / Context manipulation (PEP 3134) / PyAPI_FUNC(PyObject ) PyException_GetContext(PyObject ); PyAPI_FUNC(void) PyException_SetContext(PyObject , PyObject ); / / #define PyExceptionClass_Check(x) \ (PyType_Check((x)) && \ 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)Py_TYPE(x)) #define _PyBaseExceptionGroup_Check(x) \ PyObject_TypeCheck(x, (PyTypeObject )PyExc_BaseExceptionGroup) /* Predefined exceptions / PyAPI_DATA(PyObject ) PyExc_BaseException; PyAPI_DATA(PyObject ) PyExc_Exception; PyAPI_DATA(PyObject ) PyExc_BaseExceptionGroup; #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 PyAPI_DATA(PyObject ) PyExc_StopAsyncIteration; #endif PyAPI_DATA(PyObject ) PyExc_StopIteration; PyAPI_DATA(PyObject ) PyExc_GeneratorExit; PyAPI_DATA(PyObject ) PyExc_ArithmeticError; PyAPI_DATA(PyObject ) PyExc_LookupError; PyAPI_DATA(PyObject ) PyExc_AssertionError; PyAPI_DATA(PyObject ) PyExc_AttributeError; PyAPI_DATA(PyObject ) PyExc_BufferError; PyAPI_DATA(PyObject ) PyExc_EOFError; PyAPI_DATA(PyObject ) PyExc_FloatingPointError; PyAPI_DATA(PyObject ) PyExc_OSError; PyAPI_DATA(PyObject ) PyExc_ImportError; #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03060000 PyAPI_DATA(PyObject ) PyExc_ModuleNotFoundError; #endif PyAPI_DATA(PyObject ) PyExc_IndexError; PyAPI_DATA(PyObject ) PyExc_KeyError; PyAPI_DATA(PyObject ) PyExc_KeyboardInterrupt; PyAPI_DATA(PyObject ) PyExc_MemoryError; PyAPI_DATA(PyObject ) PyExc_NameError; PyAPI_DATA(PyObject ) PyExc_OverflowError; PyAPI_DATA(PyObject ) PyExc_RuntimeError; #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 PyAPI_DATA(PyObject ) PyExc_RecursionError; #endif PyAPI_DATA(PyObject ) PyExc_NotImplementedError; PyAPI_DATA(PyObject ) PyExc_SyntaxError; PyAPI_DATA(PyObject ) PyExc_IndentationError; PyAPI_DATA(PyObject ) PyExc_TabError; PyAPI_DATA(PyObject ) PyExc_ReferenceError; PyAPI_DATA(PyObject ) PyExc_SystemError; PyAPI_DATA(PyObject ) PyExc_SystemExit; PyAPI_DATA(PyObject ) PyExc_TypeError; PyAPI_DATA(PyObject ) PyExc_UnboundLocalError; PyAPI_DATA(PyObject ) PyExc_UnicodeError; PyAPI_DATA(PyObject ) PyExc_UnicodeEncodeError; PyAPI_DATA(PyObject ) PyExc_UnicodeDecodeError; PyAPI_DATA(PyObject ) PyExc_UnicodeTranslateError; PyAPI_DATA(PyObject ) PyExc_ValueError; PyAPI_DATA(PyObject ) PyExc_ZeroDivisionError; #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_DATA(PyObject ) PyExc_BlockingIOError; PyAPI_DATA(PyObject ) PyExc_BrokenPipeError; PyAPI_DATA(PyObject ) PyExc_ChildProcessError; PyAPI_DATA(PyObject ) PyExc_ConnectionError; PyAPI_DATA(PyObject ) PyExc_ConnectionAbortedError; PyAPI_DATA(PyObject ) PyExc_ConnectionRefusedError; PyAPI_DATA(PyObject ) PyExc_ConnectionResetError; PyAPI_DATA(PyObject ) PyExc_FileExistsError; PyAPI_DATA(PyObject ) PyExc_FileNotFoundError; PyAPI_DATA(PyObject ) PyExc_InterruptedError; PyAPI_DATA(PyObject ) PyExc_IsADirectoryError; PyAPI_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_DeprecationWarning; PyAPI_DATA(PyObject ) PyExc_PendingDeprecationWarning; PyAPI_DATA(PyObject ) PyExc_SyntaxWarning; PyAPI_DATA(PyObject ) PyExc_RuntimeWarning; PyAPI_DATA(PyObject ) PyExc_FutureWarning; PyAPI_DATA(PyObject ) PyExc_ImportWarning; PyAPI_DATA(PyObject ) PyExc_UnicodeWarning; PyAPI_DATA(PyObject ) PyExc_BytesWarning; PyAPI_DATA(PyObject ) PyExc_EncodingWarning; PyAPI_DATA(PyObject ) PyExc_ResourceWarning; / Convenience functions / PyAPI_FUNC(int) PyErr_BadArgument(void); PyAPI_FUNC(PyObject ) PyErr_NoMemory(void); PyAPI_FUNC(PyObject ) PyErr_SetFromErrno(PyObject ); PyAPI_FUNC(PyObject ) PyErr_SetFromErrnoWithFilenameObject( PyObject , PyObject ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03040000 PyAPI_FUNC(PyObject ) PyErr_SetFromErrnoWithFilenameObjects( PyObject , PyObject , PyObject ); #endif PyAPI_FUNC(PyObject ) PyErr_SetFromErrnoWithFilename( PyObject exc, const char filename /* decoded from the filesystem encoding / ); PyAPI_FUNC(PyObject ) PyErr_Format( PyObject exception, const char format, /* ASCII-encoded string / ... ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 PyAPI_FUNC(PyObject ) PyErr_FormatV( PyObject exception, const char format, va_list vargs); #endif #ifdef MS_WINDOWS PyAPI_FUNC(PyObject ) PyErr_SetFromWindowsErrWithFilename( int ierr, const char filename /* decoded from the filesystem encoding / ); PyAPI_FUNC(PyObject ) PyErr_SetFromWindowsErr(int); PyAPI_FUNC(PyObject ) PyErr_SetExcFromWindowsErrWithFilenameObject( PyObject ,int, PyObject ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03040000 PyAPI_FUNC(PyObject ) PyErr_SetExcFromWindowsErrWithFilenameObjects( PyObject ,int, PyObject , PyObject ); #endif PyAPI_FUNC(PyObject ) PyErr_SetExcFromWindowsErrWithFilename( PyObject exc, int ierr, const char filename /* decoded from the filesystem encoding / ); PyAPI_FUNC(PyObject ) PyErr_SetExcFromWindowsErr(PyObject , int); #endif / MS_WINDOWS / #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03060000 PyAPI_FUNC(PyObject ) PyErr_SetImportErrorSubclass(PyObject , PyObject , PyObject , PyObject ); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_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( const char name, PyObject base, PyObject dict); PyAPI_FUNC(PyObject ) PyErr_NewExceptionWithDoc( const char name, const char doc, PyObject base, PyObject dict); PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject ); / In signalmodule.c / PyAPI_FUNC(int) PyErr_CheckSignals(void); PyAPI_FUNC(void) PyErr_SetInterrupt(void); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030A0000 PyAPI_FUNC(int) PyErr_SetInterruptEx(int signum); #endif / Support for adding program text to SyntaxErrors / PyAPI_FUNC(void) PyErr_SyntaxLocation( const char filename, /* decoded from the filesystem encoding / int lineno); PyAPI_FUNC(void) PyErr_SyntaxLocationEx( const char filename, /* decoded from the filesystem encoding / 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 / UTF-8 encoded string / ); / get the encoding attribute / PyAPI_FUNC(PyObject ) PyUnicodeEncodeError_GetEncoding(PyObject ); PyAPI_FUNC(PyObject ) PyUnicodeDecodeError_GetEncoding(PyObject ); / get the object attribute / PyAPI_FUNC(PyObject ) PyUnicodeEncodeError_GetObject(PyObject ); PyAPI_FUNC(PyObject ) PyUnicodeDecodeError_GetObject(PyObject ); PyAPI_FUNC(PyObject ) PyUnicodeTranslateError_GetObject(PyObject ); / get the value of the start attribute (the int * may not be NULL) return 0 on success, -1 on failure / PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject , Py_ssize_t ); PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject , Py_ssize_t ); PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject , Py_ssize_t ); / assign a new value to the start attribute return 0 on success, -1 on failure / PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject , Py_ssize_t); PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject , Py_ssize_t); PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject , Py_ssize_t); /* get the value of the end attribute (the int may not be NULL) return 0 on success, -1 on failure / PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject , Py_ssize_t ); PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject , Py_ssize_t ); PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject , Py_ssize_t ); /* assign a new value to the end attribute return 0 on success, -1 on failure / PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject , Py_ssize_t); PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject , Py_ssize_t); PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject , Py_ssize_t); /* get the value of the reason attribute / PyAPI_FUNC(PyObject ) PyUnicodeEncodeError_GetReason(PyObject ); PyAPI_FUNC(PyObject ) PyUnicodeDecodeError_GetReason(PyObject ); PyAPI_FUNC(PyObject ) PyUnicodeTranslateError_GetReason(PyObject ); / assign a new value to the reason attribute return 0 on success, -1 on failure / PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason( PyObject exc, const char reason / UTF-8 encoded string / ); PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason( PyObject exc, const char reason / UTF-8 encoded string / ); PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason( PyObject exc, const char reason / UTF-8 encoded string / ); PyAPI_FUNC(int) PyOS_snprintf(char str, size_t size, const char format, ...) Py_GCC_ATTRIBUTE((format(printf, 3, 4))); PyAPI_FUNC(int) PyOS_vsnprintf(char str, size_t size, const char format, va_list va) Py_GCC_ATTRIBUTE((format(printf, 3, 0))); #ifndef Py_LIMITED_API # define Py_CPYTHON_ERRORS_H # include "cpython/pyerrors.h" # undef Py_CPYTHON_ERRORS_H #endif #ifdef __cplusplus } #endif #endif / !Py_ERRORS_H */	12.48 KB	2025-10-09 16:16
📄 pyexpat.h /* Stuff to export relevant 'expat' entry points from pyexpat to other * parser modules, such as cElementTree. / / note: you must import expat.h before importing this module! / #define PyExpat_CAPI_MAGIC "pyexpat.expat_CAPI 1.1" #define PyExpat_CAPSULE_NAME "pyexpat.expat_CAPI" struct PyExpat_CAPI { char magic; /* set to PyExpat_CAPI_MAGIC / int size; / set to sizeof(struct PyExpat_CAPI) / int MAJOR_VERSION; int MINOR_VERSION; int MICRO_VERSION; / pointers to selected expat functions. add new functions at the end, if needed / const XML_LChar (ErrorString)(enum XML_Error code); enum XML_Error (GetErrorCode)(XML_Parser parser); XML_Size (GetErrorColumnNumber)(XML_Parser parser); XML_Size (GetErrorLineNumber)(XML_Parser parser); enum XML_Status (Parse)( XML_Parser parser, const char s, int len, int isFinal); XML_Parser (ParserCreate_MM)( const XML_Char encoding, const XML_Memory_Handling_Suite memsuite, const XML_Char namespaceSeparator); void (ParserFree)(XML_Parser parser); void (SetCharacterDataHandler)( XML_Parser parser, XML_CharacterDataHandler handler); void (SetCommentHandler)( XML_Parser parser, XML_CommentHandler handler); void (SetDefaultHandlerExpand)( XML_Parser parser, XML_DefaultHandler handler); void (SetElementHandler)( XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end); void (SetNamespaceDeclHandler)( XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end); void (SetProcessingInstructionHandler)( XML_Parser parser, XML_ProcessingInstructionHandler handler); void (SetUnknownEncodingHandler)( XML_Parser parser, XML_UnknownEncodingHandler handler, void encodingHandlerData); void (SetUserData)(XML_Parser parser, void userData); void (SetStartDoctypeDeclHandler)(XML_Parser parser, XML_StartDoctypeDeclHandler start); enum XML_Status (SetEncoding)(XML_Parser parser, const XML_Char encoding); int (DefaultUnknownEncodingHandler)( void encodingHandlerData, const XML_Char name, XML_Encoding info); /* might be NULL for expat < 2.1.0 / int (SetHashSalt)(XML_Parser parser, unsigned long hash_salt); /* might be NULL for expat < 2.6.0 / XML_Bool (SetReparseDeferralEnabled)(XML_Parser parser, XML_Bool enabled); /* always add new stuff to the end! */ };	2.51 KB	2025-10-09 16:16
📄 pyframe.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 # include "cpython/pyframe.h" # undef Py_CPYTHON_PYFRAME_H #endif #ifdef __cplusplus } #endif #endif /* !Py_PYFRAME_H */	551 B	2025-10-09 16:16
📄 pyhash.h #ifndef Py_HASH_H #define Py_HASH_H #ifdef __cplusplus extern "C" { #endif /* Helpers for hash functions / #ifndef Py_LIMITED_API PyAPI_FUNC(Py_hash_t) _Py_HashDouble(PyObject , double); PyAPI_FUNC(Py_hash_t) _Py_HashPointer(const void); // Similar to _Py_HashPointer(), but don't replace -1 with -2 PyAPI_FUNC(Py_hash_t) _Py_HashPointerRaw(const void); PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void, Py_ssize_t); #endif / Prime multiplier used in string and various other hashes. / #define _PyHASH_MULTIPLIER 1000003UL / 0xf4243 / / Parameters used for the numeric hash implementation. See notes for _Py_HashDouble in Python/pyhash.c. Numeric hashes are based on reduction modulo the prime 2*_PyHASH_BITS - 1. / #if SIZEOF_VOID_P >= 8 # define _PyHASH_BITS 61 #else # define _PyHASH_BITS 31 #endif #define _PyHASH_MODULUS (((size_t)1 << _PyHASH_BITS) - 1) #define _PyHASH_INF 314159 #define _PyHASH_IMAG _PyHASH_MULTIPLIER /* hash secret * * memory layout on 64 bit systems * cccccccc cccccccc cccccccc uc -- unsigned char[24] * pppppppp ssssssss ........ fnv -- two Py_hash_t * k0k0k0k0 k1k1k1k1 ........ siphash -- two uint64_t * ........ ........ ssssssss djbx33a -- 16 bytes padding + one Py_hash_t * ........ ........ eeeeeeee pyexpat XML hash salt * * 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]; / two Py_hash_t for FNV / struct { Py_hash_t prefix; Py_hash_t suffix; } fnv; / two uint64 for SipHash24 / struct { uint64_t k0; 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; const int hash_bits; const int seed_bits; } PyHash_FuncDef; PyAPI_FUNC(PyHash_FuncDef) PyHash_GetFuncDef(void); #endif / cutoff for small string DJBX33A optimization in range [1, cutoff). * * About 50% of the strings in a typical Python application are smaller than * 6 to 7 chars. However DJBX33A is vulnerable to hash collision attacks. * NEVER use DJBX33A for long strings! * * A Py_HASH_CUTOFF of 0 disables small string optimization. 32 bit platforms * should use a smaller cutoff because it is easier to create colliding * strings. A cutoff of 7 on 64bit platforms and 5 on 32bit platforms should * provide a decent safety margin. / #ifndef Py_HASH_CUTOFF # define Py_HASH_CUTOFF 0 #elif (Py_HASH_CUTOFF > 7 \|\| Py_HASH_CUTOFF < 0) # error Py_HASH_CUTOFF must in range 0...7. #endif / Py_HASH_CUTOFF / / hash algorithm selection * * The values for Py_HASH_* are hard-coded in the * configure script. * * - FNV and SIPHASH* are available on all platforms and architectures. * - With EXTERNAL embedders can provide an alternative implementation with:: * * PyHash_FuncDef PyHash_Func = {...}; * * XXX: Figure out __declspec() for extern PyHash_FuncDef. / #define Py_HASH_EXTERNAL 0 #define Py_HASH_SIPHASH24 1 #define Py_HASH_FNV 2 #define Py_HASH_SIPHASH13 3 #ifndef Py_HASH_ALGORITHM # ifndef HAVE_ALIGNED_REQUIRED # define Py_HASH_ALGORITHM Py_HASH_SIPHASH13 # else # define Py_HASH_ALGORITHM Py_HASH_FNV # endif / uint64_t && uint32_t && aligned / #endif / Py_HASH_ALGORITHM / #ifdef __cplusplus } #endif #endif / !Py_HASH_H */	4.06 KB	2025-10-09 16:16
📄 pylifecycle.h /* Interfaces to configure, query, create & destroy the Python runtime / #ifndef Py_PYLIFECYCLE_H #define Py_PYLIFECYCLE_H #ifdef __cplusplus extern "C" { #endif / Initialization and finalization / PyAPI_FUNC(void) Py_Initialize(void); PyAPI_FUNC(void) Py_InitializeEx(int); PyAPI_FUNC(void) Py_Finalize(void); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03060000 PyAPI_FUNC(int) Py_FinalizeEx(void); #endif PyAPI_FUNC(int) Py_IsInitialized(void); / Subinterpreter support / PyAPI_FUNC(PyThreadState ) Py_NewInterpreter(void); PyAPI_FUNC(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); Py_DEPRECATED(3.11) PyAPI_FUNC(void) Py_SetPythonHome(const wchar_t ); PyAPI_FUNC(wchar_t ) Py_GetPythonHome(void); PyAPI_FUNC(wchar_t ) Py_GetProgramFullPath(void); PyAPI_FUNC(wchar_t ) Py_GetPrefix(void); PyAPI_FUNC(wchar_t ) Py_GetExecPrefix(void); PyAPI_FUNC(wchar_t ) Py_GetPath(void); Py_DEPRECATED(3.11) PyAPI_FUNC(void) Py_SetPath(const wchar_t ); #ifdef MS_WINDOWS int _Py_CheckPython3(void); #endif /* In their own files / PyAPI_FUNC(const char ) Py_GetVersion(void); PyAPI_FUNC(const char ) Py_GetPlatform(void); PyAPI_FUNC(const char ) Py_GetCopyright(void); PyAPI_FUNC(const char ) Py_GetCompiler(void); PyAPI_FUNC(const char ) Py_GetBuildInfo(void); /* Signals / typedef void (PyOS_sighandler_t)(int); PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int); PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030B0000 PyAPI_DATA(const unsigned long) Py_Version; #endif #ifndef Py_LIMITED_API # define Py_CPYTHON_PYLIFECYCLE_H # include "cpython/pylifecycle.h" # undef Py_CPYTHON_PYLIFECYCLE_H #endif #ifdef __cplusplus } #endif #endif /* !Py_PYLIFECYCLE_H */	2.2 KB	2025-10-09 16:16
📄 pymacconfig.h #ifndef PYMACCONFIG_H #define PYMACCONFIG_H /* * This file moves some of the autoconf magic to compile-time * when building on MacOSX. This is needed for building 4-way * universal binaries and for 64-bit universal binaries because * the values redefined below aren't configure-time constant but * only compile-time constant in these scenarios. / #if defined(__APPLE__) # undef SIZEOF_LONG # undef SIZEOF_PTHREAD_T # undef SIZEOF_SIZE_T # undef SIZEOF_TIME_T # undef SIZEOF_VOID_P # undef SIZEOF__BOOL # undef SIZEOF_UINTPTR_T # undef SIZEOF_PTHREAD_T # undef WORDS_BIGENDIAN # undef DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754 # undef DOUBLE_IS_BIG_ENDIAN_IEEE754 # undef DOUBLE_IS_LITTLE_ENDIAN_IEEE754 # undef HAVE_GCC_ASM_FOR_X87 # undef VA_LIST_IS_ARRAY # if defined(__LP64__) && defined(__x86_64__) # define VA_LIST_IS_ARRAY 1 # endif # undef HAVE_LARGEFILE_SUPPORT # ifndef __LP64__ # define HAVE_LARGEFILE_SUPPORT 1 # endif # undef SIZEOF_LONG # ifdef __LP64__ # define SIZEOF__BOOL 1 # define SIZEOF__BOOL 1 # define SIZEOF_LONG 8 # define SIZEOF_PTHREAD_T 8 # define SIZEOF_SIZE_T 8 # define SIZEOF_TIME_T 8 # define SIZEOF_VOID_P 8 # define SIZEOF_UINTPTR_T 8 # define SIZEOF_PTHREAD_T 8 # else # ifdef __ppc__ # define SIZEOF__BOOL 4 # else # define SIZEOF__BOOL 1 # endif # define SIZEOF_LONG 4 # define SIZEOF_PTHREAD_T 4 # define SIZEOF_SIZE_T 4 # define SIZEOF_TIME_T 4 # define SIZEOF_VOID_P 4 # define SIZEOF_UINTPTR_T 4 # 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 #define DOUBLE_IS_LITTLE_ENDIAN_IEEE754 #endif / __BIG_ENDIAN / #ifdef __i386__ # define HAVE_GCC_ASM_FOR_X87 #endif / * The definition in pyconfig.h is only valid on the OS release * where configure ran on and not necessarily for all systems where * the executable can be used on. * * Specifically: OSX 10.4 has limited supported for '%zd', while * 10.5 has full support for '%zd'. A binary built on 10.5 won't * work properly on 10.4 unless we suppress the definition * of PY_FORMAT_SIZE_T / #undef PY_FORMAT_SIZE_T #endif / defined(_APPLE__) / #endif / PYMACCONFIG_H */	2.92 KB	2025-10-09 16:16
📄 pymacro.h #ifndef Py_PYMACRO_H #define Py_PYMACRO_H // gh-91782: On FreeBSD 12, if the _POSIX_C_SOURCE and _XOPEN_SOURCE macros are // defined, <sys/cdefs.h> disables C11 support and <assert.h> does not define // the static_assert() macro. // https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=255290 // // macOS <= 10.10 doesn't define static_assert in assert.h at all despite // having C11 compiler support. // // static_assert is defined in glibc from version 2.16. Compiler support for // the C11 _Static_assert keyword is in gcc >= 4.6. // // MSVC makes static_assert a keyword in C11-17, contrary to the standards. // // In C++11 and C2x, static_assert is a keyword, redefining is undefined // behaviour. So only define if building as C (if __STDC_VERSION__ is defined), // not C++, and only for C11-17. #if !defined(static_assert) && (defined(__GNUC__) \|\| defined(__clang__)) \ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \ && __STDC_VERSION__ <= 201710L # define static_assert _Static_assert #endif /* Minimum value between x and y / #define Py_MIN(x, y) (((x) > (y)) ? (y) : (x)) / Maximum value between x and y / #define Py_MAX(x, y) (((x) > (y)) ? (x) : (y)) / Absolute value of the number x / #define Py_ABS(x) ((x) < 0 ? -(x) : (x)) #define _Py_XSTRINGIFY(x) #x / Convert the argument to a string. For example, Py_STRINGIFY(123) is replaced with "123" by the preprocessor. Defines are also replaced by their value. For example Py_STRINGIFY(__LINE__) is replaced by the line number, not by "__LINE__". / #define Py_STRINGIFY(x) _Py_XSTRINGIFY(x) / Get the size of a structure member in bytes / #define Py_MEMBER_SIZE(type, member) sizeof(((type )0)->member) /* Argument must be a char or an int in [-128, 127] or [0, 255]. / #define Py_CHARMASK(c) ((unsigned char)((c) & 0xff)) / Assert a build-time dependency, as an expression. Your compile will fail if the condition isn't true, or can't be evaluated by the compiler. This can be used in an expression: its value is 0. Example: #define foo_to_char(foo) \ ((char )(foo) \ + Py_BUILD_ASSERT_EXPR(offsetof(struct foo, string) == 0)) Written by Rusty Russell, public domain, http://ccodearchive.net/ / #define Py_BUILD_ASSERT_EXPR(cond) \ (sizeof(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__) && \ (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) \|\| (__GNUC__ >= 4))) / Two gcc extensions. &a[0] degrades to a pointer: a different type from an array / #define Py_ARRAY_LENGTH(array) \ (sizeof(array) / sizeof((array)[0]) \ + Py_BUILD_ASSERT_EXPR(!__builtin_types_compatible_p(typeof(array), \ typeof(&(array)[0])))) #else #define Py_ARRAY_LENGTH(array) \ (sizeof(array) / sizeof((array)[0])) #endif / Define macros for inline documentation. / #define PyDoc_VAR(name) static const char name[] #define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str) #ifdef WITH_DOC_STRINGS #define PyDoc_STR(str) str #else #define PyDoc_STR(str) "" #endif / Below "a" is a power of 2. / / Round down size "n" to be a multiple of "a". / #define _Py_SIZE_ROUND_DOWN(n, a) ((size_t)(n) & ~(size_t)((a) - 1)) / Round up size "n" to be a multiple of "a". / #define _Py_SIZE_ROUND_UP(n, a) (((size_t)(n) + \ (size_t)((a) - 1)) & ~(size_t)((a) - 1)) / Round pointer "p" down to the closest "a"-aligned address <= "p". / #define _Py_ALIGN_DOWN(p, a) ((void )((uintptr_t)(p) & ~(uintptr_t)((a) - 1))) /* Round pointer "p" up to the closest "a"-aligned address >= "p". / #define _Py_ALIGN_UP(p, a) ((void )(((uintptr_t)(p) + \ (uintptr_t)((a) - 1)) & ~(uintptr_t)((a) - 1))) /* Check if pointer "p" is aligned to "a"-bytes boundary. / #define _Py_IS_ALIGNED(p, a) (!((uintptr_t)(p) & (uintptr_t)((a) - 1))) / Use this for unused arguments in a function definition to silence compiler * warnings. Example: * * int func(int a, int Py_UNUSED(b)) { return a; } / #if defined(__GNUC__) \|\| defined(__clang__) # define Py_UNUSED(name) _unused_ ## name __attribute__((unused)) #else # define Py_UNUSED(name) _unused_ ## name #endif #if defined(RANDALL_WAS_HERE) # define Py_UNREACHABLE() \ Py_FatalError( \ "If you're seeing this, the code is in what I thought was\n" \ "an unreachable state.\n\n" \ "I could give you advice for what to do, but honestly, why\n" \ "should you trust me? I clearly screwed this up. I'm writing\n" \ "a message that should never appear, yet I know it will\n" \ "probably appear someday.\n\n" \ "On a deep level, I know I'm not up to this task.\n" \ "I'm so sorry.\n" \ "https://xkcd.com/2200") #elif defined(Py_DEBUG) # define Py_UNREACHABLE() \ Py_FatalError( \ "We've reached an unreachable state. Anything is possible.\n" \ "The limits were in our heads all along. Follow your dreams.\n" \ "https://xkcd.com/2200") #elif defined(__GNUC__) && (__GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) # define Py_UNREACHABLE() __builtin_unreachable() #elif defined(__clang__) \|\| defined(__INTEL_COMPILER) # define Py_UNREACHABLE() __builtin_unreachable() #elif defined(_MSC_VER) # define Py_UNREACHABLE() __assume(0) #else # define Py_UNREACHABLE() \ Py_FatalError("Unreachable C code path reached") #endif // Prevent using an expression as a l-value. // For example, "int x; _Py_RVALUE(x) = 1;" fails with a compiler error. #define _Py_RVALUE(EXPR) ((void)0, (EXPR)) #endif / Py_PYMACRO_H */	5.92 KB	2025-10-09 16:16
📄 pymath.h // Symbols and macros to supply platform-independent interfaces to mathematical // functions and constants. #ifndef Py_PYMATH_H #define Py_PYMATH_H /* High precision definition of pi and e (Euler) * The values are taken from libc6's math.h. / #ifndef Py_MATH_PIl #define Py_MATH_PIl 3.1415926535897932384626433832795029L #endif #ifndef Py_MATH_PI #define Py_MATH_PI 3.14159265358979323846 #endif #ifndef Py_MATH_El #define Py_MATH_El 2.7182818284590452353602874713526625L #endif #ifndef Py_MATH_E #define Py_MATH_E 2.7182818284590452354 #endif / Tau (2pi) to 40 digits, taken from tauday.com/tau-digits. / #ifndef Py_MATH_TAU #define Py_MATH_TAU 6.2831853071795864769252867665590057683943L #endif // Py_IS_NAN(X) // Return 1 if float or double arg is a NaN, else 0. #define Py_IS_NAN(X) isnan(X) // Py_IS_INFINITY(X) // Return 1 if float or double arg is an infinity, else 0. #define Py_IS_INFINITY(X) isinf(X) // Py_IS_FINITE(X) // Return 1 if float or double arg is neither infinite nor NAN, else 0. #define Py_IS_FINITE(X) isfinite(X) / HUGE_VAL is supposed to expand to a positive double infinity. Python * uses Py_HUGE_VAL instead because some platforms are broken in this * respect. We used to embed code in pyport.h to try to worm around that, * but different platforms are broken in conflicting ways. If you're on * a platform where HUGE_VAL is defined incorrectly, fiddle your Python * config to #define Py_HUGE_VAL to something that works on your platform. / #ifndef Py_HUGE_VAL # define Py_HUGE_VAL HUGE_VAL #endif // Py_NAN: Value that evaluates to a quiet Not-a-Number (NaN). #if !defined(Py_NAN) # if _Py__has_builtin(__builtin_nan) // Built-in implementation of the ISO C99 function nan(): quiet NaN. # define Py_NAN (__builtin_nan("")) #else // Use C99 NAN constant: quiet Not-A-Number. // NAN is a float, Py_NAN is a double: cast to double. # define Py_NAN ((double)NAN) # endif #endif #endif / Py_PYMATH_H */	1.93 KB	2025-10-09 16:16
📄 pymem.h /* The PyMem_ family: low-level memory allocation interfaces. See objimpl.h for the PyObject_ memory family. / #ifndef Py_PYMEM_H #define Py_PYMEM_H #include "pyport.h" #ifdef __cplusplus extern "C" { #endif / BEWARE: Each interface exports both functions and macros. Extension modules should use the functions, to ensure binary compatibility across Python versions. Because the Python implementation is free to change internal details, and the macros may (or may not) expose details for speed, if you do use the macros you must recompile your extensions with each Python release. Never mix calls to PyMem_ with calls to the platform malloc/realloc/ calloc/free. For example, on Windows different DLLs may end up using different heaps, and if you use PyMem_Malloc you'll get the memory from the heap used by the Python DLL; it could be a disaster if you free()'ed that directly in your own extension. Using PyMem_Free instead ensures Python can return the memory to the proper heap. As another example, in a debug build (Py_DEBUG macro), Python wraps all calls to all PyMem_ and PyObject_ memory functions in special debugging wrappers that add additional debugging info to dynamic memory blocks. The system routines have no idea what to do with that stuff, and the Python wrappers have no idea what to do with raw blocks obtained directly by the system routines then. The GIL must be held when using these APIs. / / * Raw memory interface * ==================== / / Functions Functions supplying platform-independent semantics for malloc/realloc/ free. These functions make sure that allocating 0 bytes returns a distinct non-NULL pointer (whenever possible -- if we're flat out of memory, NULL may be returned), even if the platform malloc and realloc don't. Returned pointers must be checked for NULL explicitly. No action is performed on failure (no exception is set, no warning is printed, etc). / PyAPI_FUNC(void ) PyMem_Malloc(size_t size); PyAPI_FUNC(void ) PyMem_Calloc(size_t nelem, size_t elsize); PyAPI_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 : \ ( (type ) PyMem_Malloc((n) * sizeof(type)) ) ) /* * The value of (p) is always clobbered by this macro regardless of success. * The caller MUST check if (p) is NULL afterwards and deal with the memory * error if so. This means the original value of (p) MUST be saved for the * caller's memory error handler to not lose track of it. / #define PyMem_Resize(p, type, n) \ ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ (type ) PyMem_Realloc((p), (n) * sizeof(type)) ) // Deprecated aliases only kept for backward compatibility. // PyMem_Del and PyMem_DEL are defined with no parameter to be able to use // them as function pointers (ex: dealloc = PyMem_Del). #define PyMem_MALLOC(n) PyMem_Malloc(n) #define PyMem_NEW(type, n) PyMem_New(type, n) #define PyMem_REALLOC(p, n) PyMem_Realloc(p, n) #define PyMem_RESIZE(p, type, n) PyMem_Resize(p, type, n) #define PyMem_FREE(p) PyMem_Free(p) #define PyMem_Del PyMem_Free #define PyMem_DEL PyMem_Free #ifndef Py_LIMITED_API # define Py_CPYTHON_PYMEM_H # include "cpython/pymem.h" # undef Py_CPYTHON_PYMEM_H #endif #ifdef __cplusplus } #endif #endif /* !Py_PYMEM_H */	3.8 KB	2025-10-09 16:16
📄 pyport.h #ifndef Py_PYPORT_H #define Py_PYPORT_H #include "pyconfig.h" /* include for defines / #include <inttypes.h> #include <limits.h> #ifndef UCHAR_MAX # error "limits.h must define UCHAR_MAX" #endif #if UCHAR_MAX != 255 # error "Python's source code assumes C's unsigned char is an 8-bit type" #endif // Macro to use C++ static_cast<> in the Python C API. #ifdef __cplusplus # define _Py_STATIC_CAST(type, expr) static_cast<type>(expr) #else # define _Py_STATIC_CAST(type, expr) ((type)(expr)) #endif // Macro to use the more powerful/dangerous C-style cast even in C++. #define _Py_CAST(type, expr) ((type)(expr)) // Static inline functions should use _Py_NULL rather than using directly NULL // to prevent C++ compiler warnings. On C++11 and newer, _Py_NULL is defined as // nullptr. #if defined(__cplusplus) && __cplusplus >= 201103 # define _Py_NULL nullptr #else # define _Py_NULL NULL #endif / Defines to build Python and its standard library: * * - Py_BUILD_CORE: Build Python core. Give access to Python internals, but * should not be used by third-party modules. * - Py_BUILD_CORE_BUILTIN: Build a Python stdlib module as a built-in module. * - Py_BUILD_CORE_MODULE: Build a Python stdlib module as a dynamic library. * * Py_BUILD_CORE_BUILTIN and Py_BUILD_CORE_MODULE imply Py_BUILD_CORE. * * On Windows, Py_BUILD_CORE_MODULE exports "PyInit_xxx" symbol, whereas * Py_BUILD_CORE_BUILTIN does not. / #if defined(Py_BUILD_CORE_BUILTIN) && !defined(Py_BUILD_CORE) # define Py_BUILD_CORE #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 defined iff i>>j does not extend the sign bit when i is a signed integral type and i < 0. Used in: Py_ARITHMETIC_RIGHT_SHIFT Py_DEBUG Meaning: Extra checks compiled in for debug mode. Used in: Py_SAFE_DOWNCAST ***********************************************************************/ / typedefs for some C9X-defined synonyms for integral types. * * The names in Python are exactly the same as the C9X names, except with a * Py_ prefix. Until C9X is universally implemented, this is the only way * to ensure that Python gets reliable names that don't conflict with names * in non-Python code that are playing their own tricks to define the C9X * names. * * NOTE: don't go nuts here! Python has no use for most of the C9X * integral synonyms. Only define the ones we actually need. / / long long is required. Ensure HAVE_LONG_LONG is defined for compatibility. / #ifndef HAVE_LONG_LONG #define HAVE_LONG_LONG 1 #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG long long / If LLONG_MAX is defined in limits.h, use that. / #define PY_LLONG_MIN LLONG_MIN #define PY_LLONG_MAX LLONG_MAX #define PY_ULLONG_MAX ULLONG_MAX #endif #define PY_UINT32_T uint32_t #define PY_UINT64_T uint64_t / Signed variants of the above / #define PY_INT32_T int32_t #define PY_INT64_T int64_t / PYLONG_BITS_IN_DIGIT describes the number of bits per "digit" (limb) in the * PyLongObject implementation (longintrepr.h). It's currently either 30 or 15, * defaulting to 30. The 15-bit digit option may be removed in the future. / #ifndef PYLONG_BITS_IN_DIGIT #define PYLONG_BITS_IN_DIGIT 30 #endif / uintptr_t is the C9X name for an unsigned integral type such that a * legitimate void* can be cast to uintptr_t and then back to void* again * without loss of information. Similarly for intptr_t, wrt a signed * integral type. / typedef uintptr_t Py_uintptr_t; typedef intptr_t Py_intptr_t; / Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) == * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an * unsigned integral type). See PEP 353 for details. * PY_SSIZE_T_MAX is the largest positive value of type Py_ssize_t. / #ifdef HAVE_PY_SSIZE_T #elif HAVE_SSIZE_T typedef ssize_t Py_ssize_t; # define PY_SSIZE_T_MAX SSIZE_MAX #elif SIZEOF_VOID_P == SIZEOF_SIZE_T typedef Py_intptr_t Py_ssize_t; # define PY_SSIZE_T_MAX INTPTR_MAX #else # error "Python needs a typedef for Py_ssize_t in pyport.h." #endif / Smallest negative value of type Py_ssize_t. / #define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1) / Py_hash_t is the same size as a pointer. / #define SIZEOF_PY_HASH_T SIZEOF_SIZE_T typedef Py_ssize_t Py_hash_t; / Py_uhash_t is the unsigned equivalent needed to calculate numeric hash. / #define SIZEOF_PY_UHASH_T SIZEOF_SIZE_T typedef size_t Py_uhash_t; / Now PY_SSIZE_T_CLEAN is mandatory. This is just for backward compatibility. / typedef Py_ssize_t Py_ssize_clean_t; / Largest possible value of size_t. / #define PY_SIZE_MAX SIZE_MAX / Macro kept for backward compatibility: use "z" in new code. * * PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf * format to convert an argument with the width of a size_t or Py_ssize_t. * C99 introduced "z" for this purpose, but old MSVCs had not supported it. * Since MSVC supports "z" since (at least) 2015, we can just use "z" * for new code. * * These "high level" Python format functions interpret "z" correctly on * all platforms (Python interprets the format string itself, and does whatever * the platform C requires to convert a size_t/Py_ssize_t argument): * * PyBytes_FromFormat * PyErr_Format * PyBytes_FromFormatV * PyUnicode_FromFormatV * * Lower-level uses require that you interpolate the correct format modifier * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for * example, * * Py_ssize_t index; * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index); * * That will expand to %zd or to something else correct for a Py_ssize_t on * the platform. / #ifndef PY_FORMAT_SIZE_T # define PY_FORMAT_SIZE_T "z" #endif / Py_LOCAL can be used instead of static to get the fastest possible calling * convention for functions that are local to a given module. * * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining, * for platforms that support that. * * NOTE: You can only use this for functions that are entirely local to a * module; functions that are exported via method tables, callbacks, etc, * should keep using static. / #if defined(_MSC_VER) / ignore warnings if the compiler decides not to inline a function / # pragma warning(disable: 4710) / fastest possible local call under MSVC / # define Py_LOCAL(type) static type __fastcall # define Py_LOCAL_INLINE(type) static __inline type __fastcall #else # define Py_LOCAL(type) static type # define Py_LOCAL_INLINE(type) static inline type #endif // bpo-28126: Py_MEMCPY is kept for backwards compatibility, #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 < 0x030b0000 # define Py_MEMCPY memcpy #endif #ifdef HAVE_IEEEFP_H #include <ieeefp.h> / needed for 'finite' declaration on some platforms / #endif #include <math.h> / Moved here from the math section, before extern "C" / /******************************************* * WRAPPER FOR <time.h> and/or <sys/time.h> * ******************************************/ #ifdef HAVE_SYS_TIME_H #include <sys/time.h> #endif #include <time.h> /**************************** * WRAPPER FOR <sys/select.h> * *****************************/ / NB caller must include <sys/types.h> / #ifdef HAVE_SYS_SELECT_H #include <sys/select.h> #endif / !HAVE_SYS_SELECT_H / /****************************** * stat() and fstat() fiddling * ******************************/ #ifdef HAVE_SYS_STAT_H #include <sys/stat.h> #elif defined(HAVE_STAT_H) #include <stat.h> #endif #ifndef S_IFMT / VisualAge C/C++ Failed to Define MountType Field in sys/stat.h / #define S_IFMT 0170000 #endif #ifndef S_IFLNK / Windows doesn't define S_IFLNK but posixmodule.c maps * IO_REPARSE_TAG_SYMLINK to S_IFLNK / # define S_IFLNK 0120000 #endif #ifndef S_ISREG #define S_ISREG(x) (((x) & S_IFMT) == S_IFREG) #endif #ifndef S_ISDIR #define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR) #endif #ifndef S_ISCHR #define S_ISCHR(x) (((x) & S_IFMT) == S_IFCHR) #endif #ifdef __cplusplus / Move this down here since some C++ #include's don't like to be included inside an extern "C" / extern "C" { #endif / Py_ARITHMETIC_RIGHT_SHIFT * C doesn't define whether a right-shift of a signed integer sign-extends * or zero-fills. Here a macro to force sign extension: * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) * Return I >> J, forcing sign extension. Arithmetically, return the * floor of I/2*J. Requirements: * I should have signed integer type. In the terminology of C99, this can * be either one of the five standard signed integer types (signed char, * short, int, long, long long) or an extended signed integer type. * J is an integer >= 0 and strictly less than the number of bits in the * type of I (because C doesn't define what happens for J outside that * range either). * TYPE used to specify the type of I, but is now ignored. It's been left * in for backwards compatibility with versions <= 2.6 or 3.0. * Caution: * I may be evaluated more than once. / #ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \ ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J)) #else #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J)) #endif / Py_FORCE_EXPANSION(X) * "Simply" returns its argument. However, macro expansions within the * argument are evaluated. This unfortunate trickery is needed to get * token-pasting to work as desired in some cases. / #define Py_FORCE_EXPANSION(X) X / Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this * assert-fails if any information is lost. * Caution: * VALUE may be evaluated more than once. / #ifdef Py_DEBUG # define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \ (assert(_Py_STATIC_CAST(WIDE, _Py_STATIC_CAST(NARROW, (VALUE))) == (VALUE)), \ _Py_STATIC_CAST(NARROW, (VALUE))) #else # define Py_SAFE_DOWNCAST(VALUE, WIDE, 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) #define Py_DEPRECATED(VERSION) __declspec(deprecated( \ "deprecated in " #VERSION)) #else #define Py_DEPRECATED(VERSION_UNUSED) #endif #if defined(__clang__) #define _Py_COMP_DIAG_PUSH _Pragma("clang diagnostic push") #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") #define _Py_COMP_DIAG_POP _Pragma("clang diagnostic pop") #elif defined(__GNUC__) \ && ((__GNUC__ >= 5) \|\| (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) #define _Py_COMP_DIAG_PUSH _Pragma("GCC diagnostic push") #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") #define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop") #elif defined(_MSC_VER) #define _Py_COMP_DIAG_PUSH __pragma(warning(push)) #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996)) #define _Py_COMP_DIAG_POP __pragma(warning(pop)) #else #define _Py_COMP_DIAG_PUSH #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS #define _Py_COMP_DIAG_POP #endif / _Py_HOT_FUNCTION * The hot attribute on a function is used to inform the compiler that the * function is a hot spot of the compiled program. The function is optimized * more aggressively and on many target it is placed into special subsection of * the text section so all hot functions appears close together improving * locality. * * Usage: * int _Py_HOT_FUNCTION x(void) { return 3; } * * Issue #28618: This attribute must not be abused, otherwise it can have a * negative effect on performance. Only the functions were Python spend most of * its time must use it. Use a profiler when running performance benchmark * suite to find these functions. / #if defined(__GNUC__) \ && ((__GNUC__ >= 5) \|\| (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) #define _Py_HOT_FUNCTION __attribute__((hot)) #else #define _Py_HOT_FUNCTION #endif // Ask the compiler to always inline a static inline function. The compiler can // ignore it and decides to not inline the function. // // It can be used to inline performance critical static inline functions when // building Python in debug mode with function inlining disabled. For example, // MSC disables function 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 defined(Py_DEBUG) // If Python is built in debug mode, usually compiler optimizations are // disabled. In this case, Py_ALWAYS_INLINE can increase a lot the stack // memory usage. For example, forcing inlining using gcc -O0 increases the // stack usage from 6 KB to 15 KB per Python function call. # define Py_ALWAYS_INLINE #elif defined(__GNUC__) \|\| defined(__clang__) \|\| defined(__INTEL_COMPILER) # define Py_ALWAYS_INLINE __attribute__((always_inline)) #elif defined(_MSC_VER) # define Py_ALWAYS_INLINE __forceinline #else # define Py_ALWAYS_INLINE #endif // Py_NO_INLINE // Disable inlining on a function. For example, it reduces the C stack // consumption: useful on LTO+PGO builds which heavily inline code (see // bpo-33720). // // Usage: // // Py_NO_INLINE static int random(void) { return 4; } #if defined(__GNUC__) \|\| defined(__clang__) \|\| defined(__INTEL_COMPILER) # define Py_NO_INLINE __attribute__ ((noinline)) #elif defined(_MSC_VER) # define Py_NO_INLINE __declspec(noinline) #else # define Py_NO_INLINE #endif /*********************************************************************** Prototypes that are missing from the standard include files on some systems (and possibly only some versions of such systems.) Please be conservative with adding new ones, document them and enclose them in platform-specific #ifdefs. ***********************************************************************/ #ifdef HAVE__GETPTY #include <sys/types.h> / we need to import mode_t / extern char _getpty(int , int, mode_t, int); #endif / On QNX 6, struct termio must be declared by including sys/termio.h if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must be included before termios.h or it will generate an error. / #if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux) #include <sys/termio.h> #endif / On 4.4BSD-descendants, ctype functions serves the whole range of * wchar_t character set rather than single byte code points only. * This characteristic can break some operations of string object * including str.upper() and str.split() on UTF-8 locales. This * workaround was provided by Tim Robbins of FreeBSD project. / #if defined(__APPLE__) # define _PY_PORT_CTYPE_UTF8_ISSUE #endif #ifdef _PY_PORT_CTYPE_UTF8_ISSUE #ifndef __cplusplus / The workaround below is unsafe in C++ because * the <locale> defines these symbols as real functions, * with a slightly different signature. * See issue #10910 / #include <ctype.h> #include <wctype.h> #undef isalnum #define isalnum(c) iswalnum(btowc(c)) #undef isalpha #define isalpha(c) iswalpha(btowc(c)) #undef islower #define islower(c) iswlower(btowc(c)) #undef isspace #define isspace(c) iswspace(btowc(c)) #undef isupper #define isupper(c) iswupper(btowc(c)) #undef tolower #define tolower(c) towlower(btowc(c)) #undef toupper #define toupper(c) towupper(btowc(c)) #endif #endif / Declarations for symbol visibility. PyAPI_FUNC(type): Declares a public Python API function and return type PyAPI_DATA(type): Declares public Python data and its type PyMODINIT_FUNC: A Python module init function. If these functions are inside the Python core, they are private to the core. If in an extension module, it may be declared with external linkage depending on the platform. As a number of platforms support/require "__declspec(dllimport/dllexport)", we support a HAVE_DECLSPEC_DLL macro to save duplication. / / All windows ports, except cygwin, are handled in PC/pyconfig.h. Cygwin is the only other autoconf platform requiring special linkage handling and it uses __declspec(). / #if defined(__CYGWIN__) # define HAVE_DECLSPEC_DLL #endif #include "exports.h" / only get special linkage if built as shared or platform is Cygwin / #if defined(Py_ENABLE_SHARED) \|\| defined(__CYGWIN__) # if defined(HAVE_DECLSPEC_DLL) # if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) # define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE # define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE / module init functions inside the core need no external linkage / / except for Cygwin to handle embedding / # if defined(__CYGWIN__) # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject # else /* __CYGWIN__ / # define PyMODINIT_FUNC PyObject # endif /* __CYGWIN__ / # else / Py_BUILD_CORE / / Building an extension module, or an embedded situation / / public Python functions and data are imported / / Under Cygwin, auto-import functions to prevent compilation / / failures similar to those described at the bottom of 4.1: / / http://docs.python.org/extending/windows.html#a-cookbook-approach / # if !defined(__CYGWIN__) # define PyAPI_FUNC(RTYPE) Py_IMPORTED_SYMBOL RTYPE # endif / !__CYGWIN__ / # define PyAPI_DATA(RTYPE) extern Py_IMPORTED_SYMBOL RTYPE / module init functions outside the core must be exported / # if defined(__cplusplus) # define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject # else /* __cplusplus / # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject # endif /* __cplusplus / # endif / Py_BUILD_CORE / # endif / HAVE_DECLSPEC_DLL / #endif / Py_ENABLE_SHARED / / If no external linkage macros defined by now, create defaults / #ifndef PyAPI_FUNC # define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE #endif #ifndef PyAPI_DATA # 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 #define LONG_MAX 0X7FFFFFFFFFFFFFFFL #else #error "could not set LONG_MAX in pyport.h" #endif #endif #ifndef LONG_MIN #define LONG_MIN (-LONG_MAX-1) #endif #ifndef LONG_BIT #define LONG_BIT (8 SIZEOF_LONG) #endif #if LONG_BIT != 8 * SIZEOF_LONG /* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent * 32-bit platforms using gcc. We try to catch that here at compile-time * rather than waiting for integer multiplication to trigger bogus * overflows. / #error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)." #endif #ifdef __cplusplus } #endif / * Hide GCC attributes from compilers that don't support them. / #if (!defined(__GNUC__) \|\| __GNUC__ < 2 \|\| \ (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) #define Py_GCC_ATTRIBUTE(x) #else #define Py_GCC_ATTRIBUTE(x) __attribute__(x) #endif / * Specify alignment on compilers that support it. / #if defined(__GNUC__) && __GNUC__ >= 3 #define Py_ALIGNED(x) __attribute__((aligned(x))) #else #define Py_ALIGNED(x) #endif / Eliminate end-of-loop code not reached warnings from SunPro C * when using do{...}while(0) macros / #ifdef __SUNPRO_C #pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED) #endif #ifndef Py_LL #define Py_LL(x) x##LL #endif #ifndef Py_ULL #define Py_ULL(x) Py_LL(x##U) #endif #define Py_VA_COPY va_copy / * Convenient macros to deal with endianness of the platform. WORDS_BIGENDIAN is * detected by configure and defined in pyconfig.h. The code in pyconfig.h * also takes care of Apple's universal builds. / #ifdef WORDS_BIGENDIAN # define PY_BIG_ENDIAN 1 # define PY_LITTLE_ENDIAN 0 #else # define PY_BIG_ENDIAN 0 # define PY_LITTLE_ENDIAN 1 #endif #ifdef __ANDROID__ / The Android langinfo.h header is not used. / # undef HAVE_LANGINFO_H # undef CODESET #endif / Maximum value of the Windows DWORD type / #define PY_DWORD_MAX 4294967295U / This macro used to tell whether Python was built with multithreading * enabled. Now multithreading is always enabled, but keep the macro * for compatibility. / #ifndef WITH_THREAD # define WITH_THREAD #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(), PyUnicode_DecodeLocale() // and PyUnicode_EncodeLocale(). # define _Py_FORCE_UTF8_LOCALE #endif #if defined(_Py_FORCE_UTF8_LOCALE) \|\| defined(__APPLE__) // Use UTF-8 as the filesystem encoding. // See PyUnicode_DecodeFSDefaultAndSize(), PyUnicode_EncodeFSDefault(), // Py_DecodeLocale() and Py_EncodeLocale(). # define _Py_FORCE_UTF8_FS_ENCODING #endif / Mark a function which cannot return. Example: PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); XLC support is intentionally omitted due to bpo-40244 / #ifndef _Py_NO_RETURN #if defined(__clang__) \|\| \ (defined(__GNUC__) && \ ((__GNUC__ >= 3) \|\| \ (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))) # define _Py_NO_RETURN __attribute__((__noreturn__)) #elif defined(_MSC_VER) # define _Py_NO_RETURN __declspec(noreturn) #else # define _Py_NO_RETURN #endif #endif // Preprocessor check for a builtin preprocessor function. Always return 0 // if __has_builtin() macro is not defined. // // __has_builtin() is available on clang and GCC 10. #ifdef __has_builtin # define _Py__has_builtin(x) __has_builtin(x) #else # define _Py__has_builtin(x) 0 #endif / A convenient way for code to know if sanitizers are enabled. / #if defined(__has_feature) # if __has_feature(memory_sanitizer) # if !defined(_Py_MEMORY_SANITIZER) # define _Py_MEMORY_SANITIZER # endif # endif # if __has_feature(address_sanitizer) # if !defined(_Py_ADDRESS_SANITIZER) # define _Py_ADDRESS_SANITIZER # endif # endif #elif defined(__GNUC__) # if defined(__SANITIZE_ADDRESS__) # define _Py_ADDRESS_SANITIZER # endif #endif #endif / Py_PYPORT_H */	23.88 KB	2025-10-09 16:16
📄 pystate.h /* Thread and interpreter state structures and their interfaces / #ifndef Py_PYSTATE_H #define Py_PYSTATE_H #ifdef __cplusplus extern "C" { #endif / This limitation is for performance and simplicity. If needed it can be removed (with effort). / #define MAX_CO_EXTRA_USERS 255 PyAPI_FUNC(PyInterpreterState ) PyInterpreterState_New(void); PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState ); PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03090000 /* New in 3.9 / / Get the current interpreter state. Issue a fatal error if there no current Python thread state or no current interpreter. It cannot return NULL. The caller must hold the GIL. / PyAPI_FUNC(PyInterpreterState ) PyInterpreterState_Get(void); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03080000 /* New in 3.8 / PyAPI_FUNC(PyObject ) PyInterpreterState_GetDict(PyInterpreterState ); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03070000 / New in 3.7 / PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState ); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 /* State unique per thread / / New in 3.3 / PyAPI_FUNC(int) PyState_AddModule(PyObject, PyModuleDef); PyAPI_FUNC(int) PyState_RemoveModule(PyModuleDef); #endif PyAPI_FUNC(PyObject) PyState_FindModule(PyModuleDef); PyAPI_FUNC(PyThreadState ) PyThreadState_New(PyInterpreterState ); PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState ); PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState ); /* Get the current thread state. When the current thread state is NULL, this issues a fatal error (so that the caller needn't check for NULL). The caller must hold the GIL. See also _PyThreadState_UncheckedGet() and _PyThreadState_GET(). / PyAPI_FUNC(PyThreadState ) PyThreadState_Get(void); // Alias to PyThreadState_Get() #define PyThreadState_GET() PyThreadState_Get() PyAPI_FUNC(PyThreadState ) PyThreadState_Swap(PyThreadState ); PyAPI_FUNC(PyObject ) PyThreadState_GetDict(void); PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03090000 /* New in 3.9 / PyAPI_FUNC(PyInterpreterState) PyThreadState_GetInterpreter(PyThreadState tstate); PyAPI_FUNC(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 may be used between _Ensure() and _Release() calls, so long as the thread-state is restored to its previous state before the Release(). For example, normal use of the Py_BEGIN_ALLOW_THREADS/ Py_END_ALLOW_THREADS macros are acceptable. The return value is an opaque "handle" to the thread state when PyGILState_Ensure() was called, and must be passed to PyGILState_Release() to ensure Python is left in the same state. Even though recursive calls are allowed, these handles can not be shared - each unique call to PyGILState_Ensure must save the handle for its call to PyGILState_Release. When the function returns, the current thread will hold the GIL. Failure is a fatal error. / PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void); / Release any resources previously acquired. After this call, Python's state will be the same as it was prior to the corresponding PyGILState_Ensure() call (but generally this state will be unknown to the caller, hence the use of the GILState API.) Every call to PyGILState_Ensure must be matched by a call to PyGILState_Release on the same thread. / PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE); / Helper/diagnostic function - get the current thread state for this thread. May return NULL if no GILState API has been used on the current thread. Note that the main thread always has such a thread-state, even if no auto-thread-state call has been made on the main thread. / PyAPI_FUNC(PyThreadState ) PyGILState_GetThisThreadState(void); #ifndef Py_LIMITED_API # define Py_CPYTHON_PYSTATE_H # include "cpython/pystate.h" # undef Py_CPYTHON_PYSTATE_H #endif #ifdef __cplusplus } #endif #endif /* !Py_PYSTATE_H */	4.53 KB	2025-10-09 16:16
📄 pystrcmp.h #ifndef Py_STRCMP_H #define Py_STRCMP_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(int) PyOS_mystrnicmp(const char , const char , Py_ssize_t); PyAPI_FUNC(int) PyOS_mystricmp(const char , const char ); #ifdef MS_WINDOWS #define PyOS_strnicmp strnicmp #define PyOS_stricmp stricmp #else #define PyOS_strnicmp PyOS_mystrnicmp #define PyOS_stricmp PyOS_mystricmp #endif #ifdef __cplusplus } #endif #endif /* !Py_STRCMP_H */	436 B	2025-10-09 16:16
📄 pystrtod.h #ifndef Py_STRTOD_H #define Py_STRTOD_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(double) PyOS_string_to_double(const char str, char endptr, PyObject overflow_exception); /* The caller is responsible for calling PyMem_Free to free the buffer that's is returned. / PyAPI_FUNC(char ) PyOS_double_to_string(double val, char format_code, int precision, int flags, int type); #ifndef Py_LIMITED_API PyAPI_FUNC(PyObject ) _Py_string_to_number_with_underscores( const char str, Py_ssize_t len, const char what, PyObject obj, void arg, PyObject (innerfunc)(const char , Py_ssize_t, void )); PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char p, char endptr); #endif / PyOS_double_to_string's "flags" parameter can be set to 0 or more of: / #define Py_DTSF_SIGN 0x01 / always add the sign / #define Py_DTSF_ADD_DOT_0 0x02 / if the result is an integer add ".0" / #define Py_DTSF_ALT 0x04 / "alternate" formatting. it's format_code specific / #define Py_DTSF_NO_NEG_0 0x08 / negative zero result is coerced to 0 / / PyOS_double_to_string's "type", if non-NULL, will be set to one of: / #define Py_DTST_FINITE 0 #define Py_DTST_INFINITE 1 #define Py_DTST_NAN 2 #ifdef __cplusplus } #endif #endif / !Py_STRTOD_H */	1.52 KB	2025-10-09 16:16
📄 pythonrun.h /* Interfaces to parse and execute pieces of python code / #ifndef Py_PYTHONRUN_H #define Py_PYTHONRUN_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(PyObject ) Py_CompileString(const char , const char , int); PyAPI_FUNC(void) PyErr_Print(void); PyAPI_FUNC(void) PyErr_PrintEx(int); PyAPI_FUNC(void) PyErr_Display(PyObject , PyObject , PyObject ); / Stuff with no proper home (yet) / PyAPI_DATA(int) (PyOS_InputHook)(void); /* Stack size, in "pointers" (so we get extra safety margins on 64-bit platforms). On a 32-bit platform, this translates to an 8k margin. / #define PYOS_STACK_MARGIN 2048 #if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300 / Enable stack checking under Microsoft C / // When changing the platforms, ensure PyOS_CheckStack() docs are still correct #define USE_STACKCHECK #endif #ifdef USE_STACKCHECK / Check that we aren't overflowing our stack / PyAPI_FUNC(int) PyOS_CheckStack(void); #endif #ifndef Py_LIMITED_API # define Py_CPYTHON_PYTHONRUN_H # include "cpython/pythonrun.h" # undef Py_CPYTHON_PYTHONRUN_H #endif #ifdef __cplusplus } #endif #endif / !Py_PYTHONRUN_H */	1.16 KB	2025-10-09 16:16
📄 pythread.h #ifndef Py_PYTHREAD_H #define Py_PYTHREAD_H typedef void PyThread_type_lock; #ifdef __cplusplus extern "C" { #endif / Return status codes for Python lock acquisition. Chosen for maximum * backwards compatibility, ie failure -> 0, success -> 1. / typedef enum PyLockStatus { PY_LOCK_FAILURE = 0, PY_LOCK_ACQUIRED = 1, PY_LOCK_INTR } PyLockStatus; PyAPI_FUNC(void) PyThread_init_thread(void); PyAPI_FUNC(unsigned long) PyThread_start_new_thread(void ()(void ), void ); PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void); #if defined(__APPLE__) \|\| defined(__linux__) \|\| defined(__FreeBSD__) \|\| defined(__OpenBSD__) \|\| defined(__NetBSD__) \|\| defined(_WIN32) \|\| defined(_AIX) #define PY_HAVE_THREAD_NATIVE_ID PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void); #endif PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void); PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock); PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int); #define WAIT_LOCK 1 #define NOWAIT_LOCK 0 /* PY_TIMEOUT_T is the integral type used to specify timeouts when waiting on a lock (see PyThread_acquire_lock_timed() below). PY_TIMEOUT_MAX is the highest usable value (in microseconds) of that type, and depends on the system threading API. NOTE: this isn't the same value as `_thread.TIMEOUT_MAX`. The _thread module exposes a higher-level API, with timeouts expressed in seconds and floating-point numbers allowed. / #define PY_TIMEOUT_T long long #if defined(_POSIX_THREADS) / PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000), convert microseconds to nanoseconds. / # define PY_TIMEOUT_MAX (LLONG_MAX / 1000) #elif defined (NT_THREADS) // WaitForSingleObject() accepts timeout in milliseconds in the range // [0; 0xFFFFFFFE] (DWORD type). INFINITE value (0xFFFFFFFF) means no // timeout. 0xFFFFFFFE milliseconds is around 49.7 days. # if 0xFFFFFFFELL 1000 < LLONG_MAX # define PY_TIMEOUT_MAX (0xFFFFFFFELL * 1000) # else # define PY_TIMEOUT_MAX LLONG_MAX # endif #else # define PY_TIMEOUT_MAX LLONG_MAX #endif /* If microseconds == 0, the call is non-blocking: it 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, PY_TIMEOUT_T microseconds, int intr_flag); PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock); PyAPI_FUNC(size_t) PyThread_get_stacksize(void); PyAPI_FUNC(int) PyThread_set_stacksize(size_t); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject) PyThread_GetInfo(void); #endif /* Thread Local Storage (TLS) API TLS API is DEPRECATED. Use Thread Specific Storage (TSS) API. The existing TLS API has used int to represent TLS keys across all platforms, but it is not POSIX-compliant. Therefore, the new TSS API uses opaque data type to represent TSS keys to be compatible (see PEP 539). / Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_create_key(void); Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key(int key); Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_set_key_value(int key, void value); Py_DEPRECATED(3.7) PyAPI_FUNC(void ) PyThread_get_key_value(int key); Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key_value(int key); / Cleanup after a fork / Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_ReInitTLS(void); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03070000 / New in 3.7 / / Thread Specific Storage (TSS) API / typedef struct _Py_tss_t Py_tss_t; / opaque / PyAPI_FUNC(Py_tss_t ) PyThread_tss_alloc(void); PyAPI_FUNC(void) PyThread_tss_free(Py_tss_t key); / The parameter key must not be NULL. / PyAPI_FUNC(int) PyThread_tss_is_created(Py_tss_t key); PyAPI_FUNC(int) PyThread_tss_create(Py_tss_t key); PyAPI_FUNC(void) PyThread_tss_delete(Py_tss_t key); PyAPI_FUNC(int) PyThread_tss_set(Py_tss_t key, void value); PyAPI_FUNC(void ) PyThread_tss_get(Py_tss_t key); #endif /* New in 3.7 / #ifndef Py_LIMITED_API # define Py_CPYTHON_PYTHREAD_H # include "cpython/pythread.h" # undef Py_CPYTHON_PYTHREAD_H #endif #ifdef __cplusplus } #endif #endif / !Py_PYTHREAD_H */	4.72 KB	2025-10-09 16:16
📄 pytypedefs.h // Forward declarations of types of the Python C API. // Declare them at the same place since redefining typedef is a C11 feature. // Only use a forward declaration if there is an interdependency between two // header files. #ifndef Py_PYTYPEDEFS_H #define Py_PYTYPEDEFS_H #ifdef __cplusplus extern "C" { #endif typedef struct PyModuleDef PyModuleDef; typedef struct PyModuleDef_Slot PyModuleDef_Slot; typedef struct PyMethodDef PyMethodDef; typedef struct PyGetSetDef PyGetSetDef; typedef struct PyMemberDef PyMemberDef; typedef struct _object PyObject; typedef struct _longobject PyLongObject; typedef struct _typeobject PyTypeObject; typedef struct PyCodeObject PyCodeObject; typedef struct _frame PyFrameObject; typedef struct _ts PyThreadState; typedef struct _is PyInterpreterState; #ifdef __cplusplus } #endif #endif // !Py_PYTYPEDEFS_H	851 B	2025-10-09 16:16
📄 rangeobject.h /* Range object interface / #ifndef Py_RANGEOBJECT_H #define Py_RANGEOBJECT_H #ifdef __cplusplus extern "C" { #endif / A range object represents an integer range. This is an immutable object; a range cannot change its value after creation. Range objects behave like the corresponding tuple objects except that they are represented by a start, stop, and step datamembers. / PyAPI_DATA(PyTypeObject) PyRange_Type; PyAPI_DATA(PyTypeObject) PyRangeIter_Type; PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type; #define PyRange_Check(op) Py_IS_TYPE(op, &PyRange_Type) #ifdef __cplusplus } #endif #endif / !Py_RANGEOBJECT_H */	628 B	2025-10-09 16:16
📄 setobject.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(PyObject set); PyAPI_FUNC(int) PySet_Contains(PyObject anyset, PyObject key); PyAPI_FUNC(int) PySet_Discard(PyObject set, PyObject key); PyAPI_FUNC(PyObject ) PySet_Pop(PyObject set); PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject anyset); #define PyFrozenSet_CheckExact(ob) Py_IS_TYPE(ob, &PyFrozenSet_Type) #define PyFrozenSet_Check(ob) \ (Py_IS_TYPE(ob, &PyFrozenSet_Type) \|\| \ PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) #define PyAnySet_CheckExact(ob) \ (Py_IS_TYPE(ob, &PySet_Type) \|\| Py_IS_TYPE(ob, &PyFrozenSet_Type)) #define PyAnySet_Check(ob) \ (Py_IS_TYPE(ob, &PySet_Type) \|\| Py_IS_TYPE(ob, &PyFrozenSet_Type) \|\| \ PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) \|\| \ PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) #define PySet_CheckExact(op) Py_IS_TYPE(op, &PySet_Type) #define 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 */	1.51 KB	2025-10-09 16:16
📄 sliceobject.h #ifndef Py_SLICEOBJECT_H #define Py_SLICEOBJECT_H #ifdef __cplusplus extern "C" { #endif /* The unique ellipsis object "..." / PyAPI_DATA(PyObject) _Py_EllipsisObject; / Don't use this directly / #define Py_Ellipsis (&_Py_EllipsisObject) / Slice object interface / / A slice object containing start, stop, and step data members (the names are from range). After much talk with Guido, it was decided to let these be any arbitrary python type. Py_None stands for omitted values. / #ifndef Py_LIMITED_API typedef struct { PyObject_HEAD PyObject start, stop, step; /* not NULL / } PySliceObject; #endif PyAPI_DATA(PyTypeObject) PySlice_Type; PyAPI_DATA(PyTypeObject) PyEllipsis_Type; #define PySlice_Check(op) Py_IS_TYPE(op, &PySlice_Type) PyAPI_FUNC(PyObject ) PySlice_New(PyObject* start, PyObject* stop, PyObject* step); #ifndef Py_LIMITED_API PyAPI_FUNC(PyObject ) _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop); PyAPI_FUNC(int) _PySlice_GetLongIndices(PySliceObject self, PyObject length, PyObject start_ptr, PyObject stop_ptr, PyObject step_ptr); #endif PyAPI_FUNC(int) PySlice_GetIndices(PyObject r, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step); Py_DEPRECATED(3.7) PyAPI_FUNC(int) PySlice_GetIndicesEx(PyObject r, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step, Py_ssize_t slicelength); #if !defined(Py_LIMITED_API) \|\| (Py_LIMITED_API+0 >= 0x03050400 && Py_LIMITED_API+0 < 0x03060000) \|\| Py_LIMITED_API+0 >= 0x03060100 #define PySlice_GetIndicesEx(slice, length, start, stop, step, slicelen) ( \ PySlice_Unpack((slice), (start), (stop), (step)) < 0 ? \ (((slicelen) = 0), -1) : \ (((slicelen) = PySlice_AdjustIndices((length), (start), (stop), (step))), \ 0)) PyAPI_FUNC(int) PySlice_Unpack(PyObject slice, Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step); PyAPI_FUNC(Py_ssize_t) PySlice_AdjustIndices(Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step); #endif #ifdef __cplusplus } #endif #endif / !Py_SLICEOBJECT_H */	2.46 KB	2025-10-09 16:16
📄 structmember.h #ifndef Py_STRUCTMEMBER_H #define Py_STRUCTMEMBER_H #ifdef __cplusplus extern "C" { #endif /* Interface to map C struct members to Python object attributes / #include <stddef.h> / For offsetof / / An array of PyMemberDef structures defines the name, type and offset of selected members of a C structure. These can be read by PyMember_GetOne() and set by PyMember_SetOne() (except if their READONLY flag is set). The array must be terminated with an entry whose name pointer is NULL. / struct PyMemberDef { const char name; int type; Py_ssize_t offset; int flags; const char doc; }; / Types / #define T_SHORT 0 #define T_INT 1 #define T_LONG 2 #define T_FLOAT 3 #define T_DOUBLE 4 #define T_STRING 5 #define T_OBJECT 6 / XXX the ordering here is weird for binary compatibility / #define T_CHAR 7 / 1-character string / #define T_BYTE 8 / 8-bit signed int / / unsigned variants: / #define T_UBYTE 9 #define T_USHORT 10 #define T_UINT 11 #define T_ULONG 12 / Added by Jack: strings contained in the structure / #define T_STRING_INPLACE 13 / Added by Lillo: bools contained in the structure (assumed char) / #define T_BOOL 14 #define T_OBJECT_EX 16 / Like T_OBJECT, but raises AttributeError when the value is NULL, instead of converting to None. / #define T_LONGLONG 17 #define T_ULONGLONG 18 #define T_PYSSIZET 19 / Py_ssize_t / #define T_NONE 20 / Value is always None / / Flags / #define READONLY 1 #define READ_RESTRICTED 2 #define PY_WRITE_RESTRICTED 4 #define RESTRICTED (READ_RESTRICTED \| PY_WRITE_RESTRICTED) #define PY_AUDIT_READ READ_RESTRICTED / Current API, use this / PyAPI_FUNC(PyObject ) PyMember_GetOne(const char , PyMemberDef ); PyAPI_FUNC(int) PyMember_SetOne(char , PyMemberDef , PyObject ); #ifdef __cplusplus } #endif #endif / !Py_STRUCTMEMBER_H */	1.99 KB	2025-10-09 16:16
📄 structseq.h /* Named tuple object interface / #ifndef Py_STRUCTSEQ_H #define Py_STRUCTSEQ_H #ifdef __cplusplus extern "C" { #endif typedef struct PyStructSequence_Field { const char name; const char doc; } PyStructSequence_Field; typedef struct PyStructSequence_Desc { const char name; const char doc; PyStructSequence_Field fields; int n_in_sequence; } PyStructSequence_Desc; PyAPI_DATA(const char * const) PyStructSequence_UnnamedField; #ifndef Py_LIMITED_API PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject type, PyStructSequence_Desc desc); PyAPI_FUNC(int) PyStructSequence_InitType2(PyTypeObject type, PyStructSequence_Desc desc); #endif PyAPI_FUNC(PyTypeObject) PyStructSequence_NewType(PyStructSequence_Desc desc); PyAPI_FUNC(PyObject ) PyStructSequence_New(PyTypeObject type); #ifndef Py_LIMITED_API typedef PyTupleObject PyStructSequence; /* Macro, only to be used to fill in brand new objects / #define PyStructSequence_SET_ITEM(op, i, v) PyTuple_SET_ITEM(op, i, v) #define PyStructSequence_GET_ITEM(op, i) PyTuple_GET_ITEM(op, i) #endif PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject, Py_ssize_t, PyObject); PyAPI_FUNC(PyObject) PyStructSequence_GetItem(PyObject, Py_ssize_t); #ifdef __cplusplus } #endif #endif / !Py_STRUCTSEQ_H */	1.36 KB	2025-10-09 16:16
📄 sysmodule.h /* 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_SetObject(const char , PyObject ); Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_SetArgv(int, wchar_t ); Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_SetArgvEx(int, wchar_t , int); Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_SetPath(const wchar_t ); PyAPI_FUNC(void) PySys_WriteStdout(const char format, ...) Py_GCC_ATTRIBUTE((format(printf, 1, 2))); PyAPI_FUNC(void) PySys_WriteStderr(const char format, ...) Py_GCC_ATTRIBUTE((format(printf, 1, 2))); PyAPI_FUNC(void) PySys_FormatStdout(const char format, ...); PyAPI_FUNC(void) PySys_FormatStderr(const char format, ...); PyAPI_FUNC(void) PySys_ResetWarnOptions(void); Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_AddWarnOption(const wchar_t ); Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_AddWarnOptionUnicode(PyObject ); Py_DEPRECATED(3.11) PyAPI_FUNC(int) PySys_HasWarnOptions(void); Py_DEPRECATED(3.11) PyAPI_FUNC(void) PySys_AddXOption(const wchar_t ); PyAPI_FUNC(PyObject ) PySys_GetXOptions(void); #ifndef Py_LIMITED_API # define Py_CPYTHON_SYSMODULE_H # include "cpython/sysmodule.h" # undef Py_CPYTHON_SYSMODULE_H #endif #ifdef __cplusplus } #endif #endif /* !Py_SYSMODULE_H */	1.35 KB	2025-10-09 16:16
📄 token.h /* Auto-generated by Tools/scripts/generate_token.py / / Token types / #ifndef Py_LIMITED_API #ifndef Py_TOKEN_H #define Py_TOKEN_H #ifdef __cplusplus extern "C" { #endif #undef TILDE / Prevent clash of our definition with system macro. Ex AIX, ioctl.h / #define ENDMARKER 0 #define NAME 1 #define NUMBER 2 #define STRING 3 #define NEWLINE 4 #define INDENT 5 #define DEDENT 6 #define LPAR 7 #define RPAR 8 #define LSQB 9 #define RSQB 10 #define COLON 11 #define COMMA 12 #define SEMI 13 #define PLUS 14 #define MINUS 15 #define STAR 16 #define SLASH 17 #define VBAR 18 #define AMPER 19 #define LESS 20 #define GREATER 21 #define EQUAL 22 #define DOT 23 #define PERCENT 24 #define LBRACE 25 #define RBRACE 26 #define EQEQUAL 27 #define NOTEQUAL 28 #define LESSEQUAL 29 #define GREATEREQUAL 30 #define TILDE 31 #define CIRCUMFLEX 32 #define LEFTSHIFT 33 #define RIGHTSHIFT 34 #define DOUBLESTAR 35 #define PLUSEQUAL 36 #define MINEQUAL 37 #define STAREQUAL 38 #define SLASHEQUAL 39 #define PERCENTEQUAL 40 #define AMPEREQUAL 41 #define VBAREQUAL 42 #define CIRCUMFLEXEQUAL 43 #define LEFTSHIFTEQUAL 44 #define RIGHTSHIFTEQUAL 45 #define DOUBLESTAREQUAL 46 #define DOUBLESLASH 47 #define DOUBLESLASHEQUAL 48 #define AT 49 #define ATEQUAL 50 #define RARROW 51 #define ELLIPSIS 52 #define COLONEQUAL 53 #define OP 54 #define AWAIT 55 #define ASYNC 56 #define TYPE_IGNORE 57 #define TYPE_COMMENT 58 #define SOFT_KEYWORD 59 #define ERRORTOKEN 60 #define N_TOKENS 64 #define NT_OFFSET 256 / Special definitions for cooperation with parser / #define ISTERMINAL(x) ((x) < NT_OFFSET) #define ISNONTERMINAL(x) ((x) >= NT_OFFSET) #define ISEOF(x) ((x) == ENDMARKER) #define ISWHITESPACE(x) ((x) == ENDMARKER \|\| \ (x) == NEWLINE \|\| \ (x) == INDENT \|\| \ (x) == DEDENT) PyAPI_DATA(const char const) _PyParser_TokenNames[]; /* Token names / PyAPI_FUNC(int) PyToken_OneChar(int); PyAPI_FUNC(int) PyToken_TwoChars(int, int); PyAPI_FUNC(int) PyToken_ThreeChars(int, int, int); #ifdef __cplusplus } #endif #endif / !Py_TOKEN_H / #endif / Py_LIMITED_API */	2.61 KB	2025-10-09 16:16
📄 traceback.h #ifndef Py_TRACEBACK_H #define Py_TRACEBACK_H #ifdef __cplusplus extern "C" { #endif /* Traceback interface / PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject ); PyAPI_FUNC(int) PyTraceBack_Print(PyObject , PyObject ); /* Reveal traceback type so we can typecheck traceback objects / PyAPI_DATA(PyTypeObject) PyTraceBack_Type; #define PyTraceBack_Check(v) Py_IS_TYPE(v, &PyTraceBack_Type) #ifndef Py_LIMITED_API # define Py_CPYTHON_TRACEBACK_H # include "cpython/traceback.h" # undef Py_CPYTHON_TRACEBACK_H #endif #ifdef __cplusplus } #endif #endif / !Py_TRACEBACK_H */	583 B	2025-10-09 16:16
📄 tracemalloc.h #ifndef Py_TRACEMALLOC_H #define Py_TRACEMALLOC_H #ifndef Py_LIMITED_API /* Track an allocated memory block in the tracemalloc module. Return 0 on success, return -1 on error (failed to allocate memory to store the trace). Return -2 if tracemalloc is disabled. If memory block is already tracked, update the existing trace. / PyAPI_FUNC(int) PyTraceMalloc_Track( unsigned int domain, uintptr_t ptr, size_t size); / Untrack an allocated memory block in the tracemalloc module. Do nothing if the block was not tracked. Return -2 if tracemalloc is disabled, otherwise return 0. / PyAPI_FUNC(int) PyTraceMalloc_Untrack( unsigned int domain, uintptr_t 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); #endif #endif /* !Py_TRACEMALLOC_H */	1.09 KB	2025-10-09 16:16
📄 tupleobject.h /* Tuple object interface / #ifndef Py_TUPLEOBJECT_H #define Py_TUPLEOBJECT_H #ifdef __cplusplus extern "C" { #endif / Another generally useful object type is a tuple of object pointers. For Python, this 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 does not increment the returned item's reference count. / PyAPI_DATA(PyTypeObject) PyTuple_Type; PyAPI_DATA(PyTypeObject) PyTupleIter_Type; #define PyTuple_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS) #define PyTuple_CheckExact(op) Py_IS_TYPE(op, &PyTuple_Type) PyAPI_FUNC(PyObject ) PyTuple_New(Py_ssize_t size); PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject ); PyAPI_FUNC(PyObject ) PyTuple_GetItem(PyObject , Py_ssize_t); PyAPI_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 */	1.58 KB	2025-10-09 16:16
📄 typeslots.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_absolute 6 #define Py_nb_add 7 #define Py_nb_and 8 #define Py_nb_bool 9 #define Py_nb_divmod 10 #define Py_nb_float 11 #define Py_nb_floor_divide 12 #define Py_nb_index 13 #define Py_nb_inplace_add 14 #define Py_nb_inplace_and 15 #define Py_nb_inplace_floor_divide 16 #define Py_nb_inplace_lshift 17 #define Py_nb_inplace_multiply 18 #define Py_nb_inplace_or 19 #define Py_nb_inplace_power 20 #define Py_nb_inplace_remainder 21 #define Py_nb_inplace_rshift 22 #define Py_nb_inplace_subtract 23 #define Py_nb_inplace_true_divide 24 #define Py_nb_inplace_xor 25 #define Py_nb_int 26 #define Py_nb_invert 27 #define Py_nb_lshift 28 #define Py_nb_multiply 29 #define Py_nb_negative 30 #define Py_nb_or 31 #define Py_nb_positive 32 #define Py_nb_power 33 #define Py_nb_remainder 34 #define Py_nb_rshift 35 #define Py_nb_subtract 36 #define Py_nb_true_divide 37 #define Py_nb_xor 38 #define Py_sq_ass_item 39 #define Py_sq_concat 40 #define Py_sq_contains 41 #define Py_sq_inplace_concat 42 #define Py_sq_inplace_repeat 43 #define Py_sq_item 44 #define Py_sq_length 45 #define Py_sq_repeat 46 #define Py_tp_alloc 47 #define Py_tp_base 48 #define Py_tp_bases 49 #define Py_tp_call 50 #define Py_tp_clear 51 #define Py_tp_dealloc 52 #define Py_tp_del 53 #define Py_tp_descr_get 54 #define Py_tp_descr_set 55 #define Py_tp_doc 56 #define Py_tp_getattr 57 #define Py_tp_getattro 58 #define Py_tp_hash 59 #define Py_tp_init 60 #define Py_tp_is_gc 61 #define Py_tp_iter 62 #define Py_tp_iternext 63 #define Py_tp_methods 64 #define Py_tp_new 65 #define Py_tp_repr 66 #define Py_tp_richcompare 67 #define Py_tp_setattr 68 #define Py_tp_setattro 69 #define Py_tp_str 70 #define Py_tp_traverse 71 #define Py_tp_members 72 #define Py_tp_getset 73 #define Py_tp_free 74 #define Py_nb_matrix_multiply 75 #define Py_nb_inplace_matrix_multiply 76 #define Py_am_await 77 #define Py_am_aiter 78 #define Py_am_anext 79 #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03050000 / New in 3.5 / #define Py_tp_finalize 80 #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030A0000 / New in 3.10 */ #define Py_am_send 81 #endif	2.29 KB	2025-10-09 16:16
📄 unicodeobject.h #ifndef Py_UNICODEOBJECT_H #define Py_UNICODEOBJECT_H #include <stdarg.h> // va_list /* Unicode implementation based on original code by Fredrik Lundh, modified by Marc-Andre Lemburg (mal@lemburg.com) according to the Unicode Integration Proposal. (See http://www.egenix.com/files/python/unicode-proposal.txt). Copyright (c) Corporation for National Research Initiatives. Original header: -------------------------------------------------------------------- * Yet another Unicode string type for Python. This type supports the * 16-bit Basic Multilingual Plane (BMP) only. * * Written by Fredrik Lundh, January 1999. * * Copyright (c) 1999 by Secret Labs AB. * Copyright (c) 1999 by Fredrik Lundh. * * fredrik@pythonware.com * http://www.pythonware.com * * -------------------------------------------------------------------- * This Unicode String Type is * * Copyright (c) 1999 by Secret Labs AB * Copyright (c) 1999 by Fredrik Lundh * * By obtaining, using, and/or copying this software and/or its * associated documentation, you agree that you have read, understood, * and will comply with the following terms and conditions: * * Permission to use, copy, modify, and distribute this software and its * associated documentation for any purpose and without fee is hereby * granted, provided that the above copyright notice appears in all * copies, and that both that copyright notice and this permission notice * appear in supporting documentation, and that the name of Secret Labs * AB or the author not be used 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 TORTIOUS ACTION, ARISING OUT * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * -------------------------------------------------------------------- / #include <ctype.h> / === Internal API ======================================================= / / --- 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-bit unsigned type / / #define HAVE_WCHAR_H / / #define HAVE_USABLE_WCHAR_T / / If the compiler provides a wchar_t type we try to support it through the interface functions PyUnicode_FromWideChar(), PyUnicode_AsWideChar() and PyUnicode_AsWideCharString(). / #ifdef HAVE_USABLE_WCHAR_T # ifndef HAVE_WCHAR_H # define HAVE_WCHAR_H # endif #endif #ifdef HAVE_WCHAR_H # include <wchar.h> #endif / Py_UCS4 and Py_UCS2 are typedefs for the respective unicode representations. / typedef uint32_t Py_UCS4; typedef uint16_t Py_UCS2; typedef uint8_t Py_UCS1; #ifdef __cplusplus extern "C" { #endif PyAPI_DATA(PyTypeObject) PyUnicode_Type; PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type; #define PyUnicode_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS) #define PyUnicode_CheckExact(op) Py_IS_TYPE(op, &PyUnicode_Type) / --- Constants ---------------------------------------------------------- / / This Unicode character will be used as replacement character during decoding if the errors argument is set to "replace". Note: the Unicode character U+FFFD is the official REPLACEMENT CHARACTER in Unicode 3.0. / #define Py_UNICODE_REPLACEMENT_CHARACTER ((Py_UCS4) 0xFFFD) / === Public API ========================================================= / / Similar to PyUnicode_FromUnicode(), but u points to UTF-8 encoded bytes / PyAPI_FUNC(PyObject) PyUnicode_FromStringAndSize( const char u, / UTF-8 encoded string / Py_ssize_t size / size of buffer / ); / Similar to PyUnicode_FromUnicode(), but u points to null-terminated UTF-8 encoded bytes. The size is determined with strlen(). / PyAPI_FUNC(PyObject) PyUnicode_FromString( const char u / UTF-8 encoded string / ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject) PyUnicode_Substring( PyObject str, Py_ssize_t start, Py_ssize_t end); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 / Copy the string into a UCS4 buffer including the null character if copy_null is set. Return NULL and raise an exception on error. Raise a SystemError if the buffer is smaller than the string. Return buffer on success. buflen is the length of the buffer in (Py_UCS4) characters. / PyAPI_FUNC(Py_UCS4) PyUnicode_AsUCS4( PyObject unicode, Py_UCS4 buffer, Py_ssize_t buflen, int copy_null); /* Copy the string into a UCS4 buffer. A new buffer is allocated using * PyMem_Malloc; if this fails, NULL is returned with a memory error exception set. / PyAPI_FUNC(Py_UCS4) PyUnicode_AsUCS4Copy(PyObject unicode); #endif #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 / Get the length of the Unicode object. / PyAPI_FUNC(Py_ssize_t) PyUnicode_GetLength( PyObject unicode ); #endif /* Get the number of Py_UNICODE units in the string representation. / Py_DEPRECATED(3.3) PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize( PyObject unicode /* Unicode object / ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 / Read a character from the string. / PyAPI_FUNC(Py_UCS4) PyUnicode_ReadChar( PyObject unicode, Py_ssize_t index ); /* Write a character to the string. The string must have been created through PyUnicode_New, must not be shared, and must not have been hashed yet. Return 0 on success, -1 on error. / PyAPI_FUNC(int) PyUnicode_WriteChar( PyObject unicode, Py_ssize_t index, Py_UCS4 character ); #endif /* Resize a Unicode object. The length is the number of characters, except if the kind of the string is PyUnicode_WCHAR_KIND: in this case, the length is the number of Py_UNICODE characters. unicode is modified to point to the new (resized) object and 0 returned on success. Try to resize the string in place (which is usually faster than allocating a new string and copy characters), or create a new string. Error handling is implemented as follows: an exception is set, -1 is returned and unicode left untouched. WARNING: The function doesn't check string content, the result may not be a string in canonical representation. / PyAPI_FUNC(int) PyUnicode_Resize( PyObject unicode, / Pointer to the Unicode object / Py_ssize_t length / New length / ); / Decode obj to a Unicode object. bytes, bytearray and other bytes-like objects are decoded according 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 / ); / Copy an instance of a Unicode subtype to a new true Unicode object if necessary. If obj is already a true Unicode object (not a subtype), return the reference with incremented refcount. The API returns NULL in case of an error. The caller is responsible for decref'ing the returned objects. / PyAPI_FUNC(PyObject) PyUnicode_FromObject( PyObject obj / Object / ); PyAPI_FUNC(PyObject ) PyUnicode_FromFormatV( const char format, / ASCII-encoded string / 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 / ); // PyUnicode_InternImmortal() is deprecated since Python 3.10 // and will be removed in Python 3.12. Use PyUnicode_InternInPlace() instead. Py_DEPRECATED(3.10) PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject ); / --- 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. / PyAPI_FUNC(PyObject) PyUnicode_FromWideChar( const wchar_t w, / wchar_t buffer / Py_ssize_t size / size of buffer / ); / Copies the Unicode Object contents into the wchar_t buffer w. At most size wchar_t characters are copied. Note that the resulting wchar_t string may or may not be 0-terminated. It is the responsibility of the caller to make sure that the wchar_t string is 0-terminated in case this is required by the application. Returns the number of wchar_t characters copied (excluding a possibly trailing 0-termination character) or -1 in case of an error. / PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar( PyObject unicode, /* Unicode object / wchar_t w, /* wchar_t buffer / 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, / Unicode object / Py_ssize_t size /* number of characters of the result / ); #endif / --- Unicode ordinals --------------------------------------------------- / / Create a Unicode Object from the given Unicode code point ordinal. The ordinal must be in range(0x110000). A ValueError is raised in case it is not. / PyAPI_FUNC(PyObject) PyUnicode_FromOrdinal(int ordinal); /* === Builtin Codecs ===================================================== Many of these APIs take two arguments encoding and errors. These parameters encoding and errors have the same semantics as the ones of the builtin str() API. Setting encoding to NULL causes the default encoding (UTF-8) to be used. Error handling is set by errors which may also be set to NULL meaning to use the default handling defined for the codec. Default error handling for all builtin codecs is "strict" (ValueErrors are raised). The codecs all use a similar interface. Only deviation from the generic ones are documented. / / --- Manage the default encoding ---------------------------------------- / / Returns "utf-8". / PyAPI_FUNC(const char) PyUnicode_GetDefaultEncoding(void); /* --- Generic Codecs ----------------------------------------------------- / / Create a Unicode object by decoding the encoded string s of the given size. / PyAPI_FUNC(PyObject) PyUnicode_Decode( const char s, / encoded string / Py_ssize_t size, / size of buffer / const char encoding, /* encoding / const char errors /* error handling / ); / Decode a Unicode object unicode and return the result as Python object. This API is DEPRECATED. The only supported standard encoding is rot13. Use PyCodec_Decode() to decode with rot13 and non-standard codecs that decode from str. / Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject) PyUnicode_AsDecodedObject( PyObject unicode, / Unicode object / const char encoding, /* encoding / const char errors /* error handling / ); / Decode a Unicode object unicode and return the result as Unicode object. This API is DEPRECATED. 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() since all standard encodings (except rot13) encode str to bytes. Use PyCodec_Encode() for encoding with rot13 and non-standard codecs that encode form str to non-bytes. / Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject) PyUnicode_AsEncodedObject( PyObject unicode, / Unicode object / const char encoding, /* encoding / const char errors /* error handling / ); / Encodes a Unicode object and returns the result as Python string object. / PyAPI_FUNC(PyObject) PyUnicode_AsEncodedString( PyObject unicode, / Unicode object / const char encoding, /* encoding / const char errors /* error handling / ); / Encodes a Unicode object and returns the result as Unicode object. This API is DEPRECATED. The only supported standard encodings is rot13. Use PyCodec_Encode() to encode with rot13 and non-standard codecs that encode from str to str. / Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject) PyUnicode_AsEncodedUnicode( PyObject unicode, / Unicode object / const char encoding, /* encoding / const char errors /* error handling / ); / Build an encoding map. / PyAPI_FUNC(PyObject) PyUnicode_BuildEncodingMap( PyObject* string /* 256 character map / ); / --- UTF-7 Codecs ------------------------------------------------------- / PyAPI_FUNC(PyObject) PyUnicode_DecodeUTF7( const char string, / UTF-7 encoded string / Py_ssize_t length, / size of string / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_DecodeUTF7Stateful( const char string, / UTF-7 encoded string / Py_ssize_t length, / size of string / const char errors, /* error handling / Py_ssize_t consumed /* bytes consumed / ); / --- UTF-8 Codecs ------------------------------------------------------- / PyAPI_FUNC(PyObject) PyUnicode_DecodeUTF8( const char string, / UTF-8 encoded string / Py_ssize_t length, / size of string / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_DecodeUTF8Stateful( const char string, / UTF-8 encoded string / Py_ssize_t length, / size of string / const char errors, /* error handling / Py_ssize_t consumed /* bytes consumed / ); PyAPI_FUNC(PyObject) PyUnicode_AsUTF8String( PyObject unicode / Unicode object / ); / Returns a pointer to the default encoding (UTF-8) of the Unicode object unicode and the size of the encoded representation in bytes stored in size. In case of an error, no size is set. This function caches the UTF-8 encoded string in the unicodeobject and subsequent calls will return the same string. The memory is released when the unicodeobject is deallocated. / #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030A0000 PyAPI_FUNC(const char ) PyUnicode_AsUTF8AndSize( PyObject unicode, Py_ssize_t size); #endif /* --- UTF-32 Codecs ------------------------------------------------------ / / Decodes length bytes from a UTF-32 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 four bytes of the stream are checked for a BOM mark. If found, the BOM mark is analysed, the byte order adjusted and the BOM skipped. In the other modes, no BOM mark interpretation is done. After completion, byteorder 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 / ); PyAPI_FUNC(PyObject) PyUnicode_DecodeUTF32Stateful( 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 / Py_ssize_t consumed /* bytes consumed / ); / Returns a Python string using the UTF-32 encoding in native byte order. The string always starts with a BOM mark. / PyAPI_FUNC(PyObject) PyUnicode_AsUTF32String( PyObject unicode / Unicode object / ); / Returns a Python string object holding the UTF-32 encoded value of the Unicode data. If byteorder is not 0, output is written according to the following byte order: byteorder == -1: little endian byteorder == 0: native byte order (writes a BOM mark) byteorder == 1: big endian If byteorder is 0, the output string will always start with the Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is prepended. / / --- UTF-16 Codecs ------------------------------------------------------ / / 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 and the BOM skipped. In the other modes, no BOM mark interpretation is done. After completion, byteorder 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_DecodeUTF16( const char string, / UTF-16 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 / ); PyAPI_FUNC(PyObject) PyUnicode_DecodeUTF16Stateful( const char string, / UTF-16 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 / Py_ssize_t consumed /* bytes consumed / ); / Returns a Python string using the UTF-16 encoding in native byte order. The string always starts with a BOM mark. / PyAPI_FUNC(PyObject) PyUnicode_AsUTF16String( PyObject unicode / Unicode object / ); / --- Unicode-Escape Codecs ---------------------------------------------- / PyAPI_FUNC(PyObject) PyUnicode_DecodeUnicodeEscape( const char string, / Unicode-Escape encoded string / Py_ssize_t length, / size of string / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_AsUnicodeEscapeString( PyObject unicode / Unicode object / ); / --- Raw-Unicode-Escape Codecs ------------------------------------------ / PyAPI_FUNC(PyObject) PyUnicode_DecodeRawUnicodeEscape( const char string, / Raw-Unicode-Escape encoded string / Py_ssize_t length, / size of string / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_AsRawUnicodeEscapeString( PyObject unicode / Unicode object / ); / --- Latin-1 Codecs ----------------------------------------------------- Note: Latin-1 corresponds to the first 256 Unicode ordinals. / PyAPI_FUNC(PyObject) PyUnicode_DecodeLatin1( const char string, / Latin-1 encoded string / Py_ssize_t length, / size of string / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_AsLatin1String( PyObject unicode / Unicode object / ); / --- ASCII Codecs ------------------------------------------------------- Only 7-bit ASCII data is excepted. All other codes generate errors. / PyAPI_FUNC(PyObject) PyUnicode_DecodeASCII( const char string, / ASCII encoded string / Py_ssize_t length, / size of string / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_AsASCIIString( PyObject unicode / Unicode object / ); / --- 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 to bytes objects, integers in the range from 0 to 255 or None. Unmapped character ordinals (ones which cause a LookupError) as well as mapped to None are treated as "undefined mapping" and cause an error. / PyAPI_FUNC(PyObject) PyUnicode_DecodeCharmap( const char string, / Encoded string / Py_ssize_t length, / size of string / PyObject mapping, /* decoding mapping / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_AsCharmapString( PyObject unicode, / Unicode object / PyObject mapping /* encoding mapping / ); / --- MBCS codecs for Windows -------------------------------------------- / #ifdef MS_WINDOWS PyAPI_FUNC(PyObject) PyUnicode_DecodeMBCS( const char string, / MBCS encoded string / Py_ssize_t length, / size of string / const char errors /* error handling / ); PyAPI_FUNC(PyObject) PyUnicode_DecodeMBCSStateful( const char string, / MBCS encoded string / Py_ssize_t length, / size of string / const char errors, /* error handling / Py_ssize_t consumed /* bytes consumed / ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject) PyUnicode_DecodeCodePageStateful( int code_page, /* code page number / const char string, /* encoded string / Py_ssize_t length, / size of string / const char errors, /* error handling / Py_ssize_t consumed /* bytes consumed / ); #endif PyAPI_FUNC(PyObject) PyUnicode_AsMBCSString( PyObject unicode / Unicode object / ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject) PyUnicode_EncodeCodePage( int code_page, /* code page number / PyObject unicode, /* Unicode object / const char errors /* error handling / ); #endif #endif / MS_WINDOWS / / --- Locale encoding --------------------------------------------------- / #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 with a null character but cannot contain embedded null characters. / PyAPI_FUNC(PyObject) PyUnicode_DecodeLocaleAndSize( const char str, Py_ssize_t len, const char errors); /* Similar to PyUnicode_DecodeLocaleAndSize(), but compute the string length using strlen(). / PyAPI_FUNC(PyObject) PyUnicode_DecodeLocale( const char str, const char errors); /* Encode a Unicode object to the current locale encoding. The encoder is strict is surrogateescape is equal to zero, otherwise the "surrogateescape" error handler is used. Return a bytes object. The string cannot contain embedded null characters. / PyAPI_FUNC(PyObject) PyUnicode_EncodeLocale( PyObject unicode, const char errors ); #endif /* --- File system encoding ---------------------------------------------- / / ParseTuple converter: encode str objects to bytes using PyUnicode_EncodeFSDefault(); bytes objects are output as-is. / PyAPI_FUNC(int) PyUnicode_FSConverter(PyObject, void); / ParseTuple converter: decode bytes objects to unicode using PyUnicode_DecodeFSDefaultAndSize(); str objects are output as-is. / PyAPI_FUNC(int) PyUnicode_FSDecoder(PyObject, void); / Decode a null-terminated string using Py_FileSystemDefaultEncoding and the "surrogateescape" error handler. If Py_FileSystemDefaultEncoding is not set, fall back to the locale encoding. Use PyUnicode_DecodeFSDefaultAndSize() if the string length is known. / PyAPI_FUNC(PyObject) PyUnicode_DecodeFSDefault( const char s / encoded string / ); / Decode a string using Py_FileSystemDefaultEncoding and the "surrogateescape" error handler. If Py_FileSystemDefaultEncoding is not set, fall back to the locale encoding. / PyAPI_FUNC(PyObject) PyUnicode_DecodeFSDefaultAndSize( const char s, / encoded string / Py_ssize_t size / size / ); / Encode a Unicode object to Py_FileSystemDefaultEncoding with the "surrogateescape" error handler, and return bytes. If Py_FileSystemDefaultEncoding is not set, fall back to the locale encoding. / PyAPI_FUNC(PyObject) PyUnicode_EncodeFSDefault( PyObject unicode ); / --- Methods & Slots ---------------------------------------------------- These are capable of handling 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 string / PyObject right /* Right string / ); / Concat two strings, put the result in pleft and drop the right object (sets pleft to NULL on error) / PyAPI_FUNC(void) PyUnicode_AppendAndDel( PyObject pleft, / Pointer to left string / PyObject right /* Right string / ); / Split a string giving a list of Unicode strings. If sep is NULL, splitting will be done at all whitespace substrings. Otherwise, splits occur at the given separator. At most maxsplit splits will be done. If negative, no limit is set. Separators are not included in the resulting list. / PyAPI_FUNC(PyObject) PyUnicode_Split( PyObject s, / String to split / PyObject sep, /* String separator / Py_ssize_t maxsplit / Maxsplit count / ); / Dito, but split at line breaks. CRLF is considered to be one line break. Line breaks are not included in the resulting list. / PyAPI_FUNC(PyObject) PyUnicode_Splitlines( PyObject s, / String to split / int keepends / If true, line end markers are included / ); / Partition a string using a given separator. / PyAPI_FUNC(PyObject) PyUnicode_Partition( PyObject s, / String to partition / PyObject sep /* String separator / ); / Partition a string using a given separator, searching from the end of the string. / PyAPI_FUNC(PyObject) PyUnicode_RPartition( PyObject s, / String to partition / PyObject sep /* String separator / ); / Split a string giving a list of Unicode strings. If sep is NULL, splitting will be done at all whitespace substrings. Otherwise, splits 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 the resulting Unicode object. The mapping table must map Unicode ordinal integers to Unicode strings, Unicode ordinal integers or None (causing deletion of the character). Mapping tables may be dictionaries or sequences. Unmapped character ordinals (ones which cause a LookupError) are left untouched and are copied as-is. / PyAPI_FUNC(PyObject ) PyUnicode_Translate( PyObject str, / String / PyObject table, /* Translate table / const char errors /* error handling / ); / Join a sequence of strings using the given separator and return the resulting Unicode string. / PyAPI_FUNC(PyObject) PyUnicode_Join( PyObject separator, / Separator string / PyObject seq /* Sequence object / ); / Return 1 if substr matches str[start:end] at the given tail end, 0 otherwise. / PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch( PyObject str, /* String / PyObject substr, /* Prefix or Suffix string / Py_ssize_t start, / Start index / Py_ssize_t end, / Stop index / int direction / Tail end: -1 prefix, +1 suffix / ); / Return the first position of substr in str[start:end] using the given search direction or -1 if not found. -2 is returned in case an error occurred and an exception is set. / PyAPI_FUNC(Py_ssize_t) PyUnicode_Find( PyObject str, /* String / PyObject substr, /* Substring to find / Py_ssize_t start, / Start index / Py_ssize_t end, / Stop index / int direction / Find direction: +1 forward, -1 backward / ); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03030000 / Like PyUnicode_Find, but search for single character only. / PyAPI_FUNC(Py_ssize_t) PyUnicode_FindChar( PyObject str, Py_UCS4 ch, Py_ssize_t start, Py_ssize_t end, int direction ); #endif /* Count the number of occurrences of substr in str[start:end]. / PyAPI_FUNC(Py_ssize_t) PyUnicode_Count( PyObject str, /* String / PyObject substr, /* Substring to count / Py_ssize_t start, / Start index / Py_ssize_t end / Stop index / ); / Replace at most maxcount occurrences of substr in str with replstr and return the resulting Unicode object. / PyAPI_FUNC(PyObject ) PyUnicode_Replace( PyObject str, / String / PyObject substr, /* Substring to find / PyObject replstr, /* Substring to replace / Py_ssize_t maxcount / Max. number of replacements to apply; -1 = all / ); / Compare two strings and return -1, 0, 1 for less than, equal, greater than resp. Raise an exception and return -1 on error. / PyAPI_FUNC(int) PyUnicode_Compare( PyObject left, /* Left string / PyObject right /* Right string / ); / Compare a Unicode object with C string and return -1, 0, 1 for less than, equal, and greater than, respectively. It is best to pass only ASCII-encoded strings, but the function interprets 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_NE, Py_LT, Py_LE / PyAPI_FUNC(PyObject ) PyUnicode_RichCompare( PyObject left, / Left string / PyObject right, /* Right string / int op / Operation: Py_EQ, Py_NE, Py_GT, etc. / ); / Apply an argument tuple or dictionary to a format string and return the resulting Unicode string. / PyAPI_FUNC(PyObject ) PyUnicode_Format( PyObject format, / Format string / PyObject args /* Argument tuple or dictionary / ); / Checks whether element is contained in container and return 1/0 accordingly. element has to coerce to a one element Unicode string. -1 is returned in case of an error. / PyAPI_FUNC(int) PyUnicode_Contains( PyObject container, /* Container string / PyObject element /* Element string / ); / Checks whether argument is a valid identifier. / PyAPI_FUNC(int) PyUnicode_IsIdentifier(PyObject s); /* === Characters Type APIs =============================================== / #ifndef Py_LIMITED_API # define Py_CPYTHON_UNICODEOBJECT_H # include "cpython/unicodeobject.h" # undef Py_CPYTHON_UNICODEOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_UNICODEOBJECT_H */	35.19 KB	2025-10-09 16:16
📄 warnings.h #ifndef Py_WARNINGS_H #define Py_WARNINGS_H #ifdef __cplusplus extern "C" { #endif PyAPI_FUNC(int) PyErr_WarnEx( PyObject category, const char message, /* UTF-8 encoded string / Py_ssize_t stack_level); PyAPI_FUNC(int) PyErr_WarnFormat( PyObject category, Py_ssize_t stack_level, const char format, / ASCII-encoded string / ...); #if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x03060000 / Emit a ResourceWarning warning / PyAPI_FUNC(int) PyErr_ResourceWarning( PyObject source, Py_ssize_t stack_level, const char format, / ASCII-encoded string / ...); #endif PyAPI_FUNC(int) PyErr_WarnExplicit( PyObject category, const char message, / UTF-8 encoded string / const char filename, /* decoded from the filesystem encoding / int lineno, const char module, /* UTF-8 encoded string / PyObject registry); #ifndef Py_LIMITED_API # define Py_CPYTHON_WARNINGS_H # include "cpython/warnings.h" # undef Py_CPYTHON_WARNINGS_H #endif #ifdef __cplusplus } #endif #endif /* !Py_WARNINGS_H */	1.1 KB	2025-10-09 16:16
📄 weakrefobject.h /* Weak 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) \ (Py_IS_TYPE(op, &_PyWeakref_ProxyType) \|\| \ Py_IS_TYPE(op, &_PyWeakref_CallableProxyType)) #define PyWeakref_Check(op) \ (PyWeakref_CheckRef(op) \|\| PyWeakref_CheckProxy(op)) PyAPI_FUNC(PyObject ) PyWeakref_NewRef(PyObject ob, PyObject callback); PyAPI_FUNC(PyObject ) PyWeakref_NewProxy(PyObject ob, PyObject callback); PyAPI_FUNC(PyObject ) PyWeakref_GetObject(PyObject ref); #ifndef Py_LIMITED_API # define Py_CPYTHON_WEAKREFOBJECT_H # include "cpython/weakrefobject.h" # undef Py_CPYTHON_WEAKREFOBJECT_H #endif #ifdef __cplusplus } #endif #endif / !Py_WEAKREFOBJECT_H */	1.2 KB	2025-10-09 16:16

Edit File:

Terminal