typeobject.c

/* Type object implementation */

#include"Python.h"
#include"structmember.h"

#include<ctype.h>


/* Support type attribute cache */

/* The cache can keep references to the names alive for longer than
 they normally would. This is why the maximum size is limited to
 MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large
 strings are used as attribute names. */
#defineMCACHE_MAX_ATTR_SIZE 100
#defineMCACHE_SIZE_EXP 12
#defineMCACHE_HASH(version, name_hash) \
 (((unsigned int)(version) ^ (unsigned int)(name_hash)) \
 & ((1 << MCACHE_SIZE_EXP) - 1))

#defineMCACHE_HASH_METHOD(type, name) \
 MCACHE_HASH((type)->tp_version_tag, \
 ((PyStringObject *)(name))->ob_shash)
#defineMCACHE_CACHEABLE_NAME(name) \
 PyString_CheckExact(name) && \
 PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE

structmethod_cache_entry {
unsigned intversion;
PyObject*name; /* reference to exactly a str or None */
PyObject*value; /* borrowed */
};

staticstructmethod_cache_entrymethod_cache[1 << MCACHE_SIZE_EXP];
staticunsigned intnext_version_tag=0;

#defineMCACHE_STATS 0

#ifMCACHE_STATS
staticsize_tmethod_cache_hits=0;
staticsize_tmethod_cache_misses=0;
staticsize_tmethod_cache_collisions=0;
#endif

unsigned int
PyType_ClearCache(void)
{
Py_ssize_ti;
unsigned intcur_version_tag=next_version_tag-1;

#ifMCACHE_STATS
size_ttotal=method_cache_hits+method_cache_collisions+method_cache_misses;
fprintf(stderr, "-- Method cache hits = %zd (%d%%)\n",
method_cache_hits, (int) (100.0*method_cache_hits / total));
fprintf(stderr, "-- Method cache true misses = %zd (%d%%)\n",
method_cache_misses, (int) (100.0*method_cache_misses / total));
fprintf(stderr, "-- Method cache collisions = %zd (%d%%)\n",
method_cache_collisions, (int) (100.0*method_cache_collisions / total));
fprintf(stderr, "-- Method cache size = %zd KB\n",
sizeof(method_cache) / 1024);
#endif

for (i=0; i< (1 << MCACHE_SIZE_EXP); i++) {
method_cache[i].version=0;
Py_CLEAR(method_cache[i].name);
method_cache[i].value=NULL;
 }
next_version_tag=0;
/* mark all version tags as invalid */
PyType_Modified(&PyBaseObject_Type);
returncur_version_tag;
}

void
PyType_Modified(PyTypeObject*type)
{
/* Invalidate any cached data for the specified type and all
 subclasses. This function is called after the base
 classes, mro, or attributes of the type are altered.

 Invariants:

 - Py_TPFLAGS_VALID_VERSION_TAG is never set if
 Py_TPFLAGS_HAVE_VERSION_TAG is not set (e.g. on type
 objects coming from non-recompiled extension modules)

 - before Py_TPFLAGS_VALID_VERSION_TAG can be set on a type,
 it must first be set on all super types.

 This function clears the Py_TPFLAGS_VALID_VERSION_TAG of a
 type (so it must first clear it on all subclasses). The
 tp_version_tag value is meaningless unless this flag is set.
 We don't assign new version tags eagerly, but only as
 needed.
 */
PyObject*raw, *ref;
Py_ssize_ti, n;

if (!PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))
return;

raw=type->tp_subclasses;
if (raw!=NULL) {
n=PyList_GET_SIZE(raw);
for (i=0; i<n; i++) {
ref=PyList_GET_ITEM(raw, i);
ref=PyWeakref_GET_OBJECT(ref);
if (ref!=Py_None) {
PyType_Modified((PyTypeObject*)ref);
 }
 }
 }
type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
}

staticvoid
type_mro_modified(PyTypeObject*type, PyObject*bases) {
/*
 Check that all base classes or elements of the mro of type are
 able to be cached. This function is called after the base
 classes or mro of the type are altered.

 Unset HAVE_VERSION_TAG and VALID_VERSION_TAG if the type
 inherits from an old-style class, either directly or if it
 appears in the MRO of a new-style class. No support either for
 custom MROs that include types that are not officially super
 types.

 Called from mro_internal, which will subsequently be called on
 each subclass when their mro is recursively updated.
 */
Py_ssize_ti, n;
intclear=0;

if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))
return;

