/* Type object implementation */

#include "Python.h"

#include "frameobject.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 10

#define MCACHE_HASH(version, name_hash) \

(((unsigned int)(version) * (unsigned int)(name_hash)) \

>> (8*sizeof(unsigned int) - MCACHE_SIZE_EXP))

#define MCACHE_HASH_METHOD(type, name) \

MCACHE_HASH((type)->tp_version_tag, \

((PyUnicodeObject *)(name))->hash)

#define MCACHE_CACHEABLE_NAME(name) \

PyUnicode_CheckExact(name) && \

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

unsigned int

PyType_ClearCache(void)

{

Py_ssize_t i;

unsigned int cur_version_tag = next_version_tag - 1;

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_XDECREF(method_cache[i].name);

method_cache[i].name = Py_None;

Py_INCREF(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 PyUnicode_FromString(s);

}

}

static int

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

{

PyHeapTypeObject* et;

char *tp_name;

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 (!PyUnicode_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;

}

/* Check absence of null characters */

tmp = PyUnicode_FromStringAndSize("\0", 1);

if (tmp == NULL)

return -1;

if (PyUnicode_Contains(value, tmp) != 0) {

Py_DECREF(tmp);

PyErr_Format(PyExc_ValueError,

"__name__ must not contain null bytes");

return -1;

}

Py_DECREF(tmp);

tp_name = _PyUnicode_AsString(value);

if (tp_name == NULL)

return -1;

et = (PyHeapTypeObject*)type;

Py_INCREF(value);

Py_DECREF(et->ht_name);

et->ht_name = value;

type->tp_name = tp_name;

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 PyUnicode_FromStringAndSize(

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

return PyUnicode_FromString("builtins");

}

}

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 (!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_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 PyUnicode_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_repr(PyTypeObject *type)

{

PyObject *mod, *name, *rtn;

mod = type_module(type, NULL);

if (mod == NULL)

PyErr_Clear();

else if (!PyUnicode_Check(mod)) {

Py_DECREF(mod);

mod = NULL;

}

name = type_name(type, NULL);

if (name == NULL) {

Py_XDECREF(mod);

return NULL;

}

if (mod != NULL && PyUnicode_CompareWithASCIIString(mod, "builtins"))

rtn = PyUnicode_FromFormat("<class '%U.%U'>", mod, name);

else

rtn = PyUnicode_FromFormat("<class '%s'>", 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(Py_TYPE(obj), type))

return obj;

type = Py_TYPE(obj);

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

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

_PyObject_GC_TRACK(self);

type->tp_del(self);

if (self->ob_refcnt > 0)

goto endlabel; /* resurrected */

else

_PyObject_GC_UNTRACK(self);

/* New weakrefs could be created during the finalizer call.

If this occurs, clear them out without calling their

finalizers since they might rely on part of the object

being finalized that has already been destroyed. */

if (type->tp_weaklistoffset && !base->tp_weaklistoffset) {

/* Modeled after GET_WEAKREFS_LISTPTR() */

PyWeakReference **list = (PyWeakReference **) \

PyObject_GET_WEAKREFS_LISTPTR(self);

while (*list)

_PyWeakref_ClearRef(*list);

}

}

/* Clear slots up to the nearest base with a different tp_dealloc */

base = type;

while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {

if (Py_SIZE(base))

clear_slots(base, self);

base = base->tp_base;

assert(base);

}

/* If we added a dict, DECREF it */

if (type->tp_dictoffset && !base->tp_dictoffset) {

PyObject **dictptr = _PyObject_GetDictPtr(self);

if (dictptr != NULL) {

PyObject *dict = *dictptr;

if (dict != NULL) {

Py_DECREF(dict);

*dictptr = NULL;

}

}

}

/* Extract the type again; tp_del may have changed it */

type = Py_TYPE(self);

/* Call the base tp_dealloc(); first retrack self if

* basedealloc knows about gc.

*/

if (PyType_IS_GC(base))

_PyObject_GC_TRACK(self);

assert(basedealloc);

basedealloc(self);

/* Can't reference self beyond this point */

Py_DECREF(type);

endlabel:

++_PyTrash_delete_nesting;

++ tstate->trash_delete_nesting;

Py_TRASHCAN_SAFE_END(self);

--_PyTrash_delete_nesting;

-- tstate->trash_delete_nesting;

/* Explanation of the weirdness around the trashcan macros:

Q. What do the trashcan macros do?

A. Read the comment titled "Trashcan mechanism" in object.h.

For one, this explains why there must be a call to GC-untrack

before the trashcan begin macro. Without understanding the

trashcan code, the answers to the following questions don't make

sense.

Q. Why do we GC-untrack before the trashcan and then immediately

GC-track again afterward?