PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *);

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

#define PyObject_New(type, typeobj) \

( (type *) _PyObject_New(typeobj) )

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

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

// Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly

// PyObject_MALLOC() with _PyObject_VAR_SIZE().

#define PyObject_NEW_VAR(type, typeobj, n) PyObject_NewVar(type, typeobj, n)

#ifdef Py_LIMITED_API

#endif

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

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

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

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

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

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

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

return (at worst) pointer-aligned memory anyway.

*/

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

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

#endif

#define _PyObject_VAR_SIZE(typeobj, nitems) \

_Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + \

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

SIZEOF_VOID_P)

#define PyObject_NEW(type, typeobj) \

( (type *) PyObject_Init( \

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

#define PyObject_NEW_VAR(type, typeobj, n) \

( (type *) PyObject_InitVar( \

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

(typeobj), (n)) )

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

allocator, where PyObject_New is inlined, and shows the important

distinction between two steps (at least):

1) the actual allocation of the object storage;

2) the initialization of the Python specific fields

in this storage with PyObject_{Init, InitVar}.

PyObject *

YourObject_New(...)

{

PyObject *op;

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

if (op == NULL)

return PyErr_NoMemory();

PyObject_Init(op, &YourTypeStruct);

op->ob_field = value;

...

return op;

}

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

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

constructor you would start directly with PyObject_Init/InitVar

*/

/*

* Garbage Collection Support

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