n=PyTuple_GET_SIZE(bases);
for (i=0; i<n; i++) {
PyObject*b=PyTuple_GET_ITEM(bases, i);
PyTypeObject*cls;

if (!PyType_Check(b) ) {
clear=1;
break;
 }

cls= (PyTypeObject*)b;

if (!PyType_HasFeature(cls, Py_TPFLAGS_HAVE_VERSION_TAG) ||
 !PyType_IsSubtype(type, cls)) {
clear=1;
break;
 }
 }

if (clear)
type->tp_flags &= ~(Py_TPFLAGS_HAVE_VERSION_TAG|
Py_TPFLAGS_VALID_VERSION_TAG);
}

staticint
assign_version_tag(PyTypeObject*type)
{
/* Ensure that the tp_version_tag is valid and set
 Py_TPFLAGS_VALID_VERSION_TAG. To respect the invariant, this
 must first be done on all super classes. Return 0 if this
 cannot be done, 1 if Py_TPFLAGS_VALID_VERSION_TAG.
 */
Py_ssize_ti, n;
PyObject*bases;

if (PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))
return1;
if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))
return0;
if (!PyType_HasFeature(type, Py_TPFLAGS_READY))
return0;

type->tp_version_tag=next_version_tag++;
/* for stress-testing: next_version_tag &= 0xFF; */

if (type->tp_version_tag==0) {
/* wrap-around or just starting Python - clear the whole
 cache by filling names with references to Py_None.
 Values are also set to NULL for added protection, as they
 are borrowed reference */
for (i=0; i< (1 << MCACHE_SIZE_EXP); i++) {
method_cache[i].value=NULL;
Py_INCREF(Py_None);
Py_XSETREF(method_cache[i].name, Py_None);
 }
/* mark all version tags as invalid */
PyType_Modified(&PyBaseObject_Type);
return1;
 }
bases=type->tp_bases;
n=PyTuple_GET_SIZE(bases);
for (i=0; i<n; i++) {
PyObject*b=PyTuple_GET_ITEM(bases, i);
assert(PyType_Check(b));
if (!assign_version_tag((PyTypeObject*)b))
return0;
 }
type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;
return1;
}


