#include "Python.h"

#include "structmember.h"

static PyMethodObject *free_list;

static int numfree = 0;

#ifndef PyMethod_MAXFREELIST

#define PyMethod_MAXFREELIST 256

#define TP_DESCR_GET(t) \

(PyType_HasFeature(t, Py_TPFLAGS_HAVE_CLASS) ? (t)->tp_descr_get : NULL)

static PyObject *class_lookup(PyClassObject *, PyObject *,

PyClassObject **);

static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);

static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);

static PyObject *getattrstr, *setattrstr, *delattrstr;

PyObject *

PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)

/* bases is NULL or tuple of classobjects! */

{

PyClassObject *op, *dummy;

static PyObject *docstr, *modstr, *namestr;

if (docstr == NULL) {

docstr= PyString_InternFromString("__doc__");

if (docstr == NULL)

return NULL;

}

if (modstr == NULL) {

modstr= PyString_InternFromString("__module__");

if (modstr == NULL)

return NULL;

}

if (namestr == NULL) {

namestr= PyString_InternFromString("__name__");

if (namestr == NULL)

return NULL;

}

if (name == NULL || !PyString_Check(name)) {

PyErr_SetString(PyExc_TypeError,

"PyClass_New: name must be a string");

return NULL;

}

if (dict == NULL || !PyDict_Check(dict)) {

PyErr_SetString(PyExc_TypeError,

"PyClass_New: dict must be a dictionary");

return NULL;

}

if (PyDict_GetItem(dict, docstr) == NULL) {

if (PyDict_SetItem(dict, docstr, Py_None) < 0)

return NULL;

}

if (PyDict_GetItem(dict, modstr) == NULL) {

PyObject *globals = PyEval_GetGlobals();

if (globals != NULL) {

PyObject *modname = PyDict_GetItem(globals, namestr);

if (modname != NULL) {

if (PyDict_SetItem(dict, modstr, modname) < 0)

return NULL;

}

}

}

if (bases == NULL) {

bases = PyTuple_New(0);

if (bases == NULL)

return NULL;

}

else {

Py_ssize_t i, n;

PyObject *base;

if (!PyTuple_Check(bases)) {

PyErr_SetString(PyExc_TypeError,

"PyClass_New: bases must be a tuple");

return NULL;

}

n = PyTuple_Size(bases);

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

base = PyTuple_GET_ITEM(bases, i);

if (!PyClass_Check(base)) {

if (PyCallable_Check(

(PyObject *) base->ob_type))

return PyObject_CallFunctionObjArgs(

(PyObject *) base->ob_type,

name, bases, dict, NULL);

PyErr_SetString(PyExc_TypeError,

"PyClass_New: base must be a class");

return NULL;

}

}

Py_INCREF(bases);

}

if (getattrstr == NULL) {

getattrstr = PyString_InternFromString("__getattr__");

if (getattrstr == NULL)

goto alloc_error;

setattrstr = PyString_InternFromString("__setattr__");

if (setattrstr == NULL)

goto alloc_error;

delattrstr = PyString_InternFromString("__delattr__");

if (delattrstr == NULL)

goto alloc_error;

}

op = PyObject_GC_New(PyClassObject, &PyClass_Type);

if (op == NULL) {

alloc_error:

Py_DECREF(bases);

return NULL;

}

op->cl_bases = bases;

Py_INCREF(dict);

op->cl_dict = dict;

Py_XINCREF(name);

op->cl_name = name;

op->cl_getattr = class_lookup(op, getattrstr, &dummy);

op->cl_setattr = class_lookup(op, setattrstr, &dummy);

op->cl_delattr = class_lookup(op, delattrstr, &dummy);

Py_XINCREF(op->cl_getattr);

Py_XINCREF(op->cl_setattr);

Py_XINCREF(op->cl_delattr);

_PyObject_GC_TRACK(op);

return (PyObject *) op;

}

PyObject *

PyMethod_Function(PyObject *im)

{

if (!PyMethod_Check(im)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyMethodObject *)im)->im_func;

}

PyObject *

PyMethod_Self(PyObject *im)

{

if (!PyMethod_Check(im)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyMethodObject *)im)->im_self;

}

PyObject *

PyMethod_Class(PyObject *im)

