/* The PyObject_ memory family: high-level object memory interfaces.

[0] Fix | Delete

See pymem.h for the low-level PyMem_ family.

[1] Fix | Delete

*/

[2] Fix | Delete

[3] Fix | Delete

#ifndef Py_OBJIMPL_H

[4] Fix | Delete

#define Py_OBJIMPL_H

[5] Fix | Delete

[6] Fix | Delete

#include "pymem.h"

[7] Fix | Delete

[8] Fix | Delete

#ifdef __cplusplus

[9] Fix | Delete

extern "C" {

[10] Fix | Delete

#endif

[11] Fix | Delete

[12] Fix | Delete

/* BEWARE:

[13] Fix | Delete

[14] Fix | Delete

Each interface exports both functions and macros. Extension modules should

[15] Fix | Delete

use the functions, to ensure binary compatibility across Python versions.

[16] Fix | Delete

Because the Python implementation is free to change internal details, and

[17] Fix | Delete

the macros may (or may not) expose details for speed, if you do use the

[18] Fix | Delete

macros you must recompile your extensions with each Python release.

[19] Fix | Delete

[20] Fix | Delete

Never mix calls to PyObject_ memory functions with calls to the platform

[21] Fix | Delete

malloc/realloc/ calloc/free, or with calls to PyMem_.

[22] Fix | Delete

*/

[23] Fix | Delete

[24] Fix | Delete

/*

[25] Fix | Delete

Functions and macros for modules that implement new object types.

[26] Fix | Delete

[27] Fix | Delete

- PyObject_New(type, typeobj) allocates memory for a new object of the given

[28] Fix | Delete

type, and initializes part of it. 'type' must be the C structure type used

[29] Fix | Delete

to represent the object, and 'typeobj' the address of the corresponding

[30] Fix | Delete

type object. Reference count and type pointer are filled in; the rest of

[31] Fix | Delete

the bytes of the object are *undefined*! The resulting expression type is

[32] Fix | Delete

'type *'. The size of the object is determined by the tp_basicsize field

[33] Fix | Delete

of the type object.

[34] Fix | Delete

[35] Fix | Delete

- PyObject_NewVar(type, typeobj, n) is similar but allocates a variable-size

[36] Fix | Delete

object with room for n items. In addition to the refcount and type pointer

[37] Fix | Delete

fields, this also fills in the ob_size field.

[38] Fix | Delete

[39] Fix | Delete

- PyObject_Del(op) releases the memory allocated for an object. It does not

[40] Fix | Delete

run a destructor -- it only frees the memory. PyObject_Free is identical.

[41] Fix | Delete

[42] Fix | Delete

- PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't

[43] Fix | Delete

allocate memory. Instead of a 'type' parameter, they take a pointer to a

[44] Fix | Delete

new object (allocated by an arbitrary allocator), and initialize its object

[45] Fix | Delete

header fields.

[46] Fix | Delete

[47] Fix | Delete

Note that objects created with PyObject_{New, NewVar} are allocated using the

[48] Fix | Delete

specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is

[49] Fix | Delete

enabled. In addition, a special debugging allocator is used if PYMALLOC_DEBUG

[50] Fix | Delete

is also #defined.

[51] Fix | Delete

[52] Fix | Delete

In case a specific form of memory management is needed (for example, if you

[53] Fix | Delete

must use the platform malloc heap(s), or shared memory, or C++ local storage or

[54] Fix | Delete

operator new), you must first allocate the object with your custom allocator,

[55] Fix | Delete

then pass its pointer to PyObject_{Init, InitVar} for filling in its Python-

[56] Fix | Delete

specific fields: reference count, type pointer, possibly others. You should

[57] Fix | Delete

be aware that Python has no control over these objects because they don't

[58] Fix | Delete

cooperate with the Python memory manager. Such objects may not be eligible

[59] Fix | Delete

for automatic garbage collection and you have to make sure that they are

[60] Fix | Delete

released accordingly whenever their destructor gets called (cf. the specific

[61] Fix | Delete

form of memory management you're using).

[62] Fix | Delete

[63] Fix | Delete

Unless you have specific memory management requirements, use

[64] Fix | Delete

PyObject_{New, NewVar, Del}.

[65] Fix | Delete

*/

[66] Fix | Delete

[67] Fix | Delete

/*

[68] Fix | Delete

* Raw object memory interface

[69] Fix | Delete

* ===========================

[70] Fix | Delete

*/

[71] Fix | Delete

[72] Fix | Delete

/* Functions to call the same malloc/realloc/free as used by Python's

[73] Fix | Delete

object allocator. If WITH_PYMALLOC is enabled, these may differ from

[74] Fix | Delete

the platform malloc/realloc/free. The Python object allocator is

[75] Fix | Delete

designed for fast, cache-conscious allocation of many "small" objects,

[76] Fix | Delete

and with low hidden memory overhead.

[77] Fix | Delete

[78] Fix | Delete

PyObject_Malloc(0) returns a unique non-NULL pointer if possible.

[79] Fix | Delete

[80] Fix | Delete

PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n).

[81] Fix | Delete

PyObject_Realloc(p != NULL, 0) does not return NULL, or free the memory

[82] Fix | Delete

at p.

[83] Fix | Delete

[84] Fix | Delete

Returned pointers must be checked for NULL explicitly; no action is

[85] Fix | Delete

performed on failure other than to return NULL (no warning it printed, no

[86] Fix | Delete

exception is set, etc).

[87] Fix | Delete

[88] Fix | Delete

For allocating objects, use PyObject_{New, NewVar} instead whenever

[89] Fix | Delete

possible. The PyObject_{Malloc, Realloc, Free} family is exposed

[90] Fix | Delete

so that you can exploit Python's small-block allocator for non-object

[91] Fix | Delete

uses. If you must use these routines to allocate object memory, make sure

[92] Fix | Delete

the object gets initialized via PyObject_{Init, InitVar} after obtaining

[93] Fix | Delete

the raw memory.

[94] Fix | Delete

*/

[95] Fix | Delete

PyAPI_FUNC(void *) PyObject_Malloc(size_t);

[96] Fix | Delete

PyAPI_FUNC(void *) PyObject_Realloc(void *, size_t);

[97] Fix | Delete

PyAPI_FUNC(void) PyObject_Free(void *);

[98] Fix | Delete

[99] Fix | Delete

[100] Fix | Delete

/* Macros */

[101] Fix | Delete

#ifdef WITH_PYMALLOC

[102] Fix | Delete

PyAPI_FUNC(void) _PyObject_DebugMallocStats(FILE *out);

[103] Fix | Delete

#ifdef PYMALLOC_DEBUG /* WITH_PYMALLOC && PYMALLOC_DEBUG */

[104] Fix | Delete

PyAPI_FUNC(void *) _PyObject_DebugMalloc(size_t nbytes);

[105] Fix | Delete

PyAPI_FUNC(void *) _PyObject_DebugRealloc(void *p, size_t nbytes);

[106] Fix | Delete

PyAPI_FUNC(void) _PyObject_DebugFree(void *p);

[107] Fix | Delete

PyAPI_FUNC(void) _PyObject_DebugDumpAddress(const void *p);

[108] Fix | Delete

PyAPI_FUNC(void) _PyObject_DebugCheckAddress(const void *p);

[109] Fix | Delete

PyAPI_FUNC(void *) _PyObject_DebugMallocApi(char api, size_t nbytes);

[110] Fix | Delete

PyAPI_FUNC(void *) _PyObject_DebugReallocApi(char api, void *p, size_t nbytes);

[111] Fix | Delete

PyAPI_FUNC(void) _PyObject_DebugFreeApi(char api, void *p);

[112] Fix | Delete

PyAPI_FUNC(void) _PyObject_DebugCheckAddressApi(char api, const void *p);

[113] Fix | Delete

PyAPI_FUNC(void *) _PyMem_DebugMalloc(size_t nbytes);

[114] Fix | Delete

PyAPI_FUNC(void *) _PyMem_DebugRealloc(void *p, size_t nbytes);

[115] Fix | Delete

PyAPI_FUNC(void) _PyMem_DebugFree(void *p);

[116] Fix | Delete

#define PyObject_MALLOC _PyObject_DebugMalloc

[117] Fix | Delete

#define PyObject_Malloc _PyObject_DebugMalloc

[118] Fix | Delete

#define PyObject_REALLOC _PyObject_DebugRealloc

[119] Fix | Delete

#define PyObject_Realloc _PyObject_DebugRealloc

[120] Fix | Delete

#define PyObject_FREE _PyObject_DebugFree

[121] Fix | Delete

#define PyObject_Free _PyObject_DebugFree

[122] Fix | Delete

[123] Fix | Delete

#else /* WITH_PYMALLOC && ! PYMALLOC_DEBUG */

[124] Fix | Delete

#define PyObject_MALLOC PyObject_Malloc

[125] Fix | Delete

#define PyObject_REALLOC PyObject_Realloc

[126] Fix | Delete

#define PyObject_FREE PyObject_Free

[127] Fix | Delete

#endif

[128] Fix | Delete

[129] Fix | Delete

#else /* ! WITH_PYMALLOC */

[130] Fix | Delete

#define PyObject_MALLOC PyMem_MALLOC

[131] Fix | Delete

#define PyObject_REALLOC PyMem_REALLOC

[132] Fix | Delete

#define PyObject_FREE PyMem_FREE

[133] Fix | Delete

[134] Fix | Delete

#endif /* WITH_PYMALLOC */

[135] Fix | Delete

[136] Fix | Delete

#define PyObject_Del PyObject_Free

[137] Fix | Delete

#define PyObject_DEL PyObject_FREE

[138] Fix | Delete

[139] Fix | Delete

/* for source compatibility with 2.2 */

[140] Fix | Delete

#define _PyObject_Del PyObject_Free

[141] Fix | Delete

[142] Fix | Delete

/*

[143] Fix | Delete

* Generic object allocator interface

[144] Fix | Delete

* ==================================

[145] Fix | Delete

*/

[146] Fix | Delete

[147] Fix | Delete

/* Functions */

[148] Fix | Delete

PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *);

