/* Type object implementation */

#include "Python.h"

#include "structmember.h"

#include <ctype.h>

static PyMemberDef type_members[] = {

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

{"__itemsize__", T_INT, 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)

{

char *s;

if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

PyHeapTypeObject* et = (PyHeapTypeObject*)type;

Py_INCREF(et->name);

return et->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;

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, value->ob_type->tp_name);

return -1;

}

if (strlen(PyString_AS_STRING(value))

!= (size_t)PyString_GET_SIZE(value)) {

PyErr_Format(PyExc_ValueError,

"__name__ must not contain null bytes");

return -1;

}

et = (PyHeapTypeObject*)type;

Py_INCREF(value);

Py_DECREF(et->name);

et->name = value;

type->tp_name = PyString_AS_STRING(value);

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, (int)(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;

}

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

}

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;

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

{

int i, 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, value->ob_type->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, ob->ob_type->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_DECREF(cls->tp_mro);

cls->tp_mro = mro;

Py_INCREF(cls->tp_mro);

}

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 (result->ob_type->tp_descr_get) {

result = result->ob_type->tp_descr_get(result, NULL,

(PyObject *)type);

}

else {

Py_INCREF(result);

}

return result;

}

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

{"__dict__", (getter)type_dict, NULL, NULL},

{"__doc__", (getter)type_get_doc, NULL, NULL},

{0}

};

static int

type_compare(PyObject *v, PyObject *w)

{

/* This is called with type objects only. So we

can just compare the addresses. */

Py_uintptr_t vv = (Py_uintptr_t)v;

Py_uintptr_t ww = (Py_uintptr_t)w;

return (vv < ww) ? -1 : (vv > ww) ? 1 : 0;

}

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)

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

{

int i, n;

PyMemberDef *mp;

n = type->ob_size;

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 = self->ob_type;

base = type;

while ((basetraverse = base->tp_traverse) == subtype_traverse) {

if (base->ob_size) {

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

int err = visit(*dictptr, arg);

if (err)

return err;

}

}

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

int err = visit((PyObject *)type, arg);

if (err)

return err;

}

if (basetraverse)

return basetraverse(self, visit, arg);

return 0;

}

static void

clear_slots(PyTypeObject *type, PyObject *self)

{

int i, n;

PyMemberDef *mp;

n = type->ob_size;

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

Py_DECREF(obj);

*(PyObject **)addr = NULL;

}

}

}

}

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 = self->ob_type;

base = type;

while ((baseclear = base->tp_clear) == subtype_clear) {

if (base->ob_size)

clear_slots(base, self);

base = base->tp_base;

assert(base);

}

/* There's no need to clear the instance dict (if any);

the collector will call its tp_clear handler. */

if (baseclear)

return baseclear(self);

return 0;

}

static void

subtype_dealloc(PyObject *self)

{

PyTypeObject *type, *base;

destructor basedealloc;

/* Extract the type; we expect it to be a heap type */

type = self->ob_type;

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(base->ob_size == 0);

base = base->tp_base;

assert(base);

}

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

Py_TRASHCAN_SAFE_BEGIN(self);

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

}

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

base = type;

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

if (base->ob_size)

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;

}

}

}

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

Py_TRASHCAN_SAFE_END(self);

--_PyTrash_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?

A. In the case that the base class is GC-aware, the base class

probably GC-untracks the object. If it does that using the

UNTRACK macro, this will crash when the object is already

untracked. Because we don't know what the base class does, the

only safe thing is to make sure the object is tracked when we

call the base class dealloc. But... The trashcan begin macro

requires that the object is *untracked* before it is called. So

the dance becomes:

GC untrack

trashcan begin

GC track

Q. Why did the last question say "immediately GC-track again"?

It's nowhere near immediately.

A. Because the code *used* to re-track immediately. Bad Idea.

self has a refcount of 0, and if gc ever gets its hands on it

(which can happen if any weakref callback gets invoked), it

looks like trash to gc too, and gc also tries to delete self

then. But we're already deleting self. Double dealloction is

a subtle disaster.

Q. Why the bizarre (net-zero) manipulation of

_PyTrash_delete_nesting around the trashcan macros?

A. Some base classes (e.g. list) also use the trashcan mechanism.

The following scenario used to be possible:

- suppose the trashcan level is one below the trashcan limit

- subtype_dealloc() is called

- the trashcan limit is not yet reached, so the trashcan level

is incremented and the code between trashcan begin and end is

executed

- this destroys much of the object's contents, including its

slots and __dict__

- basedealloc() is called; this is really list_dealloc(), or

some other type which also uses the trashcan macros

- the trashcan limit is now reached, so the object is put on the

trashcan's to-be-deleted-later list

- basedealloc() returns

- subtype_dealloc() decrefs the object's type

- subtype_dealloc() returns

- later, the trashcan code starts deleting the objects from its

to-be-deleted-later list

- subtype_dealloc() is called *AGAIN* for the same object

- at the very least (if the destroyed slots and __dict__ don't

cause problems) the object's type gets decref'ed a second

time, which is *BAD*!!!

The remedy is to make sure that if the code between trashcan

begin and end in subtype_dealloc() is called, the code between