{

if (!PyMethod_Check(im)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyMethodObject *)im)->im_class;

}

PyDoc_STRVAR(class_doc,

a tuple of classes, and the third a dictionary.");

static PyObject *

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

{

PyObject *name, *bases, *dict;

static char *kwlist[] = {"name", "bases", "dict", 0};

if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,

&name, &bases, &dict))

return NULL;

return PyClass_New(bases, dict, name);

}

static void

class_dealloc(PyClassObject *op)

{

_PyObject_GC_UNTRACK(op);

Py_DECREF(op->cl_bases);

Py_DECREF(op->cl_dict);

Py_XDECREF(op->cl_name);

Py_XDECREF(op->cl_getattr);

Py_XDECREF(op->cl_setattr);

Py_XDECREF(op->cl_delattr);

PyObject_GC_Del(op);

}

static PyObject *

class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)

{

Py_ssize_t i, n;

PyObject *value = PyDict_GetItem(cp->cl_dict, name);

if (value != NULL) {

*pclass = cp;

return value;

}

n = PyTuple_Size(cp->cl_bases);

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

/* XXX What if one of the bases is not a class? */

PyObject *v = class_lookup(

(PyClassObject *)

PyTuple_GetItem(cp->cl_bases, i), name, pclass);

if (v != NULL)

return v;

}

return NULL;

}

static PyObject *

class_getattr(register PyClassObject *op, PyObject *name)

{

register PyObject *v;

register char *sname = PyString_AsString(name);

PyClassObject *klass;

descrgetfunc f;

if (sname[0] == '_' && sname[1] == '_') {

if (strcmp(sname, "__dict__") == 0) {

if (PyEval_GetRestricted()) {

PyErr_SetString(PyExc_RuntimeError,

"class.__dict__ not accessible in restricted mode");

return NULL;

}

Py_INCREF(op->cl_dict);

return op->cl_dict;

}

if (strcmp(sname, "__bases__") == 0) {

Py_INCREF(op->cl_bases);

return op->cl_bases;

}

if (strcmp(sname, "__name__") == 0) {

if (op->cl_name == NULL)

v = Py_None;

else

v = op->cl_name;

Py_INCREF(v);

return v;

}

}

v = class_lookup(op, name, &klass);

if (v == NULL) {

PyErr_Format(PyExc_AttributeError,

"class %.50s has no attribute '%.400s'",

PyString_AS_STRING(op->cl_name), sname);

return NULL;

}

f = TP_DESCR_GET(v->ob_type);

if (f == NULL)

Py_INCREF(v);

else

v = f(v, (PyObject *)NULL, (PyObject *)op);

return v;

}

static void

set_slot(PyObject **slot, PyObject *v)

{

PyObject *temp = *slot;

Py_XINCREF(v);

*slot = v;

Py_XDECREF(temp);

}

static void

set_attr_slots(PyClassObject *c)

{

PyClassObject *dummy;

set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));

set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));

set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));

}

static char *

set_dict(PyClassObject *c, PyObject *v)

{

if (v == NULL || !PyDict_Check(v))

return "__dict__ must be a dictionary object";

set_slot(&c->cl_dict, v);

set_attr_slots(c);

return "";

}

static char *

set_bases(PyClassObject *c, PyObject *v)

{

Py_ssize_t i, n;

if (v == NULL || !PyTuple_Check(v))

return "__bases__ must be a tuple object";

n = PyTuple_Size(v);

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

PyObject *x = PyTuple_GET_ITEM(v, i);

if (!PyClass_Check(x))

return "__bases__ items must be classes";

if (PyClass_IsSubclass(x, (PyObject *)c))

return "a __bases__ item causes an inheritance cycle";

}

set_slot(&c->cl_bases, v);

set_attr_slots(c);

return "";

}

static char *

set_name(PyClassObject *c, PyObject *v)

{

if (v == NULL || !PyString_Check(v))

return "__name__ must be a string object";

if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))

return "__name__ must not contain null bytes";

set_slot(&c->cl_name, v);

return "";

}

static int

class_setattr(PyClassObject *op, PyObject *name, PyObject *v)