staticPyMemberDeftype_members[] = {
 {"__basicsize__", T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),READONLY},
 {"__itemsize__", T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), READONLY},
 {"__flags__", T_ULONG, offsetof(PyTypeObject, tp_flags), READONLY},
 {"__weakrefoffset__", T_PYSSIZET,
 offsetof(PyTypeObject, tp_weaklistoffset), READONLY},
 {"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY},
 {"__dictoffset__", T_PYSSIZET,
 offsetof(PyTypeObject, tp_dictoffset), READONLY},
 {"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY},
 {0}
};

staticPyObject*
type_name(PyTypeObject*type, void*context)
{
constchar*s;

if (type->tp_flags&Py_TPFLAGS_HEAPTYPE) {
PyHeapTypeObject*et= (PyHeapTypeObject*)type;

Py_INCREF(et->ht_name);
returnet->ht_name;
 }
else {
s=strrchr(type->tp_name, '.');
if (s==NULL)
s=type->tp_name;
else
s++;
returnPyString_FromString(s);
 }
}

staticint
type_set_name(PyTypeObject*type, PyObject*value, void*context)
{
PyHeapTypeObject*et;
PyObject*tmp;

if (!(type->tp_flags&Py_TPFLAGS_HEAPTYPE)) {
PyErr_Format(PyExc_TypeError,
"can't set %s.__name__", type->tp_name);
return-1;
 }
if (!value) {
PyErr_Format(PyExc_TypeError,
"can't delete %s.__name__", type->tp_name);
return-1;
 }
if (!PyString_Check(value)) {
PyErr_Format(PyExc_TypeError,
"can only assign string to %s.__name__, not '%s'",
type->tp_name, Py_TYPE(value)->tp_name);
return-1;
 }
if (strlen(PyString_AS_STRING(value))
!= (size_t)PyString_GET_SIZE(value)) {
PyErr_SetString(PyExc_ValueError,
"type name must not contain null characters");
return-1;
 }

et= (PyHeapTypeObject*)type;

Py_INCREF(value);

/* Wait until et is a sane state before Py_DECREF'ing the old et->ht_name
 value. (Bug #16447.) */
tmp=et->ht_name;
et->ht_name=value;

type->tp_name=PyString_AS_STRING(value);
Py_DECREF(tmp);

return0;
}

staticPyObject*
type_module(PyTypeObject*type, void*context)
{
PyObject*mod;
char*s;

if (type->tp_flags&Py_TPFLAGS_HEAPTYPE) {
mod=PyDict_GetItemString(type->tp_dict, "__module__");
if (!mod) {
PyErr_Format(PyExc_AttributeError, "__module__");
return0;
 }
Py_XINCREF(mod);
returnmod;
 }
else {
s=strrchr(type->tp_name, '.');
if (s!=NULL)
returnPyString_FromStringAndSize(
type->tp_name, (Py_ssize_t)(s-type->tp_name));
returnPyString_FromString("__builtin__");
 }
}

staticint
type_set_module(PyTypeObject*type, PyObject*value, void*context)
{
if (!(type->tp_flags&Py_TPFLAGS_HEAPTYPE)) {
PyErr_Format(PyExc_TypeError,
"can't set %s.__module__", type->tp_name);
return-1;
 }
if (!value) {
PyErr_Format(PyExc_TypeError,
"can't delete %s.__module__", type->tp_name);
return-1;
 }

PyType_Modified(type);

returnPyDict_SetItemString(type->tp_dict, "__module__", value);
}

staticPyObject*
type_abstractmethods(PyTypeObject*type, void*context)
{
PyObject*mod=NULL;
/* type itself has an __abstractmethods__ descriptor (this). Don't return
 that. */
if (type!=&PyType_Type)
mod=PyDict_GetItemString(type->tp_dict, "__abstractmethods__");
if (!mod) {
PyErr_SetString(PyExc_AttributeError, "__abstractmethods__");
returnNULL;
 }
Py_XINCREF(mod);
returnmod;
}

staticint
type_set_abstractmethods(PyTypeObject*type, PyObject*value, void*context)
{
/* __abstractmethods__ should only be set once on a type, in
 abc.ABCMeta.__new__, so this function doesn't do anything
 special to update subclasses.
 */
intabstract, res;
if (value!=NULL) {
abstract=PyObject_IsTrue(value);
if (abstract<0)
return-1;
res=PyDict_SetItemString(type->tp_dict, "__abstractmethods__", value);
 }
else {
abstract=0;
res=PyDict_DelItemString(type->tp_dict, "__abstractmethods__");
if (res&&PyErr_ExceptionMatches(PyExc_KeyError)) {
PyErr_SetString(PyExc_AttributeError, "__abstractmethods__");
return-1;
 }
 }
if (res==0) {
PyType_Modified(type);
if (abstract)
type->tp_flags |= Py_TPFLAGS_IS_ABSTRACT;
else
type->tp_flags &= ~Py_TPFLAGS_IS_ABSTRACT;
 }
returnres;
}

staticPyObject*
type_get_bases(PyTypeObject*type, void*context)
{
Py_INCREF(type->tp_bases);
returntype->tp_bases;
}

staticPyTypeObject*best_base(PyObject*);
staticintmro_internal(PyTypeObject*);
staticintcompatible_for_assignment(PyTypeObject*, PyTypeObject*, char*);
staticintadd_subclass(PyTypeObject*, PyTypeObject*);
staticvoidremove_subclass(PyTypeObject*, PyTypeObject*);
staticvoidupdate_all_slots(PyTypeObject*);

typedefint (*update_callback)(PyTypeObject*, void*);
staticintupdate_subclasses(PyTypeObject*type, PyObject*name,
update_callbackcallback, void*data);
staticintrecurse_down_subclasses(PyTypeObject*type, PyObject*name,
update_callbackcallback, void*data);

staticint
mro_subclasses(PyTypeObject*type, PyObject*temp)
{
PyTypeObject*subclass;
PyObject*ref, *subclasses, *old_mro;
Py_ssize_ti, n;

subclasses=type->tp_subclasses;
if (subclasses==NULL)
return0;
assert(PyList_Check(subclasses));
n=PyList_GET_SIZE(subclasses);
for (i=0; i<n; i++) {
ref=PyList_GET_ITEM(subclasses, i);
assert(PyWeakref_CheckRef(ref));
subclass= (PyTypeObject*)PyWeakref_GET_OBJECT(ref);
assert(subclass!=NULL);
if ((PyObject*)subclass==Py_None)
continue;
assert(PyType_Check(subclass));
old_mro=subclass->tp_mro;
if (mro_internal(subclass) <0) {
subclass->tp_mro=old_mro;
return-1;
 }
else {
PyObject*tuple;
tuple=PyTuple_Pack(2, subclass, old_mro);
Py_DECREF(old_mro);
if (!tuple)
return-1;
if (PyList_Append(temp, tuple) <0)
return-1;
Py_DECREF(tuple);
 }
if (mro_subclasses(subclass, temp) <0)
return-1;
 }
return0;
}

staticint
type_set_bases(PyTypeObject*type, PyObject*value, void*context)
{
Py_ssize_ti;
intr=0;
PyObject*ob, *temp;
PyTypeObject*new_base, *old_base;
PyObject*old_bases, *old_mro;

if (!(type->tp_flags&Py_TPFLAGS_HEAPTYPE)) {
PyErr_Format(PyExc_TypeError,
"can't set %s.__bases__", type->tp_name);
return-1;
 }
if (!value) {
PyErr_Format(PyExc_TypeError,
"can't delete %s.__bases__", type->tp_name);
return-1;
 }
if (!PyTuple_Check(value)) {
PyErr_Format(PyExc_TypeError,
"can only assign tuple to %s.__bases__, not %s",
type->tp_name, Py_TYPE(value)->tp_name);
return-1;
 }
if (PyTuple_GET_SIZE(value) ==0) {
PyErr_Format(PyExc_TypeError,
"can only assign non-empty tuple to %s.__bases__, not ()",
type->tp_name);
return-1;
 }
for (i=0; i<PyTuple_GET_SIZE(value); i++) {
ob=PyTuple_GET_ITEM(value, i);
if (!PyClass_Check(ob) && !PyType_Check(ob)) {
PyErr_Format(
PyExc_TypeError,
"%s.__bases__ must be tuple of old- or new-style classes, not '%s'",
type->tp_name, Py_TYPE(ob)->tp_name);
return-1;
 }
if (PyType_Check(ob)) {
if (PyType_IsSubtype((PyTypeObject*)ob, type)) {
PyErr_SetString(PyExc_TypeError,
"a __bases__ item causes an inheritance cycle");
return-1;
 }
 }
 }

new_base=best_base(value);

if (!new_base) {
return-1;
 }

if (!compatible_for_assignment(type->tp_base, new_base, "__bases__"))
return-1;

Py_INCREF(new_base);
Py_INCREF(value);

old_bases=type->tp_bases;
old_base=type->tp_base;
old_mro=type->tp_mro;

type->tp_bases=value;
type->tp_base=new_base;

if (mro_internal(type) <0) {
 goto bail;
 }

temp=PyList_New(0);
if (!temp)
 goto bail;

r=mro_subclasses(type, temp);

if (r<0) {
for (i=0; i<PyList_Size(temp); i++) {
PyTypeObject*cls;
PyObject*mro;
PyArg_UnpackTuple(PyList_GET_ITEM(temp, i),
"", 2, 2, &cls, &mro);
Py_INCREF(mro);
ob=cls->tp_mro;
cls->tp_mro=mro;
Py_DECREF(ob);
 }
Py_DECREF(temp);
 goto bail;
 }

Py_DECREF(temp);

/* any base that was in __bases__ but now isn't, we
 need to remove |type| from its tp_subclasses.
 conversely, any class now in __bases__ that wasn't
 needs to have |type| added to its subclasses. */

/* for now, sod that: just remove from all old_bases,
 add to all new_bases */

for (i=PyTuple_GET_SIZE(old_bases) -1; i >= 0; i--) {
ob=PyTuple_GET_ITEM(old_bases, i);
if (PyType_Check(ob)) {
remove_subclass(
 (PyTypeObject*)ob, type);
 }
 }

for (i=PyTuple_GET_SIZE(value) -1; i >= 0; i--) {
ob=PyTuple_GET_ITEM(value, i);
if (PyType_Check(ob)) {
if (add_subclass((PyTypeObject*)ob, type) <0)
r=-1;
 }
 }

update_all_slots(type);

Py_DECREF(old_bases);
Py_DECREF(old_base);
Py_DECREF(old_mro);

returnr;

bail:
Py_DECREF(type->tp_bases);
Py_DECREF(type->tp_base);
if (type->tp_mro!=old_mro) {
Py_DECREF(type->tp_mro);
 }

type->tp_bases=old_bases;
type->tp_base=old_base;
type->tp_mro=old_mro;

return-1;
}

staticPyObject*
type_dict(PyTypeObject*type, void*context)
{
if (type->tp_dict==NULL) {
Py_INCREF(Py_None);
returnPy_None;
 }
returnPyDictProxy_New(type->tp_dict);
}

staticPyObject*
type_get_doc(PyTypeObject*type, void*context)
{
PyObject*result;
if (!(type->tp_flags&Py_TPFLAGS_HEAPTYPE) &&type->tp_doc!=NULL)
returnPyString_FromString(type->tp_doc);
result=PyDict_GetItemString(type->tp_dict, "__doc__");
if (result==NULL) {
result=Py_None;
Py_INCREF(result);
 }
elseif (Py_TYPE(result)->tp_descr_get) {
result=Py_TYPE(result)->tp_descr_get(result, NULL,
 (PyObject*)type);
 }
else {
Py_INCREF(result);
 }
returnresult;
}

staticPyObject*
type___instancecheck__(PyObject*type, PyObject*inst)
{
switch (_PyObject_RealIsInstance(inst, type)) {
case-1:
returnNULL;
case0:
Py_RETURN_FALSE;
default:
Py_RETURN_TRUE;
 }
}


staticPyObject*
type___subclasscheck__(PyObject*type, PyObject*inst)
{
switch (_PyObject_RealIsSubclass(inst, type)) {
case-1:
returnNULL;
case0:
Py_RETURN_FALSE;
default:
Py_RETURN_TRUE;
 }
}


staticPyGetSetDeftype_getsets[] = {
 {"__name__", (getter)type_name, (setter)type_set_name, NULL},
 {"__bases__", (getter)type_get_bases, (setter)type_set_bases, NULL},
 {"__module__", (getter)type_module, (setter)type_set_module, NULL},
 {"__abstractmethods__", (getter)type_abstractmethods,
 (setter)type_set_abstractmethods, NULL},
 {"__dict__", (getter)type_dict, NULL, NULL},
 {"__doc__", (getter)type_get_doc, NULL, NULL},
 {0}
};


staticPyObject*
type_richcompare(PyObject*v, PyObject*w, intop)
{
PyObject*result;
Py_uintptr_tvv, ww;
intc;

/* Make sure both arguments are types. */
if (!PyType_Check(v) || !PyType_Check(w) ||
/* If there is a __cmp__ method defined, let it be called instead
 of our dumb function designed merely to warn. See bug
 #7491. */
Py_TYPE(v)->tp_compare||Py_TYPE(w)->tp_compare) {
result=Py_NotImplemented;
 goto out;
 }

/* Py3K warning if comparison isn't == or != */
if (Py_Py3kWarningFlag&&op!=Py_EQ&&op!=Py_NE&&
PyErr_WarnEx(PyExc_DeprecationWarning,
"type inequality comparisons not supported "
"in 3.x", 1) <0) {
returnNULL;
 }

/* Compare addresses */
vv= (Py_uintptr_t)v;
ww= (Py_uintptr_t)w;
switch (op) {
casePy_LT: c=vv<ww; break;
casePy_LE: c=vv <= ww; break;
casePy_EQ: c=vv==ww; break;
casePy_NE: c=vv!=ww; break;
casePy_GT: c=vv>ww; break;
casePy_GE: c=vv >= ww; break;
default:
result=Py_NotImplemented;
 goto out;
 }
result=c ? Py_True : Py_False;

/* incref and return */
out:
Py_INCREF(result);
returnresult;
}

staticPyObject*
type_repr(PyTypeObject*type)
{
PyObject*mod, *name, *rtn;
char*kind;

mod=type_module(type, NULL);
if (mod==NULL)
PyErr_Clear();
elseif (!PyString_Check(mod)) {
Py_DECREF(mod);
mod=NULL;
 }
name=type_name(type, NULL);
if (name==NULL) {
Py_XDECREF(mod);
returnNULL;
 }

if (type->tp_flags&Py_TPFLAGS_HEAPTYPE)
kind="class";
else
kind="type";

if (mod!=NULL&&strcmp(PyString_AS_STRING(mod), "__builtin__")) {
rtn=PyString_FromFormat("<%s '%s.%s'>",
kind,
PyString_AS_STRING(mod),
PyString_AS_STRING(name));
 }
else
rtn=PyString_FromFormat("<%s '%s'>", kind, type->tp_name);

Py_XDECREF(mod);
Py_DECREF(name);
returnrtn;
}

staticPyObject*
type_call(PyTypeObject*type, PyObject*args, PyObject*kwds)
{
PyObject*obj;

if (type->tp_new==NULL) {
PyErr_Format(PyExc_TypeError,
"cannot create '%.100s' instances",
type->tp_name);
returnNULL;
 }

obj=type->tp_new(type, args, kwds);
if (obj!=NULL) {
/* Ugly exception: when the call was type(something),
 don't call tp_init on the result. */
if (type==&PyType_Type&&
PyTuple_Check(args) &&PyTuple_GET_SIZE(args) ==1&&
 (kwds==NULL||
 (PyDict_Check(kwds) &&PyDict_Size(kwds) ==0)))
returnobj;
/* If the returned object is not an instance of type,
 it won't be initialized. */
if (!PyType_IsSubtype(obj->ob_type, type))
returnobj;
type=obj->ob_type;
if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS) &&
type->tp_init!=NULL&&
type->tp_init(obj, args, kwds) <0) {
Py_DECREF(obj);
obj=NULL;
 }
 }
