#include "Python.h"

#include "structmember.h"

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

"PyClass_New: name must be a string");

return NULL;

}

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

PyErr_SetString(PyExc_SystemError,

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

int i;

if (!PyTuple_Check(bases)) {

PyErr_SetString(PyExc_SystemError,

"PyClass_New: bases must be a tuple");

return NULL;

}

i = PyTuple_Size(bases);

while (--i >= 0) {

if (!PyClass_Check(PyTuple_GetItem(bases, i))) {

PyErr_SetString(PyExc_SystemError,

"PyClass_New: base must be a class");

return NULL;

}

}

Py_INCREF(bases);

}

op = PyObject_NEW(PyClassObject, &PyClass_Type);

if (op == NULL) {

Py_DECREF(bases);

return NULL;

}

op->cl_bases = bases;

Py_INCREF(dict);

op->cl_dict = dict;

Py_XINCREF(name);

op->cl_name = name;

if (getattrstr == NULL) {

getattrstr = PyString_InternFromString("__getattr__");

setattrstr = PyString_InternFromString("__setattr__");

delattrstr = PyString_InternFromString("__delattr__");

}

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_Init(op);

return (PyObject *) op;

}

static void

class_dealloc(PyClassObject *op)

{

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

op = (PyClassObject *) PyObject_AS_GC(op);

PyObject_DEL(op);

}

static PyObject *

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

{

int 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 *class;

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, &class);

if (v == NULL) {

PyErr_Format(PyExc_AttributeError,

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

PyString_AS_STRING(op->cl_name), sname);

return NULL;

}

Py_INCREF(v);

if (PyFunction_Check(v)) {

PyObject *w = PyMethod_New(v, (PyObject *)NULL,

(PyObject *)class);

Py_DECREF(v);

v = w;

}

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)

{

int 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] == '_') {

int 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 buf[140];

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

sprintf(buf, "<class ?.%.100s at %p>", name, op);

else

sprintf(buf, "<class %.50s.%.50s at %p>",

PyString_AsString(mod),

name, op);

return PyString_FromString(buf);

}

static PyObject *

class_str(PyClassObject *op)

{

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

PyObject *name = op->cl_name;

PyObject *res;

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

n = PyString_Size(name);

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

if (res != NULL) {

char *s = PyString_AsString(res);

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

s += m;

*s++ = '.';

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

}

return res;

}

static int

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

{

int err;

if (o->cl_bases) {

err = visit(o->cl_bases, arg);

if (err)

return err;

}

if (o->cl_dict) {

err = visit(o->cl_dict, arg);

if (err)

return err;

}

if (o->cl_name) {

err = visit(o->cl_name, arg);

if (err)

return err;

}

if (o->cl_getattr) {

err = visit(o->cl_getattr, arg);

if (err)

return err;

}

if (o->cl_setattr) {

err = visit(o->cl_setattr, arg);

if (err)

return err;

}

if (o->cl_delattr) {

err = visit(o->cl_delattr, arg);

if (err)

return err;

}

return 0;

}

PyTypeObject PyClass_Type = {

PyObject_HEAD_INIT(&PyType_Type)

0,

"class",

sizeof(PyClassObject) + PyGC_HEAD_SIZE,

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

0, /* 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_GC, /* tp_flags */

0, /* tp_doc */

(traverseproc)class_traverse, /* tp_traverse */

};

PyClass_IsSubclass(PyObject *class, PyObject *base)

{

int i, n;

PyClassObject *cp;

if (class == base)

return 1;

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

return 0;

cp = (PyClassObject *)class;

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_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_Init(inst);

return (PyObject *)inst;

}

PyObject *

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

{

register PyInstanceObject *inst;

PyObject *init;

static PyObject *initstr;

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

if (inst == NULL)

return NULL;

if (initstr == NULL)

initstr = PyString_InternFromString("__init__");

init = instance_getattr2(inst, initstr);

if (init == 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;

}

static void

instance_dealloc(register PyInstanceObject *inst)

{

PyObject *error_type, *error_value, *error_traceback;

PyObject *del;

static PyObject *delstr;

#ifdef Py_REF_DEBUG

extern long _Py_RefTotal;

PyObject_ClearWeakRefs((PyObject *) inst);

/* Temporarily resurrect the object. */

#ifdef Py_TRACE_REFS

#ifndef Py_REF_DEBUG

# error "Py_TRACE_REFS defined but Py_REF_DEBUG not."

/* much too complicated if Py_TRACE_REFS defined */

inst->ob_type = &PyInstance_Type;

_Py_NewReference((PyObject *)inst);

#ifdef COUNT_ALLOCS

/* compensate for boost in _Py_NewReference; note that

inst->ob_type->tp_alloc--;

#else /* !Py_TRACE_REFS */

/* Py_INCREF boosts _Py_RefTotal if Py_REF_DEBUG is defined */

Py_INCREF(inst);

#endif /* !Py_TRACE_REFS */

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

#ifdef Py_REF_DEBUG

/* _Py_RefTotal was boosted either by _Py_NewReference or

_Py_RefTotal--;

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

#ifdef COUNT_ALLOCS

inst->ob_type->tp_free--;

return; /* __del__ added a reference; don't delete now */

}

#ifdef Py_TRACE_REFS

_Py_ForgetReference((PyObject *)inst);

#ifdef COUNT_ALLOCS

/* compensate for increment in _Py_ForgetReference */

inst->ob_type->tp_free--;

#ifndef WITH_CYCLE_GC

inst->ob_type = NULL;

PyObject_GC_Fini(inst);

Py_DECREF(inst->in_class);

Py_XDECREF(inst->in_dict);

inst = (PyInstanceObject *) PyObject_AS_GC(inst);

PyObject_DEL(inst);

}

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_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 *class;

