1 

     2 /* Class object implementation */

     3 

     4 #include "Python.h"

     5 #include "structmember.h"

     6 

     7 /* Free list for method objects to safe malloc/free overhead

     8  * The im_self element is used to chain the elements.

     9  */

    10 static PyMethodObject *free_list;

    11 static int numfree = 0;

    12 #ifndef PyMethod_MAXFREELIST

    13 #define PyMethod_MAXFREELIST 256

    14 #endif

    15 

    16 #define TP_DESCR_GET(t) \

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

    18 

    19 /* Forward */

    20 static PyObject *class_lookup(PyClassObject *, PyObject *,

    21 			      PyClassObject **);

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

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

    24 

    25 static PyObject *getattrstr, *setattrstr, *delattrstr;

    26 

    27 

    28 PyObject *

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

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

    31 {

    32 	PyClassObject *op, *dummy;

    33 	static PyObject *docstr, *modstr, *namestr;

    34 	if (docstr == NULL) {

    35 		docstr= PyString_InternFromString("__doc__");

    36 		if (docstr == NULL)

    37 			return NULL;

    38 	}

    39 	if (modstr == NULL) {

    40 		modstr= PyString_InternFromString("__module__");

    41 		if (modstr == NULL)

    42 			return NULL;

    43 	}

    44 	if (namestr == NULL) {

    45 		namestr= PyString_InternFromString("__name__");

    46 		if (namestr == NULL)

    47 			return NULL;

    48 	}

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

    50 		PyErr_SetString(PyExc_TypeError,

    51 				"PyClass_New: name must be a string");

    52 		return NULL;

    53 	}

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

    55 		PyErr_SetString(PyExc_TypeError,

    56 				"PyClass_New: dict must be a dictionary");

    57 		return NULL;

    58 	}

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

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

    61 			return NULL;

    62 	}

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

    64 		PyObject *globals = PyEval_GetGlobals();

    65 		if (globals != NULL) {

    66 			PyObject *modname = PyDict_GetItem(globals, namestr);

    67 			if (modname != NULL) {

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

    69 					return NULL;

    70 			}

    71 		}

    72 	}

    73 	if (bases == NULL) {

    74 		bases = PyTuple_New(0);

    75 		if (bases == NULL)

    76 			return NULL;

    77 	}

    78 	else {

    79 		Py_ssize_t i, n;

    80 		PyObject *base;

    81 		if (!PyTuple_Check(bases)) {

    82 			PyErr_SetString(PyExc_TypeError,

    83 					"PyClass_New: bases must be a tuple");

    84 			return NULL;

    85 		}

    86 		n = PyTuple_Size(bases);

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

    88 			base = PyTuple_GET_ITEM(bases, i);

    89 			if (!PyClass_Check(base)) {

    90 				if (PyCallable_Check(

    91 					(PyObject *) base->ob_type))

    92 					return PyObject_CallFunctionObjArgs(

    93 						(PyObject *) base->ob_type,

    94 						name, bases, dict, NULL);

    95 				PyErr_SetString(PyExc_TypeError,

    96 					"PyClass_New: base must be a class");

    97 				return NULL;

    98 			}

    99 		}

   100 		Py_INCREF(bases);

   101 	}

   102 

   103 	if (getattrstr == NULL) {

   104 		getattrstr = PyString_InternFromString("__getattr__");

   105 		if (getattrstr == NULL)

   106 			goto alloc_error;

   107 		setattrstr = PyString_InternFromString("__setattr__");

   108 		if (setattrstr == NULL)

   109 			goto alloc_error;

   110 		delattrstr = PyString_InternFromString("__delattr__");

   111 		if (delattrstr == NULL)

   112 			goto alloc_error;

   113 	}

   114 

   115 	op = PyObject_GC_New(PyClassObject, &PyClass_Type);

   116 	if (op == NULL) {

   117 alloc_error:

   118 		Py_DECREF(bases);

   119 		return NULL;

   120 	}

   121 	op->cl_bases = bases;

   122 	Py_INCREF(dict);

   123 	op->cl_dict = dict;

   124 	Py_XINCREF(name);

   125 	op->cl_name = name;

   126 

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

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

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

   130 	Py_XINCREF(op->cl_getattr);

   131 	Py_XINCREF(op->cl_setattr);

   132 	Py_XINCREF(op->cl_delattr);

   133 	_PyObject_GC_TRACK(op);

   134 	return (PyObject *) op;

   135 }

   136 

   137 PyObject *

   138 PyMethod_Function(PyObject *im)

   139 {

   140 	if (!PyMethod_Check(im)) {

   141 		PyErr_BadInternalCall();

   142 		return NULL;

   143 	}

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

   145 }

   146 

   147 PyObject *

   148 PyMethod_Self(PyObject *im)

   149 {

   150 	if (!PyMethod_Check(im)) {

   151 		PyErr_BadInternalCall();

   152 		return NULL;

   153 	}

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

   155 }

   156 

   157 PyObject *

   158 PyMethod_Class(PyObject *im)

   159 {

   160 	if (!PyMethod_Check(im)) {

   161 		PyErr_BadInternalCall();

   162 		return NULL;

   163 	}

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

   165 }

   166 

   167 PyDoc_STRVAR(class_doc,

   168 "classobj(name, bases, dict)\n\

   169 \n\

   170 Create a class object.  The name must be a string; the second argument\n\

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

   172 

   173 static PyObject *

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

   175 {

   176 	PyObject *name, *bases, *dict;

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

   178 

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

   180 					 &name, &bases, &dict))

   181 		return NULL;

   182 	return PyClass_New(bases, dict, name);

   183 }

   184 

   185 /* Class methods */

   186 

   187 static void

   188 class_dealloc(PyClassObject *op)

   189 {

   190 	_PyObject_GC_UNTRACK(op);

   191 	Py_DECREF(op->cl_bases);

   192 	Py_DECREF(op->cl_dict);

   193 	Py_XDECREF(op->cl_name);

   194 	Py_XDECREF(op->cl_getattr);

   195 	Py_XDECREF(op->cl_setattr);

   196 	Py_XDECREF(op->cl_delattr);

   197 	PyObject_GC_Del(op);

   198 }

   199 

   200 static PyObject *

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

   202 {

   203 	Py_ssize_t i, n;

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

   205 	if (value != NULL) {

   206 		*pclass = cp;

   207 		return value;

   208 	}

   209 	n = PyTuple_Size(cp->cl_bases);

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

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

   212 		PyObject *v = class_lookup(

   213 			(PyClassObject *)

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

   215 		if (v != NULL)

   216 			return v;

   217 	}

   218 	return NULL;

   219 }

   220 

   221 static PyObject *

   222 class_getattr(register PyClassObject *op, PyObject *name)

   223 {

   224 	register PyObject *v;

   225 	register char *sname = PyString_AsString(name);

   226 	PyClassObject *klass;

   227 	descrgetfunc f;

   228 

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

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

   231 			if (PyEval_GetRestricted()) {

   232 				PyErr_SetString(PyExc_RuntimeError,

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

   234 				return NULL;

   235 			}

   236 			Py_INCREF(op->cl_dict);

   237 			return op->cl_dict;

   238 		}

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

   240 			Py_INCREF(op->cl_bases);

   241 			return op->cl_bases;

   242 		}

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

   244 			if (op->cl_name == NULL)

   245 				v = Py_None;

   246 			else

   247 				v = op->cl_name;

   248 			Py_INCREF(v);

   249 			return v;

   250 		}

   251 	}

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

   253 	if (v == NULL) {

   254 		PyErr_Format(PyExc_AttributeError,

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

   256 			     PyString_AS_STRING(op->cl_name), sname);

   257 		return NULL;

   258 	}

   259 	f = TP_DESCR_GET(v->ob_type);

   260 	if (f == NULL)

   261 		Py_INCREF(v);

   262 	else

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

   264 	return v;

   265 }

   266 

   267 static void

   268 set_slot(PyObject **slot, PyObject *v)

   269 {

   270 	PyObject *temp = *slot;

   271 	Py_XINCREF(v);

   272 	*slot = v;

   273 	Py_XDECREF(temp);

   274 }

   275 

   276 static void

   277 set_attr_slots(PyClassObject *c)

   278 {

   279 	PyClassObject *dummy;

   280 

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

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

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

   284 }

   285 

   286 static char *

   287 set_dict(PyClassObject *c, PyObject *v)

   288 {

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

   290 		return "__dict__ must be a dictionary object";

   291 	set_slot(&c->cl_dict, v);

   292 	set_attr_slots(c);

   293 	return "";

   294 }

   295 

   296 static char *

   297 set_bases(PyClassObject *c, PyObject *v)

   298 {

   299 	Py_ssize_t i, n;

   300 

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

   302 		return "__bases__ must be a tuple object";

   303 	n = PyTuple_Size(v);

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

   305 		PyObject *x = PyTuple_GET_ITEM(v, i);

   306 		if (!PyClass_Check(x))

   307 			return "__bases__ items must be classes";

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

   309 			return "a __bases__ item causes an inheritance cycle";

   310 	}

   311 	set_slot(&c->cl_bases, v);

   312 	set_attr_slots(c);

   313 	return "";

   314 }

   315 

   316 static char *

   317 set_name(PyClassObject *c, PyObject *v)

   318 {

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

   320 		return "__name__ must be a string object";

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

   322 		return "__name__ must not contain null bytes";

   323 	set_slot(&c->cl_name, v);

   324 	return "";

   325 }

   326 

   327 static int

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

   329 {

   330 	char *sname;

   331 	if (PyEval_GetRestricted()) {

   332 		PyErr_SetString(PyExc_RuntimeError,

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

   334 		return -1;

   335 	}

   336 	sname = PyString_AsString(name);

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

   338 		Py_ssize_t n = PyString_Size(name);

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

   340 			char *err = NULL;

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

   342 				err = set_dict(op, v);

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

   344 				err = set_bases(op, v);

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

   346 				err = set_name(op, v);

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

   348 				set_slot(&op->cl_getattr, v);

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

   350 				set_slot(&op->cl_setattr, v);

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

   352 				set_slot(&op->cl_delattr, v);

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

   354 			   dictionary as well. */

   355 			if (err != NULL) {

   356 				if (*err == '\0')

   357 					return 0;

   358 				PyErr_SetString(PyExc_TypeError, err);

   359 				return -1;

   360 			}

   361 		}

   362 	}

   363 	if (v == NULL) {

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

   365 		if (rv < 0)

   366 			PyErr_Format(PyExc_AttributeError,

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

   368 				     PyString_AS_STRING(op->cl_name), sname);

   369 		return rv;

   370 	}

   371 	else

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

   373 }

   374 

   375 static PyObject *

   376 class_repr(PyClassObject *op)

   377 {

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

   379 	char *name;

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

   381 		name = "?";

   382 	else

   383 		name = PyString_AsString(op->cl_name);

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

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

   386 	else

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

   388 					   PyString_AsString(mod),

   389 					   name, op);

   390 }

   391 

   392 static PyObject *

   393 class_str(PyClassObject *op)

   394 {

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

   396 	PyObject *name = op->cl_name;

   397 	PyObject *res;

   398 	Py_ssize_t m, n;

   399 

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

   401 		return class_repr(op);

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

   403 		Py_INCREF(name);

   404 		return name;

   405 	}

   406 	m = PyString_GET_SIZE(mod);

   407 	n = PyString_GET_SIZE(name);

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

   409 	if (res != NULL) {

   410 		char *s = PyString_AS_STRING(res);

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

   412 		s += m;

   413 		*s++ = '.';

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

   415 	}

   416 	return res;

   417 }

   418 

   419 static int

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

   421 {

   422 	Py_VISIT(o->cl_bases);

   423 	Py_VISIT(o->cl_dict);

   424 	Py_VISIT(o->cl_name);

   425 	Py_VISIT(o->cl_getattr);

   426 	Py_VISIT(o->cl_setattr);

   427 	Py_VISIT(o->cl_delattr);

   428 	return 0;

   429 }

   430 

   431 PyTypeObject PyClass_Type = {

   432 	PyObject_HEAD_INIT(&PyType_Type)

   433 	0,

   434 	"classobj",

   435 	sizeof(PyClassObject),

   436 	0,

   437 	(destructor)class_dealloc,		/* tp_dealloc */

   438 	0,					/* tp_print */

   439 	0,					/* tp_getattr */

   440 	0,					/* tp_setattr */

   441 	0,					/* tp_compare */

   442 	(reprfunc)class_repr,			/* tp_repr */

   443 	0,					/* tp_as_number */

   444 	0,					/* tp_as_sequence */

   445 	0,					/* tp_as_mapping */

   446 	0,					/* tp_hash */

   447 	PyInstance_New,				/* tp_call */

   448 	(reprfunc)class_str,			/* tp_str */

   449 	(getattrofunc)class_getattr,		/* tp_getattro */

   450 	(setattrofunc)class_setattr,		/* tp_setattro */

   451 	0,					/* tp_as_buffer */

   452 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */

   453 	class_doc,				/* tp_doc */

   454 	(traverseproc)class_traverse,		/* tp_traverse */

   455  	0,					/* tp_clear */

   456 	0,					/* tp_richcompare */

   457 	0,					/* tp_weaklistoffset */

   458 	0,					/* tp_iter */

   459 	0,					/* tp_iternext */

   460 	0,					/* tp_methods */

   461 	0,					/* tp_members */

   462 	0,					/* tp_getset */

   463 	0,					/* tp_base */

   464 	0,					/* tp_dict */

   465 	0,					/* tp_descr_get */

   466 	0,					/* tp_descr_set */

   467 	0,					/* tp_dictoffset */

   468 	0,					/* tp_init */

   469 	0,					/* tp_alloc */

   470 	class_new,				/* tp_new */

   471 };

   472 

   473 int

   474 PyClass_IsSubclass(PyObject *klass, PyObject *base)

   475 {

   476 	Py_ssize_t i, n;

   477 	PyClassObject *cp;

   478 	if (klass == base)

   479 		return 1;

   480 	if (PyTuple_Check(base)) {

   481 		n = PyTuple_GET_SIZE(base);

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

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

   484 				return 1;

   485 		}

   486 		return 0;

   487 	}

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

   489 		return 0;

   490 	cp = (PyClassObject *)klass;

   491 	n = PyTuple_Size(cp->cl_bases);

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

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

   494 			return 1;

   495 	}

   496 	return 0;

   497 }

   498 

   499 

   500 /* Instance objects */

   501 

   502 PyObject *

   503 PyInstance_NewRaw(PyObject *klass, PyObject *dict)

   504 {

   505 	PyInstanceObject *inst;

   506 

   507 	if (!PyClass_Check(klass)) {

   508 		PyErr_BadInternalCall();

   509 		return NULL;

   510 	}

   511 	if (dict == NULL) {

   512 		dict = PyDict_New();

   513 		if (dict == NULL)

   514 			return NULL;

   515 	}

   516 	else {

   517 		if (!PyDict_Check(dict)) {

   518 			PyErr_BadInternalCall();

   519 			return NULL;

   520 		}

   521 		Py_INCREF(dict);

   522 	}

   523 	inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);

   524 	if (inst == NULL) {

   525 		Py_DECREF(dict);

   526 		return NULL;

   527 	}

   528 	inst->in_weakreflist = NULL;

   529 	Py_INCREF(klass);

   530 	inst->in_class = (PyClassObject *)klass;

   531 	inst->in_dict = dict;

   532 	_PyObject_GC_TRACK(inst);

   533 	return (PyObject *)inst;

   534 }

   535 

   536 PyObject *

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

   538 {

   539 	register PyInstanceObject *inst;

   540 	PyObject *init;

   541 	static PyObject *initstr;

   542 

   543 	if (initstr == NULL) {

   544 		initstr = PyString_InternFromString("__init__");

   545 		if (initstr == NULL)

   546 			return NULL;

   547 	}

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

   549 	if (inst == NULL)

   550 		return NULL;

   551 	init = instance_getattr2(inst, initstr);

   552 	if (init == NULL) {

   553 		if (PyErr_Occurred()) {

   554 			Py_DECREF(inst);

   555 			return NULL;

   556 		}

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

   558 				     PyTuple_Size(arg) != 0))

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

   560 				      PyDict_Size(kw) != 0))) {

   561 			PyErr_SetString(PyExc_TypeError,

   562 				   "this constructor takes no arguments");

   563 			Py_DECREF(inst);

   564 			inst = NULL;

   565 		}

   566 	}

   567 	else {

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

   569 		Py_DECREF(init);

   570 		if (res == NULL) {

   571 			Py_DECREF(inst);

   572 			inst = NULL;

   573 		}

   574 		else {

   575 			if (res != Py_None) {

   576 				PyErr_SetString(PyExc_TypeError,

   577 					   "__init__() should return None");

   578 				Py_DECREF(inst);

   579 				inst = NULL;

   580 			}

   581 			Py_DECREF(res);

   582 		}

   583 	}

   584 	return (PyObject *)inst;

   585 }

   586 

   587 /* Instance methods */

   588 

   589 PyDoc_STRVAR(instance_doc,

   590 "instance(class[, dict])\n\

   591 \n\

   592 Create an instance without calling its __init__() method.\n\

   593 The class must be a classic class.\n\

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

   595 

   596 static PyObject *

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

   598 {

   599 	PyObject *klass;

   600 	PyObject *dict = Py_None;

   601 

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

   603 			      &PyClass_Type, &klass, &dict))

   604 		return NULL;

   605 

   606 	if (dict == Py_None)

   607 		dict = NULL;

   608 	else if (!PyDict_Check(dict)) {

   609 		PyErr_SetString(PyExc_TypeError,

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

   611 		return NULL;

   612 	}

   613 	return PyInstance_NewRaw(klass, dict);

   614 }

   615 

   616 

   617 static void

   618 instance_dealloc(register PyInstanceObject *inst)

   619 {

   620 	PyObject *error_type, *error_value, *error_traceback;

   621 	PyObject *del;

   622 	static PyObject *delstr;

   623 

   624 	_PyObject_GC_UNTRACK(inst);

   625 	if (inst->in_weakreflist != NULL)

   626 		PyObject_ClearWeakRefs((PyObject *) inst);

   627 

   628 	/* Temporarily resurrect the object. */

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

   630 	assert(inst->ob_refcnt == 0);

   631 	inst->ob_refcnt = 1;

   632 

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

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

   635 	/* Execute __del__ method, if any. */

   636 	if (delstr == NULL) {

   637 		delstr = PyString_InternFromString("__del__");

   638 		if (delstr == NULL)

   639 			PyErr_WriteUnraisable((PyObject*)inst);

   640 	}

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

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

   643 		if (res == NULL)

   644 			PyErr_WriteUnraisable(del);

   645 		else

   646 			Py_DECREF(res);

   647 		Py_DECREF(del);

   648 	}

   649 	/* Restore the saved exception. */

   650 	PyErr_Restore(error_type, error_value, error_traceback);

   651 

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

   653 	 * cause a recursive call.

   654 	 */

   655 	assert(inst->ob_refcnt > 0);

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

   657 

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

   659 		    If this occurs, clear them out without calling their

   660 		    finalizers since they might rely on part of the object

   661 		    being finalized that has already been destroyed. */

   662 		while (inst->in_weakreflist != NULL) {

   663 			_PyWeakref_ClearRef((PyWeakReference *)

   664                                             (inst->in_weakreflist));

   665 		}

   666 

   667 		Py_DECREF(inst->in_class);

   668 		Py_XDECREF(inst->in_dict);

   669 		PyObject_GC_Del(inst);

   670 	}

   671 	else {

   672 		Py_ssize_t refcnt = inst->ob_refcnt;

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

   674 		 * Py_DECREF never happened.

   675 		 */

   676 		_Py_NewReference((PyObject *)inst);

   677 		inst->ob_refcnt = refcnt;

   678 		_PyObject_GC_TRACK(inst);

   679 		/* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so

   680 		 * we need to undo that. */

   681 		_Py_DEC_REFTOTAL;

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

   683 		 * object chain, so no more to do there.

   684 		 * If COUNT_ALLOCS, the original decref bumped tp_frees, and

   685 		 * _Py_NewReference bumped tp_allocs: both of those need to be

   686 		 * undone.

   687 		 */

   688 #ifdef COUNT_ALLOCS

   689 		--inst->ob_type->tp_frees;

   690 		--inst->ob_type->tp_allocs;

   691 #endif

   692 	}

   693 }

   694 

   695 static PyObject *

   696 instance_getattr1(register PyInstanceObject *inst, PyObject *name)

   697 {

   698 	register PyObject *v;

   699 	register char *sname = PyString_AsString(name);

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

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

   702 			if (PyEval_GetRestricted()) {

   703 				PyErr_SetString(PyExc_RuntimeError,

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

   705 				return NULL;

   706 			}

   707 			Py_INCREF(inst->in_dict);

   708 			return inst->in_dict;

   709 		}

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

   711 			Py_INCREF(inst->in_class);

   712 			return (PyObject *)inst->in_class;

   713 		}

   714 	}

   715 	v = instance_getattr2(inst, name);

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

   717 		PyErr_Format(PyExc_AttributeError,

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

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

   720 	}

   721 	return v;

   722 }

   723 

   724 static PyObject *

   725 instance_getattr2(register PyInstanceObject *inst, PyObject *name)

   726 {

   727 	register PyObject *v;

   728 	PyClassObject *klass;

   729 	descrgetfunc f;

   730 

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

   732 	if (v != NULL) {

   733 		Py_INCREF(v);

   734 		return v;

   735 	}

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

   737 	if (v != NULL) {

   738 		Py_INCREF(v);

   739 		f = TP_DESCR_GET(v->ob_type);

   740 		if (f != NULL) {

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

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

   743 			Py_DECREF(v);

   744 			v = w;

   745 		}

   746 	}

   747 	return v;

   748 }

   749 

   750 static PyObject *

   751 instance_getattr(register PyInstanceObject *inst, PyObject *name)

   752 {

   753 	register PyObject *func, *res;

   754 	res = instance_getattr1(inst, name);

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

   756 		PyObject *args;

   757 		if (!PyErr_ExceptionMatches(PyExc_AttributeError))

   758 			return NULL;

   759 		PyErr_Clear();

   760 		args = PyTuple_Pack(2, inst, name);

   761 		if (args == NULL)

   762 			return NULL;

   763 		res = PyEval_CallObject(func, args);

   764 		Py_DECREF(args);

   765 	}

   766 	return res;

   767 }

   768 

   769 /* See classobject.h comments:  this only does dict lookups, and is always

   770  * safe to call.

   771  */

   772 PyObject *

   773 _PyInstance_Lookup(PyObject *pinst, PyObject *name)

   774 {

   775 	PyObject *v;

   776 	PyClassObject *klass;

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

   778 

   779 	assert(PyInstance_Check(pinst));

   780 	inst = (PyInstanceObject *)pinst;

   781 

   782 	assert(PyString_Check(name));

   783 

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

   785 	if (v == NULL)

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

   787 	return v;

   788 }

   789 

   790 static int

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

   792 {

   793 	if (v == NULL) {

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

   795 		if (rv < 0)

   796 			PyErr_Format(PyExc_AttributeError,

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

   798 				     PyString_AS_STRING(inst->in_class->cl_name),

   799 				     PyString_AS_STRING(name));

   800 		return rv;

   801 	}

   802 	else

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

   804 }

   805 

   806 static int

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

   808 {

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

   810 	char *sname = PyString_AsString(name);

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

   812 		Py_ssize_t n = PyString_Size(name);

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

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

   815 				if (PyEval_GetRestricted()) {

   816 					PyErr_SetString(PyExc_RuntimeError,

   817 				 "__dict__ not accessible in restricted mode");

   818 					return -1;

   819 				}

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

   821 				    PyErr_SetString(PyExc_TypeError,

   822 				       "__dict__ must be set to a dictionary");

   823 				    return -1;

   824 				}

   825 				tmp = inst->in_dict;

   826 				Py_INCREF(v);

   827 				inst->in_dict = v;

   828 				Py_DECREF(tmp);

   829 				return 0;

   830 			}

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

   832 				if (PyEval_GetRestricted()) {

   833 					PyErr_SetString(PyExc_RuntimeError,

   834 				"__class__ not accessible in restricted mode");

   835 					return -1;

   836 				}

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

   838 					PyErr_SetString(PyExc_TypeError,

   839 					   "__class__ must be set to a class");

   840 					return -1;

   841 				}

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

   843 				Py_INCREF(v);

   844 				inst->in_class = (PyClassObject *)v;

   845 				Py_DECREF(tmp);

   846 				return 0;

   847 			}

   848 		}

   849 	}

   850 	if (v == NULL)

   851 		func = inst->in_class->cl_delattr;

   852 	else

   853 		func = inst->in_class->cl_setattr;

   854 	if (func == NULL)

   855 		return instance_setattr1(inst, name, v);

   856 	if (v == NULL)

   857 		args = PyTuple_Pack(2, inst, name);

   858 	else

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

   860 	if (args == NULL)

   861 		return -1;

   862 	res = PyEval_CallObject(func, args);

   863 	Py_DECREF(args);

   864 	if (res == NULL)

   865 		return -1;

   866 	Py_DECREF(res);

   867 	return 0;

   868 }

   869 

   870 static PyObject *

   871 instance_repr(PyInstanceObject *inst)

   872 {

   873 	PyObject *func;

   874 	PyObject *res;

   875 	static PyObject *reprstr;

   876 

   877 	if (reprstr == NULL) {

   878 		reprstr = PyString_InternFromString("__repr__");

   879 		if (reprstr == NULL)

   880 			return NULL;

   881 	}

   882 	func = instance_getattr(inst, reprstr);

   883 	if (func == NULL) {

   884 		PyObject *classname, *mod;

   885 		char *cname;

   886 		if (!PyErr_ExceptionMatches(PyExc_AttributeError))

   887 			return NULL;

   888 		PyErr_Clear();

   889 		classname = inst->in_class->cl_name;

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

   891 					   "__module__");

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

   893 			cname = PyString_AsString(classname);

   894 		else

   895 			cname = "?";

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

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

   898 						   cname, inst);

   899 		else

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

   901 						   PyString_AsString(mod),

   902 						   cname, inst);

   903 	}

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

   905 	Py_DECREF(func);

   906 	return res;

   907 }

   908 

   909 static PyObject *

   910 instance_str(PyInstanceObject *inst)

   911 {

   912 	PyObject *func;

   913 	PyObject *res;

   914 	static PyObject *strstr;

   915 

   916 	if (strstr == NULL) {

   917 		strstr = PyString_InternFromString("__str__");

   918 		if (strstr == NULL)

   919 			return NULL;

   920 	}

   921 	func = instance_getattr(inst, strstr);

   922 	if (func == NULL) {

   923 		if (!PyErr_ExceptionMatches(PyExc_AttributeError))

   924 			return NULL;

   925 		PyErr_Clear();

   926 		return instance_repr(inst);

   927 	}

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

   929 	Py_DECREF(func);

   930 	return res;

   931 }

   932 

   933 static long

   934 instance_hash(PyInstanceObject *inst)

   935 {

   936 	PyObject *func;

   937 	PyObject *res;

   938 	long outcome;

   939 	static PyObject *hashstr, *eqstr, *cmpstr;

   940 

   941 	if (hashstr == NULL) {

   942 		hashstr = PyString_InternFromString("__hash__");

   943 		if (hashstr == NULL)

   944 			return -1;

   945 	}

   946 	func = instance_getattr(inst, hashstr);

   947 	if (func == NULL) {

   948 		if (!PyErr_ExceptionMatches(PyExc_AttributeError))

   949 			return -1;

   950 		PyErr_Clear();

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

   952 		   address.  If an __eq__ or __cmp__ method exists, there must

   953 		   be a __hash__. */

   954 		if (eqstr == NULL) {

   955 			eqstr = PyString_InternFromString("__eq__");

   956 			if (eqstr == NULL)

   957 				return -1;

   958 		}

   959 		func = instance_getattr(inst, eqstr);

   960 		if (func == NULL) {

   961 			if (!PyErr_ExceptionMatches(PyExc_AttributeError))

   962 				return -1;

   963 			PyErr_Clear();

   964 			if (cmpstr == NULL) {

   965 				cmpstr = PyString_InternFromString("__cmp__");

   966 				if (cmpstr == NULL)

   967 					return -1;

   968 			}

   969 			func = instance_getattr(inst, cmpstr);

   970 			if (func == NULL) {

   971 				if (!PyErr_ExceptionMatches(

   972 					PyExc_AttributeError))

   973 					return -1;

   974 				PyErr_Clear();

   975 				return _Py_HashPointer(inst);

   976 			}

   977 		}

   978 		Py_XDECREF(func);

   979 		PyErr_SetString(PyExc_TypeError, "unhashable instance");

   980 		return -1;

   981 	}

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

   983 	Py_DECREF(func);

   984 	if (res == NULL)

   985 		return -1;

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

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

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

   989 	else {

   990 		PyErr_SetString(PyExc_TypeError,

   991 				"__hash__() should return an int");

   992 		outcome = -1;

   993 	}

   994 	Py_DECREF(res);

   995 	return outcome;

   996 }

   997 

   998 static int

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

  1000 {

  1001 	Py_VISIT(o->in_class);

  1002 	Py_VISIT(o->in_dict);

  1003 	return 0;

  1004 }

  1005 

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

  1007 static PyObject *iterstr, *nextstr;

  1008 

  1009 static Py_ssize_t

  1010 instance_length(PyInstanceObject *inst)

  1011 {

  1012 	PyObject *func;

  1013 	PyObject *res;

  1014 	Py_ssize_t outcome;

  1015 

  1016 	if (lenstr == NULL) {

  1017 		lenstr = PyString_InternFromString("__len__");

  1018 		if (lenstr == NULL)

  1019 			return -1;

  1020 	}

  1021 	func = instance_getattr(inst, lenstr);

  1022 	if (func == NULL)

  1023 		return -1;

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

  1025 	Py_DECREF(func);

  1026 	if (res == NULL)

  1027 		return -1;

  1028 	if (PyInt_Check(res)) {

  1029 		outcome = PyInt_AsSsize_t(res);

  1030 		if (outcome == -1 && PyErr_Occurred()) {

  1031 			Py_DECREF(res);

  1032 			return -1;

  1033 		}

  1034 #if SIZEOF_SIZE_T < SIZEOF_INT

  1035 		/* Overflow check -- range of PyInt is more than C int */

  1036 		if (outcome != (int)outcome) {

  1037 			PyErr_SetString(PyExc_OverflowError,

  1038 			 "__len__() should return 0 <= outcome < 2**31");

  1039 			outcome = -1;

  1040 		}

  1041 		else

  1042 #endif

  1043 		if (outcome < 0) {

  1044 			PyErr_SetString(PyExc_ValueError,

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

  1046 			outcome = -1;

  1047 		}

  1048 	}

  1049 	else {

  1050 		PyErr_SetString(PyExc_TypeError,

  1051 				"__len__() should return an int");

  1052 		outcome = -1;

  1053 	}

  1054 	Py_DECREF(res);

  1055 	return outcome;

  1056 }

  1057 

  1058 static PyObject *

  1059 instance_subscript(PyInstanceObject *inst, PyObject *key)

  1060 {

  1061 	PyObject *func;

  1062 	PyObject *arg;

  1063 	PyObject *res;

  1064 

  1065 	if (getitemstr == NULL) {

  1066 		getitemstr = PyString_InternFromString("__getitem__");

  1067 		if (getitemstr == NULL)

  1068 			return NULL;

  1069 	}

  1070 	func = instance_getattr(inst, getitemstr);

  1071 	if (func == NULL)

  1072 		return NULL;

  1073 	arg = PyTuple_Pack(1, key);

  1074 	if (arg == NULL) {

  1075 		Py_DECREF(func);

  1076 		return NULL;

  1077 	}

  1078 	res = PyEval_CallObject(func, arg);

  1079 	Py_DECREF(func);

  1080 	Py_DECREF(arg);

  1081 	return res;

  1082 }

  1083 

  1084 static int

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

  1086 {

  1087 	PyObject *func;

  1088 	PyObject *arg;

  1089 	PyObject *res;

  1090 

  1091 	if (value == NULL) {

  1092 		if (delitemstr == NULL) {

  1093 			delitemstr = PyString_InternFromString("__delitem__");

  1094 			if (delitemstr == NULL)

  1095 				return -1;

  1096 		}

  1097 		func = instance_getattr(inst, delitemstr);

  1098 	}

  1099 	else {

  1100 		if (setitemstr == NULL) {

  1101 			setitemstr = PyString_InternFromString("__setitem__");

  1102 			if (setitemstr == NULL)

  1103 				return -1;

  1104 		}

  1105 		func = instance_getattr(inst, setitemstr);

  1106 	}

  1107 	if (func == NULL)

  1108 		return -1;

  1109 	if (value == NULL)

  1110 		arg = PyTuple_Pack(1, key);

  1111 	else

  1112 		arg = PyTuple_Pack(2, key, value);

  1113 	if (arg == NULL) {

  1114 		Py_DECREF(func);

  1115 		return -1;

  1116 	}

  1117 	res = PyEval_CallObject(func, arg);

  1118 	Py_DECREF(func);

  1119 	Py_DECREF(arg);

  1120 	if (res == NULL)

  1121 		return -1;

  1122 	Py_DECREF(res);

  1123 	return 0;

  1124 }

  1125 

  1126 static PyMappingMethods instance_as_mapping = {

  1127 	(lenfunc)instance_length,		/* mp_length */

  1128 	(binaryfunc)instance_subscript,		/* mp_subscript */

  1129 	(objobjargproc)instance_ass_subscript,	/* mp_ass_subscript */

  1130 };

  1131 

  1132 static PyObject *

  1133 instance_item(PyInstanceObject *inst, Py_ssize_t i)

  1134 {

  1135 	PyObject *func, *res;