trashcan begin and end in basedealloc() will also be called.

This is done by decrementing the level after passing into the

trashcan block, and incrementing it just before leaving the

block.

But now it's possible that a chain of objects consisting solely

of objects whose deallocator is subtype_dealloc() will defeat

the trashcan mechanism completely: the decremented level means

that the effective level never reaches the limit. Therefore, we

*increment* the level *before* entering the trashcan block, and

matchingly decrement it after leaving. This means the trashcan

code will trigger a little early, but that's no big deal.

Q. Are there any live examples of code in need of all this

complexity?

A. Yes. See SF bug 668433 for code that crashed (when Python was

compiled in debug mode) before the trashcan level manipulations

were added. For more discussion, see SF patches 581742, 575073

and bug 574207.

*/

}

static PyTypeObject *solid_base(PyTypeObject *type);

/* type test with subclassing support */

int

PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)

{

PyObject *mro;

if (!(a->tp_flags & Py_TPFLAGS_HAVE_CLASS))

return b == a || b == &PyBaseObject_Type;

mro = a->tp_mro;

if (mro != NULL) {

/* Deal with multiple inheritance without recursion

by walking the MRO tuple */

int i, n;

assert(PyTuple_Check(mro));

n = PyTuple_GET_SIZE(mro);

for (i = 0; i < n; i++) {

if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)

return 1;

}

return 0;

}

else {

/* a is not completely initilized yet; follow tp_base */

do {

if (a == b)

return 1;

a = a->tp_base;

} while (a != NULL);

return b == &PyBaseObject_Type;

}

}

/* Internal routines to do a method lookup in the type

without looking in the instance dictionary

(so we can't use PyObject_GetAttr) but still binding

it to the instance. The arguments are the object,

the method name as a C string, and the address of a

static variable used to cache the interned Python string.

Two variants:

- lookup_maybe() returns NULL without raising an exception

when the _PyType_Lookup() call fails;

- lookup_method() always raises an exception upon errors.

*/

static PyObject *

lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj)

{

PyObject *res;

if (*attrobj == NULL) {

*attrobj = PyString_InternFromString(attrstr);

if (*attrobj == NULL)

return NULL;

}

res = _PyType_Lookup(self->ob_type, *attrobj);

if (res != NULL) {

descrgetfunc f;

if ((f = res->ob_type->tp_descr_get) == NULL)

Py_INCREF(res);

else

res = f(res, self, (PyObject *)(self->ob_type));

}

return res;

}

static PyObject *

lookup_method(PyObject *self, char *attrstr, PyObject **attrobj)

{

PyObject *res = lookup_maybe(self, attrstr, attrobj);

if (res == NULL && !PyErr_Occurred())

PyErr_SetObject(PyExc_AttributeError, *attrobj);

return res;

}

/* A variation of PyObject_CallMethod that uses lookup_method()

instead of PyObject_GetAttrString(). This uses the same convention

as lookup_method to cache the interned name string object. */

static PyObject *

call_method(PyObject *o, char *name, PyObject **nameobj, char *format, ...)

{

va_list va;

PyObject *args, *func = 0, *retval;

va_start(va, format);

func = lookup_maybe(o, name, nameobj);

if (func == NULL) {

va_end(va);

if (!PyErr_Occurred())

PyErr_SetObject(PyExc_AttributeError, *nameobj);

return NULL;

}

if (format && *format)

args = Py_VaBuildValue(format, va);

else

args = PyTuple_New(0);

va_end(va);

if (args == NULL)

return NULL;

assert(PyTuple_Check(args));

retval = PyObject_Call(func, args, NULL);

Py_DECREF(args);

Py_DECREF(func);

return retval;

}

/* Clone of call_method() that returns NotImplemented when the lookup fails. */

static PyObject *

call_maybe(PyObject *o, char *name, PyObject **nameobj, char *format, ...)

{

va_list va;

PyObject *args, *func = 0, *retval;

va_start(va, format);

func = lookup_maybe(o, name, nameobj);

if (func == NULL) {

va_end(va);

if (!PyErr_Occurred()) {

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

return NULL;

}

if (format && *format)

args = Py_VaBuildValue(format, va);

else

args = PyTuple_New(0);

va_end(va);

if (args == NULL)

return NULL;

assert(PyTuple_Check(args));

retval = PyObject_Call(func, args, NULL);

Py_DECREF(args);

Py_DECREF(func);

return retval;

}

static int

fill_classic_mro(PyObject *mro, PyObject *cls)

{

PyObject *bases, *base;

int i, n;

assert(PyList_Check(mro));

assert(PyClass_Check(cls));

i = PySequence_Contains(mro, cls);

if (i < 0)

return -1;

if (!i) {

if (PyList_Append(mro, cls) < 0)

return -1;

}

bases = ((PyClassObject *)cls)->cl_bases;

assert(bases && PyTuple_Check(bases));

n = PyTuple_GET_SIZE(bases);

for (i = 0; i < n; i++) {

base = PyTuple_GET_ITEM(bases, i);

if (fill_classic_mro(mro, base) < 0)

return -1;

}

return 0;

}

static PyObject *

classic_mro(PyObject *cls)

{

PyObject *mro;

assert(PyClass_Check(cls));