{

char *sname;

if (PyEval_GetRestricted()) {

PyErr_SetString(PyExc_RuntimeError,

"classes are read-only in restricted mode");

return -1;

}

sname = PyString_AsString(name);

if (sname[0] == '_' && sname[1] == '_') {

Py_ssize_t n = PyString_Size(name);

if (sname[n-1] == '_' && sname[n-2] == '_') {

char *err = NULL;

if (strcmp(sname, "__dict__") == 0)

err = set_dict(op, v);

else if (strcmp(sname, "__bases__") == 0)

err = set_bases(op, v);

else if (strcmp(sname, "__name__") == 0)

err = set_name(op, v);

else if (strcmp(sname, "__getattr__") == 0)

set_slot(&op->cl_getattr, v);

else if (strcmp(sname, "__setattr__") == 0)

set_slot(&op->cl_setattr, v);

else if (strcmp(sname, "__delattr__") == 0)

set_slot(&op->cl_delattr, v);

/* For the last three, we fall through to update the

if (err != NULL) {

if (*err == '\0')

return 0;

PyErr_SetString(PyExc_TypeError, err);

return -1;

}

}

}

if (v == NULL) {

int rv = PyDict_DelItem(op->cl_dict, name);

if (rv < 0)

PyErr_Format(PyExc_AttributeError,

"class %.50s has no attribute '%.400s'",

PyString_AS_STRING(op->cl_name), sname);

return rv;

}

else

return PyDict_SetItem(op->cl_dict, name, v);

}

static PyObject *

class_repr(PyClassObject *op)

{

PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");

char *name;

if (op->cl_name == NULL || !PyString_Check(op->cl_name))

name = "?";

else

name = PyString_AsString(op->cl_name);

if (mod == NULL || !PyString_Check(mod))

return PyString_FromFormat("<class ?.%s at %p>", name, op);

else

return PyString_FromFormat("<class %s.%s at %p>",

PyString_AsString(mod),

name, op);

}

static PyObject *

class_str(PyClassObject *op)

{

PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");

PyObject *name = op->cl_name;

PyObject *res;

Py_ssize_t m, n;

if (name == NULL || !PyString_Check(name))

return class_repr(op);

if (mod == NULL || !PyString_Check(mod)) {

Py_INCREF(name);

return name;

}

m = PyString_GET_SIZE(mod);

n = PyString_GET_SIZE(name);

res = PyString_FromStringAndSize((char *)NULL, m+1+n);

if (res != NULL) {

char *s = PyString_AS_STRING(res);

memcpy(s, PyString_AS_STRING(mod), m);

s += m;

*s++ = '.';

memcpy(s, PyString_AS_STRING(name), n);

}

return res;

}

static int

class_traverse(PyClassObject *o, visitproc visit, void *arg)

{

Py_VISIT(o->cl_bases);

Py_VISIT(o->cl_dict);

Py_VISIT(o->cl_name);

Py_VISIT(o->cl_getattr);

Py_VISIT(o->cl_setattr);

Py_VISIT(o->cl_delattr);

return 0;

}

PyTypeObject PyClass_Type = {

PyObject_HEAD_INIT(&PyType_Type)

0,

"classobj",

sizeof(PyClassObject),

0,

(destructor)class_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

(reprfunc)class_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

PyInstance_New, /* tp_call */

(reprfunc)class_str, /* tp_str */

(getattrofunc)class_getattr, /* tp_getattro */

(setattrofunc)class_setattr, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */

class_doc, /* tp_doc */

(traverseproc)class_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

class_new, /* tp_new */

};

PyClass_IsSubclass(PyObject *klass, PyObject *base)

{

Py_ssize_t i, n;

PyClassObject *cp;

if (klass == base)

return 1;

if (PyTuple_Check(base)) {

n = PyTuple_GET_SIZE(base);

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

if (PyClass_IsSubclass(klass, PyTuple_GET_ITEM(base, i)))

return 1;

}

return 0;

}

if (klass == NULL || !PyClass_Check(klass))

return 0;

cp = (PyClassObject *)klass;

n = PyTuple_Size(cp->cl_bases);

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

if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))

return 1;

}

return 0;

}

PyObject *

PyInstance_NewRaw(PyObject *klass, PyObject *dict)

