deimos.python.object

Mirror object.h

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.

Members

Aliases

PyObject_Bytes
alias PyObject_Bytes = PyObject_Str

Availability: 2.*

allocfunc
alias allocfunc = PyObject* function(PyTypeObject*, Py_ssize_t)

_

binaryfunc
alias binaryfunc = PyObject* function(PyObject*, PyObject*)

_

charbufferproc
alias charbufferproc = Py_ssize_t function(PyObject*, Py_ssize_t, char**)

ssize_t-based buffer interface Availability: 2.*

cmpfunc
alias cmpfunc = int function(PyObject*, PyObject*)

Availability: 2.*

coercion
alias coercion = int function(PyObject**, PyObject**)

Availability: 2.*

descrgetfunc
alias descrgetfunc = PyObject* function(PyObject*, PyObject*, PyObject*)

_

descrsetfunc
alias descrsetfunc = int function(PyObject*, PyObject*, PyObject*)

_

destructor
alias destructor = void function(PyObject*)

_

freefunc
alias freefunc = void function(void*)

_

getattrfunc
alias getattrfunc = PyObject* function(PyObject*, char*)

_

getattrofunc
alias getattrofunc = PyObject* function(PyObject*, PyObject*)

_

getbufferproc
alias getbufferproc = int function(PyObject*, Py_buffer*, int)

Availability: >= 2.6

getcharbufferproc
alias getcharbufferproc = charbufferproc

int-based buffer interface Availability: 2.4

getiterfunc
alias getiterfunc = PyObject* function(PyObject*)

_

getreadbufferproc
alias getreadbufferproc = readbufferproc
getsegcountproc
alias getsegcountproc = segcountproc
getwritebufferproc
alias getwritebufferproc = writebufferproc

int-based buffer interface Availability: 2.4

hashfunc
alias hashfunc = Py_hash_t function(PyObject*)

_

initproc
alias initproc = int function(PyObject*, PyObject*, PyObject*)

_

inquiry
alias inquiry = lenfunc

_

intargfunc
alias intargfunc = ssizeargfunc

Availability: 2.4

intintargfunc
alias intintargfunc = ssizessizeargfunc

Availability: 2.4

intintobjargproc
alias intintobjargproc = ssizessizeobjargproc

Availability: 2.4

intobjargproc
alias intobjargproc = ssizeobjargproc

Availability: 2.4

iternextfunc
alias iternextfunc = PyObject* function(PyObject*)

_

lenfunc
alias lenfunc = Py_ssize_t function(PyObject*)

_

newfunc
alias newfunc = PyObject* function(PyTypeObject*, PyObject*, PyObject*)

_

objobjargproc
alias objobjargproc = int function(PyObject*, PyObject*, PyObject*)

_

objobjproc
alias objobjproc = int function(PyObject*, PyObject*)

_

printfunc
alias printfunc = int function(PyObject*, FILE*, int)

_

readbufferproc
alias readbufferproc = Py_ssize_t function(PyObject*, Py_ssize_t, void**)

ssize_t-based buffer interface Availability: 2.*

releasebufferproc
alias releasebufferproc = void function(PyObject*, Py_buffer*)

Availability: >= 2.6

reprfunc
alias reprfunc = PyObject* function(PyObject*)

_

richcmpfunc
alias richcmpfunc = PyObject* function(PyObject*, PyObject*, int)

_

segcountproc
alias segcountproc = Py_ssize_t function(PyObject*, Py_ssize_t*)

ssize_t-based buffer interface Availability: 2.*

setattrfunc
alias setattrfunc = int function(PyObject*, char*, PyObject*)

_

setattrofunc
alias setattrofunc = int function(PyObject*, PyObject*, PyObject*)

_

ssizeargfunc
alias ssizeargfunc = PyObject* function(PyObject*, Py_ssize_t)

_

ssizeobjargproc
alias ssizeobjargproc = int function(PyObject*, Py_ssize_t, PyObject*)

_

ssizessizeargfunc
alias ssizessizeargfunc = PyObject* function(PyObject*, Py_ssize_t, Py_ssize_t)

_