[149] Fix | Delete

PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *,

[150] Fix | Delete

PyTypeObject *, Py_ssize_t);

[151] Fix | Delete

PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *);

[152] Fix | Delete

PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);

[153] Fix | Delete

[154] Fix | Delete

#define PyObject_New(type, typeobj) \

[155] Fix | Delete

( (type *) _PyObject_New(typeobj) )

[156] Fix | Delete

#define PyObject_NewVar(type, typeobj, n) \

[157] Fix | Delete

( (type *) _PyObject_NewVar((typeobj), (n)) )

[158] Fix | Delete

[159] Fix | Delete

/* Macros trading binary compatibility for speed. See also pymem.h.

[160] Fix | Delete

Note that these macros expect non-NULL object pointers.*/

[161] Fix | Delete

#define PyObject_INIT(op, typeobj) \

[162] Fix | Delete

( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )

[163] Fix | Delete

#define PyObject_INIT_VAR(op, typeobj, size) \

[164] Fix | Delete

( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) )

[165] Fix | Delete

[166] Fix | Delete

#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )

[167] Fix | Delete

[168] Fix | Delete

/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a

[169] Fix | Delete

vrbl-size object with nitems items, exclusive of gc overhead (if any). The

[170] Fix | Delete

value is rounded up to the closest multiple of sizeof(void *), in order to

