#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

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

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.

*/

#include "pystats.h"

/* Py_DEBUG implies Py_REF_DEBUG. */

#if defined(Py_DEBUG) && !defined(Py_REF_DEBUG)

#if defined(Py_LIMITED_API) && defined(Py_TRACE_REFS)

# error Py_LIMITED_API is incompatible with Py_TRACE_REFS

#endif

PyObject *_ob_next; \

PyObject *_ob_prev;

#else

# define _PyObject_HEAD_EXTRA

# define _PyObject_EXTRA_INIT

#endif

/* PyObject_HEAD defines the initial segment of every PyObject. */

/*

Immortalization:

The following indicates the immortalization strategy depending on the amount

of available bits in the reference count field. All strategies are backwards

compatible but the specific reference count value or immortalization check

might change depending on the specializations for the underlying system.

Proper deallocation of immortal instances requires distinguishing between

statically allocated immortal instances vs those promoted by the runtime to be

immortal. The latter should be the only instances that require

cleanup during runtime finalization.

*/

#if SIZEOF_VOID_P > 4

/*

In 64+ bit systems, an object will be marked as immortal by setting all of the

lower 32 bits of the reference count field, which is equal to: 0xFFFFFFFF

Using the lower 32 bits makes the value backwards compatible by allowing

C-Extensions without the updated checks in Py_INCREF and Py_DECREF to safely

increase and decrease the objects reference count. The object would lose its

immortality, but the execution would still be correct.

Reference count increases will use saturated arithmetic, taking advantage of

having all the lower 32 bits set, which will avoid the reference count to go

beyond the refcount limit. Immortality checks for reference count decreases will

be done by checking the bit sign flag in the lower 32 bits.

*/

#define _Py_IMMORTAL_REFCNT UINT_MAX

#else

/*

In 32 bit systems, an object will be marked as immortal by setting all of the

lower 30 bits of the reference count field, which is equal to: 0x3FFFFFFF

Using the lower 30 bits makes the value backwards compatible by allowing

C-Extensions without the updated checks in Py_INCREF and Py_DECREF to safely

increase and decrease the objects reference count. The object would lose its

immortality, but the execution would still be correct.

Reference count increases and decreases will first go through an immortality

check by comparing the reference count field to the immortality reference count.

*/

#define _Py_IMMORTAL_REFCNT (UINT_MAX >> 2)

#endif

// Make all internal uses of PyObject_HEAD_INIT immortal while preserving the

// C-API expectation that the refcnt will be set to 1.

#ifdef Py_BUILD_CORE

#define PyObject_HEAD_INIT(type) \

{ \

_PyObject_EXTRA_INIT \

{ _Py_IMMORTAL_REFCNT }, \

(type) \

},

#else

#define PyObject_HEAD_INIT(type) \

{ \

_PyObject_EXTRA_INIT \

{ 1 }, \

(type) \

},

#endif /* Py_BUILD_CORE */

#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.

*/

/* 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*.

*/

union {

Py_ssize_t ob_refcnt;

#if SIZEOF_VOID_P > 4

PY_UINT32_T ob_refcnt_split[2];

#endif

};

PyObject ob_base;

Py_ssize_t ob_size; /* Number of items in variable part */

// 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))

return ob->ob_refcnt;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_REFCNT(ob) Py_REFCNT(_PyObject_CAST(ob))

#endif

return ob->ob_type;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_TYPE(ob) Py_TYPE(_PyObject_CAST(ob))

#endif

PyAPI_DATA(PyTypeObject) PyLong_Type;

PyAPI_DATA(PyTypeObject) PyBool_Type;

assert(ob->ob_type != &PyLong_Type);

assert(ob->ob_type != &PyBool_Type);

PyVarObject *var_ob = _PyVarObject_CAST(ob);

return var_ob->ob_size;

static inline Py_ALWAYS_INLINE int _Py_IsImmortal(PyObject *op)

{

#if SIZEOF_VOID_P > 4

return _Py_CAST(PY_INT32_T, op->ob_refcnt) < 0;

#else

return op->ob_refcnt == _Py_IMMORTAL_REFCNT;

#endif

}

#define _Py_IsImmortal(op) _Py_IsImmortal(_PyObject_CAST(op))

static inline int Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {

return Py_TYPE(ob) == type;

// This immortal check is for code that is unaware of immortal objects.

// The runtime tracks these objects and we should avoid as much

// as possible having extensions inadvertently change the refcnt

// of an immortalized object.

if (_Py_IsImmortal(ob)) {

return;

}

ob->ob_refcnt = refcnt;

}

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

assert(ob->ob_base.ob_type != &PyLong_Type);

assert(ob->ob_base.ob_type != &PyBool_Type);

/*

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

checking for a nil pointer; it should always be implemented except if

the implementation can guarantee that the reference count will never

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 (*objobjproc)(PyObject *, PyObject *);

typedef int (*visitproc)(PyObject *, void *);

typedef int (*traverseproc)(PyObject *, visitproc, void *);

typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);

typedef PyObject *(*reprfunc)(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);

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030c0000 // 3.12

typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args,

size_t nargsf, PyObject *kwnames);

#endif

typedef struct{

int slot; /* slot id, see below */

void *pfunc; /* function pointer */

} PyType_Slot;

typedef struct{

const char* name;

int basicsize;

int itemsize;

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 >= 0x03090000

PyAPI_FUNC(PyObject*) PyType_FromModuleAndSpec(PyObject *, PyType_Spec *, PyObject *);

PyAPI_FUNC(PyObject *) PyType_GetModule(PyTypeObject *);

PyAPI_FUNC(void *) PyType_GetModuleState(PyTypeObject *);

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030B0000

PyAPI_FUNC(PyObject *) PyType_GetName(PyTypeObject *);

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030C0000

PyAPI_FUNC(PyObject *) PyType_FromMetaclass(PyTypeObject*, PyObject*, PyType_Spec*, PyObject*);

PyAPI_FUNC(void *) PyObject_GetTypeData(PyObject *obj, PyTypeObject *cls);

PyAPI_FUNC(Py_ssize_t) PyType_GetTypeDataSize(PyTypeObject *cls);

return Py_IS_TYPE(ob, type) || PyType_IsSubtype(Py_TYPE(ob), type);

}

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(int) PyType_Ready(PyTypeObject *);

PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);

PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,

PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_Str(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(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.

*/

/* Pickle support. */

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *) _PyObject_GetState(PyObject *);

#endif

PyAPI_FUNC(int) Py_ReprEnter(PyObject *);

PyAPI_FUNC(void) Py_ReprLeave(PyObject *);

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

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.

*/