ssizessizeobjargproc
alias ssizessizeobjargproc = int function(PyObject*, Py_ssize_t, Py_ssize_t, PyObject*)

_

ternaryfunc
alias ternaryfunc = PyObject* function(PyObject*, PyObject*, PyObject*)

_

traverseproc
alias traverseproc = int function(PyObject*, visitproc, void*)

_

unaryfunc
alias unaryfunc = PyObject* function(PyObject*)

_

visitproc
alias visitproc = int function(PyObject*, void*)

_

writebufferproc
alias writebufferproc = Py_ssize_t function(PyObject*, Py_ssize_t, void**)

ssize_t-based buffer interface Availability: 2.*

Functions

PyCallable_Check
int PyCallable_Check(PyObject*)

_

PyNumber_Coerce
int PyNumber_Coerce(PyObject**, PyObject**)

Availability: 2.*

PyNumber_CoerceEx
int PyNumber_CoerceEx(PyObject**, PyObject**)

Availability: 2.*

PyObject_ASCII
PyObject* PyObject_ASCII(PyObject*)

Availability: 3.*

PyObject_Bytes
PyObject* PyObject_Bytes(PyObject*)

Availability: 3.*

PyObject_ClearWeakRefs
void PyObject_ClearWeakRefs(PyObject*)

_

PyObject_Compare
int PyObject_Compare(PyObject*, PyObject*)

Availability: 2.*

PyObject_Dir
PyObject* PyObject_Dir(PyObject*)

PyObject_Dir(obj) acts like Python __builtin__.dir(obj), returning a list of strings. PyObject_Dir(NULL) is like __builtin__.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.

PyObject_GenericGetAttr
PyObject* PyObject_GenericGetAttr(PyObject*, PyObject*)

_

PyObject_GenericSetAttr
int PyObject_GenericSetAttr(PyObject*, PyObject*, PyObject*)

_

PyObject_GetAttr
PyObject* PyObject_GetAttr(PyObject*, PyObject*)

_

PyObject_GetAttrString
PyObject* PyObject_GetAttrString(PyObject*, const(char)*)

_

PyObject_HasAttr
int PyObject_HasAttr(PyObject*, PyObject*)

_

PyObject_HasAttrString
int PyObject_HasAttrString(PyObject*, const(char)*)

_

PyObject_Hash
Py_hash_t PyObject_Hash(PyObject*)

_

PyObject_HashNotImplemented
Py_hash_t PyObject_HashNotImplemented(PyObject*)

Availability: >= 2.6

PyObject_IsTrue
int PyObject_IsTrue(PyObject*)

_

PyObject_Not
int PyObject_Not(PyObject*)

_

PyObject_Print
int PyObject_Print(PyObject*, FILE*, int)

_

PyObject_REPR
auto PyObject_REPR(PyObject* obj)

_

PyObject_Repr
PyObject* PyObject_Repr(PyObject*)

_

PyObject_RichCompare
PyObject* PyObject_RichCompare(PyObject*, PyObject*, int)

_

PyObject_RichCompareBool
int PyObject_RichCompareBool(PyObject*, PyObject*, int)

_

PyObject_SelfIter
PyObject* PyObject_SelfIter(PyObject*)

_

PyObject_SetAttr
int PyObject_SetAttr(PyObject*, PyObject*, PyObject*)

_

PyObject_SetAttrString
int PyObject_SetAttrString(PyObject*, const(char)*, PyObject*)

_

PyObject_Str
PyObject* PyObject_Str(PyObject*)

_

PyObject_TypeCheck
int PyObject_TypeCheck(PyObject* ob, PyTypeObject* tp)

_

PyObject_Unicode
PyObject* PyObject_Unicode(PyObject*)

Availability: 2.*

PyType_Check
int PyType_Check(PyObject* op)

_

PyType_CheckExact
int PyType_CheckExact(PyObject* op)

_

PyType_ClearCache
uint PyType_ClearCache()

Availability: >= 2.6

PyType_FromSpec
PyObject* PyType_FromSpec(PyType_Spec*)

Availability: 3.*

PyType_GenericAlloc
PyObject* PyType_GenericAlloc(PyTypeObject*, Py_ssize_t)

_