{

PyInstanceObject *inst;

if (!PyClass_Check(klass)) {

PyErr_BadInternalCall();

return NULL;

}

if (dict == NULL) {

dict = PyDict_New();

if (dict == NULL)

return NULL;

}

else {

if (!PyDict_Check(dict)) {

PyErr_BadInternalCall();

return NULL;

}

Py_INCREF(dict);

}

inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);

if (inst == NULL) {

Py_DECREF(dict);

return NULL;

}

inst->in_weakreflist = NULL;

Py_INCREF(klass);

inst->in_class = (PyClassObject *)klass;

inst->in_dict = dict;

_PyObject_GC_TRACK(inst);

return (PyObject *)inst;

}

PyObject *

PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)

{

register PyInstanceObject *inst;

PyObject *init;

static PyObject *initstr;

if (initstr == NULL) {

initstr = PyString_InternFromString("__init__");

if (initstr == NULL)

return NULL;

}

inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);

if (inst == NULL)

return NULL;

init = instance_getattr2(inst, initstr);

if (init == NULL) {

if (PyErr_Occurred()) {

Py_DECREF(inst);

return NULL;

}

if ((arg != NULL && (!PyTuple_Check(arg) ||

PyTuple_Size(arg) != 0))

|| (kw != NULL && (!PyDict_Check(kw) ||

PyDict_Size(kw) != 0))) {

PyErr_SetString(PyExc_TypeError,

"this constructor takes no arguments");

Py_DECREF(inst);

inst = NULL;

}

}

else {

PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);

Py_DECREF(init);

if (res == NULL) {

Py_DECREF(inst);

inst = NULL;

}

else {

if (res != Py_None) {

PyErr_SetString(PyExc_TypeError,

"__init__() should return None");

Py_DECREF(inst);

inst = NULL;

}

Py_DECREF(res);

}

}

return (PyObject *)inst;

}

PyDoc_STRVAR(instance_doc,

If present, dict must be a dictionary or None.");

static PyObject *

instance_new(PyTypeObject* type, PyObject* args, PyObject *kw)

{

PyObject *klass;

PyObject *dict = Py_None;

if (!PyArg_ParseTuple(args, "O!|O:instance",

&PyClass_Type, &klass, &dict))

return NULL;

if (dict == Py_None)

dict = NULL;

else if (!PyDict_Check(dict)) {

PyErr_SetString(PyExc_TypeError,

"instance() second arg must be dictionary or None");

return NULL;

}

return PyInstance_NewRaw(klass, dict);

}

static void

instance_dealloc(register PyInstanceObject *inst)

{

PyObject *error_type, *error_value, *error_traceback;

PyObject *del;

static PyObject *delstr;

_PyObject_GC_UNTRACK(inst);

if (inst->in_weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) inst);

/* Temporarily resurrect the object. */

assert(inst->ob_type == &PyInstance_Type);

assert(inst->ob_refcnt == 0);

inst->ob_refcnt = 1;

/* Save the current exception, if any. */

PyErr_Fetch(&error_type, &error_value, &error_traceback);

/* Execute __del__ method, if any. */

if (delstr == NULL) {

delstr = PyString_InternFromString("__del__");

if (delstr == NULL)

PyErr_WriteUnraisable((PyObject*)inst);

}

if (delstr && (del = instance_getattr2(inst, delstr)) != NULL) {

PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);

if (res == NULL)

PyErr_WriteUnraisable(del);

else

Py_DECREF(res);

Py_DECREF(del);

}

/* Restore the saved exception. */

PyErr_Restore(error_type, error_value, error_traceback);