returnobj;
}

PyObject*
PyType_GenericAlloc(PyTypeObject*type, Py_ssize_tnitems)
{
PyObject*obj;
constsize_tsize=_PyObject_VAR_SIZE(type, nitems+1);
/* note that we need to add one, for the sentinel */

if (PyType_IS_GC(type))
obj=_PyObject_GC_Malloc(size);
else
obj= (PyObject*)PyObject_MALLOC(size);

if (obj==NULL)
returnPyErr_NoMemory();

memset(obj, '\0', size);

if (type->tp_flags&Py_TPFLAGS_HEAPTYPE)
Py_INCREF(type);

if (type->tp_itemsize==0)
 (void)PyObject_INIT(obj, type);
else
 (void) PyObject_INIT_VAR((PyVarObject*)obj, type, nitems);

if (PyType_IS_GC(type))
_PyObject_GC_TRACK(obj);
returnobj;
}

PyObject*
PyType_GenericNew(PyTypeObject*type, PyObject*args, PyObject*kwds)
{
returntype->tp_alloc(type, 0);
}

/* Helpers for subtyping */

staticint
traverse_slots(PyTypeObject*type, PyObject*self, visitprocvisit, void*arg)
{
Py_ssize_ti, n;
PyMemberDef*mp;

n=Py_SIZE(type);
mp=PyHeapType_GET_MEMBERS((PyHeapTypeObject*)type);
for (i=0; i<n; i++, mp++) {
if (mp->type==T_OBJECT_EX) {
char*addr= (char*)self+mp->offset;
PyObject*obj=*(PyObject**)addr;
if (obj!=NULL) {
interr=visit(obj, arg);
if (err)
returnerr;
 }
 }
 }
return0;
}

