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