/* Undo the temporary resurrection; can't use DECREF here, it would

assert(inst->ob_refcnt > 0);

if (--inst->ob_refcnt == 0) {

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

while (inst->in_weakreflist != NULL) {

_PyWeakref_ClearRef((PyWeakReference *)

(inst->in_weakreflist));

}

Py_DECREF(inst->in_class);

Py_XDECREF(inst->in_dict);

PyObject_GC_Del(inst);

}

else {

Py_ssize_t refcnt = inst->ob_refcnt;

/* __del__ resurrected it! Make it look like the original

_Py_NewReference((PyObject *)inst);

inst->ob_refcnt = refcnt;

_PyObject_GC_TRACK(inst);

/* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so

_Py_DEC_REFTOTAL;

/* If Py_TRACE_REFS, _Py_NewReference re-added self to the

#ifdef COUNT_ALLOCS

--inst->ob_type->tp_frees;

--inst->ob_type->tp_allocs;

}

}

static PyObject *

instance_getattr1(register PyInstanceObject *inst, PyObject *name)

{

register PyObject *v;

register char *sname = PyString_AsString(name);

if (sname[0] == '_' && sname[1] == '_') {

if (strcmp(sname, "__dict__") == 0) {

if (PyEval_GetRestricted()) {

PyErr_SetString(PyExc_RuntimeError,

"instance.__dict__ not accessible in restricted mode");

return NULL;

}

Py_INCREF(inst->in_dict);

return inst->in_dict;

}

if (strcmp(sname, "__class__") == 0) {

Py_INCREF(inst->in_class);

return (PyObject *)inst->in_class;

}

}

v = instance_getattr2(inst, name);

if (v == NULL && !PyErr_Occurred()) {

PyErr_Format(PyExc_AttributeError,

"%.50s instance has no attribute '%.400s'",

PyString_AS_STRING(inst->in_class->cl_name), sname);

}

return v;

}

static PyObject *

instance_getattr2(register PyInstanceObject *inst, PyObject *name)

{

register PyObject *v;

PyClassObject *klass;

descrgetfunc f;

v = PyDict_GetItem(inst->in_dict, name);

if (v != NULL) {

Py_INCREF(v);

return v;

}

v = class_lookup(inst->in_class, name, &klass);

if (v != NULL) {

Py_INCREF(v);

f = TP_DESCR_GET(v->ob_type);

if (f != NULL) {

PyObject *w = f(v, (PyObject *)inst,

(PyObject *)(inst->in_class));

Py_DECREF(v);

v = w;

}

}

return v;

}

static PyObject *

instance_getattr(register PyInstanceObject *inst, PyObject *name)

{

register PyObject *func, *res;

res = instance_getattr1(inst, name);

if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {

PyObject *args;

if (!PyErr_ExceptionMatches(PyExc_AttributeError))

return NULL;

PyErr_Clear();

args = PyTuple_Pack(2, inst, name);

if (args == NULL)

return NULL;

res = PyEval_CallObject(func, args);

Py_DECREF(args);

}

return res;

}

PyObject *

_PyInstance_Lookup(PyObject *pinst, PyObject *name)

{

PyObject *v;

PyClassObject *klass;

PyInstanceObject *inst; /* pinst cast to the right type */

assert(PyInstance_Check(pinst));

inst = (PyInstanceObject *)pinst;

assert(PyString_Check(name));

v = PyDict_GetItem(inst->in_dict, name);

if (v == NULL)

v = class_lookup(inst->in_class, name, &klass);

return v;

}

static int

instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)

{

if (v == NULL) {

int rv = PyDict_DelItem(inst->in_dict, name);

if (rv < 0)

PyErr_Format(PyExc_AttributeError,

"%.50s instance has no attribute '%.400s'",

PyString_AS_STRING(inst->in_class->cl_name),

PyString_AS_STRING(name));

return rv;

}

else

return PyDict_SetItem(inst->in_dict, name, v);

}

static int

instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)

{

PyObject *func, *args, *res, *tmp;

char *sname = PyString_AsString(name);

if (sname[0] == '_' && sname[1] == '_') {

Py_ssize_t n = PyString_Size(name);

if (sname[n-1] == '_' && sname[n-2] == '_') {

if (strcmp(sname, "__dict__") == 0) {

if (PyEval_GetRestricted()) {

PyErr_SetString(PyExc_RuntimeError,

"__dict__ not accessible in restricted mode");

return -1;

}

if (v == NULL || !PyDict_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"__dict__ must be set to a dictionary");

return -1;

}

tmp = inst->in_dict;

Py_INCREF(v);

inst->in_dict = v;

Py_DECREF(tmp);

return 0;

}

if (strcmp(sname, "__class__") == 0) {

if (PyEval_GetRestricted()) {

PyErr_SetString(PyExc_RuntimeError,

"__class__ not accessible in restricted mode");

return -1;

}

if (v == NULL || !PyClass_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"__class__ must be set to a class");

return -1;

}

tmp = (PyObject *)(inst->in_class);

Py_INCREF(v);

inst->in_class = (PyClassObject *)v;

Py_DECREF(tmp);

return 0;

}

}

}

