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