vidya7732/AI_Doctor_LLM_GenModel
0
1#ifndef Py_CPYTHON_OBJECT_H2# error "this header file must not be included directly"3#endif4 5#ifdef __cplusplus6extern "C" {7#endif8 9PyAPI_FUNC(void) _Py_NewReference(PyObject *op);10 11#ifdef Py_TRACE_REFS12/* Py_TRACE_REFS is such major surgery that we call external routines. */13PyAPI_FUNC(void) _Py_ForgetReference(PyObject *);14#endif15 16/* Update the Python traceback of an object. This function must be called17 when a memory block is reused from a free list. */18PyAPI_FUNC(int) _PyTraceMalloc_NewReference(PyObject *op);19 20#ifdef Py_REF_DEBUG21PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);22#endif23 24 25/********************* String Literals ****************************************/26/* This structure helps managing static strings. The basic usage goes like this:27 Instead of doing28 29 r = PyObject_CallMethod(o, "foo", "args", ...);30 31 do32 33 _Py_IDENTIFIER(foo);34 ...35 r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...);36 37 PyId_foo is a static variable, either on block level or file level. On first38 usage, the string "foo" is interned, and the structures are linked. On interpreter39 shutdown, all strings are released.40 41 Alternatively, _Py_static_string allows choosing the variable name.42 _PyUnicode_FromId returns a borrowed reference to the interned string.43 _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*.44*/45typedef struct _Py_Identifier {46 struct _Py_Identifier *next;47 const char* string;48 PyObject *object;49} _Py_Identifier;50 51#define _Py_static_string_init(value) { .next = NULL, .string = value, .object = NULL }52#define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value)53#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname)54 55/* buffer interface */56typedef struct bufferinfo {57 void *buf;58 PyObject *obj; /* owned reference */59 Py_ssize_t len;60 Py_ssize_t itemsize; /* This is Py_ssize_t so it can be61 pointed to by strides in simple case.*/62 int readonly;63 int ndim;64 char *format;65 Py_ssize_t *shape;66 Py_ssize_t *strides;67 Py_ssize_t *suboffsets;68 void *internal;69} Py_buffer;70 71typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);72typedef void (*releasebufferproc)(PyObject *, Py_buffer *);73 74typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args,75 size_t nargsf, PyObject *kwnames);76 77/* Maximum number of dimensions */78#define PyBUF_MAX_NDIM 6479 80/* Flags for getting buffers */81#define PyBUF_SIMPLE 082#define PyBUF_WRITABLE 0x000183/* we used to include an E, backwards compatible alias */84#define PyBUF_WRITEABLE PyBUF_WRITABLE85#define PyBUF_FORMAT 0x000486#define PyBUF_ND 0x000887#define PyBUF_STRIDES (0x0010 | PyBUF_ND)88#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)89#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)90#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)91#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)92 93#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)94#define PyBUF_CONTIG_RO (PyBUF_ND)95 96#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)97#define PyBUF_STRIDED_RO (PyBUF_STRIDES)98 99#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)100#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)101 102#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)103#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)104 105 106#define PyBUF_READ 0x100107#define PyBUF_WRITE 0x200108/* End buffer interface */109 110 111typedef struct {112 /* Number implementations must check *both*113 arguments for proper type and implement the necessary conversions114 in the slot functions themselves. */115 116 binaryfunc nb_add;117 binaryfunc nb_subtract;118 binaryfunc nb_multiply;119 binaryfunc nb_remainder;120 binaryfunc nb_divmod;121 ternaryfunc nb_power;122 unaryfunc nb_negative;123 unaryfunc nb_positive;124 unaryfunc nb_absolute;125 inquiry nb_bool;126 unaryfunc nb_invert;127 binaryfunc nb_lshift;128 binaryfunc nb_rshift;129 binaryfunc nb_and;130 binaryfunc nb_xor;131 binaryfunc nb_or;132 unaryfunc nb_int;133 void *nb_reserved; /* the slot formerly known as nb_long */134 unaryfunc nb_float;135 136 binaryfunc nb_inplace_add;137 binaryfunc nb_inplace_subtract;138 binaryfunc nb_inplace_multiply;139 binaryfunc nb_inplace_remainder;140 ternaryfunc nb_inplace_power;141 binaryfunc nb_inplace_lshift;142 binaryfunc nb_inplace_rshift;143 binaryfunc nb_inplace_and;144 binaryfunc nb_inplace_xor;145 binaryfunc nb_inplace_or;146 147 binaryfunc nb_floor_divide;148 binaryfunc nb_true_divide;149 binaryfunc nb_inplace_floor_divide;150 binaryfunc nb_inplace_true_divide;151 152 unaryfunc nb_index;153 154 binaryfunc nb_matrix_multiply;155 binaryfunc nb_inplace_matrix_multiply;156} PyNumberMethods;157 158typedef struct {159 lenfunc sq_length;160 binaryfunc sq_concat;161 ssizeargfunc sq_repeat;162 ssizeargfunc sq_item;163 void *was_sq_slice;164 ssizeobjargproc sq_ass_item;165 void *was_sq_ass_slice;166 objobjproc sq_contains;167 168 binaryfunc sq_inplace_concat;169 ssizeargfunc sq_inplace_repeat;170} PySequenceMethods;171 172typedef struct {173 lenfunc mp_length;174 binaryfunc mp_subscript;175 objobjargproc mp_ass_subscript;176} PyMappingMethods;177 178typedef struct {179 unaryfunc am_await;180 unaryfunc am_aiter;181 unaryfunc am_anext;182} PyAsyncMethods;183 184typedef struct {185 getbufferproc bf_getbuffer;186 releasebufferproc bf_releasebuffer;187} PyBufferProcs;188 189/* Allow printfunc in the tp_vectorcall_offset slot for190 * backwards-compatibility */191typedef Py_ssize_t printfunc;192 193struct _typeobject {194 PyObject_VAR_HEAD195 const char *tp_name; /* For printing, in format "<module>.<name>" */196 Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */197 198 /* Methods to implement standard operations */199 200 destructor tp_dealloc;201 Py_ssize_t tp_vectorcall_offset;202 getattrfunc tp_getattr;203 setattrfunc tp_setattr;204 PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)205 or tp_reserved (Python 3) */206 reprfunc tp_repr;207 208 /* Method suites for standard classes */209 210 PyNumberMethods *tp_as_number;211 PySequenceMethods *tp_as_sequence;212 PyMappingMethods *tp_as_mapping;213 214 /* More standard operations (here for binary compatibility) */215 216 hashfunc tp_hash;217 ternaryfunc tp_call;218 reprfunc tp_str;219 getattrofunc tp_getattro;220 setattrofunc tp_setattro;221 222 /* Functions to access object as input/output buffer */223 PyBufferProcs *tp_as_buffer;224 225 /* Flags to define presence of optional/expanded features */226 unsigned long tp_flags;227 228 const char *tp_doc; /* Documentation string */229 230 /* Assigned meaning in release 2.0 */231 /* call function for all accessible objects */232 traverseproc tp_traverse;233 234 /* delete references to contained objects */235 inquiry tp_clear;236 237 /* Assigned meaning in release 2.1 */238 /* rich comparisons */239 richcmpfunc tp_richcompare;240 241 /* weak reference enabler */242 Py_ssize_t tp_weaklistoffset;243 244 /* Iterators */245 getiterfunc tp_iter;246 iternextfunc tp_iternext;247 248 /* Attribute descriptor and subclassing stuff */249 struct PyMethodDef *tp_methods;250 struct PyMemberDef *tp_members;251 struct PyGetSetDef *tp_getset;252 struct _typeobject *tp_base;253 PyObject *tp_dict;254 descrgetfunc tp_descr_get;255 descrsetfunc tp_descr_set;256 Py_ssize_t tp_dictoffset;257 initproc tp_init;258 allocfunc tp_alloc;259 newfunc tp_new;260 freefunc tp_free; /* Low-level free-memory routine */261 inquiry tp_is_gc; /* For PyObject_IS_GC */262 PyObject *tp_bases;263 PyObject *tp_mro; /* method resolution order */264 PyObject *tp_cache;265 PyObject *tp_subclasses;266 PyObject *tp_weaklist;267 destructor tp_del;268 269 /* Type attribute cache version tag. Added in version 2.6 */270 unsigned int tp_version_tag;271 272 destructor tp_finalize;273 vectorcallfunc tp_vectorcall;274};275 276/* The *real* layout of a type object when allocated on the heap */277typedef struct _heaptypeobject {278 /* Note: there's a dependency on the order of these members279 in slotptr() in typeobject.c . */280 PyTypeObject ht_type;281 PyAsyncMethods as_async;282 PyNumberMethods as_number;283 PyMappingMethods as_mapping;284 PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,285 so that the mapping wins when both286 the mapping and the sequence define287 a given operator (e.g. __getitem__).288 see add_operators() in typeobject.c . */289 PyBufferProcs as_buffer;290 PyObject *ht_name, *ht_slots, *ht_qualname;291 struct _dictkeysobject *ht_cached_keys;292 PyObject *ht_module;293 /* here are optional user slots, followed by the members. */294} PyHeapTypeObject;295 296/* access macro to the members which are floating "behind" the object */297#define PyHeapType_GET_MEMBERS(etype) \298 ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize))299 300PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *);301PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);302PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *);303PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *);304PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *);305PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *);306PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *);307 308struct _Py_Identifier;309PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int);310PyAPI_FUNC(void) _Py_BreakPoint(void);311PyAPI_FUNC(void) _PyObject_Dump(PyObject *);312PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *);313 314PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *);315PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *);316PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *);317PyAPI_FUNC(int) _PyObject_HasAttrId(PyObject *, struct _Py_Identifier *);318/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which319 don't raise AttributeError.320 321 Return 1 and set *result != NULL if an attribute is found.322 Return 0 and set *result == NULL if an attribute is not found;323 an AttributeError is silenced.324 Return -1 and set *result == NULL if an error other than AttributeError325 is raised.326*/327PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **);328PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, struct _Py_Identifier *, PyObject **);329 330PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);331 332PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *);333PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);334PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *);335PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *);336 337/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes338 dict as the last parameter. */339PyAPI_FUNC(PyObject *)340_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int);341PyAPI_FUNC(int)342_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *,343 PyObject *, PyObject *);344 345PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *);346 347/* Safely decref `op` and set `op` to `op2`.348 *349 * As in case of Py_CLEAR "the obvious" code can be deadly:350 *351 * Py_DECREF(op);352 * op = op2;353 *354 * The safe way is:355 *356 * Py_SETREF(op, op2);357 *358 * That arranges to set `op` to `op2` _before_ decref'ing, so that any code359 * triggered as a side-effect of `op` getting torn down no longer believes360 * `op` points to a valid object.361 *362 * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of363 * Py_DECREF.364 */365 366#define Py_SETREF(op, op2) \367 do { \368 PyObject *_py_tmp = _PyObject_CAST(op); \369 (op) = (op2); \370 Py_DECREF(_py_tmp); \371 } while (0)372 373#define Py_XSETREF(op, op2) \374 do { \375 PyObject *_py_tmp = _PyObject_CAST(op); \376 (op) = (op2); \377 Py_XDECREF(_py_tmp); \378 } while (0)379 380 381PyAPI_DATA(PyTypeObject) _PyNone_Type;382PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type;383 384/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE.385 * Defined in object.c.386 */387PyAPI_DATA(int) _Py_SwappedOp[];388 389PyAPI_FUNC(void)390_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks,391 size_t sizeof_block);392PyAPI_FUNC(void)393_PyObject_DebugTypeStats(FILE *out);394 395/* Define a pair of assertion macros:396 _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT().397 398 These work like the regular C assert(), in that they will abort the399 process with a message on stderr if the given condition fails to hold,400 but compile away to nothing if NDEBUG is defined.401 402 However, before aborting, Python will also try to call _PyObject_Dump() on403 the given object. This may be of use when investigating bugs in which a404 particular object is corrupt (e.g. buggy a tp_visit method in an extension405 module breaking the garbage collector), to help locate the broken objects.406 407 The WITH_MSG variant allows you to supply an additional message that Python408 will attempt to print to stderr, after the object dump. */409#ifdef NDEBUG410 /* No debugging: compile away the assertions: */411# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \412 ((void)0)413#else414 /* With debugging: generate checks: */415# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \416 ((expr) \417 ? (void)(0) \418 : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \419 (msg), (filename), (lineno), (func)))420#endif421 422#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \423 _PyObject_ASSERT_FROM(obj, expr, msg, __FILE__, __LINE__, __func__)424#define _PyObject_ASSERT(obj, expr) \425 _PyObject_ASSERT_WITH_MSG(obj, expr, NULL)426 427#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \428 _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__)429 430/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined,431 to avoid causing compiler/linker errors when building extensions without432 NDEBUG against a Python built with NDEBUG defined.433 434 msg, expr and function can be NULL. */435PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed(436 PyObject *obj,437 const char *expr,438 const char *msg,439 const char *file,440 int line,441 const char *function);442 443/* Check if an object is consistent. For example, ensure that the reference444 counter is greater than or equal to 1, and ensure that ob_type is not NULL.445 446 Call _PyObject_AssertFailed() if the object is inconsistent.447 448 If check_content is zero, only check header fields: reduce the overhead.449 450 The function always return 1. The return value is just here to be able to451 write:452 453 assert(_PyObject_CheckConsistency(obj, 1)); */454PyAPI_FUNC(int) _PyObject_CheckConsistency(455 PyObject *op,456 int check_content);457 458 459/* Trashcan mechanism, thanks to Christian Tismer.460 461When deallocating a container object, it's possible to trigger an unbounded462chain of deallocations, as each Py_DECREF in turn drops the refcount on "the463next" object in the chain to 0. This can easily lead to stack overflows,464especially in threads (which typically have less stack space to work with).465 466A container object can avoid this by bracketing the body of its tp_dealloc467function with a pair of macros:468 469static void470mytype_dealloc(mytype *p)471{472 ... declarations go here ...473 474 PyObject_GC_UnTrack(p); // must untrack first475 Py_TRASHCAN_BEGIN(p, mytype_dealloc)476 ... The body of the deallocator goes here, including all calls ...477 ... to Py_DECREF on contained objects. ...478 Py_TRASHCAN_END // there should be no code after this479}480 481CAUTION: Never return from the middle of the body! If the body needs to482"get out early", put a label immediately before the Py_TRASHCAN_END483call, and goto it. Else the call-depth counter (see below) will stay484above 0 forever, and the trashcan will never get emptied.485 486How it works: The BEGIN macro increments a call-depth counter. So long487as this counter is small, the body of the deallocator is run directly without488further ado. But if the counter gets large, it instead adds p to a list of489objects to be deallocated later, skips the body of the deallocator, and490resumes execution after the END macro. The tp_dealloc routine then returns491without deallocating anything (and so unbounded call-stack depth is avoided).492 493When the call stack finishes unwinding again, code generated by the END macro494notices this, and calls another routine to deallocate all the objects that495may have been added to the list of deferred deallocations. In effect, a496chain of N deallocations is broken into (N-1)/(PyTrash_UNWIND_LEVEL-1) pieces,497with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL.498 499Since the tp_dealloc of a subclass typically calls the tp_dealloc of the base500class, we need to ensure that the trashcan is only triggered on the tp_dealloc501of the actual class being deallocated. Otherwise we might end up with a502partially-deallocated object. To check this, the tp_dealloc function must be503passed as second argument to Py_TRASHCAN_BEGIN().504*/505 506/* This is the old private API, invoked by the macros before 3.2.4.507 Kept for binary compatibility of extensions using the stable ABI. */508PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*);509PyAPI_FUNC(void) _PyTrash_destroy_chain(void);510 511/* This is the old private API, invoked by the macros before 3.9.512 Kept for binary compatibility of extensions using the stable ABI. */513PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*);514PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void);515 516/* Forward declarations for PyThreadState */517struct _ts;518 519/* Python 3.9 private API, invoked by the macros below. */520PyAPI_FUNC(int) _PyTrash_begin(struct _ts *tstate, PyObject *op);521PyAPI_FUNC(void) _PyTrash_end(struct _ts *tstate);522 523#define PyTrash_UNWIND_LEVEL 50524 525#define Py_TRASHCAN_BEGIN_CONDITION(op, cond) \526 do { \527 PyThreadState *_tstate = NULL; \528 /* If "cond" is false, then _tstate remains NULL and the deallocator \529 * is run normally without involving the trashcan */ \530 if (cond) { \531 _tstate = PyThreadState_GET(); \532 if (_PyTrash_begin(_tstate, _PyObject_CAST(op))) { \533 break; \534 } \535 }536 /* The body of the deallocator is here. */537#define Py_TRASHCAN_END \538 if (_tstate) { \539 _PyTrash_end(_tstate); \540 } \541 } while (0);542 543#define Py_TRASHCAN_BEGIN(op, dealloc) \544 Py_TRASHCAN_BEGIN_CONDITION(op, \545 Py_TYPE(op)->tp_dealloc == (destructor)(dealloc))546 547/* For backwards compatibility, these macros enable the trashcan548 * unconditionally */549#define Py_TRASHCAN_SAFE_BEGIN(op) Py_TRASHCAN_BEGIN_CONDITION(op, 1)550#define Py_TRASHCAN_SAFE_END(op) Py_TRASHCAN_END551 552#ifdef __cplusplus553}554#endif555