[171] Fix | Delete

ensure that pointer fields at the end of the object are correctly aligned

[172] Fix | Delete

for the platform (this is of special importance for subclasses of, e.g.,

[173] Fix | Delete

str or long, so that pointers can be stored after the embedded data).

[174] Fix | Delete

[175] Fix | Delete

Note that there's no memory wastage in doing this, as malloc has to

[176] Fix | Delete

return (at worst) pointer-aligned memory anyway.

[177] Fix | Delete

*/

[178] Fix | Delete

#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0

[179] Fix | Delete

# error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2"

[180] Fix | Delete

#endif

[181] Fix | Delete

[182] Fix | Delete

#define _PyObject_VAR_SIZE(typeobj, nitems) \

[183] Fix | Delete

(size_t) \

[184] Fix | Delete

( ( (typeobj)->tp_basicsize + \

[185] Fix | Delete

(nitems)*(typeobj)->tp_itemsize + \

[186] Fix | Delete

(SIZEOF_VOID_P - 1) \

[187] Fix | Delete

) & ~(SIZEOF_VOID_P - 1) \

[188] Fix | Delete

)

[189] Fix | Delete

[190] Fix | Delete

#define PyObject_NEW(type, typeobj) \

[191] Fix | Delete

( (type *) PyObject_Init( \

[192] Fix | Delete

(PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )

[193] Fix | Delete

[194] Fix | Delete

#define PyObject_NEW_VAR(type, typeobj, n) \

[195] Fix | Delete

( (type *) PyObject_InitVar( \

[196] Fix | Delete

(PyVarObject *) PyObject_MALLOC(_PyObject_VAR_SIZE((typeobj),(n)) ),\

[197] Fix | Delete

(typeobj), (n)) )

[198] Fix | Delete

[199] Fix | Delete

/* This example code implements an object constructor with a custom

[200] Fix | Delete

allocator, where PyObject_New is inlined, and shows the important

[201] Fix | Delete

distinction between two steps (at least):

[202] Fix | Delete

1) the actual allocation of the object storage;

[203] Fix | Delete

2) the initialization of the Python specific fields

[204] Fix | Delete

in this storage with PyObject_{Init, InitVar}.

[205] Fix | Delete

[206] Fix | Delete

PyObject *

[207] Fix | Delete

YourObject_New(...)

[208] Fix | Delete

{

[209] Fix | Delete

PyObject *op;

[210] Fix | Delete

[211] Fix | Delete

op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));

[212] Fix | Delete

if (op == NULL)

[213] Fix | Delete

return PyErr_NoMemory();

[214] Fix | Delete

[215] Fix | Delete

PyObject_Init(op, &YourTypeStruct);

[216] Fix | Delete

[217] Fix | Delete

op->ob_field = value;

[218] Fix | Delete

...

[219] Fix | Delete

return op;

[220] Fix | Delete

}

[221] Fix | Delete

[222] Fix | Delete

Note that in C++, the use of the new operator usually implies that

[223] Fix | Delete

the 1st step is performed automatically for you, so in a C++ class

[224] Fix | Delete

constructor you would start directly with PyObject_Init/InitVar

[225] Fix | Delete

*/

[226] Fix | Delete

[227] Fix | Delete

/*

[228] Fix | Delete

* Garbage Collection Support

[229] Fix | Delete

* ==========================

[230] Fix | Delete

*/

[231] Fix | Delete

[232] Fix | Delete

/* C equivalent of gc.collect(). */

[233] Fix | Delete

PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void);

[234] Fix | Delete

[235] Fix | Delete

/* Test if a type has a GC head */

[236] Fix | Delete

#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)

[237] Fix | Delete

[238] Fix | Delete

/* Test if an object has a GC head */

[239] Fix | Delete

#define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) && \

[240] Fix | Delete

(Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))

