typeobject.c revision 5083dc552b4e7026c2f405b37d7691131bc96955
1/* Type object implementation */ 2 3#include "Python.h" 4#include "structmember.h" 5 6#include <ctype.h> 7 8 9/* Support type attribute cache */ 10 11/* The cache can keep references to the names alive for longer than 12 they normally would. This is why the maximum size is limited to 13 MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large 14 strings are used as attribute names. */ 15#define MCACHE_MAX_ATTR_SIZE 100 16#define MCACHE_SIZE_EXP 10 17#define MCACHE_HASH(version, name_hash) \ 18 (((unsigned int)(version) * (unsigned int)(name_hash)) \ 19 >> (8*sizeof(unsigned int) - MCACHE_SIZE_EXP)) 20#define MCACHE_HASH_METHOD(type, name) \ 21 MCACHE_HASH((type)->tp_version_tag, \ 22 ((PyStringObject *)(name))->ob_shash) 23#define MCACHE_CACHEABLE_NAME(name) \ 24 PyString_CheckExact(name) && \ 25 PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE 26 27struct method_cache_entry { 28 unsigned int version; 29 PyObject *name; /* reference to exactly a str or None */ 30 PyObject *value; /* borrowed */ 31}; 32 33static struct method_cache_entry method_cache[1 << MCACHE_SIZE_EXP]; 34static unsigned int next_version_tag = 0; 35 36unsigned int 37PyType_ClearCache(void) 38{ 39 Py_ssize_t i; 40 unsigned int cur_version_tag = next_version_tag - 1; 41 42 for (i = 0; i < (1 << MCACHE_SIZE_EXP); i++) { 43 method_cache[i].version = 0; 44 Py_CLEAR(method_cache[i].name); 45 method_cache[i].value = NULL; 46 } 47 next_version_tag = 0; 48 /* mark all version tags as invalid */ 49 PyType_Modified(&PyBaseObject_Type); 50 return cur_version_tag; 51} 52 53void 54PyType_Modified(PyTypeObject *type) 55{ 56 /* Invalidate any cached data for the specified type and all 57 subclasses. This function is called after the base 58 classes, mro, or attributes of the type are altered. 59 60 Invariants: 61 62 - Py_TPFLAGS_VALID_VERSION_TAG is never set if 63 Py_TPFLAGS_HAVE_VERSION_TAG is not set (e.g. on type 64 objects coming from non-recompiled extension modules) 65 66 - before Py_TPFLAGS_VALID_VERSION_TAG can be set on a type, 67 it must first be set on all super types. 68 69 This function clears the Py_TPFLAGS_VALID_VERSION_TAG of a 70 type (so it must first clear it on all subclasses). The 71 tp_version_tag value is meaningless unless this flag is set. 72 We don't assign new version tags eagerly, but only as 73 needed. 74 */ 75 PyObject *raw, *ref; 76 Py_ssize_t i, n; 77 78 if (!PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) 79 return; 80 81 raw = type->tp_subclasses; 82 if (raw != NULL) { 83 n = PyList_GET_SIZE(raw); 84 for (i = 0; i < n; i++) { 85 ref = PyList_GET_ITEM(raw, i); 86 ref = PyWeakref_GET_OBJECT(ref); 87 if (ref != Py_None) { 88 PyType_Modified((PyTypeObject *)ref); 89 } 90 } 91 } 92 type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; 93} 94 95static void 96type_mro_modified(PyTypeObject *type, PyObject *bases) { 97 /* 98 Check that all base classes or elements of the mro of type are 99 able to be cached. This function is called after the base 100 classes or mro of the type are altered. 101 102 Unset HAVE_VERSION_TAG and VALID_VERSION_TAG if the type 103 inherits from an old-style class, either directly or if it 104 appears in the MRO of a new-style class. No support either for 105 custom MROs that include types that are not officially super 106 types. 107 108 Called from mro_internal, which will subsequently be called on 109 each subclass when their mro is recursively updated. 110 */ 111 Py_ssize_t i, n; 112 int clear = 0; 113 114 if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG)) 115 return; 116 117 n = PyTuple_GET_SIZE(bases); 118 for (i = 0; i < n; i++) { 119 PyObject *b = PyTuple_GET_ITEM(bases, i); 120 PyTypeObject *cls; 121 122 if (!PyType_Check(b) ) { 123 clear = 1; 124 break; 125 } 126 127 cls = (PyTypeObject *)b; 128 129 if (!PyType_HasFeature(cls, Py_TPFLAGS_HAVE_VERSION_TAG) || 130 !PyType_IsSubtype(type, cls)) { 131 clear = 1; 132 break; 133 } 134 } 135 136 if (clear) 137 type->tp_flags &= ~(Py_TPFLAGS_HAVE_VERSION_TAG| 138 Py_TPFLAGS_VALID_VERSION_TAG); 139} 140 141static int 142assign_version_tag(PyTypeObject *type) 143{ 144 /* Ensure that the tp_version_tag is valid and set 145 Py_TPFLAGS_VALID_VERSION_TAG. To respect the invariant, this 146 must first be done on all super classes. Return 0 if this 147 cannot be done, 1 if Py_TPFLAGS_VALID_VERSION_TAG. 148 */ 149 Py_ssize_t i, n; 150 PyObject *bases; 151 152 if (PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) 153 return 1; 154 if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG)) 155 return 0; 156 if (!PyType_HasFeature(type, Py_TPFLAGS_READY)) 157 return 0; 158 159 type->tp_version_tag = next_version_tag++; 160 /* for stress-testing: next_version_tag &= 0xFF; */ 161 162 if (type->tp_version_tag == 0) { 163 /* wrap-around or just starting Python - clear the whole 164 cache by filling names with references to Py_None. 165 Values are also set to NULL for added protection, as they 166 are borrowed reference */ 167 for (i = 0; i < (1 << MCACHE_SIZE_EXP); i++) { 168 method_cache[i].value = NULL; 169 Py_XDECREF(method_cache[i].name); 170 method_cache[i].name = Py_None; 171 Py_INCREF(Py_None); 172 } 173 /* mark all version tags as invalid */ 174 PyType_Modified(&PyBaseObject_Type); 175 return 1; 176 } 177 bases = type->tp_bases; 178 n = PyTuple_GET_SIZE(bases); 179 for (i = 0; i < n; i++) { 180 PyObject *b = PyTuple_GET_ITEM(bases, i); 181 assert(PyType_Check(b)); 182 if (!assign_version_tag((PyTypeObject *)b)) 183 return 0; 184 } 185 type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG; 186 return 1; 187} 188 189 190static PyMemberDef type_members[] = { 191 {"__basicsize__", T_INT, offsetof(PyTypeObject,tp_basicsize),READONLY}, 192 {"__itemsize__", T_INT, offsetof(PyTypeObject, tp_itemsize), READONLY}, 193 {"__flags__", T_LONG, offsetof(PyTypeObject, tp_flags), READONLY}, 194 {"__weakrefoffset__", T_LONG, 195 offsetof(PyTypeObject, tp_weaklistoffset), READONLY}, 196 {"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY}, 197 {"__dictoffset__", T_LONG, 198 offsetof(PyTypeObject, tp_dictoffset), READONLY}, 199 {"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY}, 200 {0} 201}; 202 203static PyObject * 204type_name(PyTypeObject *type, void *context) 205{ 206 const char *s; 207 208 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) { 209 PyHeapTypeObject* et = (PyHeapTypeObject*)type; 210 211 Py_INCREF(et->ht_name); 212 return et->ht_name; 213 } 214 else { 215 s = strrchr(type->tp_name, '.'); 216 if (s == NULL) 217 s = type->tp_name; 218 else 219 s++; 220 return PyString_FromString(s); 221 } 222} 223 224static int 225type_set_name(PyTypeObject *type, PyObject *value, void *context) 226{ 227 PyHeapTypeObject* et; 228 229 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) { 230 PyErr_Format(PyExc_TypeError, 231 "can't set %s.__name__", type->tp_name); 232 return -1; 233 } 234 if (!value) { 235 PyErr_Format(PyExc_TypeError, 236 "can't delete %s.__name__", type->tp_name); 237 return -1; 238 } 239 if (!PyString_Check(value)) { 240 PyErr_Format(PyExc_TypeError, 241 "can only assign string to %s.__name__, not '%s'", 242 type->tp_name, Py_TYPE(value)->tp_name); 243 return -1; 244 } 245 if (strlen(PyString_AS_STRING(value)) 246 != (size_t)PyString_GET_SIZE(value)) { 247 PyErr_Format(PyExc_ValueError, 248 "__name__ must not contain null bytes"); 249 return -1; 250 } 251 252 et = (PyHeapTypeObject*)type; 253 254 Py_INCREF(value); 255 256 Py_DECREF(et->ht_name); 257 et->ht_name = value; 258 259 type->tp_name = PyString_AS_STRING(value); 260 261 return 0; 262} 263 264static PyObject * 265type_module(PyTypeObject *type, void *context) 266{ 267 PyObject *mod; 268 char *s; 269 270 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) { 271 mod = PyDict_GetItemString(type->tp_dict, "__module__"); 272 if (!mod) { 273 PyErr_Format(PyExc_AttributeError, "__module__"); 274 return 0; 275 } 276 Py_XINCREF(mod); 277 return mod; 278 } 279 else { 280 s = strrchr(type->tp_name, '.'); 281 if (s != NULL) 282 return PyString_FromStringAndSize( 283 type->tp_name, (Py_ssize_t)(s - type->tp_name)); 284 return PyString_FromString("__builtin__"); 285 } 286} 287 288static int 289type_set_module(PyTypeObject *type, PyObject *value, void *context) 290{ 291 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) { 292 PyErr_Format(PyExc_TypeError, 293 "can't set %s.__module__", type->tp_name); 294 return -1; 295 } 296 if (!value) { 297 PyErr_Format(PyExc_TypeError, 298 "can't delete %s.__module__", type->tp_name); 299 return -1; 300 } 301 302 PyType_Modified(type); 303 304 return PyDict_SetItemString(type->tp_dict, "__module__", value); 305} 306 307static PyObject * 308type_abstractmethods(PyTypeObject *type, void *context) 309{ 310 PyObject *mod = PyDict_GetItemString(type->tp_dict, 311 "__abstractmethods__"); 312 if (!mod) { 313 PyErr_Format(PyExc_AttributeError, "__abstractmethods__"); 314 return NULL; 315 } 316 Py_XINCREF(mod); 317 return mod; 318} 319 320static int 321type_set_abstractmethods(PyTypeObject *type, PyObject *value, void *context) 322{ 323 /* __abstractmethods__ should only be set once on a type, in 324 abc.ABCMeta.__new__, so this function doesn't do anything 325 special to update subclasses. 326 */ 327 int res = PyDict_SetItemString(type->tp_dict, 328 "__abstractmethods__", value); 329 if (res == 0) { 330 PyType_Modified(type); 331 if (value && PyObject_IsTrue(value)) { 332 type->tp_flags |= Py_TPFLAGS_IS_ABSTRACT; 333 } 334 else { 335 type->tp_flags &= ~Py_TPFLAGS_IS_ABSTRACT; 336 } 337 } 338 return res; 339} 340 341static PyObject * 342type_get_bases(PyTypeObject *type, void *context) 343{ 344 Py_INCREF(type->tp_bases); 345 return type->tp_bases; 346} 347 348static PyTypeObject *best_base(PyObject *); 349static int mro_internal(PyTypeObject *); 350static int compatible_for_assignment(PyTypeObject *, PyTypeObject *, char *); 351static int add_subclass(PyTypeObject*, PyTypeObject*); 352static void remove_subclass(PyTypeObject *, PyTypeObject *); 353static void update_all_slots(PyTypeObject *); 354 355typedef int (*update_callback)(PyTypeObject *, void *); 356static int update_subclasses(PyTypeObject *type, PyObject *name, 357 update_callback callback, void *data); 358static int recurse_down_subclasses(PyTypeObject *type, PyObject *name, 359 update_callback callback, void *data); 360 361static int 362mro_subclasses(PyTypeObject *type, PyObject* temp) 363{ 364 PyTypeObject *subclass; 365 PyObject *ref, *subclasses, *old_mro; 366 Py_ssize_t i, n; 367 368 subclasses = type->tp_subclasses; 369 if (subclasses == NULL) 370 return 0; 371 assert(PyList_Check(subclasses)); 372 n = PyList_GET_SIZE(subclasses); 373 for (i = 0; i < n; i++) { 374 ref = PyList_GET_ITEM(subclasses, i); 375 assert(PyWeakref_CheckRef(ref)); 376 subclass = (PyTypeObject *)PyWeakref_GET_OBJECT(ref); 377 assert(subclass != NULL); 378 if ((PyObject *)subclass == Py_None) 379 continue; 380 assert(PyType_Check(subclass)); 381 old_mro = subclass->tp_mro; 382 if (mro_internal(subclass) < 0) { 383 subclass->tp_mro = old_mro; 384 return -1; 385 } 386 else { 387 PyObject* tuple; 388 tuple = PyTuple_Pack(2, subclass, old_mro); 389 Py_DECREF(old_mro); 390 if (!tuple) 391 return -1; 392 if (PyList_Append(temp, tuple) < 0) 393 return -1; 394 Py_DECREF(tuple); 395 } 396 if (mro_subclasses(subclass, temp) < 0) 397 return -1; 398 } 399 return 0; 400} 401 402static int 403type_set_bases(PyTypeObject *type, PyObject *value, void *context) 404{ 405 Py_ssize_t i; 406 int r = 0; 407 PyObject *ob, *temp; 408 PyTypeObject *new_base, *old_base; 409 PyObject *old_bases, *old_mro; 410 411 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) { 412 PyErr_Format(PyExc_TypeError, 413 "can't set %s.__bases__", type->tp_name); 414 return -1; 415 } 416 if (!value) { 417 PyErr_Format(PyExc_TypeError, 418 "can't delete %s.__bases__", type->tp_name); 419 return -1; 420 } 421 if (!PyTuple_Check(value)) { 422 PyErr_Format(PyExc_TypeError, 423 "can only assign tuple to %s.__bases__, not %s", 424 type->tp_name, Py_TYPE(value)->tp_name); 425 return -1; 426 } 427 if (PyTuple_GET_SIZE(value) == 0) { 428 PyErr_Format(PyExc_TypeError, 429 "can only assign non-empty tuple to %s.__bases__, not ()", 430 type->tp_name); 431 return -1; 432 } 433 for (i = 0; i < PyTuple_GET_SIZE(value); i++) { 434 ob = PyTuple_GET_ITEM(value, i); 435 if (!PyClass_Check(ob) && !PyType_Check(ob)) { 436 PyErr_Format( 437 PyExc_TypeError, 438 "%s.__bases__ must be tuple of old- or new-style classes, not '%s'", 439 type->tp_name, Py_TYPE(ob)->tp_name); 440 return -1; 441 } 442 if (PyType_Check(ob)) { 443 if (PyType_IsSubtype((PyTypeObject*)ob, type)) { 444 PyErr_SetString(PyExc_TypeError, 445 "a __bases__ item causes an inheritance cycle"); 446 return -1; 447 } 448 } 449 } 450 451 new_base = best_base(value); 452 453 if (!new_base) { 454 return -1; 455 } 456 457 if (!compatible_for_assignment(type->tp_base, new_base, "__bases__")) 458 return -1; 459 460 Py_INCREF(new_base); 461 Py_INCREF(value); 462 463 old_bases = type->tp_bases; 464 old_base = type->tp_base; 465 old_mro = type->tp_mro; 466 467 type->tp_bases = value; 468 type->tp_base = new_base; 469 470 if (mro_internal(type) < 0) { 471 goto bail; 472 } 473 474 temp = PyList_New(0); 475 if (!temp) 476 goto bail; 477 478 r = mro_subclasses(type, temp); 479 480 if (r < 0) { 481 for (i = 0; i < PyList_Size(temp); i++) { 482 PyTypeObject* cls; 483 PyObject* mro; 484 PyArg_UnpackTuple(PyList_GET_ITEM(temp, i), 485 "", 2, 2, &cls, &mro); 486 Py_INCREF(mro); 487 ob = cls->tp_mro; 488 cls->tp_mro = mro; 489 Py_DECREF(ob); 490 } 491 Py_DECREF(temp); 492 goto bail; 493 } 494 495 Py_DECREF(temp); 496 497 /* any base that was in __bases__ but now isn't, we 498 need to remove |type| from its tp_subclasses. 499 conversely, any class now in __bases__ that wasn't 500 needs to have |type| added to its subclasses. */ 501 502 /* for now, sod that: just remove from all old_bases, 503 add to all new_bases */ 504 505 for (i = PyTuple_GET_SIZE(old_bases) - 1; i >= 0; i--) { 506 ob = PyTuple_GET_ITEM(old_bases, i); 507 if (PyType_Check(ob)) { 508 remove_subclass( 509 (PyTypeObject*)ob, type); 510 } 511 } 512 513 for (i = PyTuple_GET_SIZE(value) - 1; i >= 0; i--) { 514 ob = PyTuple_GET_ITEM(value, i); 515 if (PyType_Check(ob)) { 516 if (add_subclass((PyTypeObject*)ob, type) < 0) 517 r = -1; 518 } 519 } 520 521 update_all_slots(type); 522 523 Py_DECREF(old_bases); 524 Py_DECREF(old_base); 525 Py_DECREF(old_mro); 526 527 return r; 528 529 bail: 530 Py_DECREF(type->tp_bases); 531 Py_DECREF(type->tp_base); 532 if (type->tp_mro != old_mro) { 533 Py_DECREF(type->tp_mro); 534 } 535 536 type->tp_bases = old_bases; 537 type->tp_base = old_base; 538 type->tp_mro = old_mro; 539 540 return -1; 541} 542 543static PyObject * 544type_dict(PyTypeObject *type, void *context) 545{ 546 if (type->tp_dict == NULL) { 547 Py_INCREF(Py_None); 548 return Py_None; 549 } 550 return PyDictProxy_New(type->tp_dict); 551} 552 553static PyObject * 554type_get_doc(PyTypeObject *type, void *context) 555{ 556 PyObject *result; 557 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL) 558 return PyString_FromString(type->tp_doc); 559 result = PyDict_GetItemString(type->tp_dict, "__doc__"); 560 if (result == NULL) { 561 result = Py_None; 562 Py_INCREF(result); 563 } 564 else if (Py_TYPE(result)->tp_descr_get) { 565 result = Py_TYPE(result)->tp_descr_get(result, NULL, 566 (PyObject *)type); 567 } 568 else { 569 Py_INCREF(result); 570 } 571 return result; 572} 573 574static PyObject * 575type___instancecheck__(PyObject *type, PyObject *inst) 576{ 577 switch (_PyObject_RealIsInstance(inst, type)) { 578 case -1: 579 return NULL; 580 case 0: 581 Py_RETURN_FALSE; 582 default: 583 Py_RETURN_TRUE; 584 } 585} 586 587 588static PyObject * 589type_get_instancecheck(PyObject *type, void *context) 590{ 591 static PyMethodDef ml = {"__instancecheck__", 592 type___instancecheck__, METH_O }; 593 return PyCFunction_New(&ml, type); 594} 595 596static PyObject * 597type___subclasscheck__(PyObject *type, PyObject *inst) 598{ 599 switch (_PyObject_RealIsSubclass(inst, type)) { 600 case -1: 601 return NULL; 602 case 0: 603 Py_RETURN_FALSE; 604 default: 605 Py_RETURN_TRUE; 606 } 607} 608 609static PyObject * 610type_get_subclasscheck(PyObject *type, void *context) 611{ 612 static PyMethodDef ml = {"__subclasscheck__", 613 type___subclasscheck__, METH_O }; 614 return PyCFunction_New(&ml, type); 615} 616 617static PyGetSetDef type_getsets[] = { 618 {"__name__", (getter)type_name, (setter)type_set_name, NULL}, 619 {"__bases__", (getter)type_get_bases, (setter)type_set_bases, NULL}, 620 {"__module__", (getter)type_module, (setter)type_set_module, NULL}, 621 {"__abstractmethods__", (getter)type_abstractmethods, 622 (setter)type_set_abstractmethods, NULL}, 623 {"__dict__", (getter)type_dict, NULL, NULL}, 624 {"__doc__", (getter)type_get_doc, NULL, NULL}, 625 {"__instancecheck__", (getter)type_get_instancecheck, NULL, NULL}, 626 {"__subclasscheck__", (getter)type_get_subclasscheck, NULL, NULL}, 627 {0} 628}; 629 630static int 631type_compare(PyObject *v, PyObject *w) 632{ 633 /* This is called with type objects only. So we 634 can just compare the addresses. */ 635 Py_uintptr_t vv = (Py_uintptr_t)v; 636 Py_uintptr_t ww = (Py_uintptr_t)w; 637 return (vv < ww) ? -1 : (vv > ww) ? 1 : 0; 638} 639 640static PyObject* 641type_richcompare(PyObject *v, PyObject *w, int op) 642{ 643 PyObject *result; 644 Py_uintptr_t vv, ww; 645 int c; 646 647 /* Make sure both arguments are types. */ 648 if (!PyType_Check(v) || !PyType_Check(w)) { 649 result = Py_NotImplemented; 650 goto out; 651 } 652 653 /* Py3K warning if comparison isn't == or != */ 654 if (Py_Py3kWarningFlag && op != Py_EQ && op != Py_NE && 655 PyErr_WarnEx(PyExc_DeprecationWarning, 656 "type inequality comparisons not supported " 657 "in 3.x", 1) < 0) { 658 return NULL; 659 } 660 661 /* Compare addresses */ 662 vv = (Py_uintptr_t)v; 663 ww = (Py_uintptr_t)w; 664 switch (op) { 665 case Py_LT: c = vv < ww; break; 666 case Py_LE: c = vv <= ww; break; 667 case Py_EQ: c = vv == ww; break; 668 case Py_NE: c = vv != ww; break; 669 case Py_GT: c = vv > ww; break; 670 case Py_GE: c = vv >= ww; break; 671 default: 672 result = Py_NotImplemented; 673 goto out; 674 } 675 result = c ? Py_True : Py_False; 676 677 /* incref and return */ 678 out: 679 Py_INCREF(result); 680 return result; 681} 682 683static PyObject * 684type_repr(PyTypeObject *type) 685{ 686 PyObject *mod, *name, *rtn; 687 char *kind; 688 689 mod = type_module(type, NULL); 690 if (mod == NULL) 691 PyErr_Clear(); 692 else if (!PyString_Check(mod)) { 693 Py_DECREF(mod); 694 mod = NULL; 695 } 696 name = type_name(type, NULL); 697 if (name == NULL) 698 return NULL; 699 700 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) 701 kind = "class"; 702 else 703 kind = "type"; 704 705 if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) { 706 rtn = PyString_FromFormat("<%s '%s.%s'>", 707 kind, 708 PyString_AS_STRING(mod), 709 PyString_AS_STRING(name)); 710 } 711 else 712 rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name); 713 714 Py_XDECREF(mod); 715 Py_DECREF(name); 716 return rtn; 717} 718 719static PyObject * 720type_call(PyTypeObject *type, PyObject *args, PyObject *kwds) 721{ 722 PyObject *obj; 723 724 if (type->tp_new == NULL) { 725 PyErr_Format(PyExc_TypeError, 726 "cannot create '%.100s' instances", 727 type->tp_name); 728 return NULL; 729 } 730 731 obj = type->tp_new(type, args, kwds); 732 if (obj != NULL) { 733 /* Ugly exception: when the call was type(something), 734 don't call tp_init on the result. */ 735 if (type == &PyType_Type && 736 PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 && 737 (kwds == NULL || 738 (PyDict_Check(kwds) && PyDict_Size(kwds) == 0))) 739 return obj; 740 /* If the returned object is not an instance of type, 741 it won't be initialized. */ 742 if (!PyType_IsSubtype(obj->ob_type, type)) 743 return obj; 744 type = obj->ob_type; 745 if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS) && 746 type->tp_init != NULL && 747 type->tp_init(obj, args, kwds) < 0) { 748 Py_DECREF(obj); 749 obj = NULL; 750 } 751 } 752 return obj; 753} 754 755PyObject * 756PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) 757{ 758 PyObject *obj; 759 const size_t size = _PyObject_VAR_SIZE(type, nitems+1); 760 /* note that we need to add one, for the sentinel */ 761 762 if (PyType_IS_GC(type)) 763 obj = _PyObject_GC_Malloc(size); 764 else 765 obj = (PyObject *)PyObject_MALLOC(size); 766 767 if (obj == NULL) 768 return PyErr_NoMemory(); 769 770 memset(obj, '\0', size); 771 772 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) 773 Py_INCREF(type); 774 775 if (type->tp_itemsize == 0) 776 PyObject_INIT(obj, type); 777 else 778 (void) PyObject_INIT_VAR((PyVarObject *)obj, type, nitems); 779 780 if (PyType_IS_GC(type)) 781 _PyObject_GC_TRACK(obj); 782 return obj; 783} 784 785PyObject * 786PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds) 787{ 788 return type->tp_alloc(type, 0); 789} 790 791/* Helpers for subtyping */ 792 793static int 794traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg) 795{ 796 Py_ssize_t i, n; 797 PyMemberDef *mp; 798 799 n = Py_SIZE(type); 800 mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type); 801 for (i = 0; i < n; i++, mp++) { 802 if (mp->type == T_OBJECT_EX) { 803 char *addr = (char *)self + mp->offset; 804 PyObject *obj = *(PyObject **)addr; 805 if (obj != NULL) { 806 int err = visit(obj, arg); 807 if (err) 808 return err; 809 } 810 } 811 } 812 return 0; 813} 814 815static int 816subtype_traverse(PyObject *self, visitproc visit, void *arg) 817{ 818 PyTypeObject *type, *base; 819 traverseproc basetraverse; 820 821 /* Find the nearest base with a different tp_traverse, 822 and traverse slots while we're at it */ 823 type = Py_TYPE(self); 824 base = type; 825 while ((basetraverse = base->tp_traverse) == subtype_traverse) { 826 if (Py_SIZE(base)) { 827 int err = traverse_slots(base, self, visit, arg); 828 if (err) 829 return err; 830 } 831 base = base->tp_base; 832 assert(base); 833 } 834 835 if (type->tp_dictoffset != base->tp_dictoffset) { 836 PyObject **dictptr = _PyObject_GetDictPtr(self); 837 if (dictptr && *dictptr) 838 Py_VISIT(*dictptr); 839 } 840 841 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) 842 /* For a heaptype, the instances count as references 843 to the type. Traverse the type so the collector 844 can find cycles involving this link. */ 845 Py_VISIT(type); 846 847 if (basetraverse) 848 return basetraverse(self, visit, arg); 849 return 0; 850} 851 852static void 853clear_slots(PyTypeObject *type, PyObject *self) 854{ 855 Py_ssize_t i, n; 856 PyMemberDef *mp; 857 858 n = Py_SIZE(type); 859 mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type); 860 for (i = 0; i < n; i++, mp++) { 861 if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) { 862 char *addr = (char *)self + mp->offset; 863 PyObject *obj = *(PyObject **)addr; 864 if (obj != NULL) { 865 *(PyObject **)addr = NULL; 866 Py_DECREF(obj); 867 } 868 } 869 } 870} 871 872static int 873subtype_clear(PyObject *self) 874{ 875 PyTypeObject *type, *base; 876 inquiry baseclear; 877 878 /* Find the nearest base with a different tp_clear 879 and clear slots while we're at it */ 880 type = Py_TYPE(self); 881 base = type; 882 while ((baseclear = base->tp_clear) == subtype_clear) { 883 if (Py_SIZE(base)) 884 clear_slots(base, self); 885 base = base->tp_base; 886 assert(base); 887 } 888 889 /* There's no need to clear the instance dict (if any); 890 the collector will call its tp_clear handler. */ 891 892 if (baseclear) 893 return baseclear(self); 894 return 0; 895} 896 897static void 898subtype_dealloc(PyObject *self) 899{ 900 PyTypeObject *type, *base; 901 destructor basedealloc; 902 903 /* Extract the type; we expect it to be a heap type */ 904 type = Py_TYPE(self); 905 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 906 907 /* Test whether the type has GC exactly once */ 908 909 if (!PyType_IS_GC(type)) { 910 /* It's really rare to find a dynamic type that doesn't have 911 GC; it can only happen when deriving from 'object' and not 912 adding any slots or instance variables. This allows 913 certain simplifications: there's no need to call 914 clear_slots(), or DECREF the dict, or clear weakrefs. */ 915 916 /* Maybe call finalizer; exit early if resurrected */ 917 if (type->tp_del) { 918 type->tp_del(self); 919 if (self->ob_refcnt > 0) 920 return; 921 } 922 923 /* Find the nearest base with a different tp_dealloc */ 924 base = type; 925 while ((basedealloc = base->tp_dealloc) == subtype_dealloc) { 926 assert(Py_SIZE(base) == 0); 927 base = base->tp_base; 928 assert(base); 929 } 930 931 /* Extract the type again; tp_del may have changed it */ 932 type = Py_TYPE(self); 933 934 /* Call the base tp_dealloc() */ 935 assert(basedealloc); 936 basedealloc(self); 937 938 /* Can't reference self beyond this point */ 939 Py_DECREF(type); 940 941 /* Done */ 942 return; 943 } 944 945 /* We get here only if the type has GC */ 946 947 /* UnTrack and re-Track around the trashcan macro, alas */ 948 /* See explanation at end of function for full disclosure */ 949 PyObject_GC_UnTrack(self); 950 ++_PyTrash_delete_nesting; 951 Py_TRASHCAN_SAFE_BEGIN(self); 952 --_PyTrash_delete_nesting; 953 /* DO NOT restore GC tracking at this point. weakref callbacks 954 * (if any, and whether directly here or indirectly in something we 955 * call) may trigger GC, and if self is tracked at that point, it 956 * will look like trash to GC and GC will try to delete self again. 957 */ 958 959 /* Find the nearest base with a different tp_dealloc */ 960 base = type; 961 while ((basedealloc = base->tp_dealloc) == subtype_dealloc) { 962 base = base->tp_base; 963 assert(base); 964 } 965 966 /* If we added a weaklist, we clear it. Do this *before* calling 967 the finalizer (__del__), clearing slots, or clearing the instance 968 dict. */ 969 970 if (type->tp_weaklistoffset && !base->tp_weaklistoffset) 971 PyObject_ClearWeakRefs(self); 972 973 /* Maybe call finalizer; exit early if resurrected */ 974 if (type->tp_del) { 975 _PyObject_GC_TRACK(self); 976 type->tp_del(self); 977 if (self->ob_refcnt > 0) 978 goto endlabel; /* resurrected */ 979 else 980 _PyObject_GC_UNTRACK(self); 981 /* New weakrefs could be created during the finalizer call. 982 If this occurs, clear them out without calling their 983 finalizers since they might rely on part of the object 984 being finalized that has already been destroyed. */ 985 if (type->tp_weaklistoffset && !base->tp_weaklistoffset) { 986 /* Modeled after GET_WEAKREFS_LISTPTR() */ 987 PyWeakReference **list = (PyWeakReference **) \ 988 PyObject_GET_WEAKREFS_LISTPTR(self); 989 while (*list) 990 _PyWeakref_ClearRef(*list); 991 } 992 } 993 994 /* Clear slots up to the nearest base with a different tp_dealloc */ 995 base = type; 996 while ((basedealloc = base->tp_dealloc) == subtype_dealloc) { 997 if (Py_SIZE(base)) 998 clear_slots(base, self); 999 base = base->tp_base; 1000 assert(base); 1001 } 1002 1003 /* If we added a dict, DECREF it */ 1004 if (type->tp_dictoffset && !base->tp_dictoffset) { 1005 PyObject **dictptr = _PyObject_GetDictPtr(self); 1006 if (dictptr != NULL) { 1007 PyObject *dict = *dictptr; 1008 if (dict != NULL) { 1009 Py_DECREF(dict); 1010 *dictptr = NULL; 1011 } 1012 } 1013 } 1014 1015 /* Extract the type again; tp_del may have changed it */ 1016 type = Py_TYPE(self); 1017 1018 /* Call the base tp_dealloc(); first retrack self if 1019 * basedealloc knows about gc. 1020 */ 1021 if (PyType_IS_GC(base)) 1022 _PyObject_GC_TRACK(self); 1023 assert(basedealloc); 1024 basedealloc(self); 1025 1026 /* Can't reference self beyond this point */ 1027 Py_DECREF(type); 1028 1029 endlabel: 1030 ++_PyTrash_delete_nesting; 1031 Py_TRASHCAN_SAFE_END(self); 1032 --_PyTrash_delete_nesting; 1033 1034 /* Explanation of the weirdness around the trashcan macros: 1035 1036 Q. What do the trashcan macros do? 1037 1038 A. Read the comment titled "Trashcan mechanism" in object.h. 1039 For one, this explains why there must be a call to GC-untrack 1040 before the trashcan begin macro. Without understanding the 1041 trashcan code, the answers to the following questions don't make 1042 sense. 1043 1044 Q. Why do we GC-untrack before the trashcan and then immediately 1045 GC-track again afterward? 1046 1047 A. In the case that the base class is GC-aware, the base class 1048 probably GC-untracks the object. If it does that using the 1049 UNTRACK macro, this will crash when the object is already 1050 untracked. Because we don't know what the base class does, the 1051 only safe thing is to make sure the object is tracked when we 1052 call the base class dealloc. But... The trashcan begin macro 1053 requires that the object is *untracked* before it is called. So 1054 the dance becomes: 1055 1056 GC untrack 1057 trashcan begin 1058 GC track 1059 1060 Q. Why did the last question say "immediately GC-track again"? 1061 It's nowhere near immediately. 1062 1063 A. Because the code *used* to re-track immediately. Bad Idea. 1064 self has a refcount of 0, and if gc ever gets its hands on it 1065 (which can happen if any weakref callback gets invoked), it 1066 looks like trash to gc too, and gc also tries to delete self 1067 then. But we're already deleting self. Double dealloction is 1068 a subtle disaster. 1069 1070 Q. Why the bizarre (net-zero) manipulation of 1071 _PyTrash_delete_nesting around the trashcan macros? 1072 1073 A. Some base classes (e.g. list) also use the trashcan mechanism. 1074 The following scenario used to be possible: 1075 1076 - suppose the trashcan level is one below the trashcan limit 1077 1078 - subtype_dealloc() is called 1079 1080 - the trashcan limit is not yet reached, so the trashcan level 1081 is incremented and the code between trashcan begin and end is 1082 executed 1083 1084 - this destroys much of the object's contents, including its 1085 slots and __dict__ 1086 1087 - basedealloc() is called; this is really list_dealloc(), or 1088 some other type which also uses the trashcan macros 1089 1090 - the trashcan limit is now reached, so the object is put on the 1091 trashcan's to-be-deleted-later list 1092 1093 - basedealloc() returns 1094 1095 - subtype_dealloc() decrefs the object's type 1096 1097 - subtype_dealloc() returns 1098 1099 - later, the trashcan code starts deleting the objects from its 1100 to-be-deleted-later list 1101 1102 - subtype_dealloc() is called *AGAIN* for the same object 1103 1104 - at the very least (if the destroyed slots and __dict__ don't 1105 cause problems) the object's type gets decref'ed a second 1106 time, which is *BAD*!!! 1107 1108 The remedy is to make sure that if the code between trashcan 1109 begin and end in subtype_dealloc() is called, the code between 1110 trashcan begin and end in basedealloc() will also be called. 1111 This is done by decrementing the level after passing into the 1112 trashcan block, and incrementing it just before leaving the 1113 block. 1114 1115 But now it's possible that a chain of objects consisting solely 1116 of objects whose deallocator is subtype_dealloc() will defeat 1117 the trashcan mechanism completely: the decremented level means 1118 that the effective level never reaches the limit. Therefore, we 1119 *increment* the level *before* entering the trashcan block, and 1120 matchingly decrement it after leaving. This means the trashcan 1121 code will trigger a little early, but that's no big deal. 1122 1123 Q. Are there any live examples of code in need of all this 1124 complexity? 1125 1126 A. Yes. See SF bug 668433 for code that crashed (when Python was 1127 compiled in debug mode) before the trashcan level manipulations 1128 were added. For more discussion, see SF patches 581742, 575073 1129 and bug 574207. 1130 */ 1131} 1132 1133static PyTypeObject *solid_base(PyTypeObject *type); 1134 1135/* type test with subclassing support */ 1136 1137int 1138PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b) 1139{ 1140 PyObject *mro; 1141 1142 if (!(a->tp_flags & Py_TPFLAGS_HAVE_CLASS)) 1143 return b == a || b == &PyBaseObject_Type; 1144 1145 mro = a->tp_mro; 1146 if (mro != NULL) { 1147 /* Deal with multiple inheritance without recursion 1148 by walking the MRO tuple */ 1149 Py_ssize_t i, n; 1150 assert(PyTuple_Check(mro)); 1151 n = PyTuple_GET_SIZE(mro); 1152 for (i = 0; i < n; i++) { 1153 if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) 1154 return 1; 1155 } 1156 return 0; 1157 } 1158 else { 1159 /* a is not completely initilized yet; follow tp_base */ 1160 do { 1161 if (a == b) 1162 return 1; 1163 a = a->tp_base; 1164 } while (a != NULL); 1165 return b == &PyBaseObject_Type; 1166 } 1167} 1168 1169/* Internal routines to do a method lookup in the type 1170 without looking in the instance dictionary 1171 (so we can't use PyObject_GetAttr) but still binding 1172 it to the instance. The arguments are the object, 1173 the method name as a C string, and the address of a 1174 static variable used to cache the interned Python string. 1175 1176 Two variants: 1177 1178 - lookup_maybe() returns NULL without raising an exception 1179 when the _PyType_Lookup() call fails; 1180 1181 - lookup_method() always raises an exception upon errors. 1182*/ 1183 1184static PyObject * 1185lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj) 1186{ 1187 PyObject *res; 1188 1189 if (*attrobj == NULL) { 1190 *attrobj = PyString_InternFromString(attrstr); 1191 if (*attrobj == NULL) 1192 return NULL; 1193 } 1194 res = _PyType_Lookup(Py_TYPE(self), *attrobj); 1195 if (res != NULL) { 1196 descrgetfunc f; 1197 if ((f = Py_TYPE(res)->tp_descr_get) == NULL) 1198 Py_INCREF(res); 1199 else 1200 res = f(res, self, (PyObject *)(Py_TYPE(self))); 1201 } 1202 return res; 1203} 1204 1205static PyObject * 1206lookup_method(PyObject *self, char *attrstr, PyObject **attrobj) 1207{ 1208 PyObject *res = lookup_maybe(self, attrstr, attrobj); 1209 if (res == NULL && !PyErr_Occurred()) 1210 PyErr_SetObject(PyExc_AttributeError, *attrobj); 1211 return res; 1212} 1213 1214/* A variation of PyObject_CallMethod that uses lookup_method() 1215 instead of PyObject_GetAttrString(). This uses the same convention 1216 as lookup_method to cache the interned name string object. */ 1217 1218static PyObject * 1219call_method(PyObject *o, char *name, PyObject **nameobj, char *format, ...) 1220{ 1221 va_list va; 1222 PyObject *args, *func = 0, *retval; 1223 va_start(va, format); 1224 1225 func = lookup_maybe(o, name, nameobj); 1226 if (func == NULL) { 1227 va_end(va); 1228 if (!PyErr_Occurred()) 1229 PyErr_SetObject(PyExc_AttributeError, *nameobj); 1230 return NULL; 1231 } 1232 1233 if (format && *format) 1234 args = Py_VaBuildValue(format, va); 1235 else 1236 args = PyTuple_New(0); 1237 1238 va_end(va); 1239 1240 if (args == NULL) 1241 return NULL; 1242 1243 assert(PyTuple_Check(args)); 1244 retval = PyObject_Call(func, args, NULL); 1245 1246 Py_DECREF(args); 1247 Py_DECREF(func); 1248 1249 return retval; 1250} 1251 1252/* Clone of call_method() that returns NotImplemented when the lookup fails. */ 1253 1254static PyObject * 1255call_maybe(PyObject *o, char *name, PyObject **nameobj, char *format, ...) 1256{ 1257 va_list va; 1258 PyObject *args, *func = 0, *retval; 1259 va_start(va, format); 1260 1261 func = lookup_maybe(o, name, nameobj); 1262 if (func == NULL) { 1263 va_end(va); 1264 if (!PyErr_Occurred()) { 1265 Py_INCREF(Py_NotImplemented); 1266 return Py_NotImplemented; 1267 } 1268 return NULL; 1269 } 1270 1271 if (format && *format) 1272 args = Py_VaBuildValue(format, va); 1273 else 1274 args = PyTuple_New(0); 1275 1276 va_end(va); 1277 1278 if (args == NULL) 1279 return NULL; 1280 1281 assert(PyTuple_Check(args)); 1282 retval = PyObject_Call(func, args, NULL); 1283 1284 Py_DECREF(args); 1285 Py_DECREF(func); 1286 1287 return retval; 1288} 1289 1290static int 1291fill_classic_mro(PyObject *mro, PyObject *cls) 1292{ 1293 PyObject *bases, *base; 1294 Py_ssize_t i, n; 1295 1296 assert(PyList_Check(mro)); 1297 assert(PyClass_Check(cls)); 1298 i = PySequence_Contains(mro, cls); 1299 if (i < 0) 1300 return -1; 1301 if (!i) { 1302 if (PyList_Append(mro, cls) < 0) 1303 return -1; 1304 } 1305 bases = ((PyClassObject *)cls)->cl_bases; 1306 assert(bases && PyTuple_Check(bases)); 1307 n = PyTuple_GET_SIZE(bases); 1308 for (i = 0; i < n; i++) { 1309 base = PyTuple_GET_ITEM(bases, i); 1310 if (fill_classic_mro(mro, base) < 0) 1311 return -1; 1312 } 1313 return 0; 1314} 1315 1316static PyObject * 1317classic_mro(PyObject *cls) 1318{ 1319 PyObject *mro; 1320 1321 assert(PyClass_Check(cls)); 1322 mro = PyList_New(0); 1323 if (mro != NULL) { 1324 if (fill_classic_mro(mro, cls) == 0) 1325 return mro; 1326 Py_DECREF(mro); 1327 } 1328 return NULL; 1329} 1330 1331/* 1332 Method resolution order algorithm C3 described in 1333 "A Monotonic Superclass Linearization for Dylan", 1334 by Kim Barrett, Bob Cassel, Paul Haahr, 1335 David A. Moon, Keith Playford, and P. Tucker Withington. 1336 (OOPSLA 1996) 1337 1338 Some notes about the rules implied by C3: 1339 1340 No duplicate bases. 1341 It isn't legal to repeat a class in a list of base classes. 1342 1343 The next three properties are the 3 constraints in "C3". 1344 1345 Local precendece order. 1346 If A precedes B in C's MRO, then A will precede B in the MRO of all 1347 subclasses of C. 1348 1349 Monotonicity. 1350 The MRO of a class must be an extension without reordering of the 1351 MRO of each of its superclasses. 1352 1353 Extended Precedence Graph (EPG). 1354 Linearization is consistent if there is a path in the EPG from 1355 each class to all its successors in the linearization. See 1356 the paper for definition of EPG. 1357 */ 1358 1359static int 1360tail_contains(PyObject *list, int whence, PyObject *o) { 1361 Py_ssize_t j, size; 1362 size = PyList_GET_SIZE(list); 1363 1364 for (j = whence+1; j < size; j++) { 1365 if (PyList_GET_ITEM(list, j) == o) 1366 return 1; 1367 } 1368 return 0; 1369} 1370 1371static PyObject * 1372class_name(PyObject *cls) 1373{ 1374 PyObject *name = PyObject_GetAttrString(cls, "__name__"); 1375 if (name == NULL) { 1376 PyErr_Clear(); 1377 Py_XDECREF(name); 1378 name = PyObject_Repr(cls); 1379 } 1380 if (name == NULL) 1381 return NULL; 1382 if (!PyString_Check(name)) { 1383 Py_DECREF(name); 1384 return NULL; 1385 } 1386 return name; 1387} 1388 1389static int 1390check_duplicates(PyObject *list) 1391{ 1392 Py_ssize_t i, j, n; 1393 /* Let's use a quadratic time algorithm, 1394 assuming that the bases lists is short. 1395 */ 1396 n = PyList_GET_SIZE(list); 1397 for (i = 0; i < n; i++) { 1398 PyObject *o = PyList_GET_ITEM(list, i); 1399 for (j = i + 1; j < n; j++) { 1400 if (PyList_GET_ITEM(list, j) == o) { 1401 o = class_name(o); 1402 PyErr_Format(PyExc_TypeError, 1403 "duplicate base class %s", 1404 o ? PyString_AS_STRING(o) : "?"); 1405 Py_XDECREF(o); 1406 return -1; 1407 } 1408 } 1409 } 1410 return 0; 1411} 1412 1413/* Raise a TypeError for an MRO order disagreement. 1414 1415 It's hard to produce a good error message. In the absence of better 1416 insight into error reporting, report the classes that were candidates 1417 to be put next into the MRO. There is some conflict between the 1418 order in which they should be put in the MRO, but it's hard to 1419 diagnose what constraint can't be satisfied. 1420*/ 1421 1422static void 1423set_mro_error(PyObject *to_merge, int *remain) 1424{ 1425 Py_ssize_t i, n, off, to_merge_size; 1426 char buf[1000]; 1427 PyObject *k, *v; 1428 PyObject *set = PyDict_New(); 1429 if (!set) return; 1430 1431 to_merge_size = PyList_GET_SIZE(to_merge); 1432 for (i = 0; i < to_merge_size; i++) { 1433 PyObject *L = PyList_GET_ITEM(to_merge, i); 1434 if (remain[i] < PyList_GET_SIZE(L)) { 1435 PyObject *c = PyList_GET_ITEM(L, remain[i]); 1436 if (PyDict_SetItem(set, c, Py_None) < 0) { 1437 Py_DECREF(set); 1438 return; 1439 } 1440 } 1441 } 1442 n = PyDict_Size(set); 1443 1444 off = PyOS_snprintf(buf, sizeof(buf), "Cannot create a \ 1445consistent method resolution\norder (MRO) for bases"); 1446 i = 0; 1447 while (PyDict_Next(set, &i, &k, &v) && (size_t)off < sizeof(buf)) { 1448 PyObject *name = class_name(k); 1449 off += PyOS_snprintf(buf + off, sizeof(buf) - off, " %s", 1450 name ? PyString_AS_STRING(name) : "?"); 1451 Py_XDECREF(name); 1452 if (--n && (size_t)(off+1) < sizeof(buf)) { 1453 buf[off++] = ','; 1454 buf[off] = '\0'; 1455 } 1456 } 1457 PyErr_SetString(PyExc_TypeError, buf); 1458 Py_DECREF(set); 1459} 1460 1461static int 1462pmerge(PyObject *acc, PyObject* to_merge) { 1463 Py_ssize_t i, j, to_merge_size, empty_cnt; 1464 int *remain; 1465 int ok; 1466 1467 to_merge_size = PyList_GET_SIZE(to_merge); 1468 1469 /* remain stores an index into each sublist of to_merge. 1470 remain[i] is the index of the next base in to_merge[i] 1471 that is not included in acc. 1472 */ 1473 remain = (int *)PyMem_MALLOC(SIZEOF_INT*to_merge_size); 1474 if (remain == NULL) 1475 return -1; 1476 for (i = 0; i < to_merge_size; i++) 1477 remain[i] = 0; 1478 1479 again: 1480 empty_cnt = 0; 1481 for (i = 0; i < to_merge_size; i++) { 1482 PyObject *candidate; 1483 1484 PyObject *cur_list = PyList_GET_ITEM(to_merge, i); 1485 1486 if (remain[i] >= PyList_GET_SIZE(cur_list)) { 1487 empty_cnt++; 1488 continue; 1489 } 1490 1491 /* Choose next candidate for MRO. 1492 1493 The input sequences alone can determine the choice. 1494 If not, choose the class which appears in the MRO 1495 of the earliest direct superclass of the new class. 1496 */ 1497 1498 candidate = PyList_GET_ITEM(cur_list, remain[i]); 1499 for (j = 0; j < to_merge_size; j++) { 1500 PyObject *j_lst = PyList_GET_ITEM(to_merge, j); 1501 if (tail_contains(j_lst, remain[j], candidate)) { 1502 goto skip; /* continue outer loop */ 1503 } 1504 } 1505 ok = PyList_Append(acc, candidate); 1506 if (ok < 0) { 1507 PyMem_Free(remain); 1508 return -1; 1509 } 1510 for (j = 0; j < to_merge_size; j++) { 1511 PyObject *j_lst = PyList_GET_ITEM(to_merge, j); 1512 if (remain[j] < PyList_GET_SIZE(j_lst) && 1513 PyList_GET_ITEM(j_lst, remain[j]) == candidate) { 1514 remain[j]++; 1515 } 1516 } 1517 goto again; 1518 skip: ; 1519 } 1520 1521 if (empty_cnt == to_merge_size) { 1522 PyMem_FREE(remain); 1523 return 0; 1524 } 1525 set_mro_error(to_merge, remain); 1526 PyMem_FREE(remain); 1527 return -1; 1528} 1529 1530static PyObject * 1531mro_implementation(PyTypeObject *type) 1532{ 1533 Py_ssize_t i, n; 1534 int ok; 1535 PyObject *bases, *result; 1536 PyObject *to_merge, *bases_aslist; 1537 1538 if (type->tp_dict == NULL) { 1539 if (PyType_Ready(type) < 0) 1540 return NULL; 1541 } 1542 1543 /* Find a superclass linearization that honors the constraints 1544 of the explicit lists of bases and the constraints implied by 1545 each base class. 1546 1547 to_merge is a list of lists, where each list is a superclass 1548 linearization implied by a base class. The last element of 1549 to_merge is the declared list of bases. 1550 */ 1551 1552 bases = type->tp_bases; 1553 n = PyTuple_GET_SIZE(bases); 1554 1555 to_merge = PyList_New(n+1); 1556 if (to_merge == NULL) 1557 return NULL; 1558 1559 for (i = 0; i < n; i++) { 1560 PyObject *base = PyTuple_GET_ITEM(bases, i); 1561 PyObject *parentMRO; 1562 if (PyType_Check(base)) 1563 parentMRO = PySequence_List( 1564 ((PyTypeObject*)base)->tp_mro); 1565 else 1566 parentMRO = classic_mro(base); 1567 if (parentMRO == NULL) { 1568 Py_DECREF(to_merge); 1569 return NULL; 1570 } 1571 1572 PyList_SET_ITEM(to_merge, i, parentMRO); 1573 } 1574 1575 bases_aslist = PySequence_List(bases); 1576 if (bases_aslist == NULL) { 1577 Py_DECREF(to_merge); 1578 return NULL; 1579 } 1580 /* This is just a basic sanity check. */ 1581 if (check_duplicates(bases_aslist) < 0) { 1582 Py_DECREF(to_merge); 1583 Py_DECREF(bases_aslist); 1584 return NULL; 1585 } 1586 PyList_SET_ITEM(to_merge, n, bases_aslist); 1587 1588 result = Py_BuildValue("[O]", (PyObject *)type); 1589 if (result == NULL) { 1590 Py_DECREF(to_merge); 1591 return NULL; 1592 } 1593 1594 ok = pmerge(result, to_merge); 1595 Py_DECREF(to_merge); 1596 if (ok < 0) { 1597 Py_DECREF(result); 1598 return NULL; 1599 } 1600 1601 return result; 1602} 1603 1604static PyObject * 1605mro_external(PyObject *self) 1606{ 1607 PyTypeObject *type = (PyTypeObject *)self; 1608 1609 return mro_implementation(type); 1610} 1611 1612static int 1613mro_internal(PyTypeObject *type) 1614{ 1615 PyObject *mro, *result, *tuple; 1616 int checkit = 0; 1617 1618 if (Py_TYPE(type) == &PyType_Type) { 1619 result = mro_implementation(type); 1620 } 1621 else { 1622 static PyObject *mro_str; 1623 checkit = 1; 1624 mro = lookup_method((PyObject *)type, "mro", &mro_str); 1625 if (mro == NULL) 1626 return -1; 1627 result = PyObject_CallObject(mro, NULL); 1628 Py_DECREF(mro); 1629 } 1630 if (result == NULL) 1631 return -1; 1632 tuple = PySequence_Tuple(result); 1633 Py_DECREF(result); 1634 if (tuple == NULL) 1635 return -1; 1636 if (checkit) { 1637 Py_ssize_t i, len; 1638 PyObject *cls; 1639 PyTypeObject *solid; 1640 1641 solid = solid_base(type); 1642 1643 len = PyTuple_GET_SIZE(tuple); 1644 1645 for (i = 0; i < len; i++) { 1646 PyTypeObject *t; 1647 cls = PyTuple_GET_ITEM(tuple, i); 1648 if (PyClass_Check(cls)) 1649 continue; 1650 else if (!PyType_Check(cls)) { 1651 PyErr_Format(PyExc_TypeError, 1652 "mro() returned a non-class ('%.500s')", 1653 Py_TYPE(cls)->tp_name); 1654 Py_DECREF(tuple); 1655 return -1; 1656 } 1657 t = (PyTypeObject*)cls; 1658 if (!PyType_IsSubtype(solid, solid_base(t))) { 1659 PyErr_Format(PyExc_TypeError, 1660 "mro() returned base with unsuitable layout ('%.500s')", 1661 t->tp_name); 1662 Py_DECREF(tuple); 1663 return -1; 1664 } 1665 } 1666 } 1667 type->tp_mro = tuple; 1668 1669 type_mro_modified(type, type->tp_mro); 1670 /* corner case: the old-style super class might have been hidden 1671 from the custom MRO */ 1672 type_mro_modified(type, type->tp_bases); 1673 1674 PyType_Modified(type); 1675 1676 return 0; 1677} 1678 1679 1680/* Calculate the best base amongst multiple base classes. 1681 This is the first one that's on the path to the "solid base". */ 1682 1683static PyTypeObject * 1684best_base(PyObject *bases) 1685{ 1686 Py_ssize_t i, n; 1687 PyTypeObject *base, *winner, *candidate, *base_i; 1688 PyObject *base_proto; 1689 1690 assert(PyTuple_Check(bases)); 1691 n = PyTuple_GET_SIZE(bases); 1692 assert(n > 0); 1693 base = NULL; 1694 winner = NULL; 1695 for (i = 0; i < n; i++) { 1696 base_proto = PyTuple_GET_ITEM(bases, i); 1697 if (PyClass_Check(base_proto)) 1698 continue; 1699 if (!PyType_Check(base_proto)) { 1700 PyErr_SetString( 1701 PyExc_TypeError, 1702 "bases must be types"); 1703 return NULL; 1704 } 1705 base_i = (PyTypeObject *)base_proto; 1706 if (base_i->tp_dict == NULL) { 1707 if (PyType_Ready(base_i) < 0) 1708 return NULL; 1709 } 1710 candidate = solid_base(base_i); 1711 if (winner == NULL) { 1712 winner = candidate; 1713 base = base_i; 1714 } 1715 else if (PyType_IsSubtype(winner, candidate)) 1716 ; 1717 else if (PyType_IsSubtype(candidate, winner)) { 1718 winner = candidate; 1719 base = base_i; 1720 } 1721 else { 1722 PyErr_SetString( 1723 PyExc_TypeError, 1724 "multiple bases have " 1725 "instance lay-out conflict"); 1726 return NULL; 1727 } 1728 } 1729 if (base == NULL) 1730 PyErr_SetString(PyExc_TypeError, 1731 "a new-style class can't have only classic bases"); 1732 return base; 1733} 1734 1735static int 1736extra_ivars(PyTypeObject *type, PyTypeObject *base) 1737{ 1738 size_t t_size = type->tp_basicsize; 1739 size_t b_size = base->tp_basicsize; 1740 1741 assert(t_size >= b_size); /* Else type smaller than base! */ 1742 if (type->tp_itemsize || base->tp_itemsize) { 1743 /* If itemsize is involved, stricter rules */ 1744 return t_size != b_size || 1745 type->tp_itemsize != base->tp_itemsize; 1746 } 1747 if (type->tp_weaklistoffset && base->tp_weaklistoffset == 0 && 1748 type->tp_weaklistoffset + sizeof(PyObject *) == t_size && 1749 type->tp_flags & Py_TPFLAGS_HEAPTYPE) 1750 t_size -= sizeof(PyObject *); 1751 if (type->tp_dictoffset && base->tp_dictoffset == 0 && 1752 type->tp_dictoffset + sizeof(PyObject *) == t_size && 1753 type->tp_flags & Py_TPFLAGS_HEAPTYPE) 1754 t_size -= sizeof(PyObject *); 1755 1756 return t_size != b_size; 1757} 1758 1759static PyTypeObject * 1760solid_base(PyTypeObject *type) 1761{ 1762 PyTypeObject *base; 1763 1764 if (type->tp_base) 1765 base = solid_base(type->tp_base); 1766 else 1767 base = &PyBaseObject_Type; 1768 if (extra_ivars(type, base)) 1769 return type; 1770 else 1771 return base; 1772} 1773 1774static void object_dealloc(PyObject *); 1775static int object_init(PyObject *, PyObject *, PyObject *); 1776static int update_slot(PyTypeObject *, PyObject *); 1777static void fixup_slot_dispatchers(PyTypeObject *); 1778 1779/* 1780 * Helpers for __dict__ descriptor. We don't want to expose the dicts 1781 * inherited from various builtin types. The builtin base usually provides 1782 * its own __dict__ descriptor, so we use that when we can. 1783 */ 1784static PyTypeObject * 1785get_builtin_base_with_dict(PyTypeObject *type) 1786{ 1787 while (type->tp_base != NULL) { 1788 if (type->tp_dictoffset != 0 && 1789 !(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) 1790 return type; 1791 type = type->tp_base; 1792 } 1793 return NULL; 1794} 1795 1796static PyObject * 1797get_dict_descriptor(PyTypeObject *type) 1798{ 1799 static PyObject *dict_str; 1800 PyObject *descr; 1801 1802 if (dict_str == NULL) { 1803 dict_str = PyString_InternFromString("__dict__"); 1804 if (dict_str == NULL) 1805 return NULL; 1806 } 1807 descr = _PyType_Lookup(type, dict_str); 1808 if (descr == NULL || !PyDescr_IsData(descr)) 1809 return NULL; 1810 1811 return descr; 1812} 1813 1814static void 1815raise_dict_descr_error(PyObject *obj) 1816{ 1817 PyErr_Format(PyExc_TypeError, 1818 "this __dict__ descriptor does not support " 1819 "'%.200s' objects", obj->ob_type->tp_name); 1820} 1821 1822static PyObject * 1823subtype_dict(PyObject *obj, void *context) 1824{ 1825 PyObject **dictptr; 1826 PyObject *dict; 1827 PyTypeObject *base; 1828 1829 base = get_builtin_base_with_dict(obj->ob_type); 1830 if (base != NULL) { 1831 descrgetfunc func; 1832 PyObject *descr = get_dict_descriptor(base); 1833 if (descr == NULL) { 1834 raise_dict_descr_error(obj); 1835 return NULL; 1836 } 1837 func = descr->ob_type->tp_descr_get; 1838 if (func == NULL) { 1839 raise_dict_descr_error(obj); 1840 return NULL; 1841 } 1842 return func(descr, obj, (PyObject *)(obj->ob_type)); 1843 } 1844 1845 dictptr = _PyObject_GetDictPtr(obj); 1846 if (dictptr == NULL) { 1847 PyErr_SetString(PyExc_AttributeError, 1848 "This object has no __dict__"); 1849 return NULL; 1850 } 1851 dict = *dictptr; 1852 if (dict == NULL) 1853 *dictptr = dict = PyDict_New(); 1854 Py_XINCREF(dict); 1855 return dict; 1856} 1857 1858static int 1859subtype_setdict(PyObject *obj, PyObject *value, void *context) 1860{ 1861 PyObject **dictptr; 1862 PyObject *dict; 1863 PyTypeObject *base; 1864 1865 base = get_builtin_base_with_dict(obj->ob_type); 1866 if (base != NULL) { 1867 descrsetfunc func; 1868 PyObject *descr = get_dict_descriptor(base); 1869 if (descr == NULL) { 1870 raise_dict_descr_error(obj); 1871 return -1; 1872 } 1873 func = descr->ob_type->tp_descr_set; 1874 if (func == NULL) { 1875 raise_dict_descr_error(obj); 1876 return -1; 1877 } 1878 return func(descr, obj, value); 1879 } 1880 1881 dictptr = _PyObject_GetDictPtr(obj); 1882 if (dictptr == NULL) { 1883 PyErr_SetString(PyExc_AttributeError, 1884 "This object has no __dict__"); 1885 return -1; 1886 } 1887 if (value != NULL && !PyDict_Check(value)) { 1888 PyErr_Format(PyExc_TypeError, 1889 "__dict__ must be set to a dictionary, " 1890 "not a '%.200s'", Py_TYPE(value)->tp_name); 1891 return -1; 1892 } 1893 dict = *dictptr; 1894 Py_XINCREF(value); 1895 *dictptr = value; 1896 Py_XDECREF(dict); 1897 return 0; 1898} 1899 1900static PyObject * 1901subtype_getweakref(PyObject *obj, void *context) 1902{ 1903 PyObject **weaklistptr; 1904 PyObject *result; 1905 1906 if (Py_TYPE(obj)->tp_weaklistoffset == 0) { 1907 PyErr_SetString(PyExc_AttributeError, 1908 "This object has no __weakref__"); 1909 return NULL; 1910 } 1911 assert(Py_TYPE(obj)->tp_weaklistoffset > 0); 1912 assert(Py_TYPE(obj)->tp_weaklistoffset + sizeof(PyObject *) <= 1913 (size_t)(Py_TYPE(obj)->tp_basicsize)); 1914 weaklistptr = (PyObject **) 1915 ((char *)obj + Py_TYPE(obj)->tp_weaklistoffset); 1916 if (*weaklistptr == NULL) 1917 result = Py_None; 1918 else 1919 result = *weaklistptr; 1920 Py_INCREF(result); 1921 return result; 1922} 1923 1924/* Three variants on the subtype_getsets list. */ 1925 1926static PyGetSetDef subtype_getsets_full[] = { 1927 {"__dict__", subtype_dict, subtype_setdict, 1928 PyDoc_STR("dictionary for instance variables (if defined)")}, 1929 {"__weakref__", subtype_getweakref, NULL, 1930 PyDoc_STR("list of weak references to the object (if defined)")}, 1931 {0} 1932}; 1933 1934static PyGetSetDef subtype_getsets_dict_only[] = { 1935 {"__dict__", subtype_dict, subtype_setdict, 1936 PyDoc_STR("dictionary for instance variables (if defined)")}, 1937 {0} 1938}; 1939 1940static PyGetSetDef subtype_getsets_weakref_only[] = { 1941 {"__weakref__", subtype_getweakref, NULL, 1942 PyDoc_STR("list of weak references to the object (if defined)")}, 1943 {0} 1944}; 1945 1946static int 1947valid_identifier(PyObject *s) 1948{ 1949 unsigned char *p; 1950 Py_ssize_t i, n; 1951 1952 if (!PyString_Check(s)) { 1953 PyErr_Format(PyExc_TypeError, 1954 "__slots__ items must be strings, not '%.200s'", 1955 Py_TYPE(s)->tp_name); 1956 return 0; 1957 } 1958 p = (unsigned char *) PyString_AS_STRING(s); 1959 n = PyString_GET_SIZE(s); 1960 /* We must reject an empty name. As a hack, we bump the 1961 length to 1 so that the loop will balk on the trailing \0. */ 1962 if (n == 0) 1963 n = 1; 1964 for (i = 0; i < n; i++, p++) { 1965 if (!(i == 0 ? isalpha(*p) : isalnum(*p)) && *p != '_') { 1966 PyErr_SetString(PyExc_TypeError, 1967 "__slots__ must be identifiers"); 1968 return 0; 1969 } 1970 } 1971 return 1; 1972} 1973 1974#ifdef Py_USING_UNICODE 1975/* Replace Unicode objects in slots. */ 1976 1977static PyObject * 1978_unicode_to_string(PyObject *slots, Py_ssize_t nslots) 1979{ 1980 PyObject *tmp = NULL; 1981 PyObject *slot_name, *new_name; 1982 Py_ssize_t i; 1983 1984 for (i = 0; i < nslots; i++) { 1985 if (PyUnicode_Check(slot_name = PyTuple_GET_ITEM(slots, i))) { 1986 if (tmp == NULL) { 1987 tmp = PySequence_List(slots); 1988 if (tmp == NULL) 1989 return NULL; 1990 } 1991 new_name = _PyUnicode_AsDefaultEncodedString(slot_name, 1992 NULL); 1993 if (new_name == NULL) { 1994 Py_DECREF(tmp); 1995 return NULL; 1996 } 1997 Py_INCREF(new_name); 1998 PyList_SET_ITEM(tmp, i, new_name); 1999 Py_DECREF(slot_name); 2000 } 2001 } 2002 if (tmp != NULL) { 2003 slots = PyList_AsTuple(tmp); 2004 Py_DECREF(tmp); 2005 } 2006 return slots; 2007} 2008#endif 2009 2010/* Forward */ 2011static int 2012object_init(PyObject *self, PyObject *args, PyObject *kwds); 2013 2014static int 2015type_init(PyObject *cls, PyObject *args, PyObject *kwds) 2016{ 2017 int res; 2018 2019 assert(args != NULL && PyTuple_Check(args)); 2020 assert(kwds == NULL || PyDict_Check(kwds)); 2021 2022 if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds) != 0) { 2023 PyErr_SetString(PyExc_TypeError, 2024 "type.__init__() takes no keyword arguments"); 2025 return -1; 2026 } 2027 2028 if (args != NULL && PyTuple_Check(args) && 2029 (PyTuple_GET_SIZE(args) != 1 && PyTuple_GET_SIZE(args) != 3)) { 2030 PyErr_SetString(PyExc_TypeError, 2031 "type.__init__() takes 1 or 3 arguments"); 2032 return -1; 2033 } 2034 2035 /* Call object.__init__(self) now. */ 2036 /* XXX Could call super(type, cls).__init__() but what's the point? */ 2037 args = PyTuple_GetSlice(args, 0, 0); 2038 res = object_init(cls, args, NULL); 2039 Py_DECREF(args); 2040 return res; 2041} 2042 2043static PyObject * 2044type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds) 2045{ 2046 PyObject *name, *bases, *dict; 2047 static char *kwlist[] = {"name", "bases", "dict", 0}; 2048 PyObject *slots, *tmp, *newslots; 2049 PyTypeObject *type, *base, *tmptype, *winner; 2050 PyHeapTypeObject *et; 2051 PyMemberDef *mp; 2052 Py_ssize_t i, nbases, nslots, slotoffset, add_dict, add_weak; 2053 int j, may_add_dict, may_add_weak; 2054 2055 assert(args != NULL && PyTuple_Check(args)); 2056 assert(kwds == NULL || PyDict_Check(kwds)); 2057 2058 /* Special case: type(x) should return x->ob_type */ 2059 { 2060 const Py_ssize_t nargs = PyTuple_GET_SIZE(args); 2061 const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_Size(kwds); 2062 2063 if (PyType_CheckExact(metatype) && nargs == 1 && nkwds == 0) { 2064 PyObject *x = PyTuple_GET_ITEM(args, 0); 2065 Py_INCREF(Py_TYPE(x)); 2066 return (PyObject *) Py_TYPE(x); 2067 } 2068 2069 /* SF bug 475327 -- if that didn't trigger, we need 3 2070 arguments. but PyArg_ParseTupleAndKeywords below may give 2071 a msg saying type() needs exactly 3. */ 2072 if (nargs + nkwds != 3) { 2073 PyErr_SetString(PyExc_TypeError, 2074 "type() takes 1 or 3 arguments"); 2075 return NULL; 2076 } 2077 } 2078 2079 /* Check arguments: (name, bases, dict) */ 2080 if (!PyArg_ParseTupleAndKeywords(args, kwds, "SO!O!:type", kwlist, 2081 &name, 2082 &PyTuple_Type, &bases, 2083 &PyDict_Type, &dict)) 2084 return NULL; 2085 2086 /* Determine the proper metatype to deal with this, 2087 and check for metatype conflicts while we're at it. 2088 Note that if some other metatype wins to contract, 2089 it's possible that its instances are not types. */ 2090 nbases = PyTuple_GET_SIZE(bases); 2091 winner = metatype; 2092 for (i = 0; i < nbases; i++) { 2093 tmp = PyTuple_GET_ITEM(bases, i); 2094 tmptype = tmp->ob_type; 2095 if (tmptype == &PyClass_Type) 2096 continue; /* Special case classic classes */ 2097 if (PyType_IsSubtype(winner, tmptype)) 2098 continue; 2099 if (PyType_IsSubtype(tmptype, winner)) { 2100 winner = tmptype; 2101 continue; 2102 } 2103 PyErr_SetString(PyExc_TypeError, 2104 "metaclass conflict: " 2105 "the metaclass of a derived class " 2106 "must be a (non-strict) subclass " 2107 "of the metaclasses of all its bases"); 2108 return NULL; 2109 } 2110 if (winner != metatype) { 2111 if (winner->tp_new != type_new) /* Pass it to the winner */ 2112 return winner->tp_new(winner, args, kwds); 2113 metatype = winner; 2114 } 2115 2116 /* Adjust for empty tuple bases */ 2117 if (nbases == 0) { 2118 bases = PyTuple_Pack(1, &PyBaseObject_Type); 2119 if (bases == NULL) 2120 return NULL; 2121 nbases = 1; 2122 } 2123 else 2124 Py_INCREF(bases); 2125 2126 /* XXX From here until type is allocated, "return NULL" leaks bases! */ 2127 2128 /* Calculate best base, and check that all bases are type objects */ 2129 base = best_base(bases); 2130 if (base == NULL) { 2131 Py_DECREF(bases); 2132 return NULL; 2133 } 2134 if (!PyType_HasFeature(base, Py_TPFLAGS_BASETYPE)) { 2135 PyErr_Format(PyExc_TypeError, 2136 "type '%.100s' is not an acceptable base type", 2137 base->tp_name); 2138 Py_DECREF(bases); 2139 return NULL; 2140 } 2141 2142 /* Check for a __slots__ sequence variable in dict, and count it */ 2143 slots = PyDict_GetItemString(dict, "__slots__"); 2144 nslots = 0; 2145 add_dict = 0; 2146 add_weak = 0; 2147 may_add_dict = base->tp_dictoffset == 0; 2148 may_add_weak = base->tp_weaklistoffset == 0 && base->tp_itemsize == 0; 2149 if (slots == NULL) { 2150 if (may_add_dict) { 2151 add_dict++; 2152 } 2153 if (may_add_weak) { 2154 add_weak++; 2155 } 2156 } 2157 else { 2158 /* Have slots */ 2159 2160 /* Make it into a tuple */ 2161 if (PyString_Check(slots) || PyUnicode_Check(slots)) 2162 slots = PyTuple_Pack(1, slots); 2163 else 2164 slots = PySequence_Tuple(slots); 2165 if (slots == NULL) { 2166 Py_DECREF(bases); 2167 return NULL; 2168 } 2169 assert(PyTuple_Check(slots)); 2170 2171 /* Are slots allowed? */ 2172 nslots = PyTuple_GET_SIZE(slots); 2173 if (nslots > 0 && base->tp_itemsize != 0) { 2174 PyErr_Format(PyExc_TypeError, 2175 "nonempty __slots__ " 2176 "not supported for subtype of '%s'", 2177 base->tp_name); 2178 bad_slots: 2179 Py_DECREF(bases); 2180 Py_DECREF(slots); 2181 return NULL; 2182 } 2183 2184#ifdef Py_USING_UNICODE 2185 tmp = _unicode_to_string(slots, nslots); 2186 if (tmp == NULL) 2187 goto bad_slots; 2188 if (tmp != slots) { 2189 Py_DECREF(slots); 2190 slots = tmp; 2191 } 2192#endif 2193 /* Check for valid slot names and two special cases */ 2194 for (i = 0; i < nslots; i++) { 2195 PyObject *tmp = PyTuple_GET_ITEM(slots, i); 2196 char *s; 2197 if (!valid_identifier(tmp)) 2198 goto bad_slots; 2199 assert(PyString_Check(tmp)); 2200 s = PyString_AS_STRING(tmp); 2201 if (strcmp(s, "__dict__") == 0) { 2202 if (!may_add_dict || add_dict) { 2203 PyErr_SetString(PyExc_TypeError, 2204 "__dict__ slot disallowed: " 2205 "we already got one"); 2206 goto bad_slots; 2207 } 2208 add_dict++; 2209 } 2210 if (strcmp(s, "__weakref__") == 0) { 2211 if (!may_add_weak || add_weak) { 2212 PyErr_SetString(PyExc_TypeError, 2213 "__weakref__ slot disallowed: " 2214 "either we already got one, " 2215 "or __itemsize__ != 0"); 2216 goto bad_slots; 2217 } 2218 add_weak++; 2219 } 2220 } 2221 2222 /* Copy slots into a list, mangle names and sort them. 2223 Sorted names are needed for __class__ assignment. 2224 Convert them back to tuple at the end. 2225 */ 2226 newslots = PyList_New(nslots - add_dict - add_weak); 2227 if (newslots == NULL) 2228 goto bad_slots; 2229 for (i = j = 0; i < nslots; i++) { 2230 char *s; 2231 tmp = PyTuple_GET_ITEM(slots, i); 2232 s = PyString_AS_STRING(tmp); 2233 if ((add_dict && strcmp(s, "__dict__") == 0) || 2234 (add_weak && strcmp(s, "__weakref__") == 0)) 2235 continue; 2236 tmp =_Py_Mangle(name, tmp); 2237 if (!tmp) 2238 goto bad_slots; 2239 PyList_SET_ITEM(newslots, j, tmp); 2240 j++; 2241 } 2242 assert(j == nslots - add_dict - add_weak); 2243 nslots = j; 2244 Py_DECREF(slots); 2245 if (PyList_Sort(newslots) == -1) { 2246 Py_DECREF(bases); 2247 Py_DECREF(newslots); 2248 return NULL; 2249 } 2250 slots = PyList_AsTuple(newslots); 2251 Py_DECREF(newslots); 2252 if (slots == NULL) { 2253 Py_DECREF(bases); 2254 return NULL; 2255 } 2256 2257 /* Secondary bases may provide weakrefs or dict */ 2258 if (nbases > 1 && 2259 ((may_add_dict && !add_dict) || 2260 (may_add_weak && !add_weak))) { 2261 for (i = 0; i < nbases; i++) { 2262 tmp = PyTuple_GET_ITEM(bases, i); 2263 if (tmp == (PyObject *)base) 2264 continue; /* Skip primary base */ 2265 if (PyClass_Check(tmp)) { 2266 /* Classic base class provides both */ 2267 if (may_add_dict && !add_dict) 2268 add_dict++; 2269 if (may_add_weak && !add_weak) 2270 add_weak++; 2271 break; 2272 } 2273 assert(PyType_Check(tmp)); 2274 tmptype = (PyTypeObject *)tmp; 2275 if (may_add_dict && !add_dict && 2276 tmptype->tp_dictoffset != 0) 2277 add_dict++; 2278 if (may_add_weak && !add_weak && 2279 tmptype->tp_weaklistoffset != 0) 2280 add_weak++; 2281 if (may_add_dict && !add_dict) 2282 continue; 2283 if (may_add_weak && !add_weak) 2284 continue; 2285 /* Nothing more to check */ 2286 break; 2287 } 2288 } 2289 } 2290 2291 /* XXX From here until type is safely allocated, 2292 "return NULL" may leak slots! */ 2293 2294 /* Allocate the type object */ 2295 type = (PyTypeObject *)metatype->tp_alloc(metatype, nslots); 2296 if (type == NULL) { 2297 Py_XDECREF(slots); 2298 Py_DECREF(bases); 2299 return NULL; 2300 } 2301 2302 /* Keep name and slots alive in the extended type object */ 2303 et = (PyHeapTypeObject *)type; 2304 Py_INCREF(name); 2305 et->ht_name = name; 2306 et->ht_slots = slots; 2307 2308 /* Initialize tp_flags */ 2309 type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | 2310 Py_TPFLAGS_BASETYPE; 2311 if (base->tp_flags & Py_TPFLAGS_HAVE_GC) 2312 type->tp_flags |= Py_TPFLAGS_HAVE_GC; 2313 if (base->tp_flags & Py_TPFLAGS_HAVE_NEWBUFFER) 2314 type->tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER; 2315 2316 /* It's a new-style number unless it specifically inherits any 2317 old-style numeric behavior */ 2318 if ((base->tp_flags & Py_TPFLAGS_CHECKTYPES) || 2319 (base->tp_as_number == NULL)) 2320 type->tp_flags |= Py_TPFLAGS_CHECKTYPES; 2321 2322 /* Initialize essential fields */ 2323 type->tp_as_number = &et->as_number; 2324 type->tp_as_sequence = &et->as_sequence; 2325 type->tp_as_mapping = &et->as_mapping; 2326 type->tp_as_buffer = &et->as_buffer; 2327 type->tp_name = PyString_AS_STRING(name); 2328 2329 /* Set tp_base and tp_bases */ 2330 type->tp_bases = bases; 2331 Py_INCREF(base); 2332 type->tp_base = base; 2333 2334 /* Initialize tp_dict from passed-in dict */ 2335 type->tp_dict = dict = PyDict_Copy(dict); 2336 if (dict == NULL) { 2337 Py_DECREF(type); 2338 return NULL; 2339 } 2340 2341 /* Set __module__ in the dict */ 2342 if (PyDict_GetItemString(dict, "__module__") == NULL) { 2343 tmp = PyEval_GetGlobals(); 2344 if (tmp != NULL) { 2345 tmp = PyDict_GetItemString(tmp, "__name__"); 2346 if (tmp != NULL) { 2347 if (PyDict_SetItemString(dict, "__module__", 2348 tmp) < 0) 2349 return NULL; 2350 } 2351 } 2352 } 2353 2354 /* Set tp_doc to a copy of dict['__doc__'], if the latter is there 2355 and is a string. The __doc__ accessor will first look for tp_doc; 2356 if that fails, it will still look into __dict__. 2357 */ 2358 { 2359 PyObject *doc = PyDict_GetItemString(dict, "__doc__"); 2360 if (doc != NULL && PyString_Check(doc)) { 2361 const size_t n = (size_t)PyString_GET_SIZE(doc); 2362 char *tp_doc = (char *)PyObject_MALLOC(n+1); 2363 if (tp_doc == NULL) { 2364 Py_DECREF(type); 2365 return NULL; 2366 } 2367 memcpy(tp_doc, PyString_AS_STRING(doc), n+1); 2368 type->tp_doc = tp_doc; 2369 } 2370 } 2371 2372 /* Special-case __new__: if it's a plain function, 2373 make it a static function */ 2374 tmp = PyDict_GetItemString(dict, "__new__"); 2375 if (tmp != NULL && PyFunction_Check(tmp)) { 2376 tmp = PyStaticMethod_New(tmp); 2377 if (tmp == NULL) { 2378 Py_DECREF(type); 2379 return NULL; 2380 } 2381 PyDict_SetItemString(dict, "__new__", tmp); 2382 Py_DECREF(tmp); 2383 } 2384 2385 /* Add descriptors for custom slots from __slots__, or for __dict__ */ 2386 mp = PyHeapType_GET_MEMBERS(et); 2387 slotoffset = base->tp_basicsize; 2388 if (slots != NULL) { 2389 for (i = 0; i < nslots; i++, mp++) { 2390 mp->name = PyString_AS_STRING( 2391 PyTuple_GET_ITEM(slots, i)); 2392 mp->type = T_OBJECT_EX; 2393 mp->offset = slotoffset; 2394 2395 /* __dict__ and __weakref__ are already filtered out */ 2396 assert(strcmp(mp->name, "__dict__") != 0); 2397 assert(strcmp(mp->name, "__weakref__") != 0); 2398 2399 slotoffset += sizeof(PyObject *); 2400 } 2401 } 2402 if (add_dict) { 2403 if (base->tp_itemsize) 2404 type->tp_dictoffset = -(long)sizeof(PyObject *); 2405 else 2406 type->tp_dictoffset = slotoffset; 2407 slotoffset += sizeof(PyObject *); 2408 } 2409 if (add_weak) { 2410 assert(!base->tp_itemsize); 2411 type->tp_weaklistoffset = slotoffset; 2412 slotoffset += sizeof(PyObject *); 2413 } 2414 type->tp_basicsize = slotoffset; 2415 type->tp_itemsize = base->tp_itemsize; 2416 type->tp_members = PyHeapType_GET_MEMBERS(et); 2417 2418 if (type->tp_weaklistoffset && type->tp_dictoffset) 2419 type->tp_getset = subtype_getsets_full; 2420 else if (type->tp_weaklistoffset && !type->tp_dictoffset) 2421 type->tp_getset = subtype_getsets_weakref_only; 2422 else if (!type->tp_weaklistoffset && type->tp_dictoffset) 2423 type->tp_getset = subtype_getsets_dict_only; 2424 else 2425 type->tp_getset = NULL; 2426 2427 /* Special case some slots */ 2428 if (type->tp_dictoffset != 0 || nslots > 0) { 2429 if (base->tp_getattr == NULL && base->tp_getattro == NULL) 2430 type->tp_getattro = PyObject_GenericGetAttr; 2431 if (base->tp_setattr == NULL && base->tp_setattro == NULL) 2432 type->tp_setattro = PyObject_GenericSetAttr; 2433 } 2434 type->tp_dealloc = subtype_dealloc; 2435 2436 /* Enable GC unless there are really no instance variables possible */ 2437 if (!(type->tp_basicsize == sizeof(PyObject) && 2438 type->tp_itemsize == 0)) 2439 type->tp_flags |= Py_TPFLAGS_HAVE_GC; 2440 2441 /* Always override allocation strategy to use regular heap */ 2442 type->tp_alloc = PyType_GenericAlloc; 2443 if (type->tp_flags & Py_TPFLAGS_HAVE_GC) { 2444 type->tp_free = PyObject_GC_Del; 2445 type->tp_traverse = subtype_traverse; 2446 type->tp_clear = subtype_clear; 2447 } 2448 else 2449 type->tp_free = PyObject_Del; 2450 2451 /* Initialize the rest */ 2452 if (PyType_Ready(type) < 0) { 2453 Py_DECREF(type); 2454 return NULL; 2455 } 2456 2457 /* Put the proper slots in place */ 2458 fixup_slot_dispatchers(type); 2459 2460 return (PyObject *)type; 2461} 2462 2463/* Internal API to look for a name through the MRO. 2464 This returns a borrowed reference, and doesn't set an exception! */ 2465PyObject * 2466_PyType_Lookup(PyTypeObject *type, PyObject *name) 2467{ 2468 Py_ssize_t i, n; 2469 PyObject *mro, *res, *base, *dict; 2470 unsigned int h; 2471 2472 if (MCACHE_CACHEABLE_NAME(name) && 2473 PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) { 2474 /* fast path */ 2475 h = MCACHE_HASH_METHOD(type, name); 2476 if (method_cache[h].version == type->tp_version_tag && 2477 method_cache[h].name == name) 2478 return method_cache[h].value; 2479 } 2480 2481 /* Look in tp_dict of types in MRO */ 2482 mro = type->tp_mro; 2483 2484 /* If mro is NULL, the type is either not yet initialized 2485 by PyType_Ready(), or already cleared by type_clear(). 2486 Either way the safest thing to do is to return NULL. */ 2487 if (mro == NULL) 2488 return NULL; 2489 2490 res = NULL; 2491 assert(PyTuple_Check(mro)); 2492 n = PyTuple_GET_SIZE(mro); 2493 for (i = 0; i < n; i++) { 2494 base = PyTuple_GET_ITEM(mro, i); 2495 if (PyClass_Check(base)) 2496 dict = ((PyClassObject *)base)->cl_dict; 2497 else { 2498 assert(PyType_Check(base)); 2499 dict = ((PyTypeObject *)base)->tp_dict; 2500 } 2501 assert(dict && PyDict_Check(dict)); 2502 res = PyDict_GetItem(dict, name); 2503 if (res != NULL) 2504 break; 2505 } 2506 2507 if (MCACHE_CACHEABLE_NAME(name) && assign_version_tag(type)) { 2508 h = MCACHE_HASH_METHOD(type, name); 2509 method_cache[h].version = type->tp_version_tag; 2510 method_cache[h].value = res; /* borrowed */ 2511 Py_INCREF(name); 2512 Py_DECREF(method_cache[h].name); 2513 method_cache[h].name = name; 2514 } 2515 return res; 2516} 2517 2518/* This is similar to PyObject_GenericGetAttr(), 2519 but uses _PyType_Lookup() instead of just looking in type->tp_dict. */ 2520static PyObject * 2521type_getattro(PyTypeObject *type, PyObject *name) 2522{ 2523 PyTypeObject *metatype = Py_TYPE(type); 2524 PyObject *meta_attribute, *attribute; 2525 descrgetfunc meta_get; 2526 2527 /* Initialize this type (we'll assume the metatype is initialized) */ 2528 if (type->tp_dict == NULL) { 2529 if (PyType_Ready(type) < 0) 2530 return NULL; 2531 } 2532 2533 /* No readable descriptor found yet */ 2534 meta_get = NULL; 2535 2536 /* Look for the attribute in the metatype */ 2537 meta_attribute = _PyType_Lookup(metatype, name); 2538 2539 if (meta_attribute != NULL) { 2540 meta_get = Py_TYPE(meta_attribute)->tp_descr_get; 2541 2542 if (meta_get != NULL && PyDescr_IsData(meta_attribute)) { 2543 /* Data descriptors implement tp_descr_set to intercept 2544 * writes. Assume the attribute is not overridden in 2545 * type's tp_dict (and bases): call the descriptor now. 2546 */ 2547 return meta_get(meta_attribute, (PyObject *)type, 2548 (PyObject *)metatype); 2549 } 2550 Py_INCREF(meta_attribute); 2551 } 2552 2553 /* No data descriptor found on metatype. Look in tp_dict of this 2554 * type and its bases */ 2555 attribute = _PyType_Lookup(type, name); 2556 if (attribute != NULL) { 2557 /* Implement descriptor functionality, if any */ 2558 descrgetfunc local_get = Py_TYPE(attribute)->tp_descr_get; 2559 2560 Py_XDECREF(meta_attribute); 2561 2562 if (local_get != NULL) { 2563 /* NULL 2nd argument indicates the descriptor was 2564 * found on the target object itself (or a base) */ 2565 return local_get(attribute, (PyObject *)NULL, 2566 (PyObject *)type); 2567 } 2568 2569 Py_INCREF(attribute); 2570 return attribute; 2571 } 2572 2573 /* No attribute found in local __dict__ (or bases): use the 2574 * descriptor from the metatype, if any */ 2575 if (meta_get != NULL) { 2576 PyObject *res; 2577 res = meta_get(meta_attribute, (PyObject *)type, 2578 (PyObject *)metatype); 2579 Py_DECREF(meta_attribute); 2580 return res; 2581 } 2582 2583 /* If an ordinary attribute was found on the metatype, return it now */ 2584 if (meta_attribute != NULL) { 2585 return meta_attribute; 2586 } 2587 2588 /* Give up */ 2589 PyErr_Format(PyExc_AttributeError, 2590 "type object '%.50s' has no attribute '%.400s'", 2591 type->tp_name, PyString_AS_STRING(name)); 2592 return NULL; 2593} 2594 2595static int 2596type_setattro(PyTypeObject *type, PyObject *name, PyObject *value) 2597{ 2598 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) { 2599 PyErr_Format( 2600 PyExc_TypeError, 2601 "can't set attributes of built-in/extension type '%s'", 2602 type->tp_name); 2603 return -1; 2604 } 2605 if (PyObject_GenericSetAttr((PyObject *)type, name, value) < 0) 2606 return -1; 2607 return update_slot(type, name); 2608} 2609 2610static void 2611type_dealloc(PyTypeObject *type) 2612{ 2613 PyHeapTypeObject *et; 2614 2615 /* Assert this is a heap-allocated type object */ 2616 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 2617 _PyObject_GC_UNTRACK(type); 2618 PyObject_ClearWeakRefs((PyObject *)type); 2619 et = (PyHeapTypeObject *)type; 2620 Py_XDECREF(type->tp_base); 2621 Py_XDECREF(type->tp_dict); 2622 Py_XDECREF(type->tp_bases); 2623 Py_XDECREF(type->tp_mro); 2624 Py_XDECREF(type->tp_cache); 2625 Py_XDECREF(type->tp_subclasses); 2626 /* A type's tp_doc is heap allocated, unlike the tp_doc slots 2627 * of most other objects. It's okay to cast it to char *. 2628 */ 2629 PyObject_Free((char *)type->tp_doc); 2630 Py_XDECREF(et->ht_name); 2631 Py_XDECREF(et->ht_slots); 2632 Py_TYPE(type)->tp_free((PyObject *)type); 2633} 2634 2635static PyObject * 2636type_subclasses(PyTypeObject *type, PyObject *args_ignored) 2637{ 2638 PyObject *list, *raw, *ref; 2639 Py_ssize_t i, n; 2640 2641 list = PyList_New(0); 2642 if (list == NULL) 2643 return NULL; 2644 raw = type->tp_subclasses; 2645 if (raw == NULL) 2646 return list; 2647 assert(PyList_Check(raw)); 2648 n = PyList_GET_SIZE(raw); 2649 for (i = 0; i < n; i++) { 2650 ref = PyList_GET_ITEM(raw, i); 2651 assert(PyWeakref_CheckRef(ref)); 2652 ref = PyWeakref_GET_OBJECT(ref); 2653 if (ref != Py_None) { 2654 if (PyList_Append(list, ref) < 0) { 2655 Py_DECREF(list); 2656 return NULL; 2657 } 2658 } 2659 } 2660 return list; 2661} 2662 2663static PyMethodDef type_methods[] = { 2664 {"mro", (PyCFunction)mro_external, METH_NOARGS, 2665 PyDoc_STR("mro() -> list\nreturn a type's method resolution order")}, 2666 {"__subclasses__", (PyCFunction)type_subclasses, METH_NOARGS, 2667 PyDoc_STR("__subclasses__() -> list of immediate subclasses")}, 2668 {0} 2669}; 2670 2671PyDoc_STRVAR(type_doc, 2672"type(object) -> the object's type\n" 2673"type(name, bases, dict) -> a new type"); 2674 2675static int 2676type_traverse(PyTypeObject *type, visitproc visit, void *arg) 2677{ 2678 /* Because of type_is_gc(), the collector only calls this 2679 for heaptypes. */ 2680 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 2681 2682 Py_VISIT(type->tp_dict); 2683 Py_VISIT(type->tp_cache); 2684 Py_VISIT(type->tp_mro); 2685 Py_VISIT(type->tp_bases); 2686 Py_VISIT(type->tp_base); 2687 2688 /* There's no need to visit type->tp_subclasses or 2689 ((PyHeapTypeObject *)type)->ht_slots, because they can't be involved 2690 in cycles; tp_subclasses is a list of weak references, 2691 and slots is a tuple of strings. */ 2692 2693 return 0; 2694} 2695 2696static int 2697type_clear(PyTypeObject *type) 2698{ 2699 /* Because of type_is_gc(), the collector only calls this 2700 for heaptypes. */ 2701 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 2702 2703 /* The only field we need to clear is tp_mro, which is part of a 2704 hard cycle (its first element is the class itself) that won't 2705 be broken otherwise (it's a tuple and tuples don't have a 2706 tp_clear handler). None of the other fields need to be 2707 cleared, and here's why: 2708 2709 tp_dict: 2710 It is a dict, so the collector will call its tp_clear. 2711 2712 tp_cache: 2713 Not used; if it were, it would be a dict. 2714 2715 tp_bases, tp_base: 2716 If these are involved in a cycle, there must be at least 2717 one other, mutable object in the cycle, e.g. a base 2718 class's dict; the cycle will be broken that way. 2719 2720 tp_subclasses: 2721 A list of weak references can't be part of a cycle; and 2722 lists have their own tp_clear. 2723 2724 slots (in PyHeapTypeObject): 2725 A tuple of strings can't be part of a cycle. 2726 */ 2727 2728 Py_CLEAR(type->tp_mro); 2729 2730 return 0; 2731} 2732 2733static int 2734type_is_gc(PyTypeObject *type) 2735{ 2736 return type->tp_flags & Py_TPFLAGS_HEAPTYPE; 2737} 2738 2739PyTypeObject PyType_Type = { 2740 PyVarObject_HEAD_INIT(&PyType_Type, 0) 2741 "type", /* tp_name */ 2742 sizeof(PyHeapTypeObject), /* tp_basicsize */ 2743 sizeof(PyMemberDef), /* tp_itemsize */ 2744 (destructor)type_dealloc, /* tp_dealloc */ 2745 0, /* tp_print */ 2746 0, /* tp_getattr */ 2747 0, /* tp_setattr */ 2748 type_compare, /* tp_compare */ 2749 (reprfunc)type_repr, /* tp_repr */ 2750 0, /* tp_as_number */ 2751 0, /* tp_as_sequence */ 2752 0, /* tp_as_mapping */ 2753 (hashfunc)_Py_HashPointer, /* tp_hash */ 2754 (ternaryfunc)type_call, /* tp_call */ 2755 0, /* tp_str */ 2756 (getattrofunc)type_getattro, /* tp_getattro */ 2757 (setattrofunc)type_setattro, /* tp_setattro */ 2758 0, /* tp_as_buffer */ 2759 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | 2760 Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS, /* tp_flags */ 2761 type_doc, /* tp_doc */ 2762 (traverseproc)type_traverse, /* tp_traverse */ 2763 (inquiry)type_clear, /* tp_clear */ 2764 type_richcompare, /* tp_richcompare */ 2765 offsetof(PyTypeObject, tp_weaklist), /* tp_weaklistoffset */ 2766 0, /* tp_iter */ 2767 0, /* tp_iternext */ 2768 type_methods, /* tp_methods */ 2769 type_members, /* tp_members */ 2770 type_getsets, /* tp_getset */ 2771 0, /* tp_base */ 2772 0, /* tp_dict */ 2773 0, /* tp_descr_get */ 2774 0, /* tp_descr_set */ 2775 offsetof(PyTypeObject, tp_dict), /* tp_dictoffset */ 2776 type_init, /* tp_init */ 2777 0, /* tp_alloc */ 2778 type_new, /* tp_new */ 2779 PyObject_GC_Del, /* tp_free */ 2780 (inquiry)type_is_gc, /* tp_is_gc */ 2781}; 2782 2783 2784/* The base type of all types (eventually)... except itself. */ 2785 2786/* You may wonder why object.__new__() only complains about arguments 2787 when object.__init__() is not overridden, and vice versa. 2788 2789 Consider the use cases: 2790 2791 1. When neither is overridden, we want to hear complaints about 2792 excess (i.e., any) arguments, since their presence could 2793 indicate there's a bug. 2794 2795 2. When defining an Immutable type, we are likely to override only 2796 __new__(), since __init__() is called too late to initialize an 2797 Immutable object. Since __new__() defines the signature for the 2798 type, it would be a pain to have to override __init__() just to 2799 stop it from complaining about excess arguments. 2800 2801 3. When defining a Mutable type, we are likely to override only 2802 __init__(). So here the converse reasoning applies: we don't 2803 want to have to override __new__() just to stop it from 2804 complaining. 2805 2806 4. When __init__() is overridden, and the subclass __init__() calls 2807 object.__init__(), the latter should complain about excess 2808 arguments; ditto for __new__(). 2809 2810 Use cases 2 and 3 make it unattractive to unconditionally check for 2811 excess arguments. The best solution that addresses all four use 2812 cases is as follows: __init__() complains about excess arguments 2813 unless __new__() is overridden and __init__() is not overridden 2814 (IOW, if __init__() is overridden or __new__() is not overridden); 2815 symmetrically, __new__() complains about excess arguments unless 2816 __init__() is overridden and __new__() is not overridden 2817 (IOW, if __new__() is overridden or __init__() is not overridden). 2818 2819 However, for backwards compatibility, this breaks too much code. 2820 Therefore, in 2.6, we'll *warn* about excess arguments when both 2821 methods are overridden; for all other cases we'll use the above 2822 rules. 2823 2824*/ 2825 2826/* Forward */ 2827static PyObject * 2828object_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 2829 2830static int 2831excess_args(PyObject *args, PyObject *kwds) 2832{ 2833 return PyTuple_GET_SIZE(args) || 2834 (kwds && PyDict_Check(kwds) && PyDict_Size(kwds)); 2835} 2836 2837static int 2838object_init(PyObject *self, PyObject *args, PyObject *kwds) 2839{ 2840 int err = 0; 2841 if (excess_args(args, kwds)) { 2842 PyTypeObject *type = Py_TYPE(self); 2843 if (type->tp_init != object_init && 2844 type->tp_new != object_new) 2845 { 2846 err = PyErr_WarnEx(PyExc_DeprecationWarning, 2847 "object.__init__() takes no parameters", 2848 1); 2849 } 2850 else if (type->tp_init != object_init || 2851 type->tp_new == object_new) 2852 { 2853 PyErr_SetString(PyExc_TypeError, 2854 "object.__init__() takes no parameters"); 2855 err = -1; 2856 } 2857 } 2858 return err; 2859} 2860 2861static PyObject * 2862object_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 2863{ 2864 int err = 0; 2865 if (excess_args(args, kwds)) { 2866 if (type->tp_new != object_new && 2867 type->tp_init != object_init) 2868 { 2869 err = PyErr_WarnEx(PyExc_DeprecationWarning, 2870 "object.__new__() takes no parameters", 2871 1); 2872 } 2873 else if (type->tp_new != object_new || 2874 type->tp_init == object_init) 2875 { 2876 PyErr_SetString(PyExc_TypeError, 2877 "object.__new__() takes no parameters"); 2878 err = -1; 2879 } 2880 } 2881 if (err < 0) 2882 return NULL; 2883 2884 if (type->tp_flags & Py_TPFLAGS_IS_ABSTRACT) { 2885 static PyObject *comma = NULL; 2886 PyObject *abstract_methods = NULL; 2887 PyObject *builtins; 2888 PyObject *sorted; 2889 PyObject *sorted_methods = NULL; 2890 PyObject *joined = NULL; 2891 const char *joined_str; 2892 2893 /* Compute ", ".join(sorted(type.__abstractmethods__)) 2894 into joined. */ 2895 abstract_methods = type_abstractmethods(type, NULL); 2896 if (abstract_methods == NULL) 2897 goto error; 2898 builtins = PyEval_GetBuiltins(); 2899 if (builtins == NULL) 2900 goto error; 2901 sorted = PyDict_GetItemString(builtins, "sorted"); 2902 if (sorted == NULL) 2903 goto error; 2904 sorted_methods = PyObject_CallFunctionObjArgs(sorted, 2905 abstract_methods, 2906 NULL); 2907 if (sorted_methods == NULL) 2908 goto error; 2909 if (comma == NULL) { 2910 comma = PyString_InternFromString(", "); 2911 if (comma == NULL) 2912 goto error; 2913 } 2914 joined = PyObject_CallMethod(comma, "join", 2915 "O", sorted_methods); 2916 if (joined == NULL) 2917 goto error; 2918 joined_str = PyString_AsString(joined); 2919 if (joined_str == NULL) 2920 goto error; 2921 2922 PyErr_Format(PyExc_TypeError, 2923 "Can't instantiate abstract class %s " 2924 "with abstract methods %s", 2925 type->tp_name, 2926 joined_str); 2927 error: 2928 Py_XDECREF(joined); 2929 Py_XDECREF(sorted_methods); 2930 Py_XDECREF(abstract_methods); 2931 return NULL; 2932 } 2933 return type->tp_alloc(type, 0); 2934} 2935 2936static void 2937object_dealloc(PyObject *self) 2938{ 2939 Py_TYPE(self)->tp_free(self); 2940} 2941 2942static PyObject * 2943object_repr(PyObject *self) 2944{ 2945 PyTypeObject *type; 2946 PyObject *mod, *name, *rtn; 2947 2948 type = Py_TYPE(self); 2949 mod = type_module(type, NULL); 2950 if (mod == NULL) 2951 PyErr_Clear(); 2952 else if (!PyString_Check(mod)) { 2953 Py_DECREF(mod); 2954 mod = NULL; 2955 } 2956 name = type_name(type, NULL); 2957 if (name == NULL) 2958 return NULL; 2959 if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) 2960 rtn = PyString_FromFormat("<%s.%s object at %p>", 2961 PyString_AS_STRING(mod), 2962 PyString_AS_STRING(name), 2963 self); 2964 else 2965 rtn = PyString_FromFormat("<%s object at %p>", 2966 type->tp_name, self); 2967 Py_XDECREF(mod); 2968 Py_DECREF(name); 2969 return rtn; 2970} 2971 2972static PyObject * 2973object_str(PyObject *self) 2974{ 2975 unaryfunc f; 2976 2977 f = Py_TYPE(self)->tp_repr; 2978 if (f == NULL) 2979 f = object_repr; 2980 return f(self); 2981} 2982 2983static PyObject * 2984object_get_class(PyObject *self, void *closure) 2985{ 2986 Py_INCREF(Py_TYPE(self)); 2987 return (PyObject *)(Py_TYPE(self)); 2988} 2989 2990static int 2991equiv_structs(PyTypeObject *a, PyTypeObject *b) 2992{ 2993 return a == b || 2994 (a != NULL && 2995 b != NULL && 2996 a->tp_basicsize == b->tp_basicsize && 2997 a->tp_itemsize == b->tp_itemsize && 2998 a->tp_dictoffset == b->tp_dictoffset && 2999 a->tp_weaklistoffset == b->tp_weaklistoffset && 3000 ((a->tp_flags & Py_TPFLAGS_HAVE_GC) == 3001 (b->tp_flags & Py_TPFLAGS_HAVE_GC))); 3002} 3003 3004static int 3005same_slots_added(PyTypeObject *a, PyTypeObject *b) 3006{ 3007 PyTypeObject *base = a->tp_base; 3008 Py_ssize_t size; 3009 PyObject *slots_a, *slots_b; 3010 3011 if (base != b->tp_base) 3012 return 0; 3013 if (equiv_structs(a, base) && equiv_structs(b, base)) 3014 return 1; 3015 size = base->tp_basicsize; 3016 if (a->tp_dictoffset == size && b->tp_dictoffset == size) 3017 size += sizeof(PyObject *); 3018 if (a->tp_weaklistoffset == size && b->tp_weaklistoffset == size) 3019 size += sizeof(PyObject *); 3020 3021 /* Check slots compliance */ 3022 slots_a = ((PyHeapTypeObject *)a)->ht_slots; 3023 slots_b = ((PyHeapTypeObject *)b)->ht_slots; 3024 if (slots_a && slots_b) { 3025 if (PyObject_Compare(slots_a, slots_b) != 0) 3026 return 0; 3027 size += sizeof(PyObject *) * PyTuple_GET_SIZE(slots_a); 3028 } 3029 return size == a->tp_basicsize && size == b->tp_basicsize; 3030} 3031 3032static int 3033compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, char* attr) 3034{ 3035 PyTypeObject *newbase, *oldbase; 3036 3037 if (newto->tp_dealloc != oldto->tp_dealloc || 3038 newto->tp_free != oldto->tp_free) 3039 { 3040 PyErr_Format(PyExc_TypeError, 3041 "%s assignment: " 3042 "'%s' deallocator differs from '%s'", 3043 attr, 3044 newto->tp_name, 3045 oldto->tp_name); 3046 return 0; 3047 } 3048 newbase = newto; 3049 oldbase = oldto; 3050 while (equiv_structs(newbase, newbase->tp_base)) 3051 newbase = newbase->tp_base; 3052 while (equiv_structs(oldbase, oldbase->tp_base)) 3053 oldbase = oldbase->tp_base; 3054 if (newbase != oldbase && 3055 (newbase->tp_base != oldbase->tp_base || 3056 !same_slots_added(newbase, oldbase))) { 3057 PyErr_Format(PyExc_TypeError, 3058 "%s assignment: " 3059 "'%s' object layout differs from '%s'", 3060 attr, 3061 newto->tp_name, 3062 oldto->tp_name); 3063 return 0; 3064 } 3065 3066 return 1; 3067} 3068 3069static int 3070object_set_class(PyObject *self, PyObject *value, void *closure) 3071{ 3072 PyTypeObject *oldto = Py_TYPE(self); 3073 PyTypeObject *newto; 3074 3075 if (value == NULL) { 3076 PyErr_SetString(PyExc_TypeError, 3077 "can't delete __class__ attribute"); 3078 return -1; 3079 } 3080 if (!PyType_Check(value)) { 3081 PyErr_Format(PyExc_TypeError, 3082 "__class__ must be set to new-style class, not '%s' object", 3083 Py_TYPE(value)->tp_name); 3084 return -1; 3085 } 3086 newto = (PyTypeObject *)value; 3087 if (!(newto->tp_flags & Py_TPFLAGS_HEAPTYPE) || 3088 !(oldto->tp_flags & Py_TPFLAGS_HEAPTYPE)) 3089 { 3090 PyErr_Format(PyExc_TypeError, 3091 "__class__ assignment: only for heap types"); 3092 return -1; 3093 } 3094 if (compatible_for_assignment(newto, oldto, "__class__")) { 3095 Py_INCREF(newto); 3096 Py_TYPE(self) = newto; 3097 Py_DECREF(oldto); 3098 return 0; 3099 } 3100 else { 3101 return -1; 3102 } 3103} 3104 3105static PyGetSetDef object_getsets[] = { 3106 {"__class__", object_get_class, object_set_class, 3107 PyDoc_STR("the object's class")}, 3108 {0} 3109}; 3110 3111 3112/* Stuff to implement __reduce_ex__ for pickle protocols >= 2. 3113 We fall back to helpers in copy_reg for: 3114 - pickle protocols < 2 3115 - calculating the list of slot names (done only once per class) 3116 - the __newobj__ function (which is used as a token but never called) 3117*/ 3118 3119static PyObject * 3120import_copyreg(void) 3121{ 3122 static PyObject *copyreg_str; 3123 3124 if (!copyreg_str) { 3125 copyreg_str = PyString_InternFromString("copy_reg"); 3126 if (copyreg_str == NULL) 3127 return NULL; 3128 } 3129 3130 return PyImport_Import(copyreg_str); 3131} 3132 3133static PyObject * 3134slotnames(PyObject *cls) 3135{ 3136 PyObject *clsdict; 3137 PyObject *copyreg; 3138 PyObject *slotnames; 3139 3140 if (!PyType_Check(cls)) { 3141 Py_INCREF(Py_None); 3142 return Py_None; 3143 } 3144 3145 clsdict = ((PyTypeObject *)cls)->tp_dict; 3146 slotnames = PyDict_GetItemString(clsdict, "__slotnames__"); 3147 if (slotnames != NULL && PyList_Check(slotnames)) { 3148 Py_INCREF(slotnames); 3149 return slotnames; 3150 } 3151 3152 copyreg = import_copyreg(); 3153 if (copyreg == NULL) 3154 return NULL; 3155 3156 slotnames = PyObject_CallMethod(copyreg, "_slotnames", "O", cls); 3157 Py_DECREF(copyreg); 3158 if (slotnames != NULL && 3159 slotnames != Py_None && 3160 !PyList_Check(slotnames)) 3161 { 3162 PyErr_SetString(PyExc_TypeError, 3163 "copy_reg._slotnames didn't return a list or None"); 3164 Py_DECREF(slotnames); 3165 slotnames = NULL; 3166 } 3167 3168 return slotnames; 3169} 3170 3171static PyObject * 3172reduce_2(PyObject *obj) 3173{ 3174 PyObject *cls, *getnewargs; 3175 PyObject *args = NULL, *args2 = NULL; 3176 PyObject *getstate = NULL, *state = NULL, *names = NULL; 3177 PyObject *slots = NULL, *listitems = NULL, *dictitems = NULL; 3178 PyObject *copyreg = NULL, *newobj = NULL, *res = NULL; 3179 Py_ssize_t i, n; 3180 3181 cls = PyObject_GetAttrString(obj, "__class__"); 3182 if (cls == NULL) 3183 return NULL; 3184 3185 getnewargs = PyObject_GetAttrString(obj, "__getnewargs__"); 3186 if (getnewargs != NULL) { 3187 args = PyObject_CallObject(getnewargs, NULL); 3188 Py_DECREF(getnewargs); 3189 if (args != NULL && !PyTuple_Check(args)) { 3190 PyErr_Format(PyExc_TypeError, 3191 "__getnewargs__ should return a tuple, " 3192 "not '%.200s'", Py_TYPE(args)->tp_name); 3193 goto end; 3194 } 3195 } 3196 else { 3197 PyErr_Clear(); 3198 args = PyTuple_New(0); 3199 } 3200 if (args == NULL) 3201 goto end; 3202 3203 getstate = PyObject_GetAttrString(obj, "__getstate__"); 3204 if (getstate != NULL) { 3205 state = PyObject_CallObject(getstate, NULL); 3206 Py_DECREF(getstate); 3207 if (state == NULL) 3208 goto end; 3209 } 3210 else { 3211 PyErr_Clear(); 3212 state = PyObject_GetAttrString(obj, "__dict__"); 3213 if (state == NULL) { 3214 PyErr_Clear(); 3215 state = Py_None; 3216 Py_INCREF(state); 3217 } 3218 names = slotnames(cls); 3219 if (names == NULL) 3220 goto end; 3221 if (names != Py_None) { 3222 assert(PyList_Check(names)); 3223 slots = PyDict_New(); 3224 if (slots == NULL) 3225 goto end; 3226 n = 0; 3227 /* Can't pre-compute the list size; the list 3228 is stored on the class so accessible to other 3229 threads, which may be run by DECREF */ 3230 for (i = 0; i < PyList_GET_SIZE(names); i++) { 3231 PyObject *name, *value; 3232 name = PyList_GET_ITEM(names, i); 3233 value = PyObject_GetAttr(obj, name); 3234 if (value == NULL) 3235 PyErr_Clear(); 3236 else { 3237 int err = PyDict_SetItem(slots, name, 3238 value); 3239 Py_DECREF(value); 3240 if (err) 3241 goto end; 3242 n++; 3243 } 3244 } 3245 if (n) { 3246 state = Py_BuildValue("(NO)", state, slots); 3247 if (state == NULL) 3248 goto end; 3249 } 3250 } 3251 } 3252 3253 if (!PyList_Check(obj)) { 3254 listitems = Py_None; 3255 Py_INCREF(listitems); 3256 } 3257 else { 3258 listitems = PyObject_GetIter(obj); 3259 if (listitems == NULL) 3260 goto end; 3261 } 3262 3263 if (!PyDict_Check(obj)) { 3264 dictitems = Py_None; 3265 Py_INCREF(dictitems); 3266 } 3267 else { 3268 dictitems = PyObject_CallMethod(obj, "iteritems", ""); 3269 if (dictitems == NULL) 3270 goto end; 3271 } 3272 3273 copyreg = import_copyreg(); 3274 if (copyreg == NULL) 3275 goto end; 3276 newobj = PyObject_GetAttrString(copyreg, "__newobj__"); 3277 if (newobj == NULL) 3278 goto end; 3279 3280 n = PyTuple_GET_SIZE(args); 3281 args2 = PyTuple_New(n+1); 3282 if (args2 == NULL) 3283 goto end; 3284 PyTuple_SET_ITEM(args2, 0, cls); 3285 cls = NULL; 3286 for (i = 0; i < n; i++) { 3287 PyObject *v = PyTuple_GET_ITEM(args, i); 3288 Py_INCREF(v); 3289 PyTuple_SET_ITEM(args2, i+1, v); 3290 } 3291 3292 res = PyTuple_Pack(5, newobj, args2, state, listitems, dictitems); 3293 3294 end: 3295 Py_XDECREF(cls); 3296 Py_XDECREF(args); 3297 Py_XDECREF(args2); 3298 Py_XDECREF(slots); 3299 Py_XDECREF(state); 3300 Py_XDECREF(names); 3301 Py_XDECREF(listitems); 3302 Py_XDECREF(dictitems); 3303 Py_XDECREF(copyreg); 3304 Py_XDECREF(newobj); 3305 return res; 3306} 3307 3308/* 3309 * There were two problems when object.__reduce__ and object.__reduce_ex__ 3310 * were implemented in the same function: 3311 * - trying to pickle an object with a custom __reduce__ method that 3312 * fell back to object.__reduce__ in certain circumstances led to 3313 * infinite recursion at Python level and eventual RuntimeError. 3314 * - Pickling objects that lied about their type by overwriting the 3315 * __class__ descriptor could lead to infinite recursion at C level 3316 * and eventual segfault. 3317 * 3318 * Because of backwards compatibility, the two methods still have to 3319 * behave in the same way, even if this is not required by the pickle 3320 * protocol. This common functionality was moved to the _common_reduce 3321 * function. 3322 */ 3323static PyObject * 3324_common_reduce(PyObject *self, int proto) 3325{ 3326 PyObject *copyreg, *res; 3327 3328 if (proto >= 2) 3329 return reduce_2(self); 3330 3331 copyreg = import_copyreg(); 3332 if (!copyreg) 3333 return NULL; 3334 3335 res = PyEval_CallMethod(copyreg, "_reduce_ex", "(Oi)", self, proto); 3336 Py_DECREF(copyreg); 3337 3338 return res; 3339} 3340 3341static PyObject * 3342object_reduce(PyObject *self, PyObject *args) 3343{ 3344 int proto = 0; 3345 3346 if (!PyArg_ParseTuple(args, "|i:__reduce__", &proto)) 3347 return NULL; 3348 3349 return _common_reduce(self, proto); 3350} 3351 3352static PyObject * 3353object_reduce_ex(PyObject *self, PyObject *args) 3354{ 3355 PyObject *reduce, *res; 3356 int proto = 0; 3357 3358 if (!PyArg_ParseTuple(args, "|i:__reduce_ex__", &proto)) 3359 return NULL; 3360 3361 reduce = PyObject_GetAttrString(self, "__reduce__"); 3362 if (reduce == NULL) 3363 PyErr_Clear(); 3364 else { 3365 PyObject *cls, *clsreduce, *objreduce; 3366 int override; 3367 cls = PyObject_GetAttrString(self, "__class__"); 3368 if (cls == NULL) { 3369 Py_DECREF(reduce); 3370 return NULL; 3371 } 3372 clsreduce = PyObject_GetAttrString(cls, "__reduce__"); 3373 Py_DECREF(cls); 3374 if (clsreduce == NULL) { 3375 Py_DECREF(reduce); 3376 return NULL; 3377 } 3378 objreduce = PyDict_GetItemString(PyBaseObject_Type.tp_dict, 3379 "__reduce__"); 3380 override = (clsreduce != objreduce); 3381 Py_DECREF(clsreduce); 3382 if (override) { 3383 res = PyObject_CallObject(reduce, NULL); 3384 Py_DECREF(reduce); 3385 return res; 3386 } 3387 else 3388 Py_DECREF(reduce); 3389 } 3390 3391 return _common_reduce(self, proto); 3392} 3393 3394static PyObject * 3395object_subclasshook(PyObject *cls, PyObject *args) 3396{ 3397 Py_INCREF(Py_NotImplemented); 3398 return Py_NotImplemented; 3399} 3400 3401PyDoc_STRVAR(object_subclasshook_doc, 3402"Abstract classes can override this to customize issubclass().\n" 3403"\n" 3404"This is invoked early on by abc.ABCMeta.__subclasscheck__().\n" 3405"It should return True, False or NotImplemented. If it returns\n" 3406"NotImplemented, the normal algorithm is used. Otherwise, it\n" 3407"overrides the normal algorithm (and the outcome is cached).\n"); 3408 3409/* 3410 from PEP 3101, this code implements: 3411 3412 class object: 3413 def __format__(self, format_spec): 3414 if isinstance(format_spec, str): 3415 return format(str(self), format_spec) 3416 elif isinstance(format_spec, unicode): 3417 return format(unicode(self), format_spec) 3418*/ 3419static PyObject * 3420object_format(PyObject *self, PyObject *args) 3421{ 3422 PyObject *format_spec; 3423 PyObject *self_as_str = NULL; 3424 PyObject *result = NULL; 3425 PyObject *format_meth = NULL; 3426 3427 if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) 3428 return NULL; 3429#ifdef Py_USING_UNICODE 3430 if (PyUnicode_Check(format_spec)) { 3431 self_as_str = PyObject_Unicode(self); 3432 } else if (PyString_Check(format_spec)) { 3433#else 3434 if (PyString_Check(format_spec)) { 3435#endif 3436 self_as_str = PyObject_Str(self); 3437 } else { 3438 PyErr_SetString(PyExc_TypeError, "argument to __format__ must be unicode or str"); 3439 return NULL; 3440 } 3441 3442 if (self_as_str != NULL) { 3443 /* find the format function */ 3444 format_meth = PyObject_GetAttrString(self_as_str, "__format__"); 3445 if (format_meth != NULL) { 3446 /* and call it */ 3447 result = PyObject_CallFunctionObjArgs(format_meth, format_spec, NULL); 3448 } 3449 } 3450 3451 Py_XDECREF(self_as_str); 3452 Py_XDECREF(format_meth); 3453 3454 return result; 3455} 3456 3457static PyObject * 3458object_sizeof(PyObject *self, PyObject *args) 3459{ 3460 Py_ssize_t res, isize; 3461 3462 res = 0; 3463 isize = self->ob_type->tp_itemsize; 3464 if (isize > 0) 3465 res = self->ob_type->ob_size * isize; 3466 res += self->ob_type->tp_basicsize; 3467 3468 return PyInt_FromSsize_t(res); 3469} 3470 3471static PyMethodDef object_methods[] = { 3472 {"__reduce_ex__", object_reduce_ex, METH_VARARGS, 3473 PyDoc_STR("helper for pickle")}, 3474 {"__reduce__", object_reduce, METH_VARARGS, 3475 PyDoc_STR("helper for pickle")}, 3476 {"__subclasshook__", object_subclasshook, METH_CLASS | METH_VARARGS, 3477 object_subclasshook_doc}, 3478 {"__format__", object_format, METH_VARARGS, 3479 PyDoc_STR("default object formatter")}, 3480 {"__sizeof__", object_sizeof, METH_NOARGS, 3481 PyDoc_STR("__sizeof__() -> size of object in memory, in bytes")}, 3482 {0} 3483}; 3484 3485 3486PyTypeObject PyBaseObject_Type = { 3487 PyVarObject_HEAD_INIT(&PyType_Type, 0) 3488 "object", /* tp_name */ 3489 sizeof(PyObject), /* tp_basicsize */ 3490 0, /* tp_itemsize */ 3491 object_dealloc, /* tp_dealloc */ 3492 0, /* tp_print */ 3493 0, /* tp_getattr */ 3494 0, /* tp_setattr */ 3495 0, /* tp_compare */ 3496 object_repr, /* tp_repr */ 3497 0, /* tp_as_number */ 3498 0, /* tp_as_sequence */ 3499 0, /* tp_as_mapping */ 3500 (hashfunc)_Py_HashPointer, /* tp_hash */ 3501 0, /* tp_call */ 3502 object_str, /* tp_str */ 3503 PyObject_GenericGetAttr, /* tp_getattro */ 3504 PyObject_GenericSetAttr, /* tp_setattro */ 3505 0, /* tp_as_buffer */ 3506 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 3507 PyDoc_STR("The most base type"), /* tp_doc */ 3508 0, /* tp_traverse */ 3509 0, /* tp_clear */ 3510 0, /* tp_richcompare */ 3511 0, /* tp_weaklistoffset */ 3512 0, /* tp_iter */ 3513 0, /* tp_iternext */ 3514 object_methods, /* tp_methods */ 3515 0, /* tp_members */ 3516 object_getsets, /* tp_getset */ 3517 0, /* tp_base */ 3518 0, /* tp_dict */ 3519 0, /* tp_descr_get */ 3520 0, /* tp_descr_set */ 3521 0, /* tp_dictoffset */ 3522 object_init, /* tp_init */ 3523 PyType_GenericAlloc, /* tp_alloc */ 3524 object_new, /* tp_new */ 3525 PyObject_Del, /* tp_free */ 3526}; 3527 3528 3529/* Initialize the __dict__ in a type object */ 3530 3531static int 3532add_methods(PyTypeObject *type, PyMethodDef *meth) 3533{ 3534 PyObject *dict = type->tp_dict; 3535 3536 for (; meth->ml_name != NULL; meth++) { 3537 PyObject *descr; 3538 if (PyDict_GetItemString(dict, meth->ml_name) && 3539 !(meth->ml_flags & METH_COEXIST)) 3540 continue; 3541 if (meth->ml_flags & METH_CLASS) { 3542 if (meth->ml_flags & METH_STATIC) { 3543 PyErr_SetString(PyExc_ValueError, 3544 "method cannot be both class and static"); 3545 return -1; 3546 } 3547 descr = PyDescr_NewClassMethod(type, meth); 3548 } 3549 else if (meth->ml_flags & METH_STATIC) { 3550 PyObject *cfunc = PyCFunction_New(meth, NULL); 3551 if (cfunc == NULL) 3552 return -1; 3553 descr = PyStaticMethod_New(cfunc); 3554 Py_DECREF(cfunc); 3555 } 3556 else { 3557 descr = PyDescr_NewMethod(type, meth); 3558 } 3559 if (descr == NULL) 3560 return -1; 3561 if (PyDict_SetItemString(dict, meth->ml_name, descr) < 0) 3562 return -1; 3563 Py_DECREF(descr); 3564 } 3565 return 0; 3566} 3567 3568static int 3569add_members(PyTypeObject *type, PyMemberDef *memb) 3570{ 3571 PyObject *dict = type->tp_dict; 3572 3573 for (; memb->name != NULL; memb++) { 3574 PyObject *descr; 3575 if (PyDict_GetItemString(dict, memb->name)) 3576 continue; 3577 descr = PyDescr_NewMember(type, memb); 3578 if (descr == NULL) 3579 return -1; 3580 if (PyDict_SetItemString(dict, memb->name, descr) < 0) 3581 return -1; 3582 Py_DECREF(descr); 3583 } 3584 return 0; 3585} 3586 3587static int 3588add_getset(PyTypeObject *type, PyGetSetDef *gsp) 3589{ 3590 PyObject *dict = type->tp_dict; 3591 3592 for (; gsp->name != NULL; gsp++) { 3593 PyObject *descr; 3594 if (PyDict_GetItemString(dict, gsp->name)) 3595 continue; 3596 descr = PyDescr_NewGetSet(type, gsp); 3597 3598 if (descr == NULL) 3599 return -1; 3600 if (PyDict_SetItemString(dict, gsp->name, descr) < 0) 3601 return -1; 3602 Py_DECREF(descr); 3603 } 3604 return 0; 3605} 3606 3607#define BUFFER_FLAGS (Py_TPFLAGS_HAVE_GETCHARBUFFER | Py_TPFLAGS_HAVE_NEWBUFFER) 3608 3609static void 3610inherit_special(PyTypeObject *type, PyTypeObject *base) 3611{ 3612 Py_ssize_t oldsize, newsize; 3613 3614 /* Special flag magic */ 3615 if (!type->tp_as_buffer && base->tp_as_buffer) { 3616 type->tp_flags &= ~BUFFER_FLAGS; 3617 type->tp_flags |= 3618 base->tp_flags & BUFFER_FLAGS; 3619 } 3620 if (!type->tp_as_sequence && base->tp_as_sequence) { 3621 type->tp_flags &= ~Py_TPFLAGS_HAVE_SEQUENCE_IN; 3622 type->tp_flags |= base->tp_flags & Py_TPFLAGS_HAVE_SEQUENCE_IN; 3623 } 3624 if ((type->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS) != 3625 (base->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS)) { 3626 if ((!type->tp_as_number && base->tp_as_number) || 3627 (!type->tp_as_sequence && base->tp_as_sequence)) { 3628 type->tp_flags &= ~Py_TPFLAGS_HAVE_INPLACEOPS; 3629 if (!type->tp_as_number && !type->tp_as_sequence) { 3630 type->tp_flags |= base->tp_flags & 3631 Py_TPFLAGS_HAVE_INPLACEOPS; 3632 } 3633 } 3634 /* Wow */ 3635 } 3636 if (!type->tp_as_number && base->tp_as_number) { 3637 type->tp_flags &= ~Py_TPFLAGS_CHECKTYPES; 3638 type->tp_flags |= base->tp_flags & Py_TPFLAGS_CHECKTYPES; 3639 } 3640 3641 /* Copying basicsize is connected to the GC flags */ 3642 oldsize = base->tp_basicsize; 3643 newsize = type->tp_basicsize ? type->tp_basicsize : oldsize; 3644 if (!(type->tp_flags & Py_TPFLAGS_HAVE_GC) && 3645 (base->tp_flags & Py_TPFLAGS_HAVE_GC) && 3646 (type->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE/*GC slots exist*/) && 3647 (!type->tp_traverse && !type->tp_clear)) { 3648 type->tp_flags |= Py_TPFLAGS_HAVE_GC; 3649 if (type->tp_traverse == NULL) 3650 type->tp_traverse = base->tp_traverse; 3651 if (type->tp_clear == NULL) 3652 type->tp_clear = base->tp_clear; 3653 } 3654 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) { 3655 /* The condition below could use some explanation. 3656 It appears that tp_new is not inherited for static types 3657 whose base class is 'object'; this seems to be a precaution 3658 so that old extension types don't suddenly become 3659 callable (object.__new__ wouldn't insure the invariants 3660 that the extension type's own factory function ensures). 3661 Heap types, of course, are under our control, so they do 3662 inherit tp_new; static extension types that specify some 3663 other built-in type as the default are considered 3664 new-style-aware so they also inherit object.__new__. */ 3665 if (base != &PyBaseObject_Type || 3666 (type->tp_flags & Py_TPFLAGS_HEAPTYPE)) { 3667 if (type->tp_new == NULL) 3668 type->tp_new = base->tp_new; 3669 } 3670 } 3671 type->tp_basicsize = newsize; 3672 3673 /* Copy other non-function slots */ 3674 3675#undef COPYVAL 3676#define COPYVAL(SLOT) \ 3677 if (type->SLOT == 0) type->SLOT = base->SLOT 3678 3679 COPYVAL(tp_itemsize); 3680 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_WEAKREFS) { 3681 COPYVAL(tp_weaklistoffset); 3682 } 3683 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) { 3684 COPYVAL(tp_dictoffset); 3685 } 3686 3687 /* Setup fast subclass flags */ 3688 if (PyType_IsSubtype(base, (PyTypeObject*)PyExc_BaseException)) 3689 type->tp_flags |= Py_TPFLAGS_BASE_EXC_SUBCLASS; 3690 else if (PyType_IsSubtype(base, &PyType_Type)) 3691 type->tp_flags |= Py_TPFLAGS_TYPE_SUBCLASS; 3692 else if (PyType_IsSubtype(base, &PyInt_Type)) 3693 type->tp_flags |= Py_TPFLAGS_INT_SUBCLASS; 3694 else if (PyType_IsSubtype(base, &PyLong_Type)) 3695 type->tp_flags |= Py_TPFLAGS_LONG_SUBCLASS; 3696 else if (PyType_IsSubtype(base, &PyString_Type)) 3697 type->tp_flags |= Py_TPFLAGS_STRING_SUBCLASS; 3698#ifdef Py_USING_UNICODE 3699 else if (PyType_IsSubtype(base, &PyUnicode_Type)) 3700 type->tp_flags |= Py_TPFLAGS_UNICODE_SUBCLASS; 3701#endif 3702 else if (PyType_IsSubtype(base, &PyTuple_Type)) 3703 type->tp_flags |= Py_TPFLAGS_TUPLE_SUBCLASS; 3704 else if (PyType_IsSubtype(base, &PyList_Type)) 3705 type->tp_flags |= Py_TPFLAGS_LIST_SUBCLASS; 3706 else if (PyType_IsSubtype(base, &PyDict_Type)) 3707 type->tp_flags |= Py_TPFLAGS_DICT_SUBCLASS; 3708} 3709 3710static int 3711overrides_name(PyTypeObject *type, char *name) 3712{ 3713 PyObject *dict = type->tp_dict; 3714 3715 assert(dict != NULL); 3716 if (PyDict_GetItemString(dict, name) != NULL) { 3717 return 1; 3718 } 3719 return 0; 3720} 3721 3722#define OVERRIDES_HASH(x) overrides_name(x, "__hash__") 3723#define OVERRIDES_CMP(x) overrides_name(x, "__cmp__") 3724#define OVERRIDES_EQ(x) overrides_name(x, "__eq__") 3725 3726static void 3727inherit_slots(PyTypeObject *type, PyTypeObject *base) 3728{ 3729 PyTypeObject *basebase; 3730 3731#undef SLOTDEFINED 3732#undef COPYSLOT 3733#undef COPYNUM 3734#undef COPYSEQ 3735#undef COPYMAP 3736#undef COPYBUF 3737 3738#define SLOTDEFINED(SLOT) \ 3739 (base->SLOT != 0 && \ 3740 (basebase == NULL || base->SLOT != basebase->SLOT)) 3741 3742#define COPYSLOT(SLOT) \ 3743 if (!type->SLOT && SLOTDEFINED(SLOT)) type->SLOT = base->SLOT 3744 3745#define COPYNUM(SLOT) COPYSLOT(tp_as_number->SLOT) 3746#define COPYSEQ(SLOT) COPYSLOT(tp_as_sequence->SLOT) 3747#define COPYMAP(SLOT) COPYSLOT(tp_as_mapping->SLOT) 3748#define COPYBUF(SLOT) COPYSLOT(tp_as_buffer->SLOT) 3749 3750 /* This won't inherit indirect slots (from tp_as_number etc.) 3751 if type doesn't provide the space. */ 3752 3753 if (type->tp_as_number != NULL && base->tp_as_number != NULL) { 3754 basebase = base->tp_base; 3755 if (basebase->tp_as_number == NULL) 3756 basebase = NULL; 3757 COPYNUM(nb_add); 3758 COPYNUM(nb_subtract); 3759 COPYNUM(nb_multiply); 3760 COPYNUM(nb_divide); 3761 COPYNUM(nb_remainder); 3762 COPYNUM(nb_divmod); 3763 COPYNUM(nb_power); 3764 COPYNUM(nb_negative); 3765 COPYNUM(nb_positive); 3766 COPYNUM(nb_absolute); 3767 COPYNUM(nb_nonzero); 3768 COPYNUM(nb_invert); 3769 COPYNUM(nb_lshift); 3770 COPYNUM(nb_rshift); 3771 COPYNUM(nb_and); 3772 COPYNUM(nb_xor); 3773 COPYNUM(nb_or); 3774 COPYNUM(nb_coerce); 3775 COPYNUM(nb_int); 3776 COPYNUM(nb_long); 3777 COPYNUM(nb_float); 3778 COPYNUM(nb_oct); 3779 COPYNUM(nb_hex); 3780 COPYNUM(nb_inplace_add); 3781 COPYNUM(nb_inplace_subtract); 3782 COPYNUM(nb_inplace_multiply); 3783 COPYNUM(nb_inplace_divide); 3784 COPYNUM(nb_inplace_remainder); 3785 COPYNUM(nb_inplace_power); 3786 COPYNUM(nb_inplace_lshift); 3787 COPYNUM(nb_inplace_rshift); 3788 COPYNUM(nb_inplace_and); 3789 COPYNUM(nb_inplace_xor); 3790 COPYNUM(nb_inplace_or); 3791 if (base->tp_flags & Py_TPFLAGS_CHECKTYPES) { 3792 COPYNUM(nb_true_divide); 3793 COPYNUM(nb_floor_divide); 3794 COPYNUM(nb_inplace_true_divide); 3795 COPYNUM(nb_inplace_floor_divide); 3796 } 3797 if (base->tp_flags & Py_TPFLAGS_HAVE_INDEX) { 3798 COPYNUM(nb_index); 3799 } 3800 } 3801 3802 if (type->tp_as_sequence != NULL && base->tp_as_sequence != NULL) { 3803 basebase = base->tp_base; 3804 if (basebase->tp_as_sequence == NULL) 3805 basebase = NULL; 3806 COPYSEQ(sq_length); 3807 COPYSEQ(sq_concat); 3808 COPYSEQ(sq_repeat); 3809 COPYSEQ(sq_item); 3810 COPYSEQ(sq_slice); 3811 COPYSEQ(sq_ass_item); 3812 COPYSEQ(sq_ass_slice); 3813 COPYSEQ(sq_contains); 3814 COPYSEQ(sq_inplace_concat); 3815 COPYSEQ(sq_inplace_repeat); 3816 } 3817 3818 if (type->tp_as_mapping != NULL && base->tp_as_mapping != NULL) { 3819 basebase = base->tp_base; 3820 if (basebase->tp_as_mapping == NULL) 3821 basebase = NULL; 3822 COPYMAP(mp_length); 3823 COPYMAP(mp_subscript); 3824 COPYMAP(mp_ass_subscript); 3825 } 3826 3827 if (type->tp_as_buffer != NULL && base->tp_as_buffer != NULL) { 3828 basebase = base->tp_base; 3829 if (basebase->tp_as_buffer == NULL) 3830 basebase = NULL; 3831 COPYBUF(bf_getreadbuffer); 3832 COPYBUF(bf_getwritebuffer); 3833 COPYBUF(bf_getsegcount); 3834 COPYBUF(bf_getcharbuffer); 3835 COPYBUF(bf_getbuffer); 3836 COPYBUF(bf_releasebuffer); 3837 } 3838 3839 basebase = base->tp_base; 3840 3841 COPYSLOT(tp_dealloc); 3842 COPYSLOT(tp_print); 3843 if (type->tp_getattr == NULL && type->tp_getattro == NULL) { 3844 type->tp_getattr = base->tp_getattr; 3845 type->tp_getattro = base->tp_getattro; 3846 } 3847 if (type->tp_setattr == NULL && type->tp_setattro == NULL) { 3848 type->tp_setattr = base->tp_setattr; 3849 type->tp_setattro = base->tp_setattro; 3850 } 3851 /* tp_compare see tp_richcompare */ 3852 COPYSLOT(tp_repr); 3853 /* tp_hash see tp_richcompare */ 3854 COPYSLOT(tp_call); 3855 COPYSLOT(tp_str); 3856 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE) { 3857 if (type->tp_compare == NULL && 3858 type->tp_richcompare == NULL && 3859 type->tp_hash == NULL) 3860 { 3861 type->tp_compare = base->tp_compare; 3862 type->tp_richcompare = base->tp_richcompare; 3863 type->tp_hash = base->tp_hash; 3864 /* Check for changes to inherited methods in Py3k*/ 3865 if (Py_Py3kWarningFlag) { 3866 if (base->tp_hash && 3867 (base->tp_hash != PyObject_HashNotImplemented) && 3868 !OVERRIDES_HASH(type)) { 3869 if (OVERRIDES_CMP(type)) { 3870 PyErr_WarnPy3k("Overriding " 3871 "__cmp__ blocks inheritance " 3872 "of __hash__ in 3.x", 3873 1); 3874 } 3875 if (OVERRIDES_EQ(type)) { 3876 PyErr_WarnPy3k("Overriding " 3877 "__eq__ blocks inheritance " 3878 "of __hash__ in 3.x", 3879 1); 3880 } 3881 } 3882 } 3883 } 3884 } 3885 else { 3886 COPYSLOT(tp_compare); 3887 } 3888 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_ITER) { 3889 COPYSLOT(tp_iter); 3890 COPYSLOT(tp_iternext); 3891 } 3892 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) { 3893 COPYSLOT(tp_descr_get); 3894 COPYSLOT(tp_descr_set); 3895 COPYSLOT(tp_dictoffset); 3896 COPYSLOT(tp_init); 3897 COPYSLOT(tp_alloc); 3898 COPYSLOT(tp_is_gc); 3899 if ((type->tp_flags & Py_TPFLAGS_HAVE_GC) == 3900 (base->tp_flags & Py_TPFLAGS_HAVE_GC)) { 3901 /* They agree about gc. */ 3902 COPYSLOT(tp_free); 3903 } 3904 else if ((type->tp_flags & Py_TPFLAGS_HAVE_GC) && 3905 type->tp_free == NULL && 3906 base->tp_free == _PyObject_Del) { 3907 /* A bit of magic to plug in the correct default 3908 * tp_free function when a derived class adds gc, 3909 * didn't define tp_free, and the base uses the 3910 * default non-gc tp_free. 3911 */ 3912 type->tp_free = PyObject_GC_Del; 3913 } 3914 /* else they didn't agree about gc, and there isn't something 3915 * obvious to be done -- the type is on its own. 3916 */ 3917 } 3918} 3919 3920static int add_operators(PyTypeObject *); 3921 3922int 3923PyType_Ready(PyTypeObject *type) 3924{ 3925 PyObject *dict, *bases; 3926 PyTypeObject *base; 3927 Py_ssize_t i, n; 3928 3929 if (type->tp_flags & Py_TPFLAGS_READY) { 3930 assert(type->tp_dict != NULL); 3931 return 0; 3932 } 3933 assert((type->tp_flags & Py_TPFLAGS_READYING) == 0); 3934 3935 type->tp_flags |= Py_TPFLAGS_READYING; 3936 3937#ifdef Py_TRACE_REFS 3938 /* PyType_Ready is the closest thing we have to a choke point 3939 * for type objects, so is the best place I can think of to try 3940 * to get type objects into the doubly-linked list of all objects. 3941 * Still, not all type objects go thru PyType_Ready. 3942 */ 3943 _Py_AddToAllObjects((PyObject *)type, 0); 3944#endif 3945 3946 /* Initialize tp_base (defaults to BaseObject unless that's us) */ 3947 base = type->tp_base; 3948 if (base == NULL && type != &PyBaseObject_Type) { 3949 base = type->tp_base = &PyBaseObject_Type; 3950 Py_INCREF(base); 3951 } 3952 3953 /* Now the only way base can still be NULL is if type is 3954 * &PyBaseObject_Type. 3955 */ 3956 3957 /* Initialize the base class */ 3958 if (base && base->tp_dict == NULL) { 3959 if (PyType_Ready(base) < 0) 3960 goto error; 3961 } 3962 3963 /* Initialize ob_type if NULL. This means extensions that want to be 3964 compilable separately on Windows can call PyType_Ready() instead of 3965 initializing the ob_type field of their type objects. */ 3966 /* The test for base != NULL is really unnecessary, since base is only 3967 NULL when type is &PyBaseObject_Type, and we know its ob_type is 3968 not NULL (it's initialized to &PyType_Type). But coverity doesn't 3969 know that. */ 3970 if (Py_TYPE(type) == NULL && base != NULL) 3971 Py_TYPE(type) = Py_TYPE(base); 3972 3973 /* Initialize tp_bases */ 3974 bases = type->tp_bases; 3975 if (bases == NULL) { 3976 if (base == NULL) 3977 bases = PyTuple_New(0); 3978 else 3979 bases = PyTuple_Pack(1, base); 3980 if (bases == NULL) 3981 goto error; 3982 type->tp_bases = bases; 3983 } 3984 3985 /* Initialize tp_dict */ 3986 dict = type->tp_dict; 3987 if (dict == NULL) { 3988 dict = PyDict_New(); 3989 if (dict == NULL) 3990 goto error; 3991 type->tp_dict = dict; 3992 } 3993 3994 /* Add type-specific descriptors to tp_dict */ 3995 if (add_operators(type) < 0) 3996 goto error; 3997 if (type->tp_methods != NULL) { 3998 if (add_methods(type, type->tp_methods) < 0) 3999 goto error; 4000 } 4001 if (type->tp_members != NULL) { 4002 if (add_members(type, type->tp_members) < 0) 4003 goto error; 4004 } 4005 if (type->tp_getset != NULL) { 4006 if (add_getset(type, type->tp_getset) < 0) 4007 goto error; 4008 } 4009 4010 /* Calculate method resolution order */ 4011 if (mro_internal(type) < 0) { 4012 goto error; 4013 } 4014 4015 /* Inherit special flags from dominant base */ 4016 if (type->tp_base != NULL) 4017 inherit_special(type, type->tp_base); 4018 4019 /* Initialize tp_dict properly */ 4020 bases = type->tp_mro; 4021 assert(bases != NULL); 4022 assert(PyTuple_Check(bases)); 4023 n = PyTuple_GET_SIZE(bases); 4024 for (i = 1; i < n; i++) { 4025 PyObject *b = PyTuple_GET_ITEM(bases, i); 4026 if (PyType_Check(b)) 4027 inherit_slots(type, (PyTypeObject *)b); 4028 } 4029 4030 /* Sanity check for tp_free. */ 4031 if (PyType_IS_GC(type) && (type->tp_flags & Py_TPFLAGS_BASETYPE) && 4032 (type->tp_free == NULL || type->tp_free == PyObject_Del)) { 4033 /* This base class needs to call tp_free, but doesn't have 4034 * one, or its tp_free is for non-gc'ed objects. 4035 */ 4036 PyErr_Format(PyExc_TypeError, "type '%.100s' participates in " 4037 "gc and is a base type but has inappropriate " 4038 "tp_free slot", 4039 type->tp_name); 4040 goto error; 4041 } 4042 4043 /* if the type dictionary doesn't contain a __doc__, set it from 4044 the tp_doc slot. 4045 */ 4046 if (PyDict_GetItemString(type->tp_dict, "__doc__") == NULL) { 4047 if (type->tp_doc != NULL) { 4048 PyObject *doc = PyString_FromString(type->tp_doc); 4049 if (doc == NULL) 4050 goto error; 4051 PyDict_SetItemString(type->tp_dict, "__doc__", doc); 4052 Py_DECREF(doc); 4053 } else { 4054 PyDict_SetItemString(type->tp_dict, 4055 "__doc__", Py_None); 4056 } 4057 } 4058 4059 /* Some more special stuff */ 4060 base = type->tp_base; 4061 if (base != NULL) { 4062 if (type->tp_as_number == NULL) 4063 type->tp_as_number = base->tp_as_number; 4064 if (type->tp_as_sequence == NULL) 4065 type->tp_as_sequence = base->tp_as_sequence; 4066 if (type->tp_as_mapping == NULL) 4067 type->tp_as_mapping = base->tp_as_mapping; 4068 if (type->tp_as_buffer == NULL) 4069 type->tp_as_buffer = base->tp_as_buffer; 4070 } 4071 4072 /* Link into each base class's list of subclasses */ 4073 bases = type->tp_bases; 4074 n = PyTuple_GET_SIZE(bases); 4075 for (i = 0; i < n; i++) { 4076 PyObject *b = PyTuple_GET_ITEM(bases, i); 4077 if (PyType_Check(b) && 4078 add_subclass((PyTypeObject *)b, type) < 0) 4079 goto error; 4080 } 4081 4082 /* All done -- set the ready flag */ 4083 assert(type->tp_dict != NULL); 4084 type->tp_flags = 4085 (type->tp_flags & ~Py_TPFLAGS_READYING) | Py_TPFLAGS_READY; 4086 return 0; 4087 4088 error: 4089 type->tp_flags &= ~Py_TPFLAGS_READYING; 4090 return -1; 4091} 4092 4093static int 4094add_subclass(PyTypeObject *base, PyTypeObject *type) 4095{ 4096 Py_ssize_t i; 4097 int result; 4098 PyObject *list, *ref, *newobj; 4099 4100 list = base->tp_subclasses; 4101 if (list == NULL) { 4102 base->tp_subclasses = list = PyList_New(0); 4103 if (list == NULL) 4104 return -1; 4105 } 4106 assert(PyList_Check(list)); 4107 newobj = PyWeakref_NewRef((PyObject *)type, NULL); 4108 i = PyList_GET_SIZE(list); 4109 while (--i >= 0) { 4110 ref = PyList_GET_ITEM(list, i); 4111 assert(PyWeakref_CheckRef(ref)); 4112 if (PyWeakref_GET_OBJECT(ref) == Py_None) 4113 return PyList_SetItem(list, i, newobj); 4114 } 4115 result = PyList_Append(list, newobj); 4116 Py_DECREF(newobj); 4117 return result; 4118} 4119 4120static void 4121remove_subclass(PyTypeObject *base, PyTypeObject *type) 4122{ 4123 Py_ssize_t i; 4124 PyObject *list, *ref; 4125 4126 list = base->tp_subclasses; 4127 if (list == NULL) { 4128 return; 4129 } 4130 assert(PyList_Check(list)); 4131 i = PyList_GET_SIZE(list); 4132 while (--i >= 0) { 4133 ref = PyList_GET_ITEM(list, i); 4134 assert(PyWeakref_CheckRef(ref)); 4135 if (PyWeakref_GET_OBJECT(ref) == (PyObject*)type) { 4136 /* this can't fail, right? */ 4137 PySequence_DelItem(list, i); 4138 return; 4139 } 4140 } 4141} 4142 4143static int 4144check_num_args(PyObject *ob, int n) 4145{ 4146 if (!PyTuple_CheckExact(ob)) { 4147 PyErr_SetString(PyExc_SystemError, 4148 "PyArg_UnpackTuple() argument list is not a tuple"); 4149 return 0; 4150 } 4151 if (n == PyTuple_GET_SIZE(ob)) 4152 return 1; 4153 PyErr_Format( 4154 PyExc_TypeError, 4155 "expected %d arguments, got %zd", n, PyTuple_GET_SIZE(ob)); 4156 return 0; 4157} 4158 4159/* Generic wrappers for overloadable 'operators' such as __getitem__ */ 4160 4161/* There's a wrapper *function* for each distinct function typedef used 4162 for type object slots (e.g. binaryfunc, ternaryfunc, etc.). There's a 4163 wrapper *table* for each distinct operation (e.g. __len__, __add__). 4164 Most tables have only one entry; the tables for binary operators have two 4165 entries, one regular and one with reversed arguments. */ 4166 4167static PyObject * 4168wrap_lenfunc(PyObject *self, PyObject *args, void *wrapped) 4169{ 4170 lenfunc func = (lenfunc)wrapped; 4171 Py_ssize_t res; 4172 4173 if (!check_num_args(args, 0)) 4174 return NULL; 4175 res = (*func)(self); 4176 if (res == -1 && PyErr_Occurred()) 4177 return NULL; 4178 return PyInt_FromLong((long)res); 4179} 4180 4181static PyObject * 4182wrap_inquirypred(PyObject *self, PyObject *args, void *wrapped) 4183{ 4184 inquiry func = (inquiry)wrapped; 4185 int res; 4186 4187 if (!check_num_args(args, 0)) 4188 return NULL; 4189 res = (*func)(self); 4190 if (res == -1 && PyErr_Occurred()) 4191 return NULL; 4192 return PyBool_FromLong((long)res); 4193} 4194 4195static PyObject * 4196wrap_binaryfunc(PyObject *self, PyObject *args, void *wrapped) 4197{ 4198 binaryfunc func = (binaryfunc)wrapped; 4199 PyObject *other; 4200 4201 if (!check_num_args(args, 1)) 4202 return NULL; 4203 other = PyTuple_GET_ITEM(args, 0); 4204 return (*func)(self, other); 4205} 4206 4207static PyObject * 4208wrap_binaryfunc_l(PyObject *self, PyObject *args, void *wrapped) 4209{ 4210 binaryfunc func = (binaryfunc)wrapped; 4211 PyObject *other; 4212 4213 if (!check_num_args(args, 1)) 4214 return NULL; 4215 other = PyTuple_GET_ITEM(args, 0); 4216 if (!(self->ob_type->tp_flags & Py_TPFLAGS_CHECKTYPES) && 4217 !PyType_IsSubtype(other->ob_type, self->ob_type)) { 4218 Py_INCREF(Py_NotImplemented); 4219 return Py_NotImplemented; 4220 } 4221 return (*func)(self, other); 4222} 4223 4224static PyObject * 4225wrap_binaryfunc_r(PyObject *self, PyObject *args, void *wrapped) 4226{ 4227 binaryfunc func = (binaryfunc)wrapped; 4228 PyObject *other; 4229 4230 if (!check_num_args(args, 1)) 4231 return NULL; 4232 other = PyTuple_GET_ITEM(args, 0); 4233 if (!(self->ob_type->tp_flags & Py_TPFLAGS_CHECKTYPES) && 4234 !PyType_IsSubtype(other->ob_type, self->ob_type)) { 4235 Py_INCREF(Py_NotImplemented); 4236 return Py_NotImplemented; 4237 } 4238 return (*func)(other, self); 4239} 4240 4241static PyObject * 4242wrap_coercefunc(PyObject *self, PyObject *args, void *wrapped) 4243{ 4244 coercion func = (coercion)wrapped; 4245 PyObject *other, *res; 4246 int ok; 4247 4248 if (!check_num_args(args, 1)) 4249 return NULL; 4250 other = PyTuple_GET_ITEM(args, 0); 4251 ok = func(&self, &other); 4252 if (ok < 0) 4253 return NULL; 4254 if (ok > 0) { 4255 Py_INCREF(Py_NotImplemented); 4256 return Py_NotImplemented; 4257 } 4258 res = PyTuple_New(2); 4259 if (res == NULL) { 4260 Py_DECREF(self); 4261 Py_DECREF(other); 4262 return NULL; 4263 } 4264 PyTuple_SET_ITEM(res, 0, self); 4265 PyTuple_SET_ITEM(res, 1, other); 4266 return res; 4267} 4268 4269static PyObject * 4270wrap_ternaryfunc(PyObject *self, PyObject *args, void *wrapped) 4271{ 4272 ternaryfunc func = (ternaryfunc)wrapped; 4273 PyObject *other; 4274 PyObject *third = Py_None; 4275 4276 /* Note: This wrapper only works for __pow__() */ 4277 4278 if (!PyArg_UnpackTuple(args, "", 1, 2, &other, &third)) 4279 return NULL; 4280 return (*func)(self, other, third); 4281} 4282 4283static PyObject * 4284wrap_ternaryfunc_r(PyObject *self, PyObject *args, void *wrapped) 4285{ 4286 ternaryfunc func = (ternaryfunc)wrapped; 4287 PyObject *other; 4288 PyObject *third = Py_None; 4289 4290 /* Note: This wrapper only works for __pow__() */ 4291 4292 if (!PyArg_UnpackTuple(args, "", 1, 2, &other, &third)) 4293 return NULL; 4294 return (*func)(other, self, third); 4295} 4296 4297static PyObject * 4298wrap_unaryfunc(PyObject *self, PyObject *args, void *wrapped) 4299{ 4300 unaryfunc func = (unaryfunc)wrapped; 4301 4302 if (!check_num_args(args, 0)) 4303 return NULL; 4304 return (*func)(self); 4305} 4306 4307static PyObject * 4308wrap_indexargfunc(PyObject *self, PyObject *args, void *wrapped) 4309{ 4310 ssizeargfunc func = (ssizeargfunc)wrapped; 4311 PyObject* o; 4312 Py_ssize_t i; 4313 4314 if (!PyArg_UnpackTuple(args, "", 1, 1, &o)) 4315 return NULL; 4316 i = PyNumber_AsSsize_t(o, PyExc_OverflowError); 4317 if (i == -1 && PyErr_Occurred()) 4318 return NULL; 4319 return (*func)(self, i); 4320} 4321 4322static Py_ssize_t 4323getindex(PyObject *self, PyObject *arg) 4324{ 4325 Py_ssize_t i; 4326 4327 i = PyNumber_AsSsize_t(arg, PyExc_OverflowError); 4328 if (i == -1 && PyErr_Occurred()) 4329 return -1; 4330 if (i < 0) { 4331 PySequenceMethods *sq = Py_TYPE(self)->tp_as_sequence; 4332 if (sq && sq->sq_length) { 4333 Py_ssize_t n = (*sq->sq_length)(self); 4334 if (n < 0) 4335 return -1; 4336 i += n; 4337 } 4338 } 4339 return i; 4340} 4341 4342static PyObject * 4343wrap_sq_item(PyObject *self, PyObject *args, void *wrapped) 4344{ 4345 ssizeargfunc func = (ssizeargfunc)wrapped; 4346 PyObject *arg; 4347 Py_ssize_t i; 4348 4349 if (PyTuple_GET_SIZE(args) == 1) { 4350 arg = PyTuple_GET_ITEM(args, 0); 4351 i = getindex(self, arg); 4352 if (i == -1 && PyErr_Occurred()) 4353 return NULL; 4354 return (*func)(self, i); 4355 } 4356 check_num_args(args, 1); 4357 assert(PyErr_Occurred()); 4358 return NULL; 4359} 4360 4361static PyObject * 4362wrap_ssizessizeargfunc(PyObject *self, PyObject *args, void *wrapped) 4363{ 4364 ssizessizeargfunc func = (ssizessizeargfunc)wrapped; 4365 Py_ssize_t i, j; 4366 4367 if (!PyArg_ParseTuple(args, "nn", &i, &j)) 4368 return NULL; 4369 return (*func)(self, i, j); 4370} 4371 4372static PyObject * 4373wrap_sq_setitem(PyObject *self, PyObject *args, void *wrapped) 4374{ 4375 ssizeobjargproc func = (ssizeobjargproc)wrapped; 4376 Py_ssize_t i; 4377 int res; 4378 PyObject *arg, *value; 4379 4380 if (!PyArg_UnpackTuple(args, "", 2, 2, &arg, &value)) 4381 return NULL; 4382 i = getindex(self, arg); 4383 if (i == -1 && PyErr_Occurred()) 4384 return NULL; 4385 res = (*func)(self, i, value); 4386 if (res == -1 && PyErr_Occurred()) 4387 return NULL; 4388 Py_INCREF(Py_None); 4389 return Py_None; 4390} 4391 4392static PyObject * 4393wrap_sq_delitem(PyObject *self, PyObject *args, void *wrapped) 4394{ 4395 ssizeobjargproc func = (ssizeobjargproc)wrapped; 4396 Py_ssize_t i; 4397 int res; 4398 PyObject *arg; 4399 4400 if (!check_num_args(args, 1)) 4401 return NULL; 4402 arg = PyTuple_GET_ITEM(args, 0); 4403 i = getindex(self, arg); 4404 if (i == -1 && PyErr_Occurred()) 4405 return NULL; 4406 res = (*func)(self, i, NULL); 4407 if (res == -1 && PyErr_Occurred()) 4408 return NULL; 4409 Py_INCREF(Py_None); 4410 return Py_None; 4411} 4412 4413static PyObject * 4414wrap_ssizessizeobjargproc(PyObject *self, PyObject *args, void *wrapped) 4415{ 4416 ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped; 4417 Py_ssize_t i, j; 4418 int res; 4419 PyObject *value; 4420 4421 if (!PyArg_ParseTuple(args, "nnO", &i, &j, &value)) 4422 return NULL; 4423 res = (*func)(self, i, j, value); 4424 if (res == -1 && PyErr_Occurred()) 4425 return NULL; 4426 Py_INCREF(Py_None); 4427 return Py_None; 4428} 4429 4430static PyObject * 4431wrap_delslice(PyObject *self, PyObject *args, void *wrapped) 4432{ 4433 ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped; 4434 Py_ssize_t i, j; 4435 int res; 4436 4437 if (!PyArg_ParseTuple(args, "nn", &i, &j)) 4438 return NULL; 4439 res = (*func)(self, i, j, NULL); 4440 if (res == -1 && PyErr_Occurred()) 4441 return NULL; 4442 Py_INCREF(Py_None); 4443 return Py_None; 4444} 4445 4446/* XXX objobjproc is a misnomer; should be objargpred */ 4447static PyObject * 4448wrap_objobjproc(PyObject *self, PyObject *args, void *wrapped) 4449{ 4450 objobjproc func = (objobjproc)wrapped; 4451 int res; 4452 PyObject *value; 4453 4454 if (!check_num_args(args, 1)) 4455 return NULL; 4456 value = PyTuple_GET_ITEM(args, 0); 4457 res = (*func)(self, value); 4458 if (res == -1 && PyErr_Occurred()) 4459 return NULL; 4460 else 4461 return PyBool_FromLong(res); 4462} 4463 4464static PyObject * 4465wrap_objobjargproc(PyObject *self, PyObject *args, void *wrapped) 4466{ 4467 objobjargproc func = (objobjargproc)wrapped; 4468 int res; 4469 PyObject *key, *value; 4470 4471 if (!PyArg_UnpackTuple(args, "", 2, 2, &key, &value)) 4472 return NULL; 4473 res = (*func)(self, key, value); 4474 if (res == -1 && PyErr_Occurred()) 4475 return NULL; 4476 Py_INCREF(Py_None); 4477 return Py_None; 4478} 4479 4480static PyObject * 4481wrap_delitem(PyObject *self, PyObject *args, void *wrapped) 4482{ 4483 objobjargproc func = (objobjargproc)wrapped; 4484 int res; 4485 PyObject *key; 4486 4487 if (!check_num_args(args, 1)) 4488 return NULL; 4489 key = PyTuple_GET_ITEM(args, 0); 4490 res = (*func)(self, key, NULL); 4491 if (res == -1 && PyErr_Occurred()) 4492 return NULL; 4493 Py_INCREF(Py_None); 4494 return Py_None; 4495} 4496 4497static PyObject * 4498wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped) 4499{ 4500 cmpfunc func = (cmpfunc)wrapped; 4501 int res; 4502 PyObject *other; 4503 4504 if (!check_num_args(args, 1)) 4505 return NULL; 4506 other = PyTuple_GET_ITEM(args, 0); 4507 if (Py_TYPE(other)->tp_compare != func && 4508 !PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self))) { 4509 PyErr_Format( 4510 PyExc_TypeError, 4511 "%s.__cmp__(x,y) requires y to be a '%s', not a '%s'", 4512 Py_TYPE(self)->tp_name, 4513 Py_TYPE(self)->tp_name, 4514 Py_TYPE(other)->tp_name); 4515 return NULL; 4516 } 4517 res = (*func)(self, other); 4518 if (PyErr_Occurred()) 4519 return NULL; 4520 return PyInt_FromLong((long)res); 4521} 4522 4523/* Helper to check for object.__setattr__ or __delattr__ applied to a type. 4524 This is called the Carlo Verre hack after its discoverer. */ 4525static int 4526hackcheck(PyObject *self, setattrofunc func, char *what) 4527{ 4528 PyTypeObject *type = Py_TYPE(self); 4529 while (type && type->tp_flags & Py_TPFLAGS_HEAPTYPE) 4530 type = type->tp_base; 4531 /* If type is NULL now, this is a really weird type. 4532 In the spirit of backwards compatibility (?), just shut up. */ 4533 if (type && type->tp_setattro != func) { 4534 PyErr_Format(PyExc_TypeError, 4535 "can't apply this %s to %s object", 4536 what, 4537 type->tp_name); 4538 return 0; 4539 } 4540 return 1; 4541} 4542 4543static PyObject * 4544wrap_setattr(PyObject *self, PyObject *args, void *wrapped) 4545{ 4546 setattrofunc func = (setattrofunc)wrapped; 4547 int res; 4548 PyObject *name, *value; 4549 4550 if (!PyArg_UnpackTuple(args, "", 2, 2, &name, &value)) 4551 return NULL; 4552 if (!hackcheck(self, func, "__setattr__")) 4553 return NULL; 4554 res = (*func)(self, name, value); 4555 if (res < 0) 4556 return NULL; 4557 Py_INCREF(Py_None); 4558 return Py_None; 4559} 4560 4561static PyObject * 4562wrap_delattr(PyObject *self, PyObject *args, void *wrapped) 4563{ 4564 setattrofunc func = (setattrofunc)wrapped; 4565 int res; 4566 PyObject *name; 4567 4568 if (!check_num_args(args, 1)) 4569 return NULL; 4570 name = PyTuple_GET_ITEM(args, 0); 4571 if (!hackcheck(self, func, "__delattr__")) 4572 return NULL; 4573 res = (*func)(self, name, NULL); 4574 if (res < 0) 4575 return NULL; 4576 Py_INCREF(Py_None); 4577 return Py_None; 4578} 4579 4580static PyObject * 4581wrap_hashfunc(PyObject *self, PyObject *args, void *wrapped) 4582{ 4583 hashfunc func = (hashfunc)wrapped; 4584 long res; 4585 4586 if (!check_num_args(args, 0)) 4587 return NULL; 4588 res = (*func)(self); 4589 if (res == -1 && PyErr_Occurred()) 4590 return NULL; 4591 return PyInt_FromLong(res); 4592} 4593 4594static PyObject * 4595wrap_call(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds) 4596{ 4597 ternaryfunc func = (ternaryfunc)wrapped; 4598 4599 return (*func)(self, args, kwds); 4600} 4601 4602static PyObject * 4603wrap_richcmpfunc(PyObject *self, PyObject *args, void *wrapped, int op) 4604{ 4605 richcmpfunc func = (richcmpfunc)wrapped; 4606 PyObject *other; 4607 4608 if (!check_num_args(args, 1)) 4609 return NULL; 4610 other = PyTuple_GET_ITEM(args, 0); 4611 return (*func)(self, other, op); 4612} 4613 4614#undef RICHCMP_WRAPPER 4615#define RICHCMP_WRAPPER(NAME, OP) \ 4616static PyObject * \ 4617richcmp_##NAME(PyObject *self, PyObject *args, void *wrapped) \ 4618{ \ 4619 return wrap_richcmpfunc(self, args, wrapped, OP); \ 4620} 4621 4622RICHCMP_WRAPPER(lt, Py_LT) 4623RICHCMP_WRAPPER(le, Py_LE) 4624RICHCMP_WRAPPER(eq, Py_EQ) 4625RICHCMP_WRAPPER(ne, Py_NE) 4626RICHCMP_WRAPPER(gt, Py_GT) 4627RICHCMP_WRAPPER(ge, Py_GE) 4628 4629static PyObject * 4630wrap_next(PyObject *self, PyObject *args, void *wrapped) 4631{ 4632 unaryfunc func = (unaryfunc)wrapped; 4633 PyObject *res; 4634 4635 if (!check_num_args(args, 0)) 4636 return NULL; 4637 res = (*func)(self); 4638 if (res == NULL && !PyErr_Occurred()) 4639 PyErr_SetNone(PyExc_StopIteration); 4640 return res; 4641} 4642 4643static PyObject * 4644wrap_descr_get(PyObject *self, PyObject *args, void *wrapped) 4645{ 4646 descrgetfunc func = (descrgetfunc)wrapped; 4647 PyObject *obj; 4648 PyObject *type = NULL; 4649 4650 if (!PyArg_UnpackTuple(args, "", 1, 2, &obj, &type)) 4651 return NULL; 4652 if (obj == Py_None) 4653 obj = NULL; 4654 if (type == Py_None) 4655 type = NULL; 4656 if (type == NULL &&obj == NULL) { 4657 PyErr_SetString(PyExc_TypeError, 4658 "__get__(None, None) is invalid"); 4659 return NULL; 4660 } 4661 return (*func)(self, obj, type); 4662} 4663 4664static PyObject * 4665wrap_descr_set(PyObject *self, PyObject *args, void *wrapped) 4666{ 4667 descrsetfunc func = (descrsetfunc)wrapped; 4668 PyObject *obj, *value; 4669 int ret; 4670 4671 if (!PyArg_UnpackTuple(args, "", 2, 2, &obj, &value)) 4672 return NULL; 4673 ret = (*func)(self, obj, value); 4674 if (ret < 0) 4675 return NULL; 4676 Py_INCREF(Py_None); 4677 return Py_None; 4678} 4679 4680static PyObject * 4681wrap_descr_delete(PyObject *self, PyObject *args, void *wrapped) 4682{ 4683 descrsetfunc func = (descrsetfunc)wrapped; 4684 PyObject *obj; 4685 int ret; 4686 4687 if (!check_num_args(args, 1)) 4688 return NULL; 4689 obj = PyTuple_GET_ITEM(args, 0); 4690 ret = (*func)(self, obj, NULL); 4691 if (ret < 0) 4692 return NULL; 4693 Py_INCREF(Py_None); 4694 return Py_None; 4695} 4696 4697static PyObject * 4698wrap_init(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds) 4699{ 4700 initproc func = (initproc)wrapped; 4701 4702 if (func(self, args, kwds) < 0) 4703 return NULL; 4704 Py_INCREF(Py_None); 4705 return Py_None; 4706} 4707 4708static PyObject * 4709tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds) 4710{ 4711 PyTypeObject *type, *subtype, *staticbase; 4712 PyObject *arg0, *res; 4713 4714 if (self == NULL || !PyType_Check(self)) 4715 Py_FatalError("__new__() called with non-type 'self'"); 4716 type = (PyTypeObject *)self; 4717 if (!PyTuple_Check(args) || PyTuple_GET_SIZE(args) < 1) { 4718 PyErr_Format(PyExc_TypeError, 4719 "%s.__new__(): not enough arguments", 4720 type->tp_name); 4721 return NULL; 4722 } 4723 arg0 = PyTuple_GET_ITEM(args, 0); 4724 if (!PyType_Check(arg0)) { 4725 PyErr_Format(PyExc_TypeError, 4726 "%s.__new__(X): X is not a type object (%s)", 4727 type->tp_name, 4728 Py_TYPE(arg0)->tp_name); 4729 return NULL; 4730 } 4731 subtype = (PyTypeObject *)arg0; 4732 if (!PyType_IsSubtype(subtype, type)) { 4733 PyErr_Format(PyExc_TypeError, 4734 "%s.__new__(%s): %s is not a subtype of %s", 4735 type->tp_name, 4736 subtype->tp_name, 4737 subtype->tp_name, 4738 type->tp_name); 4739 return NULL; 4740 } 4741 4742 /* Check that the use doesn't do something silly and unsafe like 4743 object.__new__(dict). To do this, we check that the 4744 most derived base that's not a heap type is this type. */ 4745 staticbase = subtype; 4746 while (staticbase && (staticbase->tp_flags & Py_TPFLAGS_HEAPTYPE)) 4747 staticbase = staticbase->tp_base; 4748 /* If staticbase is NULL now, it is a really weird type. 4749 In the spirit of backwards compatibility (?), just shut up. */ 4750 if (staticbase && staticbase->tp_new != type->tp_new) { 4751 PyErr_Format(PyExc_TypeError, 4752 "%s.__new__(%s) is not safe, use %s.__new__()", 4753 type->tp_name, 4754 subtype->tp_name, 4755 staticbase == NULL ? "?" : staticbase->tp_name); 4756 return NULL; 4757 } 4758 4759 args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args)); 4760 if (args == NULL) 4761 return NULL; 4762 res = type->tp_new(subtype, args, kwds); 4763 Py_DECREF(args); 4764 return res; 4765} 4766 4767static struct PyMethodDef tp_new_methoddef[] = { 4768 {"__new__", (PyCFunction)tp_new_wrapper, METH_VARARGS|METH_KEYWORDS, 4769 PyDoc_STR("T.__new__(S, ...) -> " 4770 "a new object with type S, a subtype of T")}, 4771 {0} 4772}; 4773 4774static int 4775add_tp_new_wrapper(PyTypeObject *type) 4776{ 4777 PyObject *func; 4778 4779 if (PyDict_GetItemString(type->tp_dict, "__new__") != NULL) 4780 return 0; 4781 func = PyCFunction_New(tp_new_methoddef, (PyObject *)type); 4782 if (func == NULL) 4783 return -1; 4784 if (PyDict_SetItemString(type->tp_dict, "__new__", func)) { 4785 Py_DECREF(func); 4786 return -1; 4787 } 4788 Py_DECREF(func); 4789 return 0; 4790} 4791 4792/* Slot wrappers that call the corresponding __foo__ slot. See comments 4793 below at override_slots() for more explanation. */ 4794 4795#define SLOT0(FUNCNAME, OPSTR) \ 4796static PyObject * \ 4797FUNCNAME(PyObject *self) \ 4798{ \ 4799 static PyObject *cache_str; \ 4800 return call_method(self, OPSTR, &cache_str, "()"); \ 4801} 4802 4803#define SLOT1(FUNCNAME, OPSTR, ARG1TYPE, ARGCODES) \ 4804static PyObject * \ 4805FUNCNAME(PyObject *self, ARG1TYPE arg1) \ 4806{ \ 4807 static PyObject *cache_str; \ 4808 return call_method(self, OPSTR, &cache_str, "(" ARGCODES ")", arg1); \ 4809} 4810 4811/* Boolean helper for SLOT1BINFULL(). 4812 right.__class__ is a nontrivial subclass of left.__class__. */ 4813static int 4814method_is_overloaded(PyObject *left, PyObject *right, char *name) 4815{ 4816 PyObject *a, *b; 4817 int ok; 4818 4819 b = PyObject_GetAttrString((PyObject *)(Py_TYPE(right)), name); 4820 if (b == NULL) { 4821 PyErr_Clear(); 4822 /* If right doesn't have it, it's not overloaded */ 4823 return 0; 4824 } 4825 4826 a = PyObject_GetAttrString((PyObject *)(Py_TYPE(left)), name); 4827 if (a == NULL) { 4828 PyErr_Clear(); 4829 Py_DECREF(b); 4830 /* If right has it but left doesn't, it's overloaded */ 4831 return 1; 4832 } 4833 4834 ok = PyObject_RichCompareBool(a, b, Py_NE); 4835 Py_DECREF(a); 4836 Py_DECREF(b); 4837 if (ok < 0) { 4838 PyErr_Clear(); 4839 return 0; 4840 } 4841 4842 return ok; 4843} 4844 4845 4846#define SLOT1BINFULL(FUNCNAME, TESTFUNC, SLOTNAME, OPSTR, ROPSTR) \ 4847static PyObject * \ 4848FUNCNAME(PyObject *self, PyObject *other) \ 4849{ \ 4850 static PyObject *cache_str, *rcache_str; \ 4851 int do_other = Py_TYPE(self) != Py_TYPE(other) && \ 4852 Py_TYPE(other)->tp_as_number != NULL && \ 4853 Py_TYPE(other)->tp_as_number->SLOTNAME == TESTFUNC; \ 4854 if (Py_TYPE(self)->tp_as_number != NULL && \ 4855 Py_TYPE(self)->tp_as_number->SLOTNAME == TESTFUNC) { \ 4856 PyObject *r; \ 4857 if (do_other && \ 4858 PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self)) && \ 4859 method_is_overloaded(self, other, ROPSTR)) { \ 4860 r = call_maybe( \ 4861 other, ROPSTR, &rcache_str, "(O)", self); \ 4862 if (r != Py_NotImplemented) \ 4863 return r; \ 4864 Py_DECREF(r); \ 4865 do_other = 0; \ 4866 } \ 4867 r = call_maybe( \ 4868 self, OPSTR, &cache_str, "(O)", other); \ 4869 if (r != Py_NotImplemented || \ 4870 Py_TYPE(other) == Py_TYPE(self)) \ 4871 return r; \ 4872 Py_DECREF(r); \ 4873 } \ 4874 if (do_other) { \ 4875 return call_maybe( \ 4876 other, ROPSTR, &rcache_str, "(O)", self); \ 4877 } \ 4878 Py_INCREF(Py_NotImplemented); \ 4879 return Py_NotImplemented; \ 4880} 4881 4882#define SLOT1BIN(FUNCNAME, SLOTNAME, OPSTR, ROPSTR) \ 4883 SLOT1BINFULL(FUNCNAME, FUNCNAME, SLOTNAME, OPSTR, ROPSTR) 4884 4885#define SLOT2(FUNCNAME, OPSTR, ARG1TYPE, ARG2TYPE, ARGCODES) \ 4886static PyObject * \ 4887FUNCNAME(PyObject *self, ARG1TYPE arg1, ARG2TYPE arg2) \ 4888{ \ 4889 static PyObject *cache_str; \ 4890 return call_method(self, OPSTR, &cache_str, \ 4891 "(" ARGCODES ")", arg1, arg2); \ 4892} 4893 4894static Py_ssize_t 4895slot_sq_length(PyObject *self) 4896{ 4897 static PyObject *len_str; 4898 PyObject *res = call_method(self, "__len__", &len_str, "()"); 4899 Py_ssize_t len; 4900 4901 if (res == NULL) 4902 return -1; 4903 len = PyInt_AsSsize_t(res); 4904 Py_DECREF(res); 4905 if (len < 0) { 4906 if (!PyErr_Occurred()) 4907 PyErr_SetString(PyExc_ValueError, 4908 "__len__() should return >= 0"); 4909 return -1; 4910 } 4911 return len; 4912} 4913 4914/* Super-optimized version of slot_sq_item. 4915 Other slots could do the same... */ 4916static PyObject * 4917slot_sq_item(PyObject *self, Py_ssize_t i) 4918{ 4919 static PyObject *getitem_str; 4920 PyObject *func, *args = NULL, *ival = NULL, *retval = NULL; 4921 descrgetfunc f; 4922 4923 if (getitem_str == NULL) { 4924 getitem_str = PyString_InternFromString("__getitem__"); 4925 if (getitem_str == NULL) 4926 return NULL; 4927 } 4928 func = _PyType_Lookup(Py_TYPE(self), getitem_str); 4929 if (func != NULL) { 4930 if ((f = Py_TYPE(func)->tp_descr_get) == NULL) 4931 Py_INCREF(func); 4932 else { 4933 func = f(func, self, (PyObject *)(Py_TYPE(self))); 4934 if (func == NULL) { 4935 return NULL; 4936 } 4937 } 4938 ival = PyInt_FromSsize_t(i); 4939 if (ival != NULL) { 4940 args = PyTuple_New(1); 4941 if (args != NULL) { 4942 PyTuple_SET_ITEM(args, 0, ival); 4943 retval = PyObject_Call(func, args, NULL); 4944 Py_XDECREF(args); 4945 Py_XDECREF(func); 4946 return retval; 4947 } 4948 } 4949 } 4950 else { 4951 PyErr_SetObject(PyExc_AttributeError, getitem_str); 4952 } 4953 Py_XDECREF(args); 4954 Py_XDECREF(ival); 4955 Py_XDECREF(func); 4956 return NULL; 4957} 4958 4959static PyObject* 4960slot_sq_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j) 4961{ 4962 static PyObject *getslice_str; 4963 4964 if (PyErr_WarnPy3k("in 3.x, __getslice__ has been removed; " 4965 "use __getitem__", 1) < 0) 4966 return NULL; 4967 return call_method(self, "__getslice__", &getslice_str, 4968 "nn", i, j); 4969} 4970 4971static int 4972slot_sq_ass_item(PyObject *self, Py_ssize_t index, PyObject *value) 4973{ 4974 PyObject *res; 4975 static PyObject *delitem_str, *setitem_str; 4976 4977 if (value == NULL) 4978 res = call_method(self, "__delitem__", &delitem_str, 4979 "(n)", index); 4980 else 4981 res = call_method(self, "__setitem__", &setitem_str, 4982 "(nO)", index, value); 4983 if (res == NULL) 4984 return -1; 4985 Py_DECREF(res); 4986 return 0; 4987} 4988 4989static int 4990slot_sq_ass_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j, PyObject *value) 4991{ 4992 PyObject *res; 4993 static PyObject *delslice_str, *setslice_str; 4994 4995 if (value == NULL) { 4996 if (PyErr_WarnPy3k("in 3.x, __delslice__ has been removed; " 4997 "use __delitem__", 1) < 0) 4998 return -1; 4999 res = call_method(self, "__delslice__", &delslice_str, 5000 "(nn)", i, j); 5001 } 5002 else { 5003 if (PyErr_WarnPy3k("in 3.x, __setslice__ has been removed; " 5004 "use __setitem__", 1) < 0) 5005 return -1; 5006 res = call_method(self, "__setslice__", &setslice_str, 5007 "(nnO)", i, j, value); 5008 } 5009 if (res == NULL) 5010 return -1; 5011 Py_DECREF(res); 5012 return 0; 5013} 5014 5015static int 5016slot_sq_contains(PyObject *self, PyObject *value) 5017{ 5018 PyObject *func, *res, *args; 5019 int result = -1; 5020 5021 static PyObject *contains_str; 5022 5023 func = lookup_maybe(self, "__contains__", &contains_str); 5024 if (func != NULL) { 5025 args = PyTuple_Pack(1, value); 5026 if (args == NULL) 5027 res = NULL; 5028 else { 5029 res = PyObject_Call(func, args, NULL); 5030 Py_DECREF(args); 5031 } 5032 Py_DECREF(func); 5033 if (res != NULL) { 5034 result = PyObject_IsTrue(res); 5035 Py_DECREF(res); 5036 } 5037 } 5038 else if (! PyErr_Occurred()) { 5039 /* Possible results: -1 and 1 */ 5040 result = (int)_PySequence_IterSearch(self, value, 5041 PY_ITERSEARCH_CONTAINS); 5042 } 5043 return result; 5044} 5045 5046#define slot_mp_length slot_sq_length 5047 5048SLOT1(slot_mp_subscript, "__getitem__", PyObject *, "O") 5049 5050static int 5051slot_mp_ass_subscript(PyObject *self, PyObject *key, PyObject *value) 5052{ 5053 PyObject *res; 5054 static PyObject *delitem_str, *setitem_str; 5055 5056 if (value == NULL) 5057 res = call_method(self, "__delitem__", &delitem_str, 5058 "(O)", key); 5059 else 5060 res = call_method(self, "__setitem__", &setitem_str, 5061 "(OO)", key, value); 5062 if (res == NULL) 5063 return -1; 5064 Py_DECREF(res); 5065 return 0; 5066} 5067 5068SLOT1BIN(slot_nb_add, nb_add, "__add__", "__radd__") 5069SLOT1BIN(slot_nb_subtract, nb_subtract, "__sub__", "__rsub__") 5070SLOT1BIN(slot_nb_multiply, nb_multiply, "__mul__", "__rmul__") 5071SLOT1BIN(slot_nb_divide, nb_divide, "__div__", "__rdiv__") 5072SLOT1BIN(slot_nb_remainder, nb_remainder, "__mod__", "__rmod__") 5073SLOT1BIN(slot_nb_divmod, nb_divmod, "__divmod__", "__rdivmod__") 5074 5075static PyObject *slot_nb_power(PyObject *, PyObject *, PyObject *); 5076 5077SLOT1BINFULL(slot_nb_power_binary, slot_nb_power, 5078 nb_power, "__pow__", "__rpow__") 5079 5080static PyObject * 5081slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus) 5082{ 5083 static PyObject *pow_str; 5084 5085 if (modulus == Py_None) 5086 return slot_nb_power_binary(self, other); 5087 /* Three-arg power doesn't use __rpow__. But ternary_op 5088 can call this when the second argument's type uses 5089 slot_nb_power, so check before calling self.__pow__. */ 5090 if (Py_TYPE(self)->tp_as_number != NULL && 5091 Py_TYPE(self)->tp_as_number->nb_power == slot_nb_power) { 5092 return call_method(self, "__pow__", &pow_str, 5093 "(OO)", other, modulus); 5094 } 5095 Py_INCREF(Py_NotImplemented); 5096 return Py_NotImplemented; 5097} 5098 5099SLOT0(slot_nb_negative, "__neg__") 5100SLOT0(slot_nb_positive, "__pos__") 5101SLOT0(slot_nb_absolute, "__abs__") 5102 5103static int 5104slot_nb_nonzero(PyObject *self) 5105{ 5106 PyObject *func, *args; 5107 static PyObject *nonzero_str, *len_str; 5108 int result = -1; 5109 int using_len = 0; 5110 5111 func = lookup_maybe(self, "__nonzero__", &nonzero_str); 5112 if (func == NULL) { 5113 if (PyErr_Occurred()) 5114 return -1; 5115 func = lookup_maybe(self, "__len__", &len_str); 5116 if (func == NULL) 5117 return PyErr_Occurred() ? -1 : 1; 5118 using_len = 1; 5119 } 5120 args = PyTuple_New(0); 5121 if (args != NULL) { 5122 PyObject *temp = PyObject_Call(func, args, NULL); 5123 Py_DECREF(args); 5124 if (temp != NULL) { 5125 if (PyInt_CheckExact(temp) || PyBool_Check(temp)) 5126 result = PyObject_IsTrue(temp); 5127 else { 5128 PyErr_Format(PyExc_TypeError, 5129 "%s should return " 5130 "bool or int, returned %s", 5131 (using_len ? "__len__" 5132 : "__nonzero__"), 5133 temp->ob_type->tp_name); 5134 result = -1; 5135 } 5136 Py_DECREF(temp); 5137 } 5138 } 5139 Py_DECREF(func); 5140 return result; 5141} 5142 5143 5144static PyObject * 5145slot_nb_index(PyObject *self) 5146{ 5147 static PyObject *index_str; 5148 return call_method(self, "__index__", &index_str, "()"); 5149} 5150 5151 5152SLOT0(slot_nb_invert, "__invert__") 5153SLOT1BIN(slot_nb_lshift, nb_lshift, "__lshift__", "__rlshift__") 5154SLOT1BIN(slot_nb_rshift, nb_rshift, "__rshift__", "__rrshift__") 5155SLOT1BIN(slot_nb_and, nb_and, "__and__", "__rand__") 5156SLOT1BIN(slot_nb_xor, nb_xor, "__xor__", "__rxor__") 5157SLOT1BIN(slot_nb_or, nb_or, "__or__", "__ror__") 5158 5159static int 5160slot_nb_coerce(PyObject **a, PyObject **b) 5161{ 5162 static PyObject *coerce_str; 5163 PyObject *self = *a, *other = *b; 5164 5165 if (self->ob_type->tp_as_number != NULL && 5166 self->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) { 5167 PyObject *r; 5168 r = call_maybe( 5169 self, "__coerce__", &coerce_str, "(O)", other); 5170 if (r == NULL) 5171 return -1; 5172 if (r == Py_NotImplemented) { 5173 Py_DECREF(r); 5174 } 5175 else { 5176 if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) { 5177 PyErr_SetString(PyExc_TypeError, 5178 "__coerce__ didn't return a 2-tuple"); 5179 Py_DECREF(r); 5180 return -1; 5181 } 5182 *a = PyTuple_GET_ITEM(r, 0); 5183 Py_INCREF(*a); 5184 *b = PyTuple_GET_ITEM(r, 1); 5185 Py_INCREF(*b); 5186 Py_DECREF(r); 5187 return 0; 5188 } 5189 } 5190 if (other->ob_type->tp_as_number != NULL && 5191 other->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) { 5192 PyObject *r; 5193 r = call_maybe( 5194 other, "__coerce__", &coerce_str, "(O)", self); 5195 if (r == NULL) 5196 return -1; 5197 if (r == Py_NotImplemented) { 5198 Py_DECREF(r); 5199 return 1; 5200 } 5201 if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) { 5202 PyErr_SetString(PyExc_TypeError, 5203 "__coerce__ didn't return a 2-tuple"); 5204 Py_DECREF(r); 5205 return -1; 5206 } 5207 *a = PyTuple_GET_ITEM(r, 1); 5208 Py_INCREF(*a); 5209 *b = PyTuple_GET_ITEM(r, 0); 5210 Py_INCREF(*b); 5211 Py_DECREF(r); 5212 return 0; 5213 } 5214 return 1; 5215} 5216 5217SLOT0(slot_nb_int, "__int__") 5218SLOT0(slot_nb_long, "__long__") 5219SLOT0(slot_nb_float, "__float__") 5220SLOT0(slot_nb_oct, "__oct__") 5221SLOT0(slot_nb_hex, "__hex__") 5222SLOT1(slot_nb_inplace_add, "__iadd__", PyObject *, "O") 5223SLOT1(slot_nb_inplace_subtract, "__isub__", PyObject *, "O") 5224SLOT1(slot_nb_inplace_multiply, "__imul__", PyObject *, "O") 5225SLOT1(slot_nb_inplace_divide, "__idiv__", PyObject *, "O") 5226SLOT1(slot_nb_inplace_remainder, "__imod__", PyObject *, "O") 5227/* Can't use SLOT1 here, because nb_inplace_power is ternary */ 5228static PyObject * 5229slot_nb_inplace_power(PyObject *self, PyObject * arg1, PyObject *arg2) 5230{ 5231 static PyObject *cache_str; 5232 return call_method(self, "__ipow__", &cache_str, "(" "O" ")", arg1); 5233} 5234SLOT1(slot_nb_inplace_lshift, "__ilshift__", PyObject *, "O") 5235SLOT1(slot_nb_inplace_rshift, "__irshift__", PyObject *, "O") 5236SLOT1(slot_nb_inplace_and, "__iand__", PyObject *, "O") 5237SLOT1(slot_nb_inplace_xor, "__ixor__", PyObject *, "O") 5238SLOT1(slot_nb_inplace_or, "__ior__", PyObject *, "O") 5239SLOT1BIN(slot_nb_floor_divide, nb_floor_divide, 5240 "__floordiv__", "__rfloordiv__") 5241SLOT1BIN(slot_nb_true_divide, nb_true_divide, "__truediv__", "__rtruediv__") 5242SLOT1(slot_nb_inplace_floor_divide, "__ifloordiv__", PyObject *, "O") 5243SLOT1(slot_nb_inplace_true_divide, "__itruediv__", PyObject *, "O") 5244 5245static int 5246half_compare(PyObject *self, PyObject *other) 5247{ 5248 PyObject *func, *args, *res; 5249 static PyObject *cmp_str; 5250 Py_ssize_t c; 5251 5252 func = lookup_method(self, "__cmp__", &cmp_str); 5253 if (func == NULL) { 5254 PyErr_Clear(); 5255 } 5256 else { 5257 args = PyTuple_Pack(1, other); 5258 if (args == NULL) 5259 res = NULL; 5260 else { 5261 res = PyObject_Call(func, args, NULL); 5262 Py_DECREF(args); 5263 } 5264 Py_DECREF(func); 5265 if (res != Py_NotImplemented) { 5266 if (res == NULL) 5267 return -2; 5268 c = PyInt_AsLong(res); 5269 Py_DECREF(res); 5270 if (c == -1 && PyErr_Occurred()) 5271 return -2; 5272 return (c < 0) ? -1 : (c > 0) ? 1 : 0; 5273 } 5274 Py_DECREF(res); 5275 } 5276 return 2; 5277} 5278 5279/* This slot is published for the benefit of try_3way_compare in object.c */ 5280int 5281_PyObject_SlotCompare(PyObject *self, PyObject *other) 5282{ 5283 int c; 5284 5285 if (Py_TYPE(self)->tp_compare == _PyObject_SlotCompare) { 5286 c = half_compare(self, other); 5287 if (c <= 1) 5288 return c; 5289 } 5290 if (Py_TYPE(other)->tp_compare == _PyObject_SlotCompare) { 5291 c = half_compare(other, self); 5292 if (c < -1) 5293 return -2; 5294 if (c <= 1) 5295 return -c; 5296 } 5297 return (void *)self < (void *)other ? -1 : 5298 (void *)self > (void *)other ? 1 : 0; 5299} 5300 5301static PyObject * 5302slot_tp_repr(PyObject *self) 5303{ 5304 PyObject *func, *res; 5305 static PyObject *repr_str; 5306 5307 func = lookup_method(self, "__repr__", &repr_str); 5308 if (func != NULL) { 5309 res = PyEval_CallObject(func, NULL); 5310 Py_DECREF(func); 5311 return res; 5312 } 5313 PyErr_Clear(); 5314 return PyString_FromFormat("<%s object at %p>", 5315 Py_TYPE(self)->tp_name, self); 5316} 5317 5318static PyObject * 5319slot_tp_str(PyObject *self) 5320{ 5321 PyObject *func, *res; 5322 static PyObject *str_str; 5323 5324 func = lookup_method(self, "__str__", &str_str); 5325 if (func != NULL) { 5326 res = PyEval_CallObject(func, NULL); 5327 Py_DECREF(func); 5328 return res; 5329 } 5330 else { 5331 PyErr_Clear(); 5332 return slot_tp_repr(self); 5333 } 5334} 5335 5336static long 5337slot_tp_hash(PyObject *self) 5338{ 5339 PyObject *func; 5340 static PyObject *hash_str, *eq_str, *cmp_str; 5341 long h; 5342 5343 func = lookup_method(self, "__hash__", &hash_str); 5344 5345 if (func != NULL && func != Py_None) { 5346 PyObject *res = PyEval_CallObject(func, NULL); 5347 Py_DECREF(func); 5348 if (res == NULL) 5349 return -1; 5350 if (PyLong_Check(res)) 5351 h = PyLong_Type.tp_hash(res); 5352 else 5353 h = PyInt_AsLong(res); 5354 Py_DECREF(res); 5355 } 5356 else { 5357 Py_XDECREF(func); /* may be None */ 5358 PyErr_Clear(); 5359 func = lookup_method(self, "__eq__", &eq_str); 5360 if (func == NULL) { 5361 PyErr_Clear(); 5362 func = lookup_method(self, "__cmp__", &cmp_str); 5363 } 5364 if (func != NULL) { 5365 Py_DECREF(func); 5366 return PyObject_HashNotImplemented(self); 5367 } 5368 PyErr_Clear(); 5369 h = _Py_HashPointer((void *)self); 5370 } 5371 if (h == -1 && !PyErr_Occurred()) 5372 h = -2; 5373 return h; 5374} 5375 5376static PyObject * 5377slot_tp_call(PyObject *self, PyObject *args, PyObject *kwds) 5378{ 5379 static PyObject *call_str; 5380 PyObject *meth = lookup_method(self, "__call__", &call_str); 5381 PyObject *res; 5382 5383 if (meth == NULL) 5384 return NULL; 5385 5386 res = PyObject_Call(meth, args, kwds); 5387 5388 Py_DECREF(meth); 5389 return res; 5390} 5391 5392/* There are two slot dispatch functions for tp_getattro. 5393 5394 - slot_tp_getattro() is used when __getattribute__ is overridden 5395 but no __getattr__ hook is present; 5396 5397 - slot_tp_getattr_hook() is used when a __getattr__ hook is present. 5398 5399 The code in update_one_slot() always installs slot_tp_getattr_hook(); this 5400 detects the absence of __getattr__ and then installs the simpler slot if 5401 necessary. */ 5402 5403static PyObject * 5404slot_tp_getattro(PyObject *self, PyObject *name) 5405{ 5406 static PyObject *getattribute_str = NULL; 5407 return call_method(self, "__getattribute__", &getattribute_str, 5408 "(O)", name); 5409} 5410 5411static PyObject * 5412call_attribute(PyObject *self, PyObject *attr, PyObject *name) 5413{ 5414 PyObject *res, *descr = NULL; 5415 descrgetfunc f = Py_TYPE(attr)->tp_descr_get; 5416 5417 if (f != NULL) { 5418 descr = f(attr, self, (PyObject *)(Py_TYPE(self))); 5419 if (descr == NULL) 5420 return NULL; 5421 else 5422 attr = descr; 5423 } 5424 res = PyObject_CallFunctionObjArgs(attr, name, NULL); 5425 Py_XDECREF(descr); 5426 return res; 5427} 5428 5429static PyObject * 5430slot_tp_getattr_hook(PyObject *self, PyObject *name) 5431{ 5432 PyTypeObject *tp = Py_TYPE(self); 5433 PyObject *getattr, *getattribute, *res; 5434 static PyObject *getattribute_str = NULL; 5435 static PyObject *getattr_str = NULL; 5436 5437 if (getattr_str == NULL) { 5438 getattr_str = PyString_InternFromString("__getattr__"); 5439 if (getattr_str == NULL) 5440 return NULL; 5441 } 5442 if (getattribute_str == NULL) { 5443 getattribute_str = 5444 PyString_InternFromString("__getattribute__"); 5445 if (getattribute_str == NULL) 5446 return NULL; 5447 } 5448 /* speed hack: we could use lookup_maybe, but that would resolve the 5449 method fully for each attribute lookup for classes with 5450 __getattr__, even when the attribute is present. So we use 5451 _PyType_Lookup and create the method only when needed, with 5452 call_attribute. */ 5453 getattr = _PyType_Lookup(tp, getattr_str); 5454 if (getattr == NULL) { 5455 /* No __getattr__ hook: use a simpler dispatcher */ 5456 tp->tp_getattro = slot_tp_getattro; 5457 return slot_tp_getattro(self, name); 5458 } 5459 Py_INCREF(getattr); 5460 /* speed hack: we could use lookup_maybe, but that would resolve the 5461 method fully for each attribute lookup for classes with 5462 __getattr__, even when self has the default __getattribute__ 5463 method. So we use _PyType_Lookup and create the method only when 5464 needed, with call_attribute. */ 5465 getattribute = _PyType_Lookup(tp, getattribute_str); 5466 if (getattribute == NULL || 5467 (Py_TYPE(getattribute) == &PyWrapperDescr_Type && 5468 ((PyWrapperDescrObject *)getattribute)->d_wrapped == 5469 (void *)PyObject_GenericGetAttr)) 5470 res = PyObject_GenericGetAttr(self, name); 5471 else { 5472 Py_INCREF(getattribute); 5473 res = call_attribute(self, getattribute, name); 5474 Py_DECREF(getattribute); 5475 } 5476 if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) { 5477 PyErr_Clear(); 5478 res = call_attribute(self, getattr, name); 5479 } 5480 Py_DECREF(getattr); 5481 return res; 5482} 5483 5484static int 5485slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value) 5486{ 5487 PyObject *res; 5488 static PyObject *delattr_str, *setattr_str; 5489 5490 if (value == NULL) 5491 res = call_method(self, "__delattr__", &delattr_str, 5492 "(O)", name); 5493 else 5494 res = call_method(self, "__setattr__", &setattr_str, 5495 "(OO)", name, value); 5496 if (res == NULL) 5497 return -1; 5498 Py_DECREF(res); 5499 return 0; 5500} 5501 5502static char *name_op[] = { 5503 "__lt__", 5504 "__le__", 5505 "__eq__", 5506 "__ne__", 5507 "__gt__", 5508 "__ge__", 5509}; 5510 5511static PyObject * 5512half_richcompare(PyObject *self, PyObject *other, int op) 5513{ 5514 PyObject *func, *args, *res; 5515 static PyObject *op_str[6]; 5516 5517 func = lookup_method(self, name_op[op], &op_str[op]); 5518 if (func == NULL) { 5519 PyErr_Clear(); 5520 Py_INCREF(Py_NotImplemented); 5521 return Py_NotImplemented; 5522 } 5523 args = PyTuple_Pack(1, other); 5524 if (args == NULL) 5525 res = NULL; 5526 else { 5527 res = PyObject_Call(func, args, NULL); 5528 Py_DECREF(args); 5529 } 5530 Py_DECREF(func); 5531 return res; 5532} 5533 5534static PyObject * 5535slot_tp_richcompare(PyObject *self, PyObject *other, int op) 5536{ 5537 PyObject *res; 5538 5539 if (Py_TYPE(self)->tp_richcompare == slot_tp_richcompare) { 5540 res = half_richcompare(self, other, op); 5541 if (res != Py_NotImplemented) 5542 return res; 5543 Py_DECREF(res); 5544 } 5545 if (Py_TYPE(other)->tp_richcompare == slot_tp_richcompare) { 5546 res = half_richcompare(other, self, _Py_SwappedOp[op]); 5547 if (res != Py_NotImplemented) { 5548 return res; 5549 } 5550 Py_DECREF(res); 5551 } 5552 Py_INCREF(Py_NotImplemented); 5553 return Py_NotImplemented; 5554} 5555 5556static PyObject * 5557slot_tp_iter(PyObject *self) 5558{ 5559 PyObject *func, *res; 5560 static PyObject *iter_str, *getitem_str; 5561 5562 func = lookup_method(self, "__iter__", &iter_str); 5563 if (func != NULL) { 5564 PyObject *args; 5565 args = res = PyTuple_New(0); 5566 if (args != NULL) { 5567 res = PyObject_Call(func, args, NULL); 5568 Py_DECREF(args); 5569 } 5570 Py_DECREF(func); 5571 return res; 5572 } 5573 PyErr_Clear(); 5574 func = lookup_method(self, "__getitem__", &getitem_str); 5575 if (func == NULL) { 5576 PyErr_Format(PyExc_TypeError, 5577 "'%.200s' object is not iterable", 5578 Py_TYPE(self)->tp_name); 5579 return NULL; 5580 } 5581 Py_DECREF(func); 5582 return PySeqIter_New(self); 5583} 5584 5585static PyObject * 5586slot_tp_iternext(PyObject *self) 5587{ 5588 static PyObject *next_str; 5589 return call_method(self, "next", &next_str, "()"); 5590} 5591 5592static PyObject * 5593slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type) 5594{ 5595 PyTypeObject *tp = Py_TYPE(self); 5596 PyObject *get; 5597 static PyObject *get_str = NULL; 5598 5599 if (get_str == NULL) { 5600 get_str = PyString_InternFromString("__get__"); 5601 if (get_str == NULL) 5602 return NULL; 5603 } 5604 get = _PyType_Lookup(tp, get_str); 5605 if (get == NULL) { 5606 /* Avoid further slowdowns */ 5607 if (tp->tp_descr_get == slot_tp_descr_get) 5608 tp->tp_descr_get = NULL; 5609 Py_INCREF(self); 5610 return self; 5611 } 5612 if (obj == NULL) 5613 obj = Py_None; 5614 if (type == NULL) 5615 type = Py_None; 5616 return PyObject_CallFunctionObjArgs(get, self, obj, type, NULL); 5617} 5618 5619static int 5620slot_tp_descr_set(PyObject *self, PyObject *target, PyObject *value) 5621{ 5622 PyObject *res; 5623 static PyObject *del_str, *set_str; 5624 5625 if (value == NULL) 5626 res = call_method(self, "__delete__", &del_str, 5627 "(O)", target); 5628 else 5629 res = call_method(self, "__set__", &set_str, 5630 "(OO)", target, value); 5631 if (res == NULL) 5632 return -1; 5633 Py_DECREF(res); 5634 return 0; 5635} 5636 5637static int 5638slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds) 5639{ 5640 static PyObject *init_str; 5641 PyObject *meth = lookup_method(self, "__init__", &init_str); 5642 PyObject *res; 5643 5644 if (meth == NULL) 5645 return -1; 5646 res = PyObject_Call(meth, args, kwds); 5647 Py_DECREF(meth); 5648 if (res == NULL) 5649 return -1; 5650 if (res != Py_None) { 5651 PyErr_Format(PyExc_TypeError, 5652 "__init__() should return None, not '%.200s'", 5653 Py_TYPE(res)->tp_name); 5654 Py_DECREF(res); 5655 return -1; 5656 } 5657 Py_DECREF(res); 5658 return 0; 5659} 5660 5661static PyObject * 5662slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 5663{ 5664 static PyObject *new_str; 5665 PyObject *func; 5666 PyObject *newargs, *x; 5667 Py_ssize_t i, n; 5668 5669 if (new_str == NULL) { 5670 new_str = PyString_InternFromString("__new__"); 5671 if (new_str == NULL) 5672 return NULL; 5673 } 5674 func = PyObject_GetAttr((PyObject *)type, new_str); 5675 if (func == NULL) 5676 return NULL; 5677 assert(PyTuple_Check(args)); 5678 n = PyTuple_GET_SIZE(args); 5679 newargs = PyTuple_New(n+1); 5680 if (newargs == NULL) 5681 return NULL; 5682 Py_INCREF(type); 5683 PyTuple_SET_ITEM(newargs, 0, (PyObject *)type); 5684 for (i = 0; i < n; i++) { 5685 x = PyTuple_GET_ITEM(args, i); 5686 Py_INCREF(x); 5687 PyTuple_SET_ITEM(newargs, i+1, x); 5688 } 5689 x = PyObject_Call(func, newargs, kwds); 5690 Py_DECREF(newargs); 5691 Py_DECREF(func); 5692 return x; 5693} 5694 5695static void 5696slot_tp_del(PyObject *self) 5697{ 5698 static PyObject *del_str = NULL; 5699 PyObject *del, *res; 5700 PyObject *error_type, *error_value, *error_traceback; 5701 5702 /* Temporarily resurrect the object. */ 5703 assert(self->ob_refcnt == 0); 5704 self->ob_refcnt = 1; 5705 5706 /* Save the current exception, if any. */ 5707 PyErr_Fetch(&error_type, &error_value, &error_traceback); 5708 5709 /* Execute __del__ method, if any. */ 5710 del = lookup_maybe(self, "__del__", &del_str); 5711 if (del != NULL) { 5712 res = PyEval_CallObject(del, NULL); 5713 if (res == NULL) 5714 PyErr_WriteUnraisable(del); 5715 else 5716 Py_DECREF(res); 5717 Py_DECREF(del); 5718 } 5719 5720 /* Restore the saved exception. */ 5721 PyErr_Restore(error_type, error_value, error_traceback); 5722 5723 /* Undo the temporary resurrection; can't use DECREF here, it would 5724 * cause a recursive call. 5725 */ 5726 assert(self->ob_refcnt > 0); 5727 if (--self->ob_refcnt == 0) 5728 return; /* this is the normal path out */ 5729 5730 /* __del__ resurrected it! Make it look like the original Py_DECREF 5731 * never happened. 5732 */ 5733 { 5734 Py_ssize_t refcnt = self->ob_refcnt; 5735 _Py_NewReference(self); 5736 self->ob_refcnt = refcnt; 5737 } 5738 assert(!PyType_IS_GC(Py_TYPE(self)) || 5739 _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); 5740 /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so 5741 * we need to undo that. */ 5742 _Py_DEC_REFTOTAL; 5743 /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object 5744 * chain, so no more to do there. 5745 * If COUNT_ALLOCS, the original decref bumped tp_frees, and 5746 * _Py_NewReference bumped tp_allocs: both of those need to be 5747 * undone. 5748 */ 5749#ifdef COUNT_ALLOCS 5750 --Py_TYPE(self)->tp_frees; 5751 --Py_TYPE(self)->tp_allocs; 5752#endif 5753} 5754 5755 5756/* Table mapping __foo__ names to tp_foo offsets and slot_tp_foo wrapper 5757 functions. The offsets here are relative to the 'PyHeapTypeObject' 5758 structure, which incorporates the additional structures used for numbers, 5759 sequences and mappings. 5760 Note that multiple names may map to the same slot (e.g. __eq__, 5761 __ne__ etc. all map to tp_richcompare) and one name may map to multiple 5762 slots (e.g. __str__ affects tp_str as well as tp_repr). The table is 5763 terminated with an all-zero entry. (This table is further initialized and 5764 sorted in init_slotdefs() below.) */ 5765 5766typedef struct wrapperbase slotdef; 5767 5768#undef TPSLOT 5769#undef FLSLOT 5770#undef ETSLOT 5771#undef SQSLOT 5772#undef MPSLOT 5773#undef NBSLOT 5774#undef UNSLOT 5775#undef IBSLOT 5776#undef BINSLOT 5777#undef RBINSLOT 5778 5779#define TPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 5780 {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \ 5781 PyDoc_STR(DOC)} 5782#define FLSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC, FLAGS) \ 5783 {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \ 5784 PyDoc_STR(DOC), FLAGS} 5785#define ETSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 5786 {NAME, offsetof(PyHeapTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \ 5787 PyDoc_STR(DOC)} 5788#define SQSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 5789 ETSLOT(NAME, as_sequence.SLOT, FUNCTION, WRAPPER, DOC) 5790#define MPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 5791 ETSLOT(NAME, as_mapping.SLOT, FUNCTION, WRAPPER, DOC) 5792#define NBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 5793 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, DOC) 5794#define UNSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 5795 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \ 5796 "x." NAME "() <==> " DOC) 5797#define IBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 5798 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \ 5799 "x." NAME "(y) <==> x" DOC "y") 5800#define BINSLOT(NAME, SLOT, FUNCTION, DOC) \ 5801 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \ 5802 "x." NAME "(y) <==> x" DOC "y") 5803#define RBINSLOT(NAME, SLOT, FUNCTION, DOC) \ 5804 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \ 5805 "x." NAME "(y) <==> y" DOC "x") 5806#define BINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \ 5807 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \ 5808 "x." NAME "(y) <==> " DOC) 5809#define RBINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \ 5810 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \ 5811 "x." NAME "(y) <==> " DOC) 5812 5813static slotdef slotdefs[] = { 5814 SQSLOT("__len__", sq_length, slot_sq_length, wrap_lenfunc, 5815 "x.__len__() <==> len(x)"), 5816 /* Heap types defining __add__/__mul__ have sq_concat/sq_repeat == NULL. 5817 The logic in abstract.c always falls back to nb_add/nb_multiply in 5818 this case. Defining both the nb_* and the sq_* slots to call the 5819 user-defined methods has unexpected side-effects, as shown by 5820 test_descr.notimplemented() */ 5821 SQSLOT("__add__", sq_concat, NULL, wrap_binaryfunc, 5822 "x.__add__(y) <==> x+y"), 5823 SQSLOT("__mul__", sq_repeat, NULL, wrap_indexargfunc, 5824 "x.__mul__(n) <==> x*n"), 5825 SQSLOT("__rmul__", sq_repeat, NULL, wrap_indexargfunc, 5826 "x.__rmul__(n) <==> n*x"), 5827 SQSLOT("__getitem__", sq_item, slot_sq_item, wrap_sq_item, 5828 "x.__getitem__(y) <==> x[y]"), 5829 SQSLOT("__getslice__", sq_slice, slot_sq_slice, wrap_ssizessizeargfunc, 5830 "x.__getslice__(i, j) <==> x[i:j]\n\ 5831 \n\ 5832 Use of negative indices is not supported."), 5833 SQSLOT("__setitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_setitem, 5834 "x.__setitem__(i, y) <==> x[i]=y"), 5835 SQSLOT("__delitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_delitem, 5836 "x.__delitem__(y) <==> del x[y]"), 5837 SQSLOT("__setslice__", sq_ass_slice, slot_sq_ass_slice, 5838 wrap_ssizessizeobjargproc, 5839 "x.__setslice__(i, j, y) <==> x[i:j]=y\n\ 5840 \n\ 5841 Use of negative indices is not supported."), 5842 SQSLOT("__delslice__", sq_ass_slice, slot_sq_ass_slice, wrap_delslice, 5843 "x.__delslice__(i, j) <==> del x[i:j]\n\ 5844 \n\ 5845 Use of negative indices is not supported."), 5846 SQSLOT("__contains__", sq_contains, slot_sq_contains, wrap_objobjproc, 5847 "x.__contains__(y) <==> y in x"), 5848 SQSLOT("__iadd__", sq_inplace_concat, NULL, 5849 wrap_binaryfunc, "x.__iadd__(y) <==> x+=y"), 5850 SQSLOT("__imul__", sq_inplace_repeat, NULL, 5851 wrap_indexargfunc, "x.__imul__(y) <==> x*=y"), 5852 5853 MPSLOT("__len__", mp_length, slot_mp_length, wrap_lenfunc, 5854 "x.__len__() <==> len(x)"), 5855 MPSLOT("__getitem__", mp_subscript, slot_mp_subscript, 5856 wrap_binaryfunc, 5857 "x.__getitem__(y) <==> x[y]"), 5858 MPSLOT("__setitem__", mp_ass_subscript, slot_mp_ass_subscript, 5859 wrap_objobjargproc, 5860 "x.__setitem__(i, y) <==> x[i]=y"), 5861 MPSLOT("__delitem__", mp_ass_subscript, slot_mp_ass_subscript, 5862 wrap_delitem, 5863 "x.__delitem__(y) <==> del x[y]"), 5864 5865 BINSLOT("__add__", nb_add, slot_nb_add, 5866 "+"), 5867 RBINSLOT("__radd__", nb_add, slot_nb_add, 5868 "+"), 5869 BINSLOT("__sub__", nb_subtract, slot_nb_subtract, 5870 "-"), 5871 RBINSLOT("__rsub__", nb_subtract, slot_nb_subtract, 5872 "-"), 5873 BINSLOT("__mul__", nb_multiply, slot_nb_multiply, 5874 "*"), 5875 RBINSLOT("__rmul__", nb_multiply, slot_nb_multiply, 5876 "*"), 5877 BINSLOT("__div__", nb_divide, slot_nb_divide, 5878 "/"), 5879 RBINSLOT("__rdiv__", nb_divide, slot_nb_divide, 5880 "/"), 5881 BINSLOT("__mod__", nb_remainder, slot_nb_remainder, 5882 "%"), 5883 RBINSLOT("__rmod__", nb_remainder, slot_nb_remainder, 5884 "%"), 5885 BINSLOTNOTINFIX("__divmod__", nb_divmod, slot_nb_divmod, 5886 "divmod(x, y)"), 5887 RBINSLOTNOTINFIX("__rdivmod__", nb_divmod, slot_nb_divmod, 5888 "divmod(y, x)"), 5889 NBSLOT("__pow__", nb_power, slot_nb_power, wrap_ternaryfunc, 5890 "x.__pow__(y[, z]) <==> pow(x, y[, z])"), 5891 NBSLOT("__rpow__", nb_power, slot_nb_power, wrap_ternaryfunc_r, 5892 "y.__rpow__(x[, z]) <==> pow(x, y[, z])"), 5893 UNSLOT("__neg__", nb_negative, slot_nb_negative, wrap_unaryfunc, "-x"), 5894 UNSLOT("__pos__", nb_positive, slot_nb_positive, wrap_unaryfunc, "+x"), 5895 UNSLOT("__abs__", nb_absolute, slot_nb_absolute, wrap_unaryfunc, 5896 "abs(x)"), 5897 UNSLOT("__nonzero__", nb_nonzero, slot_nb_nonzero, wrap_inquirypred, 5898 "x != 0"), 5899 UNSLOT("__invert__", nb_invert, slot_nb_invert, wrap_unaryfunc, "~x"), 5900 BINSLOT("__lshift__", nb_lshift, slot_nb_lshift, "<<"), 5901 RBINSLOT("__rlshift__", nb_lshift, slot_nb_lshift, "<<"), 5902 BINSLOT("__rshift__", nb_rshift, slot_nb_rshift, ">>"), 5903 RBINSLOT("__rrshift__", nb_rshift, slot_nb_rshift, ">>"), 5904 BINSLOT("__and__", nb_and, slot_nb_and, "&"), 5905 RBINSLOT("__rand__", nb_and, slot_nb_and, "&"), 5906 BINSLOT("__xor__", nb_xor, slot_nb_xor, "^"), 5907 RBINSLOT("__rxor__", nb_xor, slot_nb_xor, "^"), 5908 BINSLOT("__or__", nb_or, slot_nb_or, "|"), 5909 RBINSLOT("__ror__", nb_or, slot_nb_or, "|"), 5910 NBSLOT("__coerce__", nb_coerce, slot_nb_coerce, wrap_coercefunc, 5911 "x.__coerce__(y) <==> coerce(x, y)"), 5912 UNSLOT("__int__", nb_int, slot_nb_int, wrap_unaryfunc, 5913 "int(x)"), 5914 UNSLOT("__long__", nb_long, slot_nb_long, wrap_unaryfunc, 5915 "long(x)"), 5916 UNSLOT("__float__", nb_float, slot_nb_float, wrap_unaryfunc, 5917 "float(x)"), 5918 UNSLOT("__oct__", nb_oct, slot_nb_oct, wrap_unaryfunc, 5919 "oct(x)"), 5920 UNSLOT("__hex__", nb_hex, slot_nb_hex, wrap_unaryfunc, 5921 "hex(x)"), 5922 NBSLOT("__index__", nb_index, slot_nb_index, wrap_unaryfunc, 5923 "x[y:z] <==> x[y.__index__():z.__index__()]"), 5924 IBSLOT("__iadd__", nb_inplace_add, slot_nb_inplace_add, 5925 wrap_binaryfunc, "+"), 5926 IBSLOT("__isub__", nb_inplace_subtract, slot_nb_inplace_subtract, 5927 wrap_binaryfunc, "-"), 5928 IBSLOT("__imul__", nb_inplace_multiply, slot_nb_inplace_multiply, 5929 wrap_binaryfunc, "*"), 5930 IBSLOT("__idiv__", nb_inplace_divide, slot_nb_inplace_divide, 5931 wrap_binaryfunc, "/"), 5932 IBSLOT("__imod__", nb_inplace_remainder, slot_nb_inplace_remainder, 5933 wrap_binaryfunc, "%"), 5934 IBSLOT("__ipow__", nb_inplace_power, slot_nb_inplace_power, 5935 wrap_binaryfunc, "**"), 5936 IBSLOT("__ilshift__", nb_inplace_lshift, slot_nb_inplace_lshift, 5937 wrap_binaryfunc, "<<"), 5938 IBSLOT("__irshift__", nb_inplace_rshift, slot_nb_inplace_rshift, 5939 wrap_binaryfunc, ">>"), 5940 IBSLOT("__iand__", nb_inplace_and, slot_nb_inplace_and, 5941 wrap_binaryfunc, "&"), 5942 IBSLOT("__ixor__", nb_inplace_xor, slot_nb_inplace_xor, 5943 wrap_binaryfunc, "^"), 5944 IBSLOT("__ior__", nb_inplace_or, slot_nb_inplace_or, 5945 wrap_binaryfunc, "|"), 5946 BINSLOT("__floordiv__", nb_floor_divide, slot_nb_floor_divide, "//"), 5947 RBINSLOT("__rfloordiv__", nb_floor_divide, slot_nb_floor_divide, "//"), 5948 BINSLOT("__truediv__", nb_true_divide, slot_nb_true_divide, "/"), 5949 RBINSLOT("__rtruediv__", nb_true_divide, slot_nb_true_divide, "/"), 5950 IBSLOT("__ifloordiv__", nb_inplace_floor_divide, 5951 slot_nb_inplace_floor_divide, wrap_binaryfunc, "//"), 5952 IBSLOT("__itruediv__", nb_inplace_true_divide, 5953 slot_nb_inplace_true_divide, wrap_binaryfunc, "/"), 5954 5955 TPSLOT("__str__", tp_str, slot_tp_str, wrap_unaryfunc, 5956 "x.__str__() <==> str(x)"), 5957 TPSLOT("__str__", tp_print, NULL, NULL, ""), 5958 TPSLOT("__repr__", tp_repr, slot_tp_repr, wrap_unaryfunc, 5959 "x.__repr__() <==> repr(x)"), 5960 TPSLOT("__repr__", tp_print, NULL, NULL, ""), 5961 TPSLOT("__cmp__", tp_compare, _PyObject_SlotCompare, wrap_cmpfunc, 5962 "x.__cmp__(y) <==> cmp(x,y)"), 5963 TPSLOT("__hash__", tp_hash, slot_tp_hash, wrap_hashfunc, 5964 "x.__hash__() <==> hash(x)"), 5965 FLSLOT("__call__", tp_call, slot_tp_call, (wrapperfunc)wrap_call, 5966 "x.__call__(...) <==> x(...)", PyWrapperFlag_KEYWORDS), 5967 TPSLOT("__getattribute__", tp_getattro, slot_tp_getattr_hook, 5968 wrap_binaryfunc, "x.__getattribute__('name') <==> x.name"), 5969 TPSLOT("__getattribute__", tp_getattr, NULL, NULL, ""), 5970 TPSLOT("__getattr__", tp_getattro, slot_tp_getattr_hook, NULL, ""), 5971 TPSLOT("__getattr__", tp_getattr, NULL, NULL, ""), 5972 TPSLOT("__setattr__", tp_setattro, slot_tp_setattro, wrap_setattr, 5973 "x.__setattr__('name', value) <==> x.name = value"), 5974 TPSLOT("__setattr__", tp_setattr, NULL, NULL, ""), 5975 TPSLOT("__delattr__", tp_setattro, slot_tp_setattro, wrap_delattr, 5976 "x.__delattr__('name') <==> del x.name"), 5977 TPSLOT("__delattr__", tp_setattr, NULL, NULL, ""), 5978 TPSLOT("__lt__", tp_richcompare, slot_tp_richcompare, richcmp_lt, 5979 "x.__lt__(y) <==> x<y"), 5980 TPSLOT("__le__", tp_richcompare, slot_tp_richcompare, richcmp_le, 5981 "x.__le__(y) <==> x<=y"), 5982 TPSLOT("__eq__", tp_richcompare, slot_tp_richcompare, richcmp_eq, 5983 "x.__eq__(y) <==> x==y"), 5984 TPSLOT("__ne__", tp_richcompare, slot_tp_richcompare, richcmp_ne, 5985 "x.__ne__(y) <==> x!=y"), 5986 TPSLOT("__gt__", tp_richcompare, slot_tp_richcompare, richcmp_gt, 5987 "x.__gt__(y) <==> x>y"), 5988 TPSLOT("__ge__", tp_richcompare, slot_tp_richcompare, richcmp_ge, 5989 "x.__ge__(y) <==> x>=y"), 5990 TPSLOT("__iter__", tp_iter, slot_tp_iter, wrap_unaryfunc, 5991 "x.__iter__() <==> iter(x)"), 5992 TPSLOT("next", tp_iternext, slot_tp_iternext, wrap_next, 5993 "x.next() -> the next value, or raise StopIteration"), 5994 TPSLOT("__get__", tp_descr_get, slot_tp_descr_get, wrap_descr_get, 5995 "descr.__get__(obj[, type]) -> value"), 5996 TPSLOT("__set__", tp_descr_set, slot_tp_descr_set, wrap_descr_set, 5997 "descr.__set__(obj, value)"), 5998 TPSLOT("__delete__", tp_descr_set, slot_tp_descr_set, 5999 wrap_descr_delete, "descr.__delete__(obj)"), 6000 FLSLOT("__init__", tp_init, slot_tp_init, (wrapperfunc)wrap_init, 6001 "x.__init__(...) initializes x; " 6002 "see x.__class__.__doc__ for signature", 6003 PyWrapperFlag_KEYWORDS), 6004 TPSLOT("__new__", tp_new, slot_tp_new, NULL, ""), 6005 TPSLOT("__del__", tp_del, slot_tp_del, NULL, ""), 6006 {NULL} 6007}; 6008 6009/* Given a type pointer and an offset gotten from a slotdef entry, return a 6010 pointer to the actual slot. This is not quite the same as simply adding 6011 the offset to the type pointer, since it takes care to indirect through the 6012 proper indirection pointer (as_buffer, etc.); it returns NULL if the 6013 indirection pointer is NULL. */ 6014static void ** 6015slotptr(PyTypeObject *type, int ioffset) 6016{ 6017 char *ptr; 6018 long offset = ioffset; 6019 6020 /* Note: this depends on the order of the members of PyHeapTypeObject! */ 6021 assert(offset >= 0); 6022 assert((size_t)offset < offsetof(PyHeapTypeObject, as_buffer)); 6023 if ((size_t)offset >= offsetof(PyHeapTypeObject, as_sequence)) { 6024 ptr = (char *)type->tp_as_sequence; 6025 offset -= offsetof(PyHeapTypeObject, as_sequence); 6026 } 6027 else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_mapping)) { 6028 ptr = (char *)type->tp_as_mapping; 6029 offset -= offsetof(PyHeapTypeObject, as_mapping); 6030 } 6031 else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_number)) { 6032 ptr = (char *)type->tp_as_number; 6033 offset -= offsetof(PyHeapTypeObject, as_number); 6034 } 6035 else { 6036 ptr = (char *)type; 6037 } 6038 if (ptr != NULL) 6039 ptr += offset; 6040 return (void **)ptr; 6041} 6042 6043/* Length of array of slotdef pointers used to store slots with the 6044 same __name__. There should be at most MAX_EQUIV-1 slotdef entries with 6045 the same __name__, for any __name__. Since that's a static property, it is 6046 appropriate to declare fixed-size arrays for this. */ 6047#define MAX_EQUIV 10 6048 6049/* Return a slot pointer for a given name, but ONLY if the attribute has 6050 exactly one slot function. The name must be an interned string. */ 6051static void ** 6052resolve_slotdups(PyTypeObject *type, PyObject *name) 6053{ 6054 /* XXX Maybe this could be optimized more -- but is it worth it? */ 6055 6056 /* pname and ptrs act as a little cache */ 6057 static PyObject *pname; 6058 static slotdef *ptrs[MAX_EQUIV]; 6059 slotdef *p, **pp; 6060 void **res, **ptr; 6061 6062 if (pname != name) { 6063 /* Collect all slotdefs that match name into ptrs. */ 6064 pname = name; 6065 pp = ptrs; 6066 for (p = slotdefs; p->name_strobj; p++) { 6067 if (p->name_strobj == name) 6068 *pp++ = p; 6069 } 6070 *pp = NULL; 6071 } 6072 6073 /* Look in all matching slots of the type; if exactly one of these has 6074 a filled-in slot, return its value. Otherwise return NULL. */ 6075 res = NULL; 6076 for (pp = ptrs; *pp; pp++) { 6077 ptr = slotptr(type, (*pp)->offset); 6078 if (ptr == NULL || *ptr == NULL) 6079 continue; 6080 if (res != NULL) 6081 return NULL; 6082 res = ptr; 6083 } 6084 return res; 6085} 6086 6087/* Common code for update_slots_callback() and fixup_slot_dispatchers(). This 6088 does some incredibly complex thinking and then sticks something into the 6089 slot. (It sees if the adjacent slotdefs for the same slot have conflicting 6090 interests, and then stores a generic wrapper or a specific function into 6091 the slot.) Return a pointer to the next slotdef with a different offset, 6092 because that's convenient for fixup_slot_dispatchers(). */ 6093static slotdef * 6094update_one_slot(PyTypeObject *type, slotdef *p) 6095{ 6096 PyObject *descr; 6097 PyWrapperDescrObject *d; 6098 void *generic = NULL, *specific = NULL; 6099 int use_generic = 0; 6100 int offset = p->offset; 6101 void **ptr = slotptr(type, offset); 6102 6103 if (ptr == NULL) { 6104 do { 6105 ++p; 6106 } while (p->offset == offset); 6107 return p; 6108 } 6109 do { 6110 descr = _PyType_Lookup(type, p->name_strobj); 6111 if (descr == NULL) { 6112 if (ptr == (void**)&type->tp_iternext) { 6113 specific = _PyObject_NextNotImplemented; 6114 } 6115 continue; 6116 } 6117 if (Py_TYPE(descr) == &PyWrapperDescr_Type) { 6118 void **tptr = resolve_slotdups(type, p->name_strobj); 6119 if (tptr == NULL || tptr == ptr) 6120 generic = p->function; 6121 d = (PyWrapperDescrObject *)descr; 6122 if (d->d_base->wrapper == p->wrapper && 6123 PyType_IsSubtype(type, d->d_type)) 6124 { 6125 if (specific == NULL || 6126 specific == d->d_wrapped) 6127 specific = d->d_wrapped; 6128 else 6129 use_generic = 1; 6130 } 6131 } 6132 else if (Py_TYPE(descr) == &PyCFunction_Type && 6133 PyCFunction_GET_FUNCTION(descr) == 6134 (PyCFunction)tp_new_wrapper && 6135 ptr == (void**)&type->tp_new) 6136 { 6137 /* The __new__ wrapper is not a wrapper descriptor, 6138 so must be special-cased differently. 6139 If we don't do this, creating an instance will 6140 always use slot_tp_new which will look up 6141 __new__ in the MRO which will call tp_new_wrapper 6142 which will look through the base classes looking 6143 for a static base and call its tp_new (usually 6144 PyType_GenericNew), after performing various 6145 sanity checks and constructing a new argument 6146 list. Cut all that nonsense short -- this speeds 6147 up instance creation tremendously. */ 6148 specific = (void *)type->tp_new; 6149 /* XXX I'm not 100% sure that there isn't a hole 6150 in this reasoning that requires additional 6151 sanity checks. I'll buy the first person to 6152 point out a bug in this reasoning a beer. */ 6153 } 6154 else if (descr == Py_None && 6155 ptr == (void**)&type->tp_hash) { 6156 /* We specifically allow __hash__ to be set to None 6157 to prevent inheritance of the default 6158 implementation from object.__hash__ */ 6159 specific = PyObject_HashNotImplemented; 6160 } 6161 else { 6162 use_generic = 1; 6163 generic = p->function; 6164 } 6165 } while ((++p)->offset == offset); 6166 if (specific && !use_generic) 6167 *ptr = specific; 6168 else 6169 *ptr = generic; 6170 return p; 6171} 6172 6173/* In the type, update the slots whose slotdefs are gathered in the pp array. 6174 This is a callback for update_subclasses(). */ 6175static int 6176update_slots_callback(PyTypeObject *type, void *data) 6177{ 6178 slotdef **pp = (slotdef **)data; 6179 6180 for (; *pp; pp++) 6181 update_one_slot(type, *pp); 6182 return 0; 6183} 6184 6185/* Comparison function for qsort() to compare slotdefs by their offset, and 6186 for equal offset by their address (to force a stable sort). */ 6187static int 6188slotdef_cmp(const void *aa, const void *bb) 6189{ 6190 const slotdef *a = (const slotdef *)aa, *b = (const slotdef *)bb; 6191 int c = a->offset - b->offset; 6192 if (c != 0) 6193 return c; 6194 else 6195 /* Cannot use a-b, as this gives off_t, 6196 which may lose precision when converted to int. */ 6197 return (a > b) ? 1 : (a < b) ? -1 : 0; 6198} 6199 6200/* Initialize the slotdefs table by adding interned string objects for the 6201 names and sorting the entries. */ 6202static void 6203init_slotdefs(void) 6204{ 6205 slotdef *p; 6206 static int initialized = 0; 6207 6208 if (initialized) 6209 return; 6210 for (p = slotdefs; p->name; p++) { 6211 p->name_strobj = PyString_InternFromString(p->name); 6212 if (!p->name_strobj) 6213 Py_FatalError("Out of memory interning slotdef names"); 6214 } 6215 qsort((void *)slotdefs, (size_t)(p-slotdefs), sizeof(slotdef), 6216 slotdef_cmp); 6217 initialized = 1; 6218} 6219 6220/* Update the slots after assignment to a class (type) attribute. */ 6221static int 6222update_slot(PyTypeObject *type, PyObject *name) 6223{ 6224 slotdef *ptrs[MAX_EQUIV]; 6225 slotdef *p; 6226 slotdef **pp; 6227 int offset; 6228 6229 /* Clear the VALID_VERSION flag of 'type' and all its 6230 subclasses. This could possibly be unified with the 6231 update_subclasses() recursion below, but carefully: 6232 they each have their own conditions on which to stop 6233 recursing into subclasses. */ 6234 PyType_Modified(type); 6235 6236 init_slotdefs(); 6237 pp = ptrs; 6238 for (p = slotdefs; p->name; p++) { 6239 /* XXX assume name is interned! */ 6240 if (p->name_strobj == name) 6241 *pp++ = p; 6242 } 6243 *pp = NULL; 6244 for (pp = ptrs; *pp; pp++) { 6245 p = *pp; 6246 offset = p->offset; 6247 while (p > slotdefs && (p-1)->offset == offset) 6248 --p; 6249 *pp = p; 6250 } 6251 if (ptrs[0] == NULL) 6252 return 0; /* Not an attribute that affects any slots */ 6253 return update_subclasses(type, name, 6254 update_slots_callback, (void *)ptrs); 6255} 6256 6257/* Store the proper functions in the slot dispatches at class (type) 6258 definition time, based upon which operations the class overrides in its 6259 dict. */ 6260static void 6261fixup_slot_dispatchers(PyTypeObject *type) 6262{ 6263 slotdef *p; 6264 6265 init_slotdefs(); 6266 for (p = slotdefs; p->name; ) 6267 p = update_one_slot(type, p); 6268} 6269 6270static void 6271update_all_slots(PyTypeObject* type) 6272{ 6273 slotdef *p; 6274 6275 init_slotdefs(); 6276 for (p = slotdefs; p->name; p++) { 6277 /* update_slot returns int but can't actually fail */ 6278 update_slot(type, p->name_strobj); 6279 } 6280} 6281 6282/* recurse_down_subclasses() and update_subclasses() are mutually 6283 recursive functions to call a callback for all subclasses, 6284 but refraining from recursing into subclasses that define 'name'. */ 6285 6286static int 6287update_subclasses(PyTypeObject *type, PyObject *name, 6288 update_callback callback, void *data) 6289{ 6290 if (callback(type, data) < 0) 6291 return -1; 6292 return recurse_down_subclasses(type, name, callback, data); 6293} 6294 6295static int 6296recurse_down_subclasses(PyTypeObject *type, PyObject *name, 6297 update_callback callback, void *data) 6298{ 6299 PyTypeObject *subclass; 6300 PyObject *ref, *subclasses, *dict; 6301 Py_ssize_t i, n; 6302 6303 subclasses = type->tp_subclasses; 6304 if (subclasses == NULL) 6305 return 0; 6306 assert(PyList_Check(subclasses)); 6307 n = PyList_GET_SIZE(subclasses); 6308 for (i = 0; i < n; i++) { 6309 ref = PyList_GET_ITEM(subclasses, i); 6310 assert(PyWeakref_CheckRef(ref)); 6311 subclass = (PyTypeObject *)PyWeakref_GET_OBJECT(ref); 6312 assert(subclass != NULL); 6313 if ((PyObject *)subclass == Py_None) 6314 continue; 6315 assert(PyType_Check(subclass)); 6316 /* Avoid recursing down into unaffected classes */ 6317 dict = subclass->tp_dict; 6318 if (dict != NULL && PyDict_Check(dict) && 6319 PyDict_GetItem(dict, name) != NULL) 6320 continue; 6321 if (update_subclasses(subclass, name, callback, data) < 0) 6322 return -1; 6323 } 6324 return 0; 6325} 6326 6327/* This function is called by PyType_Ready() to populate the type's 6328 dictionary with method descriptors for function slots. For each 6329 function slot (like tp_repr) that's defined in the type, one or more 6330 corresponding descriptors are added in the type's tp_dict dictionary 6331 under the appropriate name (like __repr__). Some function slots 6332 cause more than one descriptor to be added (for example, the nb_add 6333 slot adds both __add__ and __radd__ descriptors) and some function 6334 slots compete for the same descriptor (for example both sq_item and 6335 mp_subscript generate a __getitem__ descriptor). 6336 6337 In the latter case, the first slotdef entry encoutered wins. Since 6338 slotdef entries are sorted by the offset of the slot in the 6339 PyHeapTypeObject, this gives us some control over disambiguating 6340 between competing slots: the members of PyHeapTypeObject are listed 6341 from most general to least general, so the most general slot is 6342 preferred. In particular, because as_mapping comes before as_sequence, 6343 for a type that defines both mp_subscript and sq_item, mp_subscript 6344 wins. 6345 6346 This only adds new descriptors and doesn't overwrite entries in 6347 tp_dict that were previously defined. The descriptors contain a 6348 reference to the C function they must call, so that it's safe if they 6349 are copied into a subtype's __dict__ and the subtype has a different 6350 C function in its slot -- calling the method defined by the 6351 descriptor will call the C function that was used to create it, 6352 rather than the C function present in the slot when it is called. 6353 (This is important because a subtype may have a C function in the 6354 slot that calls the method from the dictionary, and we want to avoid 6355 infinite recursion here.) */ 6356 6357static int 6358add_operators(PyTypeObject *type) 6359{ 6360 PyObject *dict = type->tp_dict; 6361 slotdef *p; 6362 PyObject *descr; 6363 void **ptr; 6364 6365 init_slotdefs(); 6366 for (p = slotdefs; p->name; p++) { 6367 if (p->wrapper == NULL) 6368 continue; 6369 ptr = slotptr(type, p->offset); 6370 if (!ptr || !*ptr) 6371 continue; 6372 if (PyDict_GetItem(dict, p->name_strobj)) 6373 continue; 6374 if (*ptr == PyObject_HashNotImplemented) { 6375 /* Classes may prevent the inheritance of the tp_hash 6376 slot by storing PyObject_HashNotImplemented in it. Make it 6377 visible as a None value for the __hash__ attribute. */ 6378 if (PyDict_SetItem(dict, p->name_strobj, Py_None) < 0) 6379 return -1; 6380 } 6381 else { 6382 descr = PyDescr_NewWrapper(type, p, *ptr); 6383 if (descr == NULL) 6384 return -1; 6385 if (PyDict_SetItem(dict, p->name_strobj, descr) < 0) 6386 return -1; 6387 Py_DECREF(descr); 6388 } 6389 } 6390 if (type->tp_new != NULL) { 6391 if (add_tp_new_wrapper(type) < 0) 6392 return -1; 6393 } 6394 return 0; 6395} 6396 6397 6398/* Cooperative 'super' */ 6399 6400typedef struct { 6401 PyObject_HEAD 6402 PyTypeObject *type; 6403 PyObject *obj; 6404 PyTypeObject *obj_type; 6405} superobject; 6406 6407static PyMemberDef super_members[] = { 6408 {"__thisclass__", T_OBJECT, offsetof(superobject, type), READONLY, 6409 "the class invoking super()"}, 6410 {"__self__", T_OBJECT, offsetof(superobject, obj), READONLY, 6411 "the instance invoking super(); may be None"}, 6412 {"__self_class__", T_OBJECT, offsetof(superobject, obj_type), READONLY, 6413 "the type of the instance invoking super(); may be None"}, 6414 {0} 6415}; 6416 6417static void 6418super_dealloc(PyObject *self) 6419{ 6420 superobject *su = (superobject *)self; 6421 6422 _PyObject_GC_UNTRACK(self); 6423 Py_XDECREF(su->obj); 6424 Py_XDECREF(su->type); 6425 Py_XDECREF(su->obj_type); 6426 Py_TYPE(self)->tp_free(self); 6427} 6428 6429static PyObject * 6430super_repr(PyObject *self) 6431{ 6432 superobject *su = (superobject *)self; 6433 6434 if (su->obj_type) 6435 return PyString_FromFormat( 6436 "<super: <class '%s'>, <%s object>>", 6437 su->type ? su->type->tp_name : "NULL", 6438 su->obj_type->tp_name); 6439 else 6440 return PyString_FromFormat( 6441 "<super: <class '%s'>, NULL>", 6442 su->type ? su->type->tp_name : "NULL"); 6443} 6444 6445static PyObject * 6446super_getattro(PyObject *self, PyObject *name) 6447{ 6448 superobject *su = (superobject *)self; 6449 int skip = su->obj_type == NULL; 6450 6451 if (!skip) { 6452 /* We want __class__ to return the class of the super object 6453 (i.e. super, or a subclass), not the class of su->obj. */ 6454 skip = (PyString_Check(name) && 6455 PyString_GET_SIZE(name) == 9 && 6456 strcmp(PyString_AS_STRING(name), "__class__") == 0); 6457 } 6458 6459 if (!skip) { 6460 PyObject *mro, *res, *tmp, *dict; 6461 PyTypeObject *starttype; 6462 descrgetfunc f; 6463 Py_ssize_t i, n; 6464 6465 starttype = su->obj_type; 6466 mro = starttype->tp_mro; 6467 6468 if (mro == NULL) 6469 n = 0; 6470 else { 6471 assert(PyTuple_Check(mro)); 6472 n = PyTuple_GET_SIZE(mro); 6473 } 6474 for (i = 0; i < n; i++) { 6475 if ((PyObject *)(su->type) == PyTuple_GET_ITEM(mro, i)) 6476 break; 6477 } 6478 i++; 6479 res = NULL; 6480 for (; i < n; i++) { 6481 tmp = PyTuple_GET_ITEM(mro, i); 6482 if (PyType_Check(tmp)) 6483 dict = ((PyTypeObject *)tmp)->tp_dict; 6484 else if (PyClass_Check(tmp)) 6485 dict = ((PyClassObject *)tmp)->cl_dict; 6486 else 6487 continue; 6488 res = PyDict_GetItem(dict, name); 6489 if (res != NULL) { 6490 Py_INCREF(res); 6491 f = Py_TYPE(res)->tp_descr_get; 6492 if (f != NULL) { 6493 tmp = f(res, 6494 /* Only pass 'obj' param if 6495 this is instance-mode super 6496 (See SF ID #743627) 6497 */ 6498 (su->obj == (PyObject *) 6499 su->obj_type 6500 ? (PyObject *)NULL 6501 : su->obj), 6502 (PyObject *)starttype); 6503 Py_DECREF(res); 6504 res = tmp; 6505 } 6506 return res; 6507 } 6508 } 6509 } 6510 return PyObject_GenericGetAttr(self, name); 6511} 6512 6513static PyTypeObject * 6514supercheck(PyTypeObject *type, PyObject *obj) 6515{ 6516 /* Check that a super() call makes sense. Return a type object. 6517 6518 obj can be a new-style class, or an instance of one: 6519 6520 - If it is a class, it must be a subclass of 'type'. This case is 6521 used for class methods; the return value is obj. 6522 6523 - If it is an instance, it must be an instance of 'type'. This is 6524 the normal case; the return value is obj.__class__. 6525 6526 But... when obj is an instance, we want to allow for the case where 6527 Py_TYPE(obj) is not a subclass of type, but obj.__class__ is! 6528 This will allow using super() with a proxy for obj. 6529 */ 6530 6531 /* Check for first bullet above (special case) */ 6532 if (PyType_Check(obj) && PyType_IsSubtype((PyTypeObject *)obj, type)) { 6533 Py_INCREF(obj); 6534 return (PyTypeObject *)obj; 6535 } 6536 6537 /* Normal case */ 6538 if (PyType_IsSubtype(Py_TYPE(obj), type)) { 6539 Py_INCREF(Py_TYPE(obj)); 6540 return Py_TYPE(obj); 6541 } 6542 else { 6543 /* Try the slow way */ 6544 static PyObject *class_str = NULL; 6545 PyObject *class_attr; 6546 6547 if (class_str == NULL) { 6548 class_str = PyString_FromString("__class__"); 6549 if (class_str == NULL) 6550 return NULL; 6551 } 6552 6553 class_attr = PyObject_GetAttr(obj, class_str); 6554 6555 if (class_attr != NULL && 6556 PyType_Check(class_attr) && 6557 (PyTypeObject *)class_attr != Py_TYPE(obj)) 6558 { 6559 int ok = PyType_IsSubtype( 6560 (PyTypeObject *)class_attr, type); 6561 if (ok) 6562 return (PyTypeObject *)class_attr; 6563 } 6564 6565 if (class_attr == NULL) 6566 PyErr_Clear(); 6567 else 6568 Py_DECREF(class_attr); 6569 } 6570 6571 PyErr_SetString(PyExc_TypeError, 6572 "super(type, obj): " 6573 "obj must be an instance or subtype of type"); 6574 return NULL; 6575} 6576 6577static PyObject * 6578super_descr_get(PyObject *self, PyObject *obj, PyObject *type) 6579{ 6580 superobject *su = (superobject *)self; 6581 superobject *newobj; 6582 6583 if (obj == NULL || obj == Py_None || su->obj != NULL) { 6584 /* Not binding to an object, or already bound */ 6585 Py_INCREF(self); 6586 return self; 6587 } 6588 if (Py_TYPE(su) != &PySuper_Type) 6589 /* If su is an instance of a (strict) subclass of super, 6590 call its type */ 6591 return PyObject_CallFunctionObjArgs((PyObject *)Py_TYPE(su), 6592 su->type, obj, NULL); 6593 else { 6594 /* Inline the common case */ 6595 PyTypeObject *obj_type = supercheck(su->type, obj); 6596 if (obj_type == NULL) 6597 return NULL; 6598 newobj = (superobject *)PySuper_Type.tp_new(&PySuper_Type, 6599 NULL, NULL); 6600 if (newobj == NULL) 6601 return NULL; 6602 Py_INCREF(su->type); 6603 Py_INCREF(obj); 6604 newobj->type = su->type; 6605 newobj->obj = obj; 6606 newobj->obj_type = obj_type; 6607 return (PyObject *)newobj; 6608 } 6609} 6610 6611static int 6612super_init(PyObject *self, PyObject *args, PyObject *kwds) 6613{ 6614 superobject *su = (superobject *)self; 6615 PyTypeObject *type; 6616 PyObject *obj = NULL; 6617 PyTypeObject *obj_type = NULL; 6618 6619 if (!_PyArg_NoKeywords("super", kwds)) 6620 return -1; 6621 if (!PyArg_ParseTuple(args, "O!|O:super", &PyType_Type, &type, &obj)) 6622 return -1; 6623 if (obj == Py_None) 6624 obj = NULL; 6625 if (obj != NULL) { 6626 obj_type = supercheck(type, obj); 6627 if (obj_type == NULL) 6628 return -1; 6629 Py_INCREF(obj); 6630 } 6631 Py_INCREF(type); 6632 su->type = type; 6633 su->obj = obj; 6634 su->obj_type = obj_type; 6635 return 0; 6636} 6637 6638PyDoc_STRVAR(super_doc, 6639"super(type) -> unbound super object\n" 6640"super(type, obj) -> bound super object; requires isinstance(obj, type)\n" 6641"super(type, type2) -> bound super object; requires issubclass(type2, type)\n" 6642"Typical use to call a cooperative superclass method:\n" 6643"class C(B):\n" 6644" def meth(self, arg):\n" 6645" super(C, self).meth(arg)"); 6646 6647static int 6648super_traverse(PyObject *self, visitproc visit, void *arg) 6649{ 6650 superobject *su = (superobject *)self; 6651 6652 Py_VISIT(su->obj); 6653 Py_VISIT(su->type); 6654 Py_VISIT(su->obj_type); 6655 6656 return 0; 6657} 6658 6659PyTypeObject PySuper_Type = { 6660 PyVarObject_HEAD_INIT(&PyType_Type, 0) 6661 "super", /* tp_name */ 6662 sizeof(superobject), /* tp_basicsize */ 6663 0, /* tp_itemsize */ 6664 /* methods */ 6665 super_dealloc, /* tp_dealloc */ 6666 0, /* tp_print */ 6667 0, /* tp_getattr */ 6668 0, /* tp_setattr */ 6669 0, /* tp_compare */ 6670 super_repr, /* tp_repr */ 6671 0, /* tp_as_number */ 6672 0, /* tp_as_sequence */ 6673 0, /* tp_as_mapping */ 6674 0, /* tp_hash */ 6675 0, /* tp_call */ 6676 0, /* tp_str */ 6677 super_getattro, /* tp_getattro */ 6678 0, /* tp_setattro */ 6679 0, /* tp_as_buffer */ 6680 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | 6681 Py_TPFLAGS_BASETYPE, /* tp_flags */ 6682 super_doc, /* tp_doc */ 6683 super_traverse, /* tp_traverse */ 6684 0, /* tp_clear */ 6685 0, /* tp_richcompare */ 6686 0, /* tp_weaklistoffset */ 6687 0, /* tp_iter */ 6688 0, /* tp_iternext */ 6689 0, /* tp_methods */ 6690 super_members, /* tp_members */ 6691 0, /* tp_getset */ 6692 0, /* tp_base */ 6693 0, /* tp_dict */ 6694 super_descr_get, /* tp_descr_get */ 6695 0, /* tp_descr_set */ 6696 0, /* tp_dictoffset */ 6697 super_init, /* tp_init */ 6698 PyType_GenericAlloc, /* tp_alloc */ 6699 PyType_GenericNew, /* tp_new */ 6700 PyObject_GC_Del, /* tp_free */ 6701}; 6702