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

#define MCACHE_MAX_ATTR_SIZE 100

#define MCACHE_SIZE_EXP 12

#define MCACHE_HASH(version, name_hash) \

(((unsigned int)(version) ^ (unsigned int)(name_hash)) \

& ((1 << MCACHE_SIZE_EXP) - 1))

#define MCACHE_HASH_METHOD(type, name) \

MCACHE_HASH((type)->tp_version_tag, \

((PyStringObject *)(name))->ob_shash)

#define MCACHE_CACHEABLE_NAME(name) \

PyString_CheckExact(name) && \

PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE

struct method_cache_entry {

unsigned int version;

PyObject *name; /* reference to exactly a str or None */

PyObject *value; /* borrowed */

};

static struct method_cache_entry method_cache[1 << MCACHE_SIZE_EXP];

static unsigned int next_version_tag = 0;

#define MCACHE_STATS 0

#if MCACHE_STATS

static size_t method_cache_hits = 0;

static size_t method_cache_misses = 0;

static size_t method_cache_collisions = 0;

#endif

unsigned int

PyType_ClearCache(void)

{

Py_ssize_t i;

unsigned int cur_version_tag = next_version_tag - 1;

#if MCACHE_STATS

size_t total = 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);

return cur_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_t i, 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;

}

static void

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_t i, n;

int clear = 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);

}

static int

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_t i, n;

PyObject *bases;

if (PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))

return 1;

if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))

return 0;

if (!PyType_HasFeature(type, Py_TPFLAGS_READY))

return 0;

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

return 1;

}

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

return 0;

}

type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;

return 1;

}

static PyMemberDef type_members[] = {

{"__basicsize__", T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),READONLY},

{"__itemsize__", T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), READONLY},

{"__flags__", T_LONG, offsetof(PyTypeObject, tp_flags), READONLY},

{"__weakrefoffset__", T_LONG,

offsetof(PyTypeObject, tp_weaklistoffset), READONLY},

{"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY},

{"__dictoffset__", T_LONG,

offsetof(PyTypeObject, tp_dictoffset), READONLY},

{"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY},

{0}

};

static PyObject *

type_name(PyTypeObject *type, void *context)

{

const char *s;

if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

PyHeapTypeObject* et = (PyHeapTypeObject*)type;

Py_INCREF(et->ht_name);

return et->ht_name;

}

else {

s = strrchr(type->tp_name, '.');

if (s == NULL)

s = type->tp_name;

else

s++;

return PyString_FromString(s);

}

}

static int

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

return 0;

}

static PyObject *

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__");

return 0;

}

Py_XINCREF(mod);

return mod;

}

else {

s = strrchr(type->tp_name, '.');

if (s != NULL)

return PyString_FromStringAndSize(

type->tp_name, (Py_ssize_t)(s - type->tp_name));

return PyString_FromString("__builtin__");

}

}

static int

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

return PyDict_SetItemString(type->tp_dict, "__module__", value);

}

static PyObject *

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__");

return NULL;

}

Py_XINCREF(mod);

return mod;

}

static int

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.

*/

int abstract, 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;

}

return res;

}

static PyObject *

type_get_bases(PyTypeObject *type, void *context)

{

Py_INCREF(type->tp_bases);

return type->tp_bases;

}

static PyTypeObject *best_base(PyObject *);

static int mro_internal(PyTypeObject *);

static int compatible_for_assignment(PyTypeObject *, PyTypeObject *, char *);

static int add_subclass(PyTypeObject*, PyTypeObject*);

static void remove_subclass(PyTypeObject *, PyTypeObject *);

static void update_all_slots(PyTypeObject *);

typedef int (*update_callback)(PyTypeObject *, void *);

static int update_subclasses(PyTypeObject *type, PyObject *name,

update_callback callback, void *data);

static int recurse_down_subclasses(PyTypeObject *type, PyObject *name,

update_callback callback, void *data);

static int

mro_subclasses(PyTypeObject *type, PyObject* temp)