if (v == NULL)

func = inst->in_class->cl_delattr;

else

func = inst->in_class->cl_setattr;

if (func == NULL)

return instance_setattr1(inst, name, v);

if (v == NULL)

args = PyTuple_Pack(2, inst, name);

else

args = PyTuple_Pack(3, inst, name, v);

if (args == NULL)

return -1;

res = PyEval_CallObject(func, args);

Py_DECREF(args);

if (res == NULL)

return -1;

Py_DECREF(res);

return 0;

}

static PyObject *

instance_repr(PyInstanceObject *inst)

{

PyObject *func;

PyObject *res;

static PyObject *reprstr;

if (reprstr == NULL) {

reprstr = PyString_InternFromString("__repr__");

if (reprstr == NULL)

return NULL;

}

func = instance_getattr(inst, reprstr);

if (func == NULL) {

PyObject *classname, *mod;

char *cname;

if (!PyErr_ExceptionMatches(PyExc_AttributeError))

return NULL;

PyErr_Clear();

classname = inst->in_class->cl_name;

mod = PyDict_GetItemString(inst->in_class->cl_dict,

"__module__");

if (classname != NULL && PyString_Check(classname))

cname = PyString_AsString(classname);

else

cname = "?";

if (mod == NULL || !PyString_Check(mod))

return PyString_FromFormat("<?.%s instance at %p>",

cname, inst);

else

return PyString_FromFormat("<%s.%s instance at %p>",

PyString_AsString(mod),

cname, inst);

}

res = PyEval_CallObject(func, (PyObject *)NULL);

Py_DECREF(func);

return res;

}

static PyObject *

instance_str(PyInstanceObject *inst)

{

PyObject *func;

PyObject *res;

static PyObject *strstr;

if (strstr == NULL) {

strstr = PyString_InternFromString("__str__");

if (strstr == NULL)

return NULL;

}

func = instance_getattr(inst, strstr);

if (func == NULL) {

if (!PyErr_ExceptionMatches(PyExc_AttributeError))

return NULL;

PyErr_Clear();

return instance_repr(inst);

}

res = PyEval_CallObject(func, (PyObject *)NULL);

Py_DECREF(func);

return res;

}

static long

instance_hash(PyInstanceObject *inst)

{

PyObject *func;

PyObject *res;

long outcome;

static PyObject *hashstr, *eqstr, *cmpstr;

if (hashstr == NULL) {

hashstr = PyString_InternFromString("__hash__");

if (hashstr == NULL)

return -1;

}

func = instance_getattr(inst, hashstr);

if (func == NULL) {

if (!PyErr_ExceptionMatches(PyExc_AttributeError))

return -1;

PyErr_Clear();

/* If there is no __eq__ and no __cmp__ method, we hash on the

if (eqstr == NULL) {

eqstr = PyString_InternFromString("__eq__");

if (eqstr == NULL)

return -1;

}

func = instance_getattr(inst, eqstr);

if (func == NULL) {

if (!PyErr_ExceptionMatches(PyExc_AttributeError))

return -1;

PyErr_Clear();

if (cmpstr == NULL) {

cmpstr = PyString_InternFromString("__cmp__");

if (cmpstr == NULL)

return -1;

}

func = instance_getattr(inst, cmpstr);

if (func == NULL) {

if (!PyErr_ExceptionMatches(

PyExc_AttributeError))

return -1;

PyErr_Clear();

return _Py_HashPointer(inst);

}

}

Py_XDECREF(func);

PyErr_SetString(PyExc_TypeError, "unhashable instance");

return -1;

}

res = PyEval_CallObject(func, (PyObject *)NULL);

Py_DECREF(func);

if (res == NULL)

return -1;

if (PyInt_Check(res) || PyLong_Check(res))

/* This already converts a -1 result to -2. */

outcome = res->ob_type->tp_hash(res);

else {

PyErr_SetString(PyExc_TypeError,

"__hash__() should return an int");

outcome = -1;

}

Py_DECREF(res);

return outcome;

}

static int

instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)

{