staticint
subtype_traverse(PyObject*self, visitprocvisit, void*arg)
{
PyTypeObject*type, *base;
traverseprocbasetraverse;

/* Find the nearest base with a different tp_traverse,
 and traverse slots while we're at it */
type=Py_TYPE(self);
base=type;
while ((basetraverse=base->tp_traverse) ==subtype_traverse) {
if (Py_SIZE(base)) {
interr=traverse_slots(base, self, visit, arg);
if (err)
returnerr;
 }
base=base->tp_base;
assert(base);
 }

if (type->tp_dictoffset!=base->tp_dictoffset) {
PyObject**dictptr=_PyObject_GetDictPtr(self);
if (dictptr&&*dictptr)
Py_VISIT(*dictptr);
 }

if (type->tp_flags&Py_TPFLAGS_HEAPTYPE)
/* For a heaptype, the instances count as references
 to the type. Traverse the type so the collector
 can find cycles involving this link. */
Py_VISIT(type);

if (basetraverse)
returnbasetraverse(self, visit, arg);
return0;
}

staticvoid
clear_slots(PyTypeObject*type, PyObject*self)
{
Py_ssize_ti, n;
PyMemberDef*mp;

n=Py_SIZE(type);
mp=PyHeapType_GET_MEMBERS((PyHeapTypeObject*)type);
for (i=0; i<n; i++, mp++) {
if (mp->type==T_OBJECT_EX&& !(mp->flags&READONLY)) {
char*addr= (char*)self+mp->offset;
PyObject*obj=*(PyObject**)addr;
if (obj!=NULL) {
*(PyObject**)addr=NULL;
Py_DECREF(obj);
 }
 }
 }
}