[241] Fix | Delete

[242] Fix | Delete

PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);

[243] Fix | Delete

#define PyObject_GC_Resize(type, op, n) \

[244] Fix | Delete

( (type *) _PyObject_GC_Resize((PyVarObject *)(op), (n)) )

[245] Fix | Delete

[246] Fix | Delete

/* for source compatibility with 2.2 */

[247] Fix | Delete

#define _PyObject_GC_Del PyObject_GC_Del

[248] Fix | Delete

[249] Fix | Delete

/*

[250] Fix | Delete

* Former over-aligned definition of PyGC_Head, used to compute the size of the

[251] Fix | Delete

* padding for the new version below.

[252] Fix | Delete

*/

[253] Fix | Delete

union _gc_head;

[254] Fix | Delete

union _gc_head_old {

[255] Fix | Delete

struct {

[256] Fix | Delete

union _gc_head_old *gc_next;

[257] Fix | Delete

union _gc_head_old *gc_prev;

[258] Fix | Delete

Py_ssize_t gc_refs;

[259] Fix | Delete

} gc;

[260] Fix | Delete

long double dummy;

[261] Fix | Delete

};

[262] Fix | Delete

[263] Fix | Delete

/* GC information is stored BEFORE the object structure. */

[264] Fix | Delete

typedef union _gc_head {

[265] Fix | Delete

struct {

[266] Fix | Delete

union _gc_head *gc_next;

[267] Fix | Delete

union _gc_head *gc_prev;

[268] Fix | Delete

Py_ssize_t gc_refs;

[269] Fix | Delete

} gc;

[270] Fix | Delete

double dummy; /* Force at least 8-byte alignment. */

[271] Fix | Delete

char dummy_padding[sizeof(union _gc_head_old)];

[272] Fix | Delete

} PyGC_Head;

