#include "Python.h"

#include "structmember.h"

#include <ctype.h>

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

};

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;

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

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;

}

PyType_Modified(PyTypeObject *type)

{

/* Invalidate any cached data for the specified type and all

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

/*

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

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

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

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

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

/* for now, sod that: just remove from all old_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

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

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,

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

}

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,

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

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

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

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

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

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

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

PyObject_ClearWeakRefs(self);

/* Maybe call finalizer; exit early if resurrected */

if (type->tp_del) {