{

PyTypeObject *subclass;

PyObject *ref, *subclasses, *old_mro;

Py_ssize_t i, n;

subclasses = type->tp_subclasses;

if (subclasses == NULL)

return 0;

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;

}

return 0;

}

static int

type_set_bases(PyTypeObject *type, PyObject *value, void *context)

{

Py_ssize_t i;

int r = 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);

return r;

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;

}

static PyObject *

type_dict(PyTypeObject *type, void *context)

{

if (type->tp_dict == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyDictProxy_New(type->tp_dict);

}

static PyObject *

type_get_doc(PyTypeObject *type, void *context)

{

PyObject *result;

if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL)

return PyString_FromString(type->tp_doc);

result = PyDict_GetItemString(type->tp_dict, "__doc__");

if (result == NULL) {

result = Py_None;

Py_INCREF(result);

}

else if (Py_TYPE(result)->tp_descr_get) {

result = Py_TYPE(result)->tp_descr_get(result, NULL,

(PyObject *)type);

}

else {

Py_INCREF(result);

}

return result;

}

static PyObject *

type___instancecheck__(PyObject *type, PyObject *inst)

{

switch (_PyObject_RealIsInstance(inst, type)) {

case -1:

return NULL;

case 0:

Py_RETURN_FALSE;

default:

Py_RETURN_TRUE;

}

}

static PyObject *

type___subclasscheck__(PyObject *type, PyObject *inst)

{

switch (_PyObject_RealIsSubclass(inst, type)) {

case -1:

return NULL;

case 0:

Py_RETURN_FALSE;

default:

Py_RETURN_TRUE;

}

}

static PyGetSetDef type_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}

};

static PyObject*

type_richcompare(PyObject *v, PyObject *w, int op)

{

PyObject *result;

Py_uintptr_t vv, ww;

int c;

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

return NULL;

}

/* Compare addresses */

vv = (Py_uintptr_t)v;

ww = (Py_uintptr_t)w;

switch (op) {

case Py_LT: c = vv < ww; break;

case Py_LE: c = vv <= ww; break;

case Py_EQ: c = vv == ww; break;

case Py_NE: c = vv != ww; break;

case Py_GT: c = vv > ww; break;

case Py_GE: c = vv >= ww; break;

default:

result = Py_NotImplemented;

goto out;

}

result = c ? Py_True : Py_False;

/* incref and return */

out:

Py_INCREF(result);

return result;

}

static PyObject *

type_repr(PyTypeObject *type)

{

PyObject *mod, *name, *rtn;

char *kind;

mod = type_module(type, NULL);

if (mod == NULL)

PyErr_Clear();

else if (!PyString_Check(mod)) {

Py_DECREF(mod);

mod = NULL;

}

name = type_name(type, NULL);

if (name == NULL) {

Py_XDECREF(mod);

return NULL;

}

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

return rtn;

}

static PyObject *

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

return NULL;

}

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

return obj;

/* If the returned object is not an instance of type,

it won't be initialized. */

if (!PyType_IsSubtype(obj->ob_type, type))

return obj;

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;

}

}

return obj;

}

PyObject *

PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)

{

PyObject *obj;

const size_t size = _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)

return PyErr_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);

return obj;

}

PyObject *

PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

return type->tp_alloc(type, 0);

}

/* Helpers for subtyping */

static int

traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg)

{

Py_ssize_t i, 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) {

int err = visit(obj, arg);

if (err)

return err;

}

}

}

return 0;

}

static int

subtype_traverse(PyObject *self, visitproc visit, void *arg)

{

PyTypeObject *type, *base;

traverseproc basetraverse;

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

int err = traverse_slots(base, self, visit, arg);

if (err)

return err;

}

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)

return basetraverse(self, visit, arg);

return 0;

}

static void

clear_slots(PyTypeObject *type, PyObject *self)

{

Py_ssize_t i, 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);

}

}

}

}

static int

subtype_clear(PyObject *self)

{

PyTypeObject *type, *base;

inquiry baseclear;

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

return baseclear(self);

return 0;

}

static void

subtype_dealloc(PyObject *self)

{

PyTypeObject *type, *base;

destructor basedealloc;

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