class = NULL;

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

if (v == NULL) {

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

if (v == NULL)

return v;

}

Py_INCREF(v);

if (class != NULL) {

if (PyFunction_Check(v)) {

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

(PyObject *)class);

Py_DECREF(v);

v = w;

}

else if (PyMethod_Check(v)) {

PyObject *im_class = PyMethod_Class(v);

/* Only if classes are compatible */

if (PyClass_IsSubclass((PyObject *)class, im_class)) {

PyObject *im_func = PyMethod_Function(v);

PyObject *w = PyMethod_New(im_func,

(PyObject *)inst, im_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;

PyErr_Clear();

args = Py_BuildValue("(OO)", inst, name);

if (args == NULL)

return NULL;

res = PyEval_CallObject(func, args);

Py_DECREF(args);

}

return res;

}

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] == '_') {

int 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 = Py_BuildValue("(OO)", inst, name);

else

args = Py_BuildValue("(OOO)", 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__");

func = instance_getattr(inst, reprstr);

if (func == NULL) {

char buf[140];

PyObject *classname = inst->in_class->cl_name;

PyObject *mod = PyDict_GetItemString(

inst->in_class->cl_dict, "__module__");

char *cname;

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

cname = PyString_AsString(classname);

else

cname = "?";

PyErr_Clear();

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

sprintf(buf, "<?.%.100s instance at %p>",

cname, inst);

else

sprintf(buf, "<%.50s.%.50s instance at %p>",

PyString_AsString(mod),

cname, inst);

return PyString_FromString(buf);

}

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

func = instance_getattr(inst, strstr);

if (func == 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__");

func = instance_getattr(inst, hashstr);

if (func == NULL) {

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

PyErr_Clear();

if (eqstr == NULL)

eqstr = PyString_InternFromString("__eq__");

func = instance_getattr(inst, eqstr);

if (func == NULL) {

PyErr_Clear();

if (cmpstr == NULL)

cmpstr = PyString_InternFromString("__cmp__");

func = instance_getattr(inst, cmpstr);

if (func == NULL) {

PyErr_Clear();

return _Py_HashPointer(inst);

}

}

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

outcome = PyInt_AsLong(res);

if (outcome == -1)

outcome = -2;

}

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)

{

int err;

if (o->in_class) {

err = visit((PyObject *)(o->in_class), arg);

if (err)

return err;

}

if (o->in_dict) {

err = visit(o->in_dict, arg);

if (err)

return err;

}

return 0;

}

static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;

static int

instance_length(PyInstanceObject *inst)

{

PyObject *func;

PyObject *res;

int outcome;

if (lenstr == NULL)

lenstr = PyString_InternFromString("__len__");

func = instance_getattr(inst, lenstr);

if (func == NULL)

return -1;

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

Py_DECREF(func);

if (res == NULL)

return -1;

if (PyInt_Check(res)) {

outcome = PyInt_AsLong(res);

if (outcome < 0)

PyErr_SetString(PyExc_ValueError,

"__len__() should return >= 0");

}

else {

PyErr_SetString(PyExc_TypeError,

"__len__() should return an int");

outcome = -1;

}

Py_DECREF(res);

return outcome;

}

static PyObject *

instance_subscript(PyInstanceObject *inst, PyObject *key)

{

PyObject *func;

PyObject *arg;

PyObject *res;

if (getitemstr == NULL)

getitemstr = PyString_InternFromString("__getitem__");

func = instance_getattr(inst, getitemstr);

if (func == NULL)

return NULL;

arg = Py_BuildValue("(O)", key);

if (arg == NULL) {

Py_DECREF(func);

return NULL;

}

res = PyEval_CallObject(func, arg);

Py_DECREF(func);

Py_DECREF(arg);

return res;

}

static int

instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)

{

PyObject *func;

PyObject *arg;

PyObject *res;

if (value == NULL) {

if (delitemstr == NULL)

delitemstr = PyString_InternFromString("__delitem__");

func = instance_getattr(inst, delitemstr);

}

else {

if (setitemstr == NULL)

setitemstr = PyString_InternFromString("__setitem__");

func = instance_getattr(inst, setitemstr);

}

if (func == NULL)

return -1;

if (value == NULL)

arg = Py_BuildValue("(O)", key);

else

arg = Py_BuildValue("(OO)", key, value);

if (arg == NULL) {

Py_DECREF(func);

return -1;

}

res = PyEval_CallObject(func, arg);

Py_DECREF(func);

Py_DECREF(arg);

if (res == NULL)

return -1;

Py_DECREF(res);

return 0;

}

static PyMappingMethods instance_as_mapping = {

(inquiry)instance_length, /* mp_length */

(binaryfunc)instance_subscript, /* mp_subscript */

(objobjargproc)instance_ass_subscript, /* mp_ass_subscript */

};

static PyObject *

instance_item(PyInstanceObject *inst, int i)

{

PyObject *func, *arg, *res;

if (getitemstr == NULL)

getitemstr = PyString_InternFromString("__getitem__");

func = instance_getattr(inst, getitemstr);

if (func == NULL)

return NULL;

arg = Py_BuildValue("(i)", i);

if (arg == NULL) {

Py_DECREF(func);

return NULL;

}

res = PyEval_CallObject(func, arg);

Py_DECREF(func);

Py_DECREF(arg);

return res;

}

static PyObject *

sliceobj_from_intint(int i, int j)

{

PyObject *start, *end, *res;

start = PyInt_FromLong((long)i);

if (!start)

return NULL;

end = PyInt_FromLong((long)j);

if (!end) {

Py_DECREF(start);