[273] Fix | Delete

[274] Fix | Delete

extern PyGC_Head *_PyGC_generation0;

[275] Fix | Delete

[276] Fix | Delete

#define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)

[277] Fix | Delete

[278] Fix | Delete

#define _PyGC_REFS_UNTRACKED (-2)

[279] Fix | Delete

#define _PyGC_REFS_REACHABLE (-3)

[280] Fix | Delete

#define _PyGC_REFS_TENTATIVELY_UNREACHABLE (-4)

[281] Fix | Delete

[282] Fix | Delete

/* Tell the GC to track this object. NB: While the object is tracked the

[283] Fix | Delete

* collector it must be safe to call the ob_traverse method. */

[284] Fix | Delete

#define _PyObject_GC_TRACK(o) do { \

[285] Fix | Delete

PyGC_Head *g = _Py_AS_GC(o); \

[286] Fix | Delete

if (g->gc.gc_refs != _PyGC_REFS_UNTRACKED) \

[287] Fix | Delete

Py_FatalError("GC object already tracked"); \

[288] Fix | Delete

g->gc.gc_refs = _PyGC_REFS_REACHABLE; \

[289] Fix | Delete

g->gc.gc_next = _PyGC_generation0; \

[290] Fix | Delete

g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \

[291] Fix | Delete

g->gc.gc_prev->gc.gc_next = g; \

[292] Fix | Delete

_PyGC_generation0->gc.gc_prev = g; \

[293] Fix | Delete

} while (0);

[294] Fix | Delete

[295] Fix | Delete

/* Tell the GC to stop tracking this object.

[296] Fix | Delete

* gc_next doesn't need to be set to NULL, but doing so is a good

[297] Fix | Delete

* way to provoke memory errors if calling code is confused.

[298] Fix | Delete

*/

[299] Fix | Delete

#define _PyObject_GC_UNTRACK(o) do { \

[300] Fix | Delete

PyGC_Head *g = _Py_AS_GC(o); \

[301] Fix | Delete

assert(g->gc.gc_refs != _PyGC_REFS_UNTRACKED); \

[302] Fix | Delete

g->gc.gc_refs = _PyGC_REFS_UNTRACKED; \

[303] Fix | Delete

g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \

[304] Fix | Delete

g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \

[305] Fix | Delete