staticint
subtype_clear(PyObject*self)
{
PyTypeObject*type, *base;
inquirybaseclear;

/* Find the nearest base with a different tp_clear
 and clear slots while we're at it */
type=Py_TYPE(self);
base=type;
while ((baseclear=base->tp_clear) ==subtype_clear) {
if (Py_SIZE(base))
clear_slots(base, self);
base=base->tp_base;
assert(base);
 }

/* Clear the instance dict (if any), to break cycles involving only
 __dict__ slots (as in the case 'self.__dict__ is self'). */
if (type->tp_dictoffset!=base->tp_dictoffset) {
PyObject**dictptr=_PyObject_GetDictPtr(self);
if (dictptr&&*dictptr)
Py_CLEAR(*dictptr);
 }

if (baseclear)
returnbaseclear(self);
return0;
}

staticvoid
subtype_dealloc(PyObject*self)
{
PyTypeObject*type, *base;
destructorbasedealloc;
PyThreadState*tstate=PyThreadState_GET();

/* Extract the type; we expect it to be a heap type */
type=Py_TYPE(self);
assert(type->tp_flags&Py_TPFLAGS_HEAPTYPE);

/* Test whether the type has GC exactly once */

if (!PyType_IS_GC(type)) {
/* It's really rare to find a dynamic type that doesn't have
 GC; it can only happen when deriving from 'object' and not
 adding any slots or instance variables. This allows
 certain simplifications: there's no need to call
 clear_slots(), or DECREF the dict, or clear weakrefs. */

/* Maybe call finalizer; exit early if resurrected */
if (type->tp_del) {
type->tp_del(self);
if (self->ob_refcnt>0)
return;
 }

/* Find the nearest base with a different tp_dealloc */
base=type;
while ((basedealloc=base->tp_dealloc) ==subtype_dealloc) {
assert(Py_SIZE(base) ==0);
base=base->tp_base;
assert(base);
 }

/* Extract the type again; tp_del may have changed it */
type=Py_TYPE(self);

/* Call the base tp_dealloc() */
assert(basedealloc);
basedealloc(self);

/* Can't reference self beyond this point */
Py_DECREF(type);

/* Done */
return;
 }

/* We get here only if the type has GC */

/* UnTrack and re-Track around the trashcan macro, alas */
/* See explanation at end of function for full disclosure */
PyObject_GC_UnTrack(self);
++_PyTrash_delete_nesting;
++tstate->trash_delete_nesting;
Py_TRASHCAN_SAFE_BEGIN(self);
--_PyTrash_delete_nesting;
--tstate->trash_delete_nesting;
/* DO NOT restore GC tracking at this point. weakref callbacks
 * (if any, and whether directly here or indirectly in something we
 * call) may trigger GC, and if self is tracked at that point, it
 * will look like trash to GC and GC will try to delete self again.
 */

/* Find the nearest base with a different tp_dealloc */
base=type;
while ((basedealloc=base->tp_dealloc) ==subtype_dealloc) {
base=base->tp_base;
assert(base);
 }

/* If we added a weaklist, we clear it. Do this *before* calling
 the finalizer (__del__), clearing slots, or clearing the instance
 dict. */

if (type->tp_weaklistoffset&& !base->tp_weaklistoffset)
PyObject_ClearWeakRefs(self);

/* Maybe call finalizer; exit early if resurrected */
if (type->tp_del) {