PyType_GenericNew
PyObject* PyType_GenericNew(PyTypeObject*, PyObject*, PyObject*)

_

PyType_GetFlags
C_long PyType_GetFlags(PyTypeObject*)

Availability: >= 3.2

PyType_HasFeature
int PyType_HasFeature(PyTypeObject* t, int f)

_

PyType_IsSubtype
int PyType_IsSubtype(PyTypeObject*, PyTypeObject*)

Generic type check

PyType_Modified
void PyType_Modified(PyTypeObject*)

Availability: >= 2.6

PyType_Ready
int PyType_Ready(PyTypeObject*)

_

Py_DECREF
void Py_DECREF(PyObject* op)

Used to decrement reference counts. 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(). Can be used wherever a void expression is allowed. The argument must not be a NULL pointer. If it may be NULL, use Py_XDECREF instead.

Py_DecRef
void Py_DecRef(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.

Py_INCREF
auto Py_INCREF(T op)

Increment reference counts. 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 instead.

Py_IncRef
void Py_IncRef(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.

Py_REFCNT
auto Py_REFCNT(T* ob)

_

Py_ReprEnter
int Py_ReprEnter(PyObject*)
Py_ReprLeave
void Py_ReprLeave(PyObject*)

Helpers for printing recursive container types

Py_SET_REFCNT
void Py_SET_REFCNT(T* ob, int refcnt)
Py_SET_SIZE
void Py_SET_SIZE(T* ob, Py_ssize_t size)
Py_SET_TYPE
void Py_SET_TYPE(T* ob, PyTypeObject* tipo)

Not part of the python api, but annoying to do without.

Py_SIZE
auto Py_SIZE(T* ob)

_

Py_TYPE
auto Py_TYPE(T* ob)

_

Py_XDECREF
void Py_XDECREF(PyObject* op)

Same as Py_DECREF, except is a no-op if op is null.

Py_XINCREF
auto Py_XINCREF(T op)

Increment reference counts. Can be used wherever a void expression is allowed. The argument may be a NULL pointer.

_PyObject_LookupSpecial
PyObject* _PyObject_LookupSpecial(PyObject*, char*, PyObject**)

Availability: >= 2.7

_PyObject_Str
PyObject* _PyObject_Str(PyObject*)

Availability: 2.5, 2.6, 2.7

_PyType_CalculateMetaclass
PyTypeObject* _PyType_CalculateMetaclass(PyTypeObject*, PyObject*)

Availability: 3.*

_PyType_Lookup
PyObject* _PyType_Lookup(PyTypeObject*, PyObject*)

_

_Py_BreakPoint
void _Py_BreakPoint()

Availability: 3.*

_Py_Dealloc
void _Py_Dealloc(PyObject*)

Availability: 3.*

_Py_HashDouble
Py_hash_t _Py_HashDouble(double)

_

_Py_HashPointer
Py_hash_t _Py_HashPointer(void*)

_

_Py_NewReference
void _Py_NewReference(PyObject* op)

Initializes reference counts to 1, and in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional bookkeeping appropriate to the special build.

borrowed
Borrowed!T* borrowed(T* obj)

Convert a python reference to borrowed reference. (Not part of Python api)

Manifest constants

PyBUF_ANY_CONTIGUOUS
enum PyBUF_ANY_CONTIGUOUS;
PyBUF_CONTIG
enum PyBUF_CONTIG;
PyBUF_CONTIG_RO
enum PyBUF_CONTIG_RO;
PyBUF_C_CONTIGUOUS
enum PyBUF_C_CONTIGUOUS;
PyBUF_FORMAT
enum PyBUF_FORMAT;
PyBUF_FULL
enum PyBUF_FULL;
PyBUF_FULL_RO
enum PyBUF_FULL_RO;
PyBUF_F_CONTIGUOUS
enum PyBUF_F_CONTIGUOUS;
PyBUF_INDIRECT
enum PyBUF_INDIRECT;
PyBUF_ND
enum PyBUF_ND;
PyBUF_READ
enum PyBUF_READ;
PyBUF_RECORDS
enum PyBUF_RECORDS;
PyBUF_RECORDS_RO
enum PyBUF_RECORDS_RO;
PyBUF_SHADOW
enum PyBUF_SHADOW;

Flags for getting buffers */ /// Availability: >= 2.

PyBUF_SIMPLE
enum PyBUF_SIMPLE;
PyBUF_STRIDED
enum PyBUF_STRIDED;
PyBUF_STRIDED_RO
enum PyBUF_STRIDED_RO;
PyBUF_STRIDES
enum PyBUF_STRIDES;
PyBUF_WRITABLE
enum PyBUF_WRITABLE;
PyBUF_WRITE
enum PyBUF_WRITE;
PyBUF_WRITEABLE
enum PyBUF_WRITEABLE;

Flags for getting buffers */ /// Availability: >= 2.

Py_EQ
enum Py_EQ;
Py_GE
enum Py_GE;
Py_GT
enum Py_GT;
Py_LE
enum Py_LE;

Rich comparison opcodes

Py_LT
enum Py_LT;
Py_NE
enum Py_NE;

Rich comparison opcodes

Py_TPFLAGS_BASE_EXC_SUBCLASS
enum Py_TPFLAGS_BASE_EXC_SUBCLASS;
Py_TPFLAGS_BYTES_SUBCLASS
enum Py_TPFLAGS_BYTES_SUBCLASS;

These flags are used to determine if a type is a subclass. */ /// Availability: >= 2.

Py_TPFLAGS_DEFAULT
enum Py_TPFLAGS_DEFAULT;

_

Py_TPFLAGS_DEFAULT
enum Py_TPFLAGS_DEFAULT;

_

Py_TPFLAGS_DICT_SUBCLASS
enum Py_TPFLAGS_DICT_SUBCLASS;

These flags are used to determine if a type is a subclass. */ /// Availability: >= 2.

Py_TPFLAGS_HAVE_INDEX
enum Py_TPFLAGS_HAVE_INDEX;

Objects support nb_index in PyNumberMethods */ /// Availability: 2.

Py_TPFLAGS_HAVE_NEWBUFFER
enum Py_TPFLAGS_HAVE_NEWBUFFER;

Has the new buffer protocol */ /// Availability: 2.6,2.

Py_TPFLAGS_HAVE_VERSION_TAG
enum Py_TPFLAGS_HAVE_VERSION_TAG;

Objects support type attribute cache */ /// Availability: >= 2.

Py_TPFLAGS_INT_SUBCLASS
enum Py_TPFLAGS_INT_SUBCLASS;

These flags are used to determine if a type is a subclass. */ /// Availability: >= 2.

Py_TPFLAGS_IS_ABSTRACT
enum Py_TPFLAGS_IS_ABSTRACT;

Type is abstract and cannot be instantiated */ /// Availability: >= 2.

Py_TPFLAGS_LIST_SUBCLASS
enum Py_TPFLAGS_LIST_SUBCLASS;
Py_TPFLAGS_LONG_SUBCLASS
enum Py_TPFLAGS_LONG_SUBCLASS;
Py_TPFLAGS_TUPLE_SUBCLASS
enum Py_TPFLAGS_TUPLE_SUBCLASS;
Py_TPFLAGS_TYPE_SUBCLASS
enum Py_TPFLAGS_TYPE_SUBCLASS;
Py_TPFLAGS_UNICODE_SUBCLASS
enum Py_TPFLAGS_UNICODE_SUBCLASS;

These flags are used to determine if a type is a subclass. */ /// Availability: >= 2.

Py_TPFLAGS_VALID_VERSION_TAG
enum Py_TPFLAGS_VALID_VERSION_TAG;

Objects support type attribute cache */ /// Availability: >= 2.

Mixin templates

PyObject_HEAD
mixin template PyObject_HEAD()

_

PyObject_HEAD
mixin template PyObject_HEAD()

_

PyObject_VAR_HEAD
mixin template PyObject_VAR_HEAD()

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.

PyObject_VAR_HEAD
mixin template PyObject_VAR_HEAD()

_

Structs

Borrowed
struct Borrowed(T)

Denotes a borrowed reference. (Not part of Python api)

PyAsyncMethods
struct PyAsyncMethods

_

PyBufferProcs
struct PyBufferProcs

_

PyHeapTypeObject
struct PyHeapTypeObject

The *real* layout of a type object when allocated on the heap

PyMappingMethods
struct PyMappingMethods

_

PyNumberMethods
struct PyNumberMethods

For numbers without flag bit Py_TPFLAGS_CHECKTYPES set, all arguments are guaranteed to be of the object's type (modulo coercion hacks -- i.e. if the type's coercion function returns other types, then these are allowed as well). Numbers that have the Py_TPFLAGS_CHECKTYPES flag bit set should check *both* arguments for proper type and implement the necessary conversions in the slot functions themselves.

PyObject
struct PyObject

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

PySequenceMethods
struct PySequenceMethods

_

PyTypeObject
struct PyTypeObject

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

PyType_Slot
struct PyType_Slot

Availability: 3.*

PyType_Spec
struct PyType_Spec

Availability: 3.*

PyVarObject
struct PyVarObject

_

Py_buffer
struct Py_buffer

Py3k buffer interface */ /// Availability: >= 2.

_Py_HashSecret_t
struct _Py_HashSecret_t

Availability: 2.7, >= 3.1

Templates

_PyObject_HEAD_EXTRA
template _PyObject_HEAD_EXTRA()

_

Variables

Py_PRINT_RAW
enum int Py_PRINT_RAW;

_

Py_TPFLAGS_BASETYPE
enum int Py_TPFLAGS_BASETYPE;

Set if the type allows subclassing

Py_TPFLAGS_CHECKTYPES
enum int Py_TPFLAGS_CHECKTYPES;

PyNumberMethods do their own coercion */ /// Availability: 2.

Py_TPFLAGS_DEFAULT
enum int Py_TPFLAGS_DEFAULT;

_

Py_TPFLAGS_GC
enum int Py_TPFLAGS_GC;

This is here for backwards compatibility. Extensions that use the old GC API will still compile but the objects will not be tracked by the GC. */ /// Availability: 2.

Py_TPFLAGS_HAVE_CLASS
enum int Py_TPFLAGS_HAVE_CLASS;

New members introduced by Python 2.2 exist */ /// Availability: 2.

Py_TPFLAGS_HAVE_GC
enum int Py_TPFLAGS_HAVE_GC;

Objects support garbage collection (see objimp.h)

Py_TPFLAGS_HAVE_GETCHARBUFFER
enum int Py_TPFLAGS_HAVE_GETCHARBUFFER;

PyBufferProcs contains bf_getcharbuffer */ /// Availability: 2.

Py_TPFLAGS_HAVE_INPLACEOPS
enum int Py_TPFLAGS_HAVE_INPLACEOPS;

PySequenceMethods and PyNumberMethods contain in-place operators */ /// Availability: 2.

Py_TPFLAGS_HAVE_ITER
enum int Py_TPFLAGS_HAVE_ITER;

tp_iter is defined */ /// Availability: 2.

Py_TPFLAGS_HAVE_RICHCOMPARE
enum int Py_TPFLAGS_HAVE_RICHCOMPARE;

tp_richcompare is defined */ /// Availability: 2.

Py_TPFLAGS_HAVE_SEQUENCE_IN
enum int Py_TPFLAGS_HAVE_SEQUENCE_IN;

PySequenceMethods contains sq_contains */ /// Availability: 2.

Py_TPFLAGS_HAVE_STACKLESS_EXTENSION
enum int Py_TPFLAGS_HAVE_STACKLESS_EXTENSION;

_

Py_TPFLAGS_HAVE_WEAKREFS
enum int Py_TPFLAGS_HAVE_WEAKREFS;

Objects which are weakly referencable if their tp_weaklistoffset is >0 */ /// Availability: 2.

Py_TPFLAGS_HEAPTYPE
enum int Py_TPFLAGS_HEAPTYPE;

Set if the type object is dynamically allocated

Py_TPFLAGS_READY
enum int Py_TPFLAGS_READY;

Set if the type is 'ready' -- fully initialized

Py_TPFLAGS_READYING
enum int Py_TPFLAGS_READYING;

Set while the type is being 'readied', to prevent recursive ready calls

Meta