g->gc.gc_next = NULL; \

[306] Fix | Delete

} while (0);

[307] Fix | Delete

[308] Fix | Delete

/* True if the object is currently tracked by the GC. */

[309] Fix | Delete

#define _PyObject_GC_IS_TRACKED(o) \

[310] Fix | Delete

((_Py_AS_GC(o))->gc.gc_refs != _PyGC_REFS_UNTRACKED)

[311] Fix | Delete

[312] Fix | Delete

/* True if the object may be tracked by the GC in the future, or already is.

[313] Fix | Delete

This can be useful to implement some optimizations. */

[314] Fix | Delete

#define _PyObject_GC_MAY_BE_TRACKED(obj) \

[315] Fix | Delete

(PyObject_IS_GC(obj) && \

[316] Fix | Delete

(!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj)))

[317] Fix | Delete

[318] Fix | Delete

[319] Fix | Delete

PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t);

[320] Fix | Delete

PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *);

[321] Fix | Delete

PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);

[322] Fix | Delete

PyAPI_FUNC(void) PyObject_GC_Track(void *);

[323] Fix | Delete

PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);

[324] Fix | Delete

PyAPI_FUNC(void) PyObject_GC_Del(void *);

[325] Fix | Delete

[326] Fix | Delete

#define PyObject_GC_New(type, typeobj) \

[327] Fix | Delete

( (type *) _PyObject_GC_New(typeobj) )

[328] Fix | Delete

#define PyObject_GC_NewVar(type, typeobj, n) \

[329] Fix | Delete

( (type *) _PyObject_GC_NewVar((typeobj), (n)) )

[330] Fix | Delete

[331] Fix | Delete

[332] Fix | Delete

/* Utility macro to help write tp_traverse functions.

[333] Fix | Delete

* To use this macro, the tp_traverse function must name its arguments

[334] Fix | Delete

* "visit" and "arg". This is intended to keep tp_traverse functions

[335] Fix | Delete

* looking as much alike as possible.

[336] Fix | Delete

*/

[337] Fix | Delete

#define Py_VISIT(op) \

[338] Fix | Delete

do { \

[339] Fix | Delete

if (op) { \

[340] Fix | Delete

int vret = visit((PyObject *)(op), arg); \

[341] Fix | Delete

if (vret) \

[342] Fix | Delete

return vret; \

[343] Fix | Delete

} \

[344] Fix | Delete

} while (0)

[345] Fix | Delete

[346] Fix | Delete

/* This is here for the sake of backwards compatibility. Extensions that

[347] Fix | Delete

* use the old GC API will still compile but the objects will not be

[348] Fix | Delete

* tracked by the GC. */

[349] Fix | Delete

#define PyGC_HEAD_SIZE 0

[350] Fix | Delete

#define PyObject_GC_Init(op)

[351] Fix | Delete

#define PyObject_GC_Fini(op)

[352] Fix | Delete

#define PyObject_AS_GC(op) (op)

[353] Fix | Delete

#define PyObject_FROM_GC(op) (op)

[354] Fix | Delete

[355] Fix | Delete

[356] Fix | Delete

/* Test if a type supports weak references */

[357] Fix | Delete

#define PyType_SUPPORTS_WEAKREFS(t) \

[358] Fix | Delete

(PyType_HasFeature((t), Py_TPFLAGS_HAVE_WEAKREFS) \

[359] Fix | Delete

&& ((t)->tp_weaklistoffset > 0))

[360] Fix | Delete

[361] Fix | Delete

#define PyObject_GET_WEAKREFS_LISTPTR(o) \

[362] Fix | Delete

((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset))

[363] Fix | Delete

[364] Fix | Delete

#ifdef __cplusplus

[365] Fix | Delete

}

[366] Fix | Delete

#endif

[367] Fix | Delete

#endif /* !Py_OBJIMPL_H */

[368] Fix | Delete

[369] Fix | Delete