?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version number to 2.4.2 to pick up the latest minor bug fixes.
[python/dscho.git] / Objects / classobject.c
blobf698cc323df70711b4b7865a12320f69a724fa71
1
2 /* Class object implementation */
3
4 #include "Python.h"
5 #include "structmember.h"
6
7 #define TP_DESCR_GET(t) \
8 (PyType_HasFeature(t, Py_TPFLAGS_HAVE_CLASS) ? (t)->tp_descr_get : NULL)
9
10
11 /* Forward */
12 static PyObject *class_lookup(PyClassObject *, PyObject *,
13 PyClassObject **);
14 static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);
15 static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);
16
17 static PyObject *getattrstr, *setattrstr, *delattrstr;
18
19
20 PyObject *
21 PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)
22 /* bases is NULL or tuple of classobjects! */
23 {
24 PyClassObject *op, *dummy;
25 static PyObject *docstr, *modstr, *namestr;
26 if (docstr == NULL) {
27 docstr= PyString_InternFromString("__doc__");
28 if (docstr == NULL)
29 return NULL;
30 }
31 if (modstr == NULL) {
32 modstr= PyString_InternFromString("__module__");
33 if (modstr == NULL)
34 return NULL;
35 }
36 if (namestr == NULL) {
37 namestr= PyString_InternFromString("__name__");
38 if (namestr == NULL)
39 return NULL;
40 }
41 if (name == NULL || !PyString_Check(name)) {
42 PyErr_SetString(PyExc_TypeError,
43 "PyClass_New: name must be a string");
44 return NULL;
45 }
46 if (dict == NULL || !PyDict_Check(dict)) {
47 PyErr_SetString(PyExc_TypeError,
48 "PyClass_New: dict must be a dictionary");
49 return NULL;
50 }
51 if (PyDict_GetItem(dict, docstr) == NULL) {
52 if (PyDict_SetItem(dict, docstr, Py_None) < 0)
53 return NULL;
54 }
55 if (PyDict_GetItem(dict, modstr) == NULL) {
56 PyObject *globals = PyEval_GetGlobals();
57 if (globals != NULL) {
58 PyObject *modname = PyDict_GetItem(globals, namestr);
59 if (modname != NULL) {
60 if (PyDict_SetItem(dict, modstr, modname) < 0)
61 return NULL;
62 }
63 }
64 }
65 if (bases == NULL) {
66 bases = PyTuple_New(0);
67 if (bases == NULL)
68 return NULL;
69 }
70 else {
71 int i, n;
72 PyObject *base;
73 if (!PyTuple_Check(bases)) {
74 PyErr_SetString(PyExc_TypeError,
75 "PyClass_New: bases must be a tuple");
76 return NULL;
77 }
78 n = PyTuple_Size(bases);
79 for (i = 0; i < n; i++) {
80 base = PyTuple_GET_ITEM(bases, i);
81 if (!PyClass_Check(base)) {
82 if (PyCallable_Check(
83 (PyObject *) base->ob_type))
84 return PyObject_CallFunction(
85 (PyObject *) base->ob_type,
86 "OOO",
87 name,
88 bases,
89 dict);
90 PyErr_SetString(PyExc_TypeError,
91 "PyClass_New: base must be a class");
92 return NULL;
93 }
94 }
95 Py_INCREF(bases);
96 }
97 op = PyObject_GC_New(PyClassObject, &PyClass_Type);
98 if (op == NULL) {
99 Py_DECREF(bases);
100 return NULL;
101 }
102 op->cl_bases = bases;
103 Py_INCREF(dict);
104 op->cl_dict = dict;
105 Py_XINCREF(name);
106 op->cl_name = name;
107 if (getattrstr == NULL) {
108 getattrstr = PyString_InternFromString("__getattr__");
109 setattrstr = PyString_InternFromString("__setattr__");
110 delattrstr = PyString_InternFromString("__delattr__");
111 }
112 op->cl_getattr = class_lookup(op, getattrstr, &dummy);
113 op->cl_setattr = class_lookup(op, setattrstr, &dummy);
114 op->cl_delattr = class_lookup(op, delattrstr, &dummy);
115 Py_XINCREF(op->cl_getattr);
116 Py_XINCREF(op->cl_setattr);
117 Py_XINCREF(op->cl_delattr);
118 _PyObject_GC_TRACK(op);
119 return (PyObject *) op;
120 }
121
122 PyObject *
123 PyMethod_Function(PyObject *im)
124 {
125 if (!PyMethod_Check(im)) {
126 PyErr_BadInternalCall();
127 return NULL;
128 }
129 return ((PyMethodObject *)im)->im_func;
130 }
131
132 PyObject *
133 PyMethod_Self(PyObject *im)
134 {
135 if (!PyMethod_Check(im)) {
136 PyErr_BadInternalCall();
137 return NULL;
138 }
139 return ((PyMethodObject *)im)->im_self;
140 }
141
142 PyObject *
143 PyMethod_Class(PyObject *im)
144 {
145 if (!PyMethod_Check(im)) {
146 PyErr_BadInternalCall();
147 return NULL;
148 }
149 return ((PyMethodObject *)im)->im_class;
150 }
151
152 PyDoc_STRVAR(class_doc,
153 "classobj(name, bases, dict)\n\
154 \n\
155 Create a class object. The name must be a string; the second argument\n\
156 a tuple of classes, and the third a dictionary.");
157
158 static PyObject *
159 class_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
160 {
161 PyObject *name, *bases, *dict;
162 static char *kwlist[] = {"name", "bases", "dict", 0};
163
164 if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,
165 &name, &bases, &dict))
166 return NULL;
167 return PyClass_New(bases, dict, name);
168 }
169
170 /* Class methods */
171
172 static void
173 class_dealloc(PyClassObject *op)
174 {
175 _PyObject_GC_UNTRACK(op);
176 Py_DECREF(op->cl_bases);
177 Py_DECREF(op->cl_dict);
178 Py_XDECREF(op->cl_name);
179 Py_XDECREF(op->cl_getattr);
180 Py_XDECREF(op->cl_setattr);
181 Py_XDECREF(op->cl_delattr);
182 PyObject_GC_Del(op);
183 }
184
185 static PyObject *
186 class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)
187 {
188 int i, n;
189 PyObject *value = PyDict_GetItem(cp->cl_dict, name);
190 if (value != NULL) {
191 *pclass = cp;
192 return value;
193 }
194 n = PyTuple_Size(cp->cl_bases);
195 for (i = 0; i < n; i++) {
196 /* XXX What if one of the bases is not a class? */
197 PyObject *v = class_lookup(
198 (PyClassObject *)
199 PyTuple_GetItem(cp->cl_bases, i), name, pclass);
200 if (v != NULL)
201 return v;
202 }
203 return NULL;
204 }
205
206 static PyObject *
207 class_getattr(register PyClassObject *op, PyObject *name)
208 {
209 register PyObject *v;
210 register char *sname = PyString_AsString(name);
211 PyClassObject *class;
212 descrgetfunc f;
213
214 if (sname[0] == '_' && sname[1] == '_') {
215 if (strcmp(sname, "__dict__") == 0) {
216 if (PyEval_GetRestricted()) {
217 PyErr_SetString(PyExc_RuntimeError,
218 "class.__dict__ not accessible in restricted mode");
219 return NULL;
220 }
221 Py_INCREF(op->cl_dict);
222 return op->cl_dict;
223 }
224 if (strcmp(sname, "__bases__") == 0) {
225 Py_INCREF(op->cl_bases);
226 return op->cl_bases;
227 }
228 if (strcmp(sname, "__name__") == 0) {
229 if (op->cl_name == NULL)
230 v = Py_None;
231 else
232 v = op->cl_name;
233 Py_INCREF(v);
234 return v;
235 }
236 }
237 v = class_lookup(op, name, &class);
238 if (v == NULL) {
239 PyErr_Format(PyExc_AttributeError,
240 "class %.50s has no attribute '%.400s'",
241 PyString_AS_STRING(op->cl_name), sname);
242 return NULL;
243 }
244 f = TP_DESCR_GET(v->ob_type);
245 if (f == NULL)
246 Py_INCREF(v);
247 else
248 v = f(v, (PyObject *)NULL, (PyObject *)op);
249 return v;
250 }
251
252 static void
253 set_slot(PyObject **slot, PyObject *v)
254 {
255 PyObject *temp = *slot;
256 Py_XINCREF(v);
257 *slot = v;
258 Py_XDECREF(temp);
259 }
260
261 static void
262 set_attr_slots(PyClassObject *c)
263 {
264 PyClassObject *dummy;
265
266 set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
267 set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
268 set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
269 }
270
271 static char *
272 set_dict(PyClassObject *c, PyObject *v)
273 {
274 if (v == NULL || !PyDict_Check(v))
275 return "__dict__ must be a dictionary object";
276 set_slot(&c->cl_dict, v);
277 set_attr_slots(c);
278 return "";
279 }
280
281 static char *
282 set_bases(PyClassObject *c, PyObject *v)
283 {
284 int i, n;
285
286 if (v == NULL || !PyTuple_Check(v))
287 return "__bases__ must be a tuple object";
288 n = PyTuple_Size(v);
289 for (i = 0; i < n; i++) {
290 PyObject *x = PyTuple_GET_ITEM(v, i);
291 if (!PyClass_Check(x))
292 return "__bases__ items must be classes";
293 if (PyClass_IsSubclass(x, (PyObject *)c))
294 return "a __bases__ item causes an inheritance cycle";
295 }
296 set_slot(&c->cl_bases, v);
297 set_attr_slots(c);
298 return "";
299 }
300
301 static char *
302 set_name(PyClassObject *c, PyObject *v)
303 {
304 if (v == NULL || !PyString_Check(v))
305 return "__name__ must be a string object";
306 if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
307 return "__name__ must not contain null bytes";
308 set_slot(&c->cl_name, v);
309 return "";
310 }
311
312 static int
313 class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
314 {
315 char *sname;
316 if (PyEval_GetRestricted()) {
317 PyErr_SetString(PyExc_RuntimeError,
318 "classes are read-only in restricted mode");
319 return -1;
320 }
321 sname = PyString_AsString(name);
322 if (sname[0] == '_' && sname[1] == '_') {
323 int n = PyString_Size(name);
324 if (sname[n-1] == '_' && sname[n-2] == '_') {
325 char *err = NULL;
326 if (strcmp(sname, "__dict__") == 0)
327 err = set_dict(op, v);
328 else if (strcmp(sname, "__bases__") == 0)
329 err = set_bases(op, v);
330 else if (strcmp(sname, "__name__") == 0)
331 err = set_name(op, v);
332 else if (strcmp(sname, "__getattr__") == 0)
333 set_slot(&op->cl_getattr, v);
334 else if (strcmp(sname, "__setattr__") == 0)
335 set_slot(&op->cl_setattr, v);
336 else if (strcmp(sname, "__delattr__") == 0)
337 set_slot(&op->cl_delattr, v);
338 /* For the last three, we fall through to update the
339 dictionary as well. */
340 if (err != NULL) {
341 if (*err == '\0')
342 return 0;
343 PyErr_SetString(PyExc_TypeError, err);
344 return -1;
345 }
346 }
347 }
348 if (v == NULL) {
349 int rv = PyDict_DelItem(op->cl_dict, name);
350 if (rv < 0)
351 PyErr_Format(PyExc_AttributeError,
352 "class %.50s has no attribute '%.400s'",
353 PyString_AS_STRING(op->cl_name), sname);
354 return rv;
355 }
356 else
357 return PyDict_SetItem(op->cl_dict, name, v);
358 }
359
360 static PyObject *
361 class_repr(PyClassObject *op)
362 {
363 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
364 char *name;
365 if (op->cl_name == NULL || !PyString_Check(op->cl_name))
366 name = "?";
367 else
368 name = PyString_AsString(op->cl_name);
369 if (mod == NULL || !PyString_Check(mod))
370 return PyString_FromFormat("<class ?.%s at %p>", name, op);
371 else
372 return PyString_FromFormat("<class %s.%s at %p>",
373 PyString_AsString(mod),
374 name, op);
375 }
376
377 static PyObject *
378 class_str(PyClassObject *op)
379 {
380 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
381 PyObject *name = op->cl_name;
382 PyObject *res;
383 int m, n;
384
385 if (name == NULL || !PyString_Check(name))
386 return class_repr(op);
387 if (mod == NULL || !PyString_Check(mod)) {
388 Py_INCREF(name);
389 return name;
390 }
391 m = PyString_Size(mod);
392 n = PyString_Size(name);
393 res = PyString_FromStringAndSize((char *)NULL, m+1+n);
394 if (res != NULL) {
395 char *s = PyString_AsString(res);
396 memcpy(s, PyString_AsString(mod), m);
397 s += m;
398 *s++ = '.';
399 memcpy(s, PyString_AsString(name), n);
400 }
401 return res;
402 }
403
404 static int
405 class_traverse(PyClassObject *o, visitproc visit, void *arg)
406 {
407 int err;
408 if (o->cl_bases) {
409 err = visit(o->cl_bases, arg);
410 if (err)
411 return err;
412 }
413 if (o->cl_dict) {
414 err = visit(o->cl_dict, arg);
415 if (err)
416 return err;
417 }
418 if (o->cl_name) {
419 err = visit(o->cl_name, arg);
420 if (err)
421 return err;
422 }
423 if (o->cl_getattr) {
424 err = visit(o->cl_getattr, arg);
425 if (err)
426 return err;
427 }
428 if (o->cl_setattr) {
429 err = visit(o->cl_setattr, arg);
430 if (err)
431 return err;
432 }
433 if (o->cl_delattr) {
434 err = visit(o->cl_delattr, arg);
435 if (err)
436 return err;
437 }
438 return 0;
439 }
440
441 PyTypeObject PyClass_Type = {
442 PyObject_HEAD_INIT(&PyType_Type)
443 0,
444 "classobj",
445 sizeof(PyClassObject),
446 0,
447 (destructor)class_dealloc, /* tp_dealloc */
448 0, /* tp_print */
449 0, /* tp_getattr */
450 0, /* tp_setattr */
451 0, /* tp_compare */
452 (reprfunc)class_repr, /* tp_repr */
453 0, /* tp_as_number */
454 0, /* tp_as_sequence */
455 0, /* tp_as_mapping */
456 0, /* tp_hash */
457 PyInstance_New, /* tp_call */
458 (reprfunc)class_str, /* tp_str */
459 (getattrofunc)class_getattr, /* tp_getattro */
460 (setattrofunc)class_setattr, /* tp_setattro */
461 0, /* tp_as_buffer */
462 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
463 class_doc, /* tp_doc */
464 (traverseproc)class_traverse, /* tp_traverse */
465 0, /* tp_clear */
466 0, /* tp_richcompare */
467 0, /* tp_weaklistoffset */
468 0, /* tp_iter */
469 0, /* tp_iternext */
470 0, /* tp_methods */
471 0, /* tp_members */
472 0, /* tp_getset */
473 0, /* tp_base */
474 0, /* tp_dict */
475 0, /* tp_descr_get */
476 0, /* tp_descr_set */
477 0, /* tp_dictoffset */
478 0, /* tp_init */
479 0, /* tp_alloc */
480 class_new, /* tp_new */
481 };
482
483 int
484 PyClass_IsSubclass(PyObject *class, PyObject *base)
485 {
486 int i, n;
487 PyClassObject *cp;
488 if (class == base)
489 return 1;
490 if (class == NULL || !PyClass_Check(class))
491 return 0;
492 cp = (PyClassObject *)class;
493 n = PyTuple_Size(cp->cl_bases);
494 for (i = 0; i < n; i++) {
495 if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
496 return 1;
497 }
498 return 0;
499 }
500
501
502 /* Instance objects */
503
504 PyObject *
505 PyInstance_NewRaw(PyObject *klass, PyObject *dict)
506 {
507 PyInstanceObject *inst;
508
509 if (!PyClass_Check(klass)) {
510 PyErr_BadInternalCall();
511 return NULL;
512 }
513 if (dict == NULL) {
514 dict = PyDict_New();
515 if (dict == NULL)
516 return NULL;
517 }
518 else {
519 if (!PyDict_Check(dict)) {
520 PyErr_BadInternalCall();
521 return NULL;
522 }
523 Py_INCREF(dict);
524 }
525 inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);
526 if (inst == NULL) {
527 Py_DECREF(dict);
528 return NULL;
529 }
530 inst->in_weakreflist = NULL;
531 Py_INCREF(klass);
532 inst->in_class = (PyClassObject *)klass;
533 inst->in_dict = dict;
534 _PyObject_GC_TRACK(inst);
535 return (PyObject *)inst;
536 }
537
538 PyObject *
539 PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)
540 {
541 register PyInstanceObject *inst;
542 PyObject *init;
543 static PyObject *initstr;
544
545 inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
546 if (inst == NULL)
547 return NULL;
548 if (initstr == NULL)
549 initstr = PyString_InternFromString("__init__");
550 init = instance_getattr2(inst, initstr);
551 if (init == NULL) {
552 if ((arg != NULL && (!PyTuple_Check(arg) ||
553 PyTuple_Size(arg) != 0))
554 || (kw != NULL && (!PyDict_Check(kw) ||
555 PyDict_Size(kw) != 0))) {
556 PyErr_SetString(PyExc_TypeError,
557 "this constructor takes no arguments");
558 Py_DECREF(inst);
559 inst = NULL;
560 }
561 }
562 else {
563 PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
564 Py_DECREF(init);
565 if (res == NULL) {
566 Py_DECREF(inst);
567 inst = NULL;
568 }
569 else {
570 if (res != Py_None) {
571 PyErr_SetString(PyExc_TypeError,
572 "__init__() should return None");
573 Py_DECREF(inst);
574 inst = NULL;
575 }
576 Py_DECREF(res);
577 }
578 }
579 return (PyObject *)inst;
580 }
581
582 /* Instance methods */
583
584 PyDoc_STRVAR(instance_doc,
585 "instance(class[, dict])\n\
586 \n\
587 Create an instance without calling its __init__() method.\n\
588 The class must be a classic class.\n\
589 If present, dict must be a dictionary or None.");
590
591 static PyObject *
592 instance_new(PyTypeObject* type, PyObject* args, PyObject *kw)
593 {
594 PyObject *klass;
595 PyObject *dict = Py_None;
596
597 if (!PyArg_ParseTuple(args, "O!|O:instance",
598 &PyClass_Type, &klass, &dict))
599 return NULL;
600
601 if (dict == Py_None)
602 dict = NULL;
603 else if (!PyDict_Check(dict)) {
604 PyErr_SetString(PyExc_TypeError,
605 "instance() second arg must be dictionary or None");
606 return NULL;
607 }
608 return PyInstance_NewRaw(klass, dict);
609 }
610
611
612 static void
613 instance_dealloc(register PyInstanceObject *inst)
614 {
615 PyObject *error_type, *error_value, *error_traceback;
616 PyObject *del;
617 static PyObject *delstr;
618
619 _PyObject_GC_UNTRACK(inst);
620 if (inst->in_weakreflist != NULL)
621 PyObject_ClearWeakRefs((PyObject *) inst);
622
623 /* Temporarily resurrect the object. */
624 assert(inst->ob_type == &PyInstance_Type);
625 assert(inst->ob_refcnt == 0);
626 inst->ob_refcnt = 1;
627
628 /* Save the current exception, if any. */
629 PyErr_Fetch(&error_type, &error_value, &error_traceback);
630 /* Execute __del__ method, if any. */
631 if (delstr == NULL)
632 delstr = PyString_InternFromString("__del__");
633 if ((del = instance_getattr2(inst, delstr)) != NULL) {
634 PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
635 if (res == NULL)
636 PyErr_WriteUnraisable(del);
637 else
638 Py_DECREF(res);
639 Py_DECREF(del);
640 }
641 /* Restore the saved exception. */
642 PyErr_Restore(error_type, error_value, error_traceback);
643
644 /* Undo the temporary resurrection; can't use DECREF here, it would
645 * cause a recursive call.
646 */
647 assert(inst->ob_refcnt > 0);
648 if (--inst->ob_refcnt == 0) {
649 Py_DECREF(inst->in_class);
650 Py_XDECREF(inst->in_dict);
651 PyObject_GC_Del(inst);
652 }
653 else {
654 int refcnt = inst->ob_refcnt;
655 /* __del__ resurrected it! Make it look like the original
656 * Py_DECREF never happened.
657 */
658 _Py_NewReference((PyObject *)inst);
659 inst->ob_refcnt = refcnt;
660 _PyObject_GC_TRACK(inst);
661 /* If Py_REF_DEBUG, the original decref dropped _Py_RefTotal,
662 * but _Py_NewReference bumped it again, so that's a wash.
663 * If Py_TRACE_REFS, _Py_NewReference re-added self to the
664 * object chain, so no more to do there either.
665 * If COUNT_ALLOCS, the original decref bumped tp_frees, and
666 * _Py_NewReference bumped tp_allocs: both of those need to
667 * be undone.
668 */
669 #ifdef COUNT_ALLOCS
670 --inst->ob_type->tp_frees;
671 --inst->ob_type->tp_allocs;
672 #endif
673 }
674 }
675
676 static PyObject *
677 instance_getattr1(register PyInstanceObject *inst, PyObject *name)
678 {
679 register PyObject *v;
680 register char *sname = PyString_AsString(name);
681 if (sname[0] == '_' && sname[1] == '_') {
682 if (strcmp(sname, "__dict__") == 0) {
683 if (PyEval_GetRestricted()) {
684 PyErr_SetString(PyExc_RuntimeError,
685 "instance.__dict__ not accessible in restricted mode");
686 return NULL;
687 }
688 Py_INCREF(inst->in_dict);
689 return inst->in_dict;
690 }
691 if (strcmp(sname, "__class__") == 0) {
692 Py_INCREF(inst->in_class);
693 return (PyObject *)inst->in_class;
694 }
695 }
696 v = instance_getattr2(inst, name);
697 if (v == NULL) {
698 PyErr_Format(PyExc_AttributeError,
699 "%.50s instance has no attribute '%.400s'",
700 PyString_AS_STRING(inst->in_class->cl_name), sname);
701 }
702 return v;
703 }
704
705 static PyObject *
706 instance_getattr2(register PyInstanceObject *inst, PyObject *name)
707 {
708 register PyObject *v;
709 PyClassObject *class;
710 descrgetfunc f;
711
712 v = PyDict_GetItem(inst->in_dict, name);
713 if (v != NULL) {
714 Py_INCREF(v);
715 return v;
716 }
717 v = class_lookup(inst->in_class, name, &class);
718 if (v != NULL) {
719 Py_INCREF(v);
720 f = TP_DESCR_GET(v->ob_type);
721 if (f != NULL) {
722 PyObject *w = f(v, (PyObject *)inst,
723 (PyObject *)(inst->in_class));
724 Py_DECREF(v);
725 v = w;
726 }
727 }
728 return v;
729 }
730
731 static PyObject *
732 instance_getattr(register PyInstanceObject *inst, PyObject *name)
733 {
734 register PyObject *func, *res;
735 res = instance_getattr1(inst, name);
736 if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
737 PyObject *args;
738 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
739 return NULL;
740 PyErr_Clear();
741 args = Py_BuildValue("(OO)", inst, name);
742 if (args == NULL)
743 return NULL;
744 res = PyEval_CallObject(func, args);
745 Py_DECREF(args);
746 }
747 return res;
748 }
749
750 static int
751 instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)
752 {
753 if (v == NULL) {
754 int rv = PyDict_DelItem(inst->in_dict, name);
755 if (rv < 0)
756 PyErr_Format(PyExc_AttributeError,
757 "%.50s instance has no attribute '%.400s'",
758 PyString_AS_STRING(inst->in_class->cl_name),
759 PyString_AS_STRING(name));
760 return rv;
761 }
762 else
763 return PyDict_SetItem(inst->in_dict, name, v);
764 }
765
766 static int
767 instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
768 {
769 PyObject *func, *args, *res, *tmp;
770 char *sname = PyString_AsString(name);
771 if (sname[0] == '_' && sname[1] == '_') {
772 int n = PyString_Size(name);
773 if (sname[n-1] == '_' && sname[n-2] == '_') {
774 if (strcmp(sname, "__dict__") == 0) {
775 if (PyEval_GetRestricted()) {
776 PyErr_SetString(PyExc_RuntimeError,
777 "__dict__ not accessible in restricted mode");
778 return -1;
779 }
780 if (v == NULL || !PyDict_Check(v)) {
781 PyErr_SetString(PyExc_TypeError,
782 "__dict__ must be set to a dictionary");
783 return -1;
784 }
785 tmp = inst->in_dict;
786 Py_INCREF(v);
787 inst->in_dict = v;
788 Py_DECREF(tmp);
789 return 0;
790 }
791 if (strcmp(sname, "__class__") == 0) {
792 if (PyEval_GetRestricted()) {
793 PyErr_SetString(PyExc_RuntimeError,
794 "__class__ not accessible in restricted mode");
795 return -1;
796 }
797 if (v == NULL || !PyClass_Check(v)) {
798 PyErr_SetString(PyExc_TypeError,
799 "__class__ must be set to a class");
800 return -1;
801 }
802 tmp = (PyObject *)(inst->in_class);
803 Py_INCREF(v);
804 inst->in_class = (PyClassObject *)v;
805 Py_DECREF(tmp);
806 return 0;
807 }
808 }
809 }
810 if (v == NULL)
811 func = inst->in_class->cl_delattr;
812 else
813 func = inst->in_class->cl_setattr;
814 if (func == NULL)
815 return instance_setattr1(inst, name, v);
816 if (v == NULL)
817 args = Py_BuildValue("(OO)", inst, name);
818 else
819 args = Py_BuildValue("(OOO)", inst, name, v);
820 if (args == NULL)
821 return -1;
822 res = PyEval_CallObject(func, args);
823 Py_DECREF(args);
824 if (res == NULL)
825 return -1;
826 Py_DECREF(res);
827 return 0;
828 }
829
830 static PyObject *
831 instance_repr(PyInstanceObject *inst)
832 {
833 PyObject *func;
834 PyObject *res;
835 static PyObject *reprstr;
836
837 if (reprstr == NULL)
838 reprstr = PyString_InternFromString("__repr__");
839 func = instance_getattr(inst, reprstr);
840 if (func == NULL) {
841 PyObject *classname, *mod;
842 char *cname;
843 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
844 return NULL;
845 PyErr_Clear();
846 classname = inst->in_class->cl_name;
847 mod = PyDict_GetItemString(inst->in_class->cl_dict,
848 "__module__");
849 if (classname != NULL && PyString_Check(classname))
850 cname = PyString_AsString(classname);
851 else
852 cname = "?";
853 if (mod == NULL || !PyString_Check(mod))
854 return PyString_FromFormat("<?.%s instance at %p>",
855 cname, inst);
856 else
857 return PyString_FromFormat("<%s.%s instance at %p>",
858 PyString_AsString(mod),
859 cname, inst);
860 }
861 res = PyEval_CallObject(func, (PyObject *)NULL);
862 Py_DECREF(func);
863 return res;
864 }
865
866 static PyObject *
867 instance_str(PyInstanceObject *inst)
868 {
869 PyObject *func;
870 PyObject *res;
871 static PyObject *strstr;
872
873 if (strstr == NULL)
874 strstr = PyString_InternFromString("__str__");
875 func = instance_getattr(inst, strstr);
876 if (func == NULL) {
877 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
878 return NULL;
879 PyErr_Clear();
880 return instance_repr(inst);
881 }
882 res = PyEval_CallObject(func, (PyObject *)NULL);
883 Py_DECREF(func);
884 return res;
885 }
886
887 static long
888 instance_hash(PyInstanceObject *inst)
889 {
890 PyObject *func;
891 PyObject *res;
892 long outcome;
893 static PyObject *hashstr, *eqstr, *cmpstr;
894
895 if (hashstr == NULL)
896 hashstr = PyString_InternFromString("__hash__");
897 func = instance_getattr(inst, hashstr);
898 if (func == NULL) {
899 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
900 return -1;
901 PyErr_Clear();
902 /* If there is no __eq__ and no __cmp__ method, we hash on the
903 address. If an __eq__ or __cmp__ method exists, there must
904 be a __hash__. */
905 if (eqstr == NULL)
906 eqstr = PyString_InternFromString("__eq__");
907 func = instance_getattr(inst, eqstr);
908 if (func == NULL) {
909 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
910 return -1;
911 PyErr_Clear();
912 if (cmpstr == NULL)
913 cmpstr = PyString_InternFromString("__cmp__");
914 func = instance_getattr(inst, cmpstr);
915 if (func == NULL) {
916 if (!PyErr_ExceptionMatches(
917 PyExc_AttributeError))
918 return -1;
919 PyErr_Clear();
920 return _Py_HashPointer(inst);
921 }
922 }
923 PyErr_SetString(PyExc_TypeError, "unhashable instance");
924 return -1;
925 }
926 res = PyEval_CallObject(func, (PyObject *)NULL);
927 Py_DECREF(func);
928 if (res == NULL)
929 return -1;
930 if (PyInt_Check(res)) {
931 outcome = PyInt_AsLong(res);
932 if (outcome == -1)
933 outcome = -2;
934 }
935 else {
936 PyErr_SetString(PyExc_TypeError,
937 "__hash__() should return an int");
938 outcome = -1;
939 }
940 Py_DECREF(res);
941 return outcome;
942 }
943
944 static int
945 instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)
946 {
947 int err;
948 if (o->in_class) {
949 err = visit((PyObject *)(o->in_class), arg);
950 if (err)
951 return err;
952 }
953 if (o->in_dict) {
954 err = visit(o->in_dict, arg);
955 if (err)
956 return err;
957 }
958 return 0;
959 }
960
961 static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
962 static PyObject *iterstr, *nextstr;
963
964 static int
965 instance_length(PyInstanceObject *inst)
966 {
967 PyObject *func;
968 PyObject *res;
969 int outcome;
970
971 if (lenstr == NULL)
972 lenstr = PyString_InternFromString("__len__");
973 func = instance_getattr(inst, lenstr);
974 if (func == NULL)
975 return -1;
976 res = PyEval_CallObject(func, (PyObject *)NULL);
977 Py_DECREF(func);
978 if (res == NULL)
979 return -1;
980 if (PyInt_Check(res)) {
981 outcome = PyInt_AsLong(res);
982 if (outcome < 0)
983 PyErr_SetString(PyExc_ValueError,
984 "__len__() should return >= 0");
985 }
986 else {
987 PyErr_SetString(PyExc_TypeError,
988 "__len__() should return an int");
989 outcome = -1;
990 }
991 Py_DECREF(res);
992 return outcome;
993 }
994
995 static PyObject *
996 instance_subscript(PyInstanceObject *inst, PyObject *key)
997 {
998 PyObject *func;
999 PyObject *arg;
1000 PyObject *res;
1001
1002 if (getitemstr == NULL)
1003 getitemstr = PyString_InternFromString("__getitem__");
1004 func = instance_getattr(inst, getitemstr);
1005 if (func == NULL)
1006 return NULL;
1007 arg = Py_BuildValue("(O)", key);
1008 if (arg == NULL) {
1009 Py_DECREF(func);
1010 return NULL;
1011 }
1012 res = PyEval_CallObject(func, arg);
1013 Py_DECREF(func);
1014 Py_DECREF(arg);
1015 return res;
1016 }
1017
1018 static int
1019 instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
1020 {
1021 PyObject *func;
1022 PyObject *arg;
1023 PyObject *res;
1024
1025 if (value == NULL) {
1026 if (delitemstr == NULL)
1027 delitemstr = PyString_InternFromString("__delitem__");
1028 func = instance_getattr(inst, delitemstr);
1029 }
1030 else {
1031 if (setitemstr == NULL)
1032 setitemstr = PyString_InternFromString("__setitem__");
1033 func = instance_getattr(inst, setitemstr);
1034 }
1035 if (func == NULL)
1036 return -1;
1037 if (value == NULL)
1038 arg = Py_BuildValue("(O)", key);
1039 else
1040 arg = Py_BuildValue("(OO)", key, value);
1041 if (arg == NULL) {
1042 Py_DECREF(func);
1043 return -1;
1044 }
1045 res = PyEval_CallObject(func, arg);
1046 Py_DECREF(func);
1047 Py_DECREF(arg);
1048 if (res == NULL)
1049 return -1;
1050 Py_DECREF(res);
1051 return 0;
1052 }
1053
1054 static PyMappingMethods instance_as_mapping = {
1055 (inquiry)instance_length, /* mp_length */
1056 (binaryfunc)instance_subscript, /* mp_subscript */
1057 (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */
1058 };
1059
1060 static PyObject *
1061 instance_item(PyInstanceObject *inst, int i)
1062 {
1063 PyObject *func, *arg, *res;
1064
1065 if (getitemstr == NULL)
1066 getitemstr = PyString_InternFromString("__getitem__");
1067 func = instance_getattr(inst, getitemstr);
1068 if (func == NULL)
1069 return NULL;
1070 arg = Py_BuildValue("(i)", i);
1071 if (arg == NULL) {
1072 Py_DECREF(func);
1073 return NULL;
1074 }
1075 res = PyEval_CallObject(func, arg);
1076 Py_DECREF(func);
1077 Py_DECREF(arg);
1078 return res;
1079 }
1080
1081 static PyObject *
1082 sliceobj_from_intint(int i, int j)
1083 {
1084 PyObject *start, *end, *res;
1085
1086 start = PyInt_FromLong((long)i);
1087 if (!start)
1088 return NULL;
1089
1090 end = PyInt_FromLong((long)j);
1091 if (!end) {
1092 Py_DECREF(start);
1093 return NULL;
1094 }
1095 res = PySlice_New(start, end, NULL);
1096 Py_DECREF(start);
1097 Py_DECREF(end);
1098 return res;
1099 }
1100
1101
1102 static PyObject *
1103 instance_slice(PyInstanceObject *inst, int i, int j)
1104 {
1105 PyObject *func, *arg, *res;
1106 static PyObject *getslicestr;
1107
1108 if (getslicestr == NULL)
1109 getslicestr = PyString_InternFromString("__getslice__");
1110 func = instance_getattr(inst, getslicestr);
1111
1112 if (func == NULL) {
1113 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1114 return NULL;
1115 PyErr_Clear();
1116
1117 if (getitemstr == NULL)
1118 getitemstr = PyString_InternFromString("__getitem__");
1119 func = instance_getattr(inst, getitemstr);
1120 if (func == NULL)
1121 return NULL;
1122 arg = Py_BuildValue("(N)", sliceobj_from_intint(i, j));
1123 } else
1124 arg = Py_BuildValue("(ii)", i, j);
1125
1126 if (arg == NULL) {
1127 Py_DECREF(func);
1128 return NULL;
1129 }
1130 res = PyEval_CallObject(func, arg);
1131 Py_DECREF(func);
1132 Py_DECREF(arg);
1133 return res;
1134 }
1135
1136 static int
1137 instance_ass_item(PyInstanceObject *inst, int i, PyObject *item)
1138 {
1139 PyObject *func, *arg, *res;
1140
1141 if (item == NULL) {
1142 if (delitemstr == NULL)
1143 delitemstr = PyString_InternFromString("__delitem__");
1144 func = instance_getattr(inst, delitemstr);
1145 }
1146 else {
1147 if (setitemstr == NULL)
1148 setitemstr = PyString_InternFromString("__setitem__");
1149 func = instance_getattr(inst, setitemstr);
1150 }
1151 if (func == NULL)
1152 return -1;
1153 if (item == NULL)
1154 arg = Py_BuildValue("i", i);
1155 else
1156 arg = Py_BuildValue("(iO)", i, item);
1157 if (arg == NULL) {
1158 Py_DECREF(func);
1159 return -1;
1160 }
1161 res = PyEval_CallObject(func, arg);
1162 Py_DECREF(func);
1163 Py_DECREF(arg);
1164 if (res == NULL)
1165 return -1;
1166 Py_DECREF(res);
1167 return 0;
1168 }
1169
1170 static int
1171 instance_ass_slice(PyInstanceObject *inst, int i, int j, PyObject *value)
1172 {
1173 PyObject *func, *arg, *res;
1174 static PyObject *setslicestr, *delslicestr;
1175
1176 if (value == NULL) {
1177 if (delslicestr == NULL)
1178 delslicestr =
1179 PyString_InternFromString("__delslice__");
1180 func = instance_getattr(inst, delslicestr);
1181 if (func == NULL) {
1182 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1183 return -1;
1184 PyErr_Clear();
1185 if (delitemstr == NULL)
1186 delitemstr =
1187 PyString_InternFromString("__delitem__");
1188 func = instance_getattr(inst, delitemstr);
1189 if (func == NULL)
1190 return -1;
1191
1192 arg = Py_BuildValue("(N)",
1193 sliceobj_from_intint(i, j));
1194 } else
1195 arg = Py_BuildValue("(ii)", i, j);
1196 }
1197 else {
1198 if (setslicestr == NULL)
1199 setslicestr =
1200 PyString_InternFromString("__setslice__");
1201 func = instance_getattr(inst, setslicestr);
1202 if (func == NULL) {
1203 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1204 return -1;
1205 PyErr_Clear();
1206 if (setitemstr == NULL)
1207 setitemstr =
1208 PyString_InternFromString("__setitem__");
1209 func = instance_getattr(inst, setitemstr);
1210 if (func == NULL)
1211 return -1;
1212
1213 arg = Py_BuildValue("(NO)",
1214 sliceobj_from_intint(i, j), value);
1215 } else
1216 arg = Py_BuildValue("(iiO)", i, j, value);
1217 }
1218 if (arg == NULL) {
1219 Py_DECREF(func);
1220 return -1;
1221 }
1222 res = PyEval_CallObject(func, arg);
1223 Py_DECREF(func);
1224 Py_DECREF(arg);
1225 if (res == NULL)
1226 return -1;
1227 Py_DECREF(res);
1228 return 0;
1229 }
1230
1231 static int
1232 instance_contains(PyInstanceObject *inst, PyObject *member)
1233 {
1234 static PyObject *__contains__;
1235 PyObject *func;
1236
1237 /* Try __contains__ first.
1238 * If that can't be done, try iterator-based searching.
1239 */
1240
1241 if(__contains__ == NULL) {
1242 __contains__ = PyString_InternFromString("__contains__");
1243 if(__contains__ == NULL)
1244 return -1;
1245 }
1246 func = instance_getattr(inst, __contains__);
1247 if (func) {
1248 PyObject *res;
1249 int ret;
1250 PyObject *arg = Py_BuildValue("(O)", member);
1251 if(arg == NULL) {
1252 Py_DECREF(func);
1253 return -1;
1254 }
1255 res = PyEval_CallObject(func, arg);
1256 Py_DECREF(func);
1257 Py_DECREF(arg);
1258 if(res == NULL)
1259 return -1;
1260 ret = PyObject_IsTrue(res);
1261 Py_DECREF(res);
1262 return ret;
1263 }
1264
1265 /* Couldn't find __contains__. */
1266 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
1267 /* Assume the failure was simply due to that there is no
1268 * __contains__ attribute, and try iterating instead.
1269 */
1270 PyErr_Clear();
1271 return _PySequence_IterSearch((PyObject *)inst, member,
1272 PY_ITERSEARCH_CONTAINS);
1273 }
1274 else
1275 return -1;
1276 }
1277
1278 static PySequenceMethods
1279 instance_as_sequence = {
1280 (inquiry)instance_length, /* sq_length */
1281 0, /* sq_concat */
1282 0, /* sq_repeat */
1283 (intargfunc)instance_item, /* sq_item */
1284 (intintargfunc)instance_slice, /* sq_slice */
1285 (intobjargproc)instance_ass_item, /* sq_ass_item */
1286 (intintobjargproc)instance_ass_slice, /* sq_ass_slice */
1287 (objobjproc)instance_contains, /* sq_contains */
1288 };
1289
1290 static PyObject *
1291 generic_unary_op(PyInstanceObject *self, PyObject *methodname)
1292 {
1293 PyObject *func, *res;
1294
1295 if ((func = instance_getattr(self, methodname)) == NULL)
1296 return NULL;
1297 res = PyEval_CallObject(func, (PyObject *)NULL);
1298 Py_DECREF(func);
1299 return res;
1300 }
1301
1302 static PyObject *
1303 generic_binary_op(PyObject *v, PyObject *w, char *opname)
1304 {
1305 PyObject *result;
1306 PyObject *args;
1307 PyObject *func = PyObject_GetAttrString(v, opname);
1308 if (func == NULL) {
1309 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1310 return NULL;
1311 PyErr_Clear();
1312 Py_INCREF(Py_NotImplemented);
1313 return Py_NotImplemented;
1314 }
1315 args = Py_BuildValue("(O)", w);
1316 if (args == NULL) {
1317 Py_DECREF(func);
1318 return NULL;
1319 }
1320 result = PyEval_CallObject(func, args);
1321 Py_DECREF(args);
1322 Py_DECREF(func);
1323 return result;
1324 }
1325
1326
1327 static PyObject *coerce_obj;
1328
1329 /* Try one half of a binary operator involving a class instance. */
1330 static PyObject *
1331 half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,
1332 int swapped)
1333 {
1334 PyObject *args;
1335 PyObject *coercefunc;
1336 PyObject *coerced = NULL;
1337 PyObject *v1;
1338 PyObject *result;
1339
1340 if (!PyInstance_Check(v)) {
1341 Py_INCREF(Py_NotImplemented);
1342 return Py_NotImplemented;
1343 }
1344
1345 if (coerce_obj == NULL) {
1346 coerce_obj = PyString_InternFromString("__coerce__");
1347 if (coerce_obj == NULL)
1348 return NULL;
1349 }
1350 coercefunc = PyObject_GetAttr(v, coerce_obj);
1351 if (coercefunc == NULL) {
1352 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1353 return NULL;
1354 PyErr_Clear();
1355 return generic_binary_op(v, w, opname);
1356 }
1357
1358 args = Py_BuildValue("(O)", w);
1359 if (args == NULL) {
1360 return NULL;
1361 }
1362 coerced = PyEval_CallObject(coercefunc, args);
1363 Py_DECREF(args);
1364 Py_DECREF(coercefunc);
1365 if (coerced == NULL) {
1366 return NULL;
1367 }
1368 if (coerced == Py_None || coerced == Py_NotImplemented) {
1369 Py_DECREF(coerced);
1370 return generic_binary_op(v, w, opname);
1371 }
1372 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
1373 Py_DECREF(coerced);
1374 PyErr_SetString(PyExc_TypeError,
1375 "coercion should return None or 2-tuple");
1376 return NULL;
1377 }
1378 v1 = PyTuple_GetItem(coerced, 0);
1379 w = PyTuple_GetItem(coerced, 1);
1380 if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
1381 /* prevent recursion if __coerce__ returns self as the first
1382 * argument */
1383 result = generic_binary_op(v1, w, opname);
1384 } else {
1385 if (swapped)
1386 result = (thisfunc)(w, v1);
1387 else
1388 result = (thisfunc)(v1, w);
1389 }
1390 Py_DECREF(coerced);
1391 return result;
1392 }
1393
1394 /* Implement a binary operator involving at least one class instance. */
1395 static PyObject *
1396 do_binop(PyObject *v, PyObject *w, char *opname, char *ropname,
1397 binaryfunc thisfunc)
1398 {
1399 PyObject *result = half_binop(v, w, opname, thisfunc, 0);
1400 if (result == Py_NotImplemented) {
1401 Py_DECREF(result);
1402 result = half_binop(w, v, ropname, thisfunc, 1);
1403 }
1404 return result;
1405 }
1406
1407 static PyObject *
1408 do_binop_inplace(PyObject *v, PyObject *w, char *iopname, char *opname,
1409 char *ropname, binaryfunc thisfunc)
1410 {
1411 PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
1412 if (result == Py_NotImplemented) {
1413 Py_DECREF(result);
1414 result = do_binop(v, w, opname, ropname, thisfunc);
1415 }
1416 return result;
1417 }
1418
1419 static int
1420 instance_coerce(PyObject **pv, PyObject **pw)
1421 {
1422 PyObject *v = *pv;
1423 PyObject *w = *pw;
1424 PyObject *coercefunc;
1425 PyObject *args;
1426 PyObject *coerced;
1427
1428 if (coerce_obj == NULL) {
1429 coerce_obj = PyString_InternFromString("__coerce__");
1430 if (coerce_obj == NULL)
1431 return -1;
1432 }
1433 coercefunc = PyObject_GetAttr(v, coerce_obj);
1434 if (coercefunc == NULL) {
1435 /* No __coerce__ method */
1436 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1437 return -1;
1438 PyErr_Clear();
1439 return 1;
1440 }
1441 /* Has __coerce__ method: call it */
1442 args = Py_BuildValue("(O)", w);
1443 if (args == NULL) {
1444 return -1;
1445 }
1446 coerced = PyEval_CallObject(coercefunc, args);
1447 Py_DECREF(args);
1448 Py_DECREF(coercefunc);
1449 if (coerced == NULL) {
1450 /* __coerce__ call raised an exception */
1451 return -1;
1452 }
1453 if (coerced == Py_None || coerced == Py_NotImplemented) {
1454 /* __coerce__ says "I can't do it" */
1455 Py_DECREF(coerced);
1456 return 1;
1457 }
1458 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
1459 /* __coerce__ return value is malformed */
1460 Py_DECREF(coerced);
1461 PyErr_SetString(PyExc_TypeError,
1462 "coercion should return None or 2-tuple");
1463 return -1;
1464 }
1465 /* __coerce__ returned two new values */
1466 *pv = PyTuple_GetItem(coerced, 0);
1467 *pw = PyTuple_GetItem(coerced, 1);
1468 Py_INCREF(*pv);
1469 Py_INCREF(*pw);
1470 Py_DECREF(coerced);
1471 return 0;
1472 }
1473
1474 #define UNARY(funcname, methodname) \
1475 static PyObject *funcname(PyInstanceObject *self) { \
1476 static PyObject *o; \
1477 if (o == NULL) o = PyString_InternFromString(methodname); \
1478 return generic_unary_op(self, o); \
1479 }
1480
1481 #define BINARY(f, m, n) \
1482 static PyObject *f(PyObject *v, PyObject *w) { \
1483 return do_binop(v, w, "__" m "__", "__r" m "__", n); \
1484 }
1485
1486 #define BINARY_INPLACE(f, m, n) \
1487 static PyObject *f(PyObject *v, PyObject *w) { \
1488 return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
1489 "__r" m "__", n); \
1490 }
1491
1492 UNARY(instance_neg, "__neg__")
1493 UNARY(instance_pos, "__pos__")
1494 UNARY(instance_abs, "__abs__")
1495
1496 BINARY(instance_or, "or", PyNumber_Or)
1497 BINARY(instance_and, "and", PyNumber_And)
1498 BINARY(instance_xor, "xor", PyNumber_Xor)
1499 BINARY(instance_lshift, "lshift", PyNumber_Lshift)
1500 BINARY(instance_rshift, "rshift", PyNumber_Rshift)
1501 BINARY(instance_add, "add", PyNumber_Add)
1502 BINARY(instance_sub, "sub", PyNumber_Subtract)
1503 BINARY(instance_mul, "mul", PyNumber_Multiply)
1504 BINARY(instance_div, "div", PyNumber_Divide)
1505 BINARY(instance_mod, "mod", PyNumber_Remainder)
1506 BINARY(instance_divmod, "divmod", PyNumber_Divmod)
1507 BINARY(instance_floordiv, "floordiv", PyNumber_FloorDivide)
1508 BINARY(instance_truediv, "truediv", PyNumber_TrueDivide)
1509
1510 BINARY_INPLACE(instance_ior, "or", PyNumber_InPlaceOr)
1511 BINARY_INPLACE(instance_ixor, "xor", PyNumber_InPlaceXor)
1512 BINARY_INPLACE(instance_iand, "and", PyNumber_InPlaceAnd)
1513 BINARY_INPLACE(instance_ilshift, "lshift", PyNumber_InPlaceLshift)
1514 BINARY_INPLACE(instance_irshift, "rshift", PyNumber_InPlaceRshift)
1515 BINARY_INPLACE(instance_iadd, "add", PyNumber_InPlaceAdd)
1516 BINARY_INPLACE(instance_isub, "sub", PyNumber_InPlaceSubtract)
1517 BINARY_INPLACE(instance_imul, "mul", PyNumber_InPlaceMultiply)
1518 BINARY_INPLACE(instance_idiv, "div", PyNumber_InPlaceDivide)
1519 BINARY_INPLACE(instance_imod, "mod", PyNumber_InPlaceRemainder)
1520 BINARY_INPLACE(instance_ifloordiv, "floordiv", PyNumber_InPlaceFloorDivide)
1521 BINARY_INPLACE(instance_itruediv, "truediv", PyNumber_InPlaceTrueDivide)
1522
1523 /* Try a 3-way comparison, returning an int; v is an instance. Return:
1524 -2 for an exception;
1525 -1 if v < w;
1526 0 if v == w;
1527 1 if v > w;
1528 2 if this particular 3-way comparison is not implemented or undefined.
1529 */
1530 static int
1531 half_cmp(PyObject *v, PyObject *w)
1532 {
1533 static PyObject *cmp_obj;
1534 PyObject *args;
1535 PyObject *cmp_func;
1536 PyObject *result;
1537 long l;
1538
1539 assert(PyInstance_Check(v));
1540
1541 if (cmp_obj == NULL) {
1542 cmp_obj = PyString_InternFromString("__cmp__");
1543 if (cmp_obj == NULL)
1544 return -2;
1545 }
1546
1547 cmp_func = PyObject_GetAttr(v, cmp_obj);
1548 if (cmp_func == NULL) {
1549 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1550 return -2;
1551 PyErr_Clear();
1552 return 2;
1553 }
1554
1555 args = Py_BuildValue("(O)", w);
1556 if (args == NULL)
1557 return -2;
1558
1559 result = PyEval_CallObject(cmp_func, args);
1560 Py_DECREF(args);
1561 Py_DECREF(cmp_func);
1562
1563 if (result == NULL)
1564 return -2;
1565
1566 if (result == Py_NotImplemented) {
1567 Py_DECREF(result);
1568 return 2;
1569 }
1570
1571 l = PyInt_AsLong(result);
1572 Py_DECREF(result);
1573 if (l == -1 && PyErr_Occurred()) {
1574 PyErr_SetString(PyExc_TypeError,
1575 "comparison did not return an int");
1576 return -2;
1577 }
1578
1579 return l < 0 ? -1 : l > 0 ? 1 : 0;
1580 }
1581
1582 /* Try a 3-way comparison, returning an int; either v or w is an instance.
1583 We first try a coercion. Return:
1584 -2 for an exception;
1585 -1 if v < w;
1586 0 if v == w;
1587 1 if v > w;
1588 2 if this particular 3-way comparison is not implemented or undefined.
1589 THIS IS ONLY CALLED FROM object.c!
1590 */
1591 static int
1592 instance_compare(PyObject *v, PyObject *w)
1593 {
1594 int c;
1595
1596 c = PyNumber_CoerceEx(&v, &w);
1597 if (c < 0)
1598 return -2;
1599 if (c == 0) {
1600 /* If neither is now an instance, use regular comparison */
1601 if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
1602 c = PyObject_Compare(v, w);
1603 Py_DECREF(v);
1604 Py_DECREF(w);
1605 if (PyErr_Occurred())
1606 return -2;
1607 return c < 0 ? -1 : c > 0 ? 1 : 0;
1608 }
1609 }
1610 else {
1611 /* The coercion didn't do anything.
1612 Treat this the same as returning v and w unchanged. */
1613 Py_INCREF(v);
1614 Py_INCREF(w);
1615 }
1616
1617 if (PyInstance_Check(v)) {
1618 c = half_cmp(v, w);
1619 if (c <= 1) {
1620 Py_DECREF(v);
1621 Py_DECREF(w);
1622 return c;
1623 }
1624 }
1625 if (PyInstance_Check(w)) {
1626 c = half_cmp(w, v);
1627 if (c <= 1) {
1628 Py_DECREF(v);
1629 Py_DECREF(w);
1630 if (c >= -1)
1631 c = -c;
1632 return c;
1633 }
1634 }
1635 Py_DECREF(v);
1636 Py_DECREF(w);
1637 return 2;
1638 }
1639
1640 static int
1641 instance_nonzero(PyInstanceObject *self)
1642 {
1643 PyObject *func, *res;
1644 long outcome;
1645 static PyObject *nonzerostr;
1646
1647 if (nonzerostr == NULL)
1648 nonzerostr = PyString_InternFromString("__nonzero__");
1649 if ((func = instance_getattr(self, nonzerostr)) == NULL) {
1650 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1651 return -1;
1652 PyErr_Clear();
1653 if (lenstr == NULL)
1654 lenstr = PyString_InternFromString("__len__");
1655 if ((func = instance_getattr(self, lenstr)) == NULL) {
1656 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1657 return -1;
1658 PyErr_Clear();
1659 /* Fall back to the default behavior:
1660 all instances are nonzero */
1661 return 1;
1662 }
1663 }
1664 res = PyEval_CallObject(func, (PyObject *)NULL);
1665 Py_DECREF(func);
1666 if (res == NULL)
1667 return -1;
1668 if (!PyInt_Check(res)) {
1669 Py_DECREF(res);
1670 PyErr_SetString(PyExc_TypeError,
1671 "__nonzero__ should return an int");
1672 return -1;
1673 }
1674 outcome = PyInt_AsLong(res);
1675 Py_DECREF(res);
1676 if (outcome < 0) {
1677 PyErr_SetString(PyExc_ValueError,
1678 "__nonzero__ should return >= 0");
1679 return -1;
1680 }
1681 return outcome > 0;
1682 }
1683
1684 UNARY(instance_invert, "__invert__")
1685 UNARY(instance_int, "__int__")
1686 UNARY(instance_long, "__long__")
1687 UNARY(instance_float, "__float__")
1688 UNARY(instance_oct, "__oct__")
1689 UNARY(instance_hex, "__hex__")
1690
1691 static PyObject *
1692 bin_power(PyObject *v, PyObject *w)
1693 {
1694 return PyNumber_Power(v, w, Py_None);
1695 }
1696
1697 /* This version is for ternary calls only (z != None) */
1698 static PyObject *
1699 instance_pow(PyObject *v, PyObject *w, PyObject *z)
1700 {
1701 if (z == Py_None) {
1702 return do_binop(v, w, "__pow__", "__rpow__", bin_power);
1703 }
1704 else {
1705 PyObject *func;
1706 PyObject *args;
1707 PyObject *result;
1708
1709 /* XXX Doesn't do coercions... */
1710 func = PyObject_GetAttrString(v, "__pow__");
1711 if (func == NULL)
1712 return NULL;
1713 args = Py_BuildValue("(OO)", w, z);
1714 if (args == NULL) {
1715 Py_DECREF(func);
1716 return NULL;
1717 }
1718 result = PyEval_CallObject(func, args);
1719 Py_DECREF(func);
1720 Py_DECREF(args);
1721 return result;
1722 }
1723 }
1724
1725 static PyObject *
1726 bin_inplace_power(PyObject *v, PyObject *w)
1727 {
1728 return PyNumber_InPlacePower(v, w, Py_None);
1729 }
1730
1731
1732 static PyObject *
1733 instance_ipow(PyObject *v, PyObject *w, PyObject *z)
1734 {
1735 if (z == Py_None) {
1736 return do_binop_inplace(v, w, "__ipow__", "__pow__",
1737 "__rpow__", bin_inplace_power);
1738 }
1739 else {
1740 /* XXX Doesn't do coercions... */
1741 PyObject *func;
1742 PyObject *args;
1743 PyObject *result;
1744
1745 func = PyObject_GetAttrString(v, "__ipow__");
1746 if (func == NULL) {
1747 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1748 return NULL;
1749 PyErr_Clear();
1750 return instance_pow(v, w, z);
1751 }
1752 args = Py_BuildValue("(OO)", w, z);
1753 if (args == NULL) {
1754 Py_DECREF(func);
1755 return NULL;
1756 }
1757 result = PyEval_CallObject(func, args);
1758 Py_DECREF(func);
1759 Py_DECREF(args);
1760 return result;
1761 }
1762 }
1763
1764
1765 /* Map rich comparison operators to their __xx__ namesakes */
1766 #define NAME_OPS 6
1767 static PyObject **name_op = NULL;
1768
1769 static int
1770 init_name_op(void)
1771 {
1772 int i;
1773 char *_name_op[] = {
1774 "__lt__",
1775 "__le__",
1776 "__eq__",
1777 "__ne__",
1778 "__gt__",
1779 "__ge__",
1780 };
1781
1782 name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);
1783 if (name_op == NULL)
1784 return -1;
1785 for (i = 0; i < NAME_OPS; ++i) {
1786 name_op[i] = PyString_InternFromString(_name_op[i]);
1787 if (name_op[i] == NULL)
1788 return -1;
1789 }
1790 return 0;
1791 }
1792
1793 static PyObject *
1794 half_richcompare(PyObject *v, PyObject *w, int op)
1795 {
1796 PyObject *method;
1797 PyObject *args;
1798 PyObject *res;
1799
1800 assert(PyInstance_Check(v));
1801
1802 if (name_op == NULL) {
1803 if (init_name_op() < 0)
1804 return NULL;
1805 }
1806 /* If the instance doesn't define an __getattr__ method, use
1807 instance_getattr2 directly because it will not set an
1808 exception on failure. */
1809 if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL) {
1810 method = instance_getattr2((PyInstanceObject *)v,
1811 name_op[op]);
1812 if (method == NULL) {
1813 assert(!PyErr_Occurred());
1814 res = Py_NotImplemented;
1815 Py_INCREF(res);
1816 return res;
1817 }
1818 } else {
1819 method = PyObject_GetAttr(v, name_op[op]);
1820 if (method == NULL) {
1821 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1822 return NULL;
1823 PyErr_Clear();
1824 res = Py_NotImplemented;
1825 Py_INCREF(res);
1826 return res;
1827 }
1828 }
1829
1830 args = Py_BuildValue("(O)", w);
1831 if (args == NULL) {
1832 Py_DECREF(method);
1833 return NULL;
1834 }
1835
1836 res = PyEval_CallObject(method, args);
1837 Py_DECREF(args);
1838 Py_DECREF(method);
1839
1840 return res;
1841 }
1842
1843 /* Map rich comparison operators to their swapped version, e.g. LT --> GT */
1844 static int swapped_op[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
1845
1846 static PyObject *
1847 instance_richcompare(PyObject *v, PyObject *w, int op)
1848 {
1849 PyObject *res;
1850
1851 if (PyInstance_Check(v)) {
1852 res = half_richcompare(v, w, op);
1853 if (res != Py_NotImplemented)
1854 return res;
1855 Py_DECREF(res);
1856 }
1857
1858 if (PyInstance_Check(w)) {
1859 res = half_richcompare(w, v, swapped_op[op]);
1860 if (res != Py_NotImplemented)
1861 return res;
1862 Py_DECREF(res);
1863 }
1864
1865 Py_INCREF(Py_NotImplemented);
1866 return Py_NotImplemented;
1867 }
1868
1869
1870 /* Get the iterator */
1871 static PyObject *
1872 instance_getiter(PyInstanceObject *self)
1873 {
1874 PyObject *func;
1875
1876 if (iterstr == NULL) {
1877 iterstr = PyString_InternFromString("__iter__");
1878 if (iterstr == NULL)
1879 return NULL;
1880 }
1881 if (getitemstr == NULL) {
1882 getitemstr = PyString_InternFromString("__getitem__");
1883 if (getitemstr == NULL)
1884 return NULL;
1885 }
1886
1887 if ((func = instance_getattr(self, iterstr)) != NULL) {
1888 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
1889 Py_DECREF(func);
1890 if (res != NULL && !PyIter_Check(res)) {
1891 PyErr_Format(PyExc_TypeError,
1892 "__iter__ returned non-iterator "
1893 "of type '%.100s'",
1894 res->ob_type->tp_name);
1895 Py_DECREF(res);
1896 res = NULL;
1897 }
1898 return res;
1899 }
1900 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1901 return NULL;
1902 PyErr_Clear();
1903 if ((func = instance_getattr(self, getitemstr)) == NULL) {
1904 PyErr_SetString(PyExc_TypeError,
1905 "iteration over non-sequence");
1906 return NULL;
1907 }
1908 Py_DECREF(func);
1909 return PySeqIter_New((PyObject *)self);
1910 }
1911
1912
1913 /* Call the iterator's next */
1914 static PyObject *
1915 instance_iternext(PyInstanceObject *self)
1916 {
1917 PyObject *func;
1918
1919 if (nextstr == NULL)
1920 nextstr = PyString_InternFromString("next");
1921
1922 if ((func = instance_getattr(self, nextstr)) != NULL) {
1923 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
1924 Py_DECREF(func);
1925 if (res != NULL) {
1926 return res;
1927 }
1928 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
1929 PyErr_Clear();
1930 return NULL;
1931 }
1932 return NULL;
1933 }
1934 PyErr_SetString(PyExc_TypeError, "instance has no next() method");
1935 return NULL;
1936 }
1937
1938 static PyObject *
1939 instance_call(PyObject *func, PyObject *arg, PyObject *kw)
1940 {
1941 PyThreadState *tstate = PyThreadState_GET();
1942 PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
1943 if (call == NULL) {
1944 PyInstanceObject *inst = (PyInstanceObject*) func;
1945 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1946 return NULL;
1947 PyErr_Clear();
1948 PyErr_Format(PyExc_AttributeError,
1949 "%.200s instance has no __call__ method",
1950 PyString_AsString(inst->in_class->cl_name));
1951 return NULL;
1952 }
1953 /* We must check and increment the recursion depth here. Scenario:
1954 class A:
1955 pass
1956 A.__call__ = A() # that's right
1957 a = A() # ok
1958 a() # infinite recursion
1959 This bounces between instance_call() and PyObject_Call() without
1960 ever hitting eval_frame() (which has the main recursion check). */
1961 if (tstate->recursion_depth++ > Py_GetRecursionLimit()) {
1962 PyErr_SetString(PyExc_RuntimeError,
1963 "maximum __call__ recursion depth exceeded");
1964 res = NULL;
1965 }
1966 else
1967 res = PyObject_Call(call, arg, kw);
1968 tstate->recursion_depth--;
1969 Py_DECREF(call);
1970 return res;
1971 }
1972
1973
1974 static PyNumberMethods instance_as_number = {
1975 (binaryfunc)instance_add, /* nb_add */
1976 (binaryfunc)instance_sub, /* nb_subtract */
1977 (binaryfunc)instance_mul, /* nb_multiply */
1978 (binaryfunc)instance_div, /* nb_divide */
1979 (binaryfunc)instance_mod, /* nb_remainder */
1980 (binaryfunc)instance_divmod, /* nb_divmod */
1981 (ternaryfunc)instance_pow, /* nb_power */
1982 (unaryfunc)instance_neg, /* nb_negative */
1983 (unaryfunc)instance_pos, /* nb_positive */
1984 (unaryfunc)instance_abs, /* nb_absolute */
1985 (inquiry)instance_nonzero, /* nb_nonzero */
1986 (unaryfunc)instance_invert, /* nb_invert */
1987 (binaryfunc)instance_lshift, /* nb_lshift */
1988 (binaryfunc)instance_rshift, /* nb_rshift */
1989 (binaryfunc)instance_and, /* nb_and */
1990 (binaryfunc)instance_xor, /* nb_xor */
1991 (binaryfunc)instance_or, /* nb_or */
1992 (coercion)instance_coerce, /* nb_coerce */
1993 (unaryfunc)instance_int, /* nb_int */
1994 (unaryfunc)instance_long, /* nb_long */
1995 (unaryfunc)instance_float, /* nb_float */
1996 (unaryfunc)instance_oct, /* nb_oct */
1997 (unaryfunc)instance_hex, /* nb_hex */
1998 (binaryfunc)instance_iadd, /* nb_inplace_add */
1999 (binaryfunc)instance_isub, /* nb_inplace_subtract */
2000 (binaryfunc)instance_imul, /* nb_inplace_multiply */
2001 (binaryfunc)instance_idiv, /* nb_inplace_divide */
2002 (binaryfunc)instance_imod, /* nb_inplace_remainder */
2003 (ternaryfunc)instance_ipow, /* nb_inplace_power */
2004 (binaryfunc)instance_ilshift, /* nb_inplace_lshift */
2005 (binaryfunc)instance_irshift, /* nb_inplace_rshift */
2006 (binaryfunc)instance_iand, /* nb_inplace_and */
2007 (binaryfunc)instance_ixor, /* nb_inplace_xor */
2008 (binaryfunc)instance_ior, /* nb_inplace_or */
2009 (binaryfunc)instance_floordiv, /* nb_floor_divide */
2010 (binaryfunc)instance_truediv, /* nb_true_divide */
2011 (binaryfunc)instance_ifloordiv, /* nb_inplace_floor_divide */
2012 (binaryfunc)instance_itruediv, /* nb_inplace_true_divide */
2013 };
2014
2015 PyTypeObject PyInstance_Type = {
2016 PyObject_HEAD_INIT(&PyType_Type)
2017 0,
2018 "instance",
2019 sizeof(PyInstanceObject),
2020 0,
2021 (destructor)instance_dealloc, /* tp_dealloc */
2022 0, /* tp_print */
2023 0, /* tp_getattr */
2024 0, /* tp_setattr */
2025 instance_compare, /* tp_compare */
2026 (reprfunc)instance_repr, /* tp_repr */
2027 &instance_as_number, /* tp_as_number */
2028 &instance_as_sequence, /* tp_as_sequence */
2029 &instance_as_mapping, /* tp_as_mapping */
2030 (hashfunc)instance_hash, /* tp_hash */
2031 instance_call, /* tp_call */
2032 (reprfunc)instance_str, /* tp_str */
2033 (getattrofunc)instance_getattr, /* tp_getattro */
2034 (setattrofunc)instance_setattr, /* tp_setattro */
2035 0, /* tp_as_buffer */
2036 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
2037 instance_doc, /* tp_doc */
2038 (traverseproc)instance_traverse, /* tp_traverse */
2039 0, /* tp_clear */
2040 instance_richcompare, /* tp_richcompare */
2041 offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
2042 (getiterfunc)instance_getiter, /* tp_iter */
2043 (iternextfunc)instance_iternext, /* tp_iternext */
2044 0, /* tp_methods */
2045 0, /* tp_members */
2046 0, /* tp_getset */
2047 0, /* tp_base */
2048 0, /* tp_dict */
2049 0, /* tp_descr_get */
2050 0, /* tp_descr_set */
2051 0, /* tp_dictoffset */
2052 0, /* tp_init */
2053 0, /* tp_alloc */
2054 instance_new, /* tp_new */
2055 };
2056
2057
2058 /* Instance method objects are used for two purposes:
2059 (a) as bound instance methods (returned by instancename.methodname)
2060 (b) as unbound methods (returned by ClassName.methodname)
2061 In case (b), im_self is NULL
2062 */
2063
2064 static PyMethodObject *free_list;
2065
2066 PyObject *
2067 PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
2068 {
2069 register PyMethodObject *im;
2070 if (!PyCallable_Check(func)) {
2071 PyErr_BadInternalCall();
2072 return NULL;
2073 }
2074 im = free_list;
2075 if (im != NULL) {
2076 free_list = (PyMethodObject *)(im->im_self);
2077 PyObject_INIT(im, &PyMethod_Type);
2078 }
2079 else {
2080 im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
2081 if (im == NULL)
2082 return NULL;
2083 }
2084 im->im_weakreflist = NULL;
2085 Py_INCREF(func);
2086 im->im_func = func;
2087 Py_XINCREF(self);
2088 im->im_self = self;
2089 Py_XINCREF(class);
2090 im->im_class = class;
2091 _PyObject_GC_TRACK(im);
2092 return (PyObject *)im;
2093 }
2094
2095 /* Descriptors for PyMethod attributes */
2096
2097 /* im_class, im_func and im_self are stored in the PyMethod object */
2098
2099 #define OFF(x) offsetof(PyMethodObject, x)
2100
2101 static PyMemberDef instancemethod_memberlist[] = {
2102 {"im_class", T_OBJECT, OFF(im_class), READONLY|RESTRICTED,
2103 "the class associated with a method"},
2104 {"im_func", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,
2105 "the function (or other callable) implementing a method"},
2106 {"im_self", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,
2107 "the instance to which a method is bound; None for unbound methods"},
2108 {NULL} /* Sentinel */
2109 };
2110
2111 /* The getattr() implementation for PyMethod objects is similar to
2112 PyObject_GenericGetAttr(), but instead of looking in __dict__ it
2113 asks im_self for the attribute. Then the error handling is a bit
2114 different because we want to preserve the exception raised by the
2115 delegate, unless we have an alternative from our class. */
2116
2117 static PyObject *
2118 instancemethod_getattro(PyObject *obj, PyObject *name)
2119 {
2120 PyMethodObject *im = (PyMethodObject *)obj;
2121 PyTypeObject *tp = obj->ob_type;
2122 PyObject *descr = NULL, *res;
2123 descrgetfunc f = NULL;
2124
2125 if (PyType_HasFeature(tp, Py_TPFLAGS_HAVE_CLASS)) {
2126 if (tp->tp_dict == NULL) {
2127 if (PyType_Ready(tp) < 0)
2128 return NULL;
2129 }
2130 descr = _PyType_Lookup(tp, name);
2131 }
2132
2133 f = NULL;
2134 if (descr != NULL) {
2135 f = TP_DESCR_GET(descr->ob_type);
2136 if (f != NULL && PyDescr_IsData(descr))
2137 return f(descr, obj, (PyObject *)obj->ob_type);
2138 }
2139
2140 res = PyObject_GetAttr(im->im_func, name);
2141 if (res != NULL || !PyErr_ExceptionMatches(PyExc_AttributeError))
2142 return res;
2143
2144 if (f != NULL) {
2145 PyErr_Clear();
2146 return f(descr, obj, (PyObject *)obj->ob_type);
2147 }
2148
2149 if (descr != NULL) {
2150 PyErr_Clear();
2151 Py_INCREF(descr);
2152 return descr;
2153 }
2154
2155 assert(PyErr_Occurred());
2156 return NULL;
2157 }
2158
2159 PyDoc_STRVAR(instancemethod_doc,
2160 "instancemethod(function, instance, class)\n\
2161 \n\
2162 Create an instance method object.");
2163
2164 static PyObject *
2165 instancemethod_new(PyTypeObject* type, PyObject* args, PyObject *kw)
2166 {
2167 PyObject *func;
2168 PyObject *self;
2169 PyObject *classObj;
2170
2171 if (!PyArg_ParseTuple(args, "OOO:instancemethod",
2172 &func, &self, &classObj))
2173 return NULL;
2174 if (!PyCallable_Check(func)) {
2175 PyErr_SetString(PyExc_TypeError,
2176 "first argument must be callable");
2177 return NULL;
2178 }
2179 if (self == Py_None)
2180 self = NULL;
2181 return PyMethod_New(func, self, classObj);
2182 }
2183
2184 static void
2185 instancemethod_dealloc(register PyMethodObject *im)
2186 {
2187 _PyObject_GC_UNTRACK(im);
2188 if (im->im_weakreflist != NULL)
2189 PyObject_ClearWeakRefs((PyObject *)im);
2190 Py_DECREF(im->im_func);
2191 Py_XDECREF(im->im_self);
2192 Py_XDECREF(im->im_class);
2193 im->im_self = (PyObject *)free_list;
2194 free_list = im;
2195 }
2196
2197 static int
2198 instancemethod_compare(PyMethodObject *a, PyMethodObject *b)
2199 {
2200 if (a->im_self != b->im_self)
2201 return (a->im_self < b->im_self) ? -1 : 1;
2202 return PyObject_Compare(a->im_func, b->im_func);
2203 }
2204
2205 static PyObject *
2206 instancemethod_repr(PyMethodObject *a)
2207 {
2208 PyObject *self = a->im_self;
2209 PyObject *func = a->im_func;
2210 PyObject *klass = a->im_class;
2211 PyObject *funcname = NULL, *klassname = NULL, *result = NULL;
2212 char *sfuncname = "?", *sklassname = "?";
2213
2214 funcname = PyObject_GetAttrString(func, "__name__");
2215 if (funcname == NULL) {
2216 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2217 return NULL;
2218 PyErr_Clear();
2219 }
2220 else if (!PyString_Check(funcname)) {
2221 Py_DECREF(funcname);
2222 funcname = NULL;
2223 }
2224 else
2225 sfuncname = PyString_AS_STRING(funcname);
2226 if (klass == NULL)
2227 klassname = NULL;
2228 else {
2229 klassname = PyObject_GetAttrString(klass, "__name__");
2230 if (klassname == NULL) {
2231 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2232 return NULL;
2233 PyErr_Clear();
2234 }
2235 else if (!PyString_Check(klassname)) {
2236 Py_DECREF(klassname);
2237 klassname = NULL;
2238 }
2239 else
2240 sklassname = PyString_AS_STRING(klassname);
2241 }
2242 if (self == NULL)
2243 result = PyString_FromFormat("<unbound method %s.%s>",
2244 sklassname, sfuncname);
2245 else {
2246 /* XXX Shouldn't use repr() here! */
2247 PyObject *selfrepr = PyObject_Repr(self);
2248 if (selfrepr == NULL)
2249 goto fail;
2250 if (!PyString_Check(selfrepr)) {
2251 Py_DECREF(selfrepr);
2252 goto fail;
2253 }
2254 result = PyString_FromFormat("<bound method %s.%s of %s>",
2255 sklassname, sfuncname,
2256 PyString_AS_STRING(selfrepr));
2257 Py_DECREF(selfrepr);
2258 }
2259 fail:
2260 Py_XDECREF(funcname);
2261 Py_XDECREF(klassname);
2262 return result;
2263 }
2264
2265 static long
2266 instancemethod_hash(PyMethodObject *a)
2267 {
2268 long x, y;
2269 if (a->im_self == NULL)
2270 x = PyObject_Hash(Py_None);
2271 else
2272 x = PyObject_Hash(a->im_self);
2273 if (x == -1)
2274 return -1;
2275 y = PyObject_Hash(a->im_func);
2276 if (y == -1)
2277 return -1;
2278 return x ^ y;
2279 }
2280
2281 static int
2282 instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
2283 {
2284 int err;
2285 if (im->im_func) {
2286 err = visit(im->im_func, arg);
2287 if (err)
2288 return err;
2289 }
2290 if (im->im_self) {
2291 err = visit(im->im_self, arg);
2292 if (err)
2293 return err;
2294 }
2295 if (im->im_class) {
2296 err = visit(im->im_class, arg);
2297 if (err)
2298 return err;
2299 }
2300 return 0;
2301 }
2302
2303 static void
2304 getclassname(PyObject *class, char *buf, int bufsize)
2305 {
2306 PyObject *name;
2307
2308 assert(bufsize > 1);
2309 strcpy(buf, "?"); /* Default outcome */
2310 if (class == NULL)
2311 return;
2312 name = PyObject_GetAttrString(class, "__name__");
2313 if (name == NULL) {
2314 /* This function cannot return an exception */
2315 PyErr_Clear();
2316 return;
2317 }
2318 if (PyString_Check(name)) {
2319 strncpy(buf, PyString_AS_STRING(name), bufsize);
2320 buf[bufsize-1] = '\0';
2321 }
2322 Py_DECREF(name);
2323 }
2324
2325 static void
2326 getinstclassname(PyObject *inst, char *buf, int bufsize)
2327 {
2328 PyObject *class;
2329
2330 if (inst == NULL) {
2331 assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));
2332 strcpy(buf, "nothing");
2333 return;
2334 }
2335
2336 class = PyObject_GetAttrString(inst, "__class__");
2337 if (class == NULL) {
2338 /* This function cannot return an exception */
2339 PyErr_Clear();
2340 class = (PyObject *)(inst->ob_type);
2341 Py_INCREF(class);
2342 }
2343 getclassname(class, buf, bufsize);
2344 Py_XDECREF(class);
2345 }
2346
2347 static PyObject *
2348 instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw)
2349 {
2350 PyObject *self = PyMethod_GET_SELF(func);
2351 PyObject *class = PyMethod_GET_CLASS(func);
2352 PyObject *result;
2353
2354 func = PyMethod_GET_FUNCTION(func);
2355 if (self == NULL) {
2356 /* Unbound methods must be called with an instance of
2357 the class (or a derived class) as first argument */
2358 int ok;
2359 if (PyTuple_Size(arg) >= 1)
2360 self = PyTuple_GET_ITEM(arg, 0);
2361 if (self == NULL)
2362 ok = 0;
2363 else {
2364 ok = PyObject_IsInstance(self, class);
2365 if (ok < 0)
2366 return NULL;
2367 }
2368 if (!ok) {
2369 char clsbuf[256];
2370 char instbuf[256];
2371 getclassname(class, clsbuf, sizeof(clsbuf));
2372 getinstclassname(self, instbuf, sizeof(instbuf));
2373 PyErr_Format(PyExc_TypeError,
2374 "unbound method %s%s must be called with "
2375 "%s instance as first argument "
2376 "(got %s%s instead)",
2377 PyEval_GetFuncName(func),
2378 PyEval_GetFuncDesc(func),
2379 clsbuf,
2380 instbuf,
2381 self == NULL ? "" : " instance");
2382 return NULL;
2383 }
2384 Py_INCREF(arg);
2385 }
2386 else {
2387 int argcount = PyTuple_Size(arg);
2388 PyObject *newarg = PyTuple_New(argcount + 1);
2389 int i;
2390 if (newarg == NULL)
2391 return NULL;
2392 Py_INCREF(self);
2393 PyTuple_SET_ITEM(newarg, 0, self);
2394 for (i = 0; i < argcount; i++) {
2395 PyObject *v = PyTuple_GET_ITEM(arg, i);
2396 Py_XINCREF(v);
2397 PyTuple_SET_ITEM(newarg, i+1, v);
2398 }
2399 arg = newarg;
2400 }
2401 result = PyObject_Call((PyObject *)func, arg, kw);
2402 Py_DECREF(arg);
2403 return result;
2404 }
2405
2406 static PyObject *
2407 instancemethod_descr_get(PyObject *meth, PyObject *obj, PyObject *class)
2408 {
2409 /* Don't rebind an already bound method, or an unbound method
2410 of a class that's not a base class of class */
2411 if (PyMethod_GET_SELF(meth) != NULL ||
2412 (PyMethod_GET_CLASS(meth) != NULL &&
2413 !PyObject_IsSubclass(class, PyMethod_GET_CLASS(meth)))) {
2414 Py_INCREF(meth);
2415 return meth;
2416 }
2417 if (obj == Py_None)
2418 obj = NULL;
2419 return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, class);
2420 }
2421
2422 PyTypeObject PyMethod_Type = {
2423 PyObject_HEAD_INIT(&PyType_Type)
2424 0,
2425 "instancemethod",
2426 sizeof(PyMethodObject),
2427 0,
2428 (destructor)instancemethod_dealloc, /* tp_dealloc */
2429 0, /* tp_print */
2430 0, /* tp_getattr */
2431 0, /* tp_setattr */
2432 (cmpfunc)instancemethod_compare, /* tp_compare */
2433 (reprfunc)instancemethod_repr, /* tp_repr */
2434 0, /* tp_as_number */
2435 0, /* tp_as_sequence */
2436 0, /* tp_as_mapping */
2437 (hashfunc)instancemethod_hash, /* tp_hash */
2438 instancemethod_call, /* tp_call */
2439 0, /* tp_str */
2440 (getattrofunc)instancemethod_getattro, /* tp_getattro */
2441 PyObject_GenericSetAttr, /* tp_setattro */
2442 0, /* tp_as_buffer */
2443 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
2444 instancemethod_doc, /* tp_doc */
2445 (traverseproc)instancemethod_traverse, /* tp_traverse */
2446 0, /* tp_clear */
2447 0, /* tp_richcompare */
2448 offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
2449 0, /* tp_iter */
2450 0, /* tp_iternext */
2451 0, /* tp_methods */
2452 instancemethod_memberlist, /* tp_members */
2453 0, /* tp_getset */
2454 0, /* tp_base */
2455 0, /* tp_dict */
2456 instancemethod_descr_get, /* tp_descr_get */
2457 0, /* tp_descr_set */
2458 0, /* tp_dictoffset */
2459 0, /* tp_init */
2460 0, /* tp_alloc */
2461 instancemethod_new, /* tp_new */
2462 };
2463
2464 /* Clear out the free list */
2465
2466 void
2467 PyMethod_Fini(void)
2468 {
2469 while (free_list) {
2470 PyMethodObject *im = free_list;
2471 free_list = (PyMethodObject *)(im->im_self);
2472 PyObject_GC_Del(im);
2473 }
2474 }