typeobject.c revision 323a9cfc8384adca677923cf3c65ad62920c76fa
1/* Type object implementation */ 2 3#include "Python.h" 4#include "structmember.h" 5 6#include <ctype.h> 7 8/* The *real* layout of a type object when allocated on the heap */ 9/* XXX Should we publish this in a header file? */ 10typedef struct { 11 /* Note: there's a dependency on the order of these members 12 in slotptr() below. */ 13 PyTypeObject type; 14 PyNumberMethods as_number; 15 PyMappingMethods as_mapping; 16 PySequenceMethods as_sequence; /* as_sequence comes after as_mapping, 17 so that the mapping wins when both 18 the mapping and the sequence define 19 a given operator (e.g. __getitem__). 20 see add_operators() below. */ 21 PyBufferProcs as_buffer; 22 PyObject *name, *slots; 23 PyMemberDef members[1]; 24} etype; 25 26static PyMemberDef type_members[] = { 27 {"__basicsize__", T_INT, offsetof(PyTypeObject,tp_basicsize),READONLY}, 28 {"__itemsize__", T_INT, offsetof(PyTypeObject, tp_itemsize), READONLY}, 29 {"__flags__", T_LONG, offsetof(PyTypeObject, tp_flags), READONLY}, 30 {"__weakrefoffset__", T_LONG, 31 offsetof(PyTypeObject, tp_weaklistoffset), READONLY}, 32 {"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY}, 33 {"__dictoffset__", T_LONG, 34 offsetof(PyTypeObject, tp_dictoffset), READONLY}, 35 {"__bases__", T_OBJECT, offsetof(PyTypeObject, tp_bases), READONLY}, 36 {"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY}, 37 {0} 38}; 39 40static PyObject * 41type_name(PyTypeObject *type, void *context) 42{ 43 char *s; 44 45 s = strrchr(type->tp_name, '.'); 46 if (s == NULL) 47 s = type->tp_name; 48 else 49 s++; 50 return PyString_FromString(s); 51} 52 53static PyObject * 54type_module(PyTypeObject *type, void *context) 55{ 56 PyObject *mod; 57 char *s; 58 59 s = strrchr(type->tp_name, '.'); 60 if (s != NULL) 61 return PyString_FromStringAndSize(type->tp_name, 62 (int)(s - type->tp_name)); 63 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) 64 return PyString_FromString("__builtin__"); 65 mod = PyDict_GetItemString(type->tp_dict, "__module__"); 66 if (mod != NULL && PyString_Check(mod)) { 67 Py_INCREF(mod); 68 return mod; 69 } 70 PyErr_SetString(PyExc_AttributeError, "__module__"); 71 return NULL; 72} 73 74static int 75type_set_module(PyTypeObject *type, PyObject *value, void *context) 76{ 77 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) || 78 strrchr(type->tp_name, '.')) { 79 PyErr_Format(PyExc_TypeError, 80 "can't set %s.__module__", type->tp_name); 81 return -1; 82 } 83 if (!value) { 84 PyErr_Format(PyExc_TypeError, 85 "can't delete %s.__module__", type->tp_name); 86 return -1; 87 } 88 return PyDict_SetItemString(type->tp_dict, "__module__", value); 89} 90 91static PyObject * 92type_dict(PyTypeObject *type, void *context) 93{ 94 if (type->tp_dict == NULL) { 95 Py_INCREF(Py_None); 96 return Py_None; 97 } 98 return PyDictProxy_New(type->tp_dict); 99} 100 101static PyObject * 102type_get_doc(PyTypeObject *type, void *context) 103{ 104 PyObject *result; 105 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL) 106 return PyString_FromString(type->tp_doc); 107 result = PyDict_GetItemString(type->tp_dict, "__doc__"); 108 if (result == NULL) { 109 result = Py_None; 110 Py_INCREF(result); 111 } 112 else if (result->ob_type->tp_descr_get) { 113 result = result->ob_type->tp_descr_get(result, NULL, 114 (PyObject *)type); 115 } 116 else { 117 Py_INCREF(result); 118 } 119 return result; 120} 121 122static PyGetSetDef type_getsets[] = { 123 {"__name__", (getter)type_name, NULL, NULL}, 124 {"__module__", (getter)type_module, (setter)type_set_module, NULL}, 125 {"__dict__", (getter)type_dict, NULL, NULL}, 126 {"__doc__", (getter)type_get_doc, NULL, NULL}, 127 {0} 128}; 129 130static int 131type_compare(PyObject *v, PyObject *w) 132{ 133 /* This is called with type objects only. So we 134 can just compare the addresses. */ 135 Py_uintptr_t vv = (Py_uintptr_t)v; 136 Py_uintptr_t ww = (Py_uintptr_t)w; 137 return (vv < ww) ? -1 : (vv > ww) ? 1 : 0; 138} 139 140static PyObject * 141type_repr(PyTypeObject *type) 142{ 143 PyObject *mod, *name, *rtn; 144 char *kind; 145 146 mod = type_module(type, NULL); 147 if (mod == NULL) 148 PyErr_Clear(); 149 else if (!PyString_Check(mod)) { 150 Py_DECREF(mod); 151 mod = NULL; 152 } 153 name = type_name(type, NULL); 154 if (name == NULL) 155 return NULL; 156 157 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) 158 kind = "class"; 159 else 160 kind = "type"; 161 162 if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) { 163 rtn = PyString_FromFormat("<%s '%s.%s'>", 164 kind, 165 PyString_AS_STRING(mod), 166 PyString_AS_STRING(name)); 167 } 168 else 169 rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name); 170 171 Py_XDECREF(mod); 172 Py_DECREF(name); 173 return rtn; 174} 175 176static PyObject * 177type_call(PyTypeObject *type, PyObject *args, PyObject *kwds) 178{ 179 PyObject *obj; 180 181 if (type->tp_new == NULL) { 182 PyErr_Format(PyExc_TypeError, 183 "cannot create '%.100s' instances", 184 type->tp_name); 185 return NULL; 186 } 187 188 obj = type->tp_new(type, args, kwds); 189 if (obj != NULL) { 190 /* Ugly exception: when the call was type(something), 191 don't call tp_init on the result. */ 192 if (type == &PyType_Type && 193 PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 && 194 (kwds == NULL || 195 (PyDict_Check(kwds) && PyDict_Size(kwds) == 0))) 196 return obj; 197 /* If the returned object is not an instance of type, 198 it won't be initialized. */ 199 if (!PyType_IsSubtype(obj->ob_type, type)) 200 return obj; 201 type = obj->ob_type; 202 if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS) && 203 type->tp_init != NULL && 204 type->tp_init(obj, args, kwds) < 0) { 205 Py_DECREF(obj); 206 obj = NULL; 207 } 208 } 209 return obj; 210} 211 212PyObject * 213PyType_GenericAlloc(PyTypeObject *type, int nitems) 214{ 215 PyObject *obj; 216 const size_t size = _PyObject_VAR_SIZE(type, nitems); 217 218 if (PyType_IS_GC(type)) 219 obj = _PyObject_GC_Malloc(size); 220 else 221 obj = PyObject_MALLOC(size); 222 223 if (obj == NULL) 224 return PyErr_NoMemory(); 225 226 memset(obj, '\0', size); 227 228 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) 229 Py_INCREF(type); 230 231 if (type->tp_itemsize == 0) 232 PyObject_INIT(obj, type); 233 else 234 (void) PyObject_INIT_VAR((PyVarObject *)obj, type, nitems); 235 236 if (PyType_IS_GC(type)) 237 _PyObject_GC_TRACK(obj); 238 return obj; 239} 240 241PyObject * 242PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds) 243{ 244 return type->tp_alloc(type, 0); 245} 246 247/* Helpers for subtyping */ 248 249static int 250traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg) 251{ 252 int i, n; 253 PyMemberDef *mp; 254 255 n = type->ob_size; 256 mp = ((etype *)type)->members; 257 for (i = 0; i < n; i++, mp++) { 258 if (mp->type == T_OBJECT_EX) { 259 char *addr = (char *)self + mp->offset; 260 PyObject *obj = *(PyObject **)addr; 261 if (obj != NULL) { 262 int err = visit(obj, arg); 263 if (err) 264 return err; 265 } 266 } 267 } 268 return 0; 269} 270 271static int 272subtype_traverse(PyObject *self, visitproc visit, void *arg) 273{ 274 PyTypeObject *type, *base; 275 traverseproc basetraverse; 276 277 /* Find the nearest base with a different tp_traverse, 278 and traverse slots while we're at it */ 279 type = self->ob_type; 280 base = type; 281 while ((basetraverse = base->tp_traverse) == subtype_traverse) { 282 if (base->ob_size) { 283 int err = traverse_slots(base, self, visit, arg); 284 if (err) 285 return err; 286 } 287 base = base->tp_base; 288 assert(base); 289 } 290 291 if (type->tp_dictoffset != base->tp_dictoffset) { 292 PyObject **dictptr = _PyObject_GetDictPtr(self); 293 if (dictptr && *dictptr) { 294 int err = visit(*dictptr, arg); 295 if (err) 296 return err; 297 } 298 } 299 300 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) { 301 /* For a heaptype, the instances count as references 302 to the type. Traverse the type so the collector 303 can find cycles involving this link. */ 304 int err = visit((PyObject *)type, arg); 305 if (err) 306 return err; 307 } 308 309 if (basetraverse) 310 return basetraverse(self, visit, arg); 311 return 0; 312} 313 314static void 315clear_slots(PyTypeObject *type, PyObject *self) 316{ 317 int i, n; 318 PyMemberDef *mp; 319 320 n = type->ob_size; 321 mp = ((etype *)type)->members; 322 for (i = 0; i < n; i++, mp++) { 323 if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) { 324 char *addr = (char *)self + mp->offset; 325 PyObject *obj = *(PyObject **)addr; 326 if (obj != NULL) { 327 Py_DECREF(obj); 328 *(PyObject **)addr = NULL; 329 } 330 } 331 } 332} 333 334static int 335subtype_clear(PyObject *self) 336{ 337 PyTypeObject *type, *base; 338 inquiry baseclear; 339 340 /* Find the nearest base with a different tp_clear 341 and clear slots while we're at it */ 342 type = self->ob_type; 343 base = type; 344 while ((baseclear = base->tp_clear) == subtype_clear) { 345 if (base->ob_size) 346 clear_slots(base, self); 347 base = base->tp_base; 348 assert(base); 349 } 350 351 /* There's no need to clear the instance dict (if any); 352 the collector will call its tp_clear handler. */ 353 354 if (baseclear) 355 return baseclear(self); 356 return 0; 357} 358 359static void 360subtype_dealloc(PyObject *self) 361{ 362 PyTypeObject *type, *base; 363 destructor basedealloc; 364 365 /* Extract the type; we expect it to be a heap type */ 366 type = self->ob_type; 367 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 368 369 /* Test whether the type has GC exactly once */ 370 371 if (!PyType_IS_GC(type)) { 372 /* It's really rare to find a dynamic type that doesn't have 373 GC; it can only happen when deriving from 'object' and not 374 adding any slots or instance variables. This allows 375 certain simplifications: there's no need to call 376 clear_slots(), or DECREF the dict, or clear weakrefs. */ 377 378 /* Maybe call finalizer; exit early if resurrected */ 379 if (type->tp_del) { 380 type->tp_del(self); 381 if (self->ob_refcnt > 0) 382 return; 383 } 384 385 /* Find the nearest base with a different tp_dealloc */ 386 base = type; 387 while ((basedealloc = base->tp_dealloc) == subtype_dealloc) { 388 assert(base->ob_size == 0); 389 base = base->tp_base; 390 assert(base); 391 } 392 393 /* Call the base tp_dealloc() */ 394 assert(basedealloc); 395 basedealloc(self); 396 397 /* Can't reference self beyond this point */ 398 Py_DECREF(type); 399 400 /* Done */ 401 return; 402 } 403 404 /* We get here only if the type has GC */ 405 406 /* UnTrack and re-Track around the trashcan macro, alas */ 407 PyObject_GC_UnTrack(self); 408 Py_TRASHCAN_SAFE_BEGIN(self); 409 _PyObject_GC_TRACK(self); /* We'll untrack for real later */ 410 411 /* Maybe call finalizer; exit early if resurrected */ 412 if (type->tp_del) { 413 type->tp_del(self); 414 if (self->ob_refcnt > 0) 415 goto endlabel; 416 } 417 418 /* Find the nearest base with a different tp_dealloc 419 and clear slots while we're at it */ 420 base = type; 421 while ((basedealloc = base->tp_dealloc) == subtype_dealloc) { 422 if (base->ob_size) 423 clear_slots(base, self); 424 base = base->tp_base; 425 assert(base); 426 } 427 428 /* If we added a dict, DECREF it */ 429 if (type->tp_dictoffset && !base->tp_dictoffset) { 430 PyObject **dictptr = _PyObject_GetDictPtr(self); 431 if (dictptr != NULL) { 432 PyObject *dict = *dictptr; 433 if (dict != NULL) { 434 Py_DECREF(dict); 435 *dictptr = NULL; 436 } 437 } 438 } 439 440 /* If we added weaklist, we clear it */ 441 if (type->tp_weaklistoffset && !base->tp_weaklistoffset) 442 PyObject_ClearWeakRefs(self); 443 444 /* Finalize GC if the base doesn't do GC and we do */ 445 if (!PyType_IS_GC(base)) 446 _PyObject_GC_UNTRACK(self); 447 448 /* Call the base tp_dealloc() */ 449 assert(basedealloc); 450 basedealloc(self); 451 452 /* Can't reference self beyond this point */ 453 Py_DECREF(type); 454 455 endlabel: 456 Py_TRASHCAN_SAFE_END(self); 457} 458 459static PyTypeObject *solid_base(PyTypeObject *type); 460 461/* type test with subclassing support */ 462 463int 464PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b) 465{ 466 PyObject *mro; 467 468 if (!(a->tp_flags & Py_TPFLAGS_HAVE_CLASS)) 469 return b == a || b == &PyBaseObject_Type; 470 471 mro = a->tp_mro; 472 if (mro != NULL) { 473 /* Deal with multiple inheritance without recursion 474 by walking the MRO tuple */ 475 int i, n; 476 assert(PyTuple_Check(mro)); 477 n = PyTuple_GET_SIZE(mro); 478 for (i = 0; i < n; i++) { 479 if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) 480 return 1; 481 } 482 return 0; 483 } 484 else { 485 /* a is not completely initilized yet; follow tp_base */ 486 do { 487 if (a == b) 488 return 1; 489 a = a->tp_base; 490 } while (a != NULL); 491 return b == &PyBaseObject_Type; 492 } 493} 494 495/* Internal routines to do a method lookup in the type 496 without looking in the instance dictionary 497 (so we can't use PyObject_GetAttr) but still binding 498 it to the instance. The arguments are the object, 499 the method name as a C string, and the address of a 500 static variable used to cache the interned Python string. 501 502 Two variants: 503 504 - lookup_maybe() returns NULL without raising an exception 505 when the _PyType_Lookup() call fails; 506 507 - lookup_method() always raises an exception upon errors. 508*/ 509 510static PyObject * 511lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj) 512{ 513 PyObject *res; 514 515 if (*attrobj == NULL) { 516 *attrobj = PyString_InternFromString(attrstr); 517 if (*attrobj == NULL) 518 return NULL; 519 } 520 res = _PyType_Lookup(self->ob_type, *attrobj); 521 if (res != NULL) { 522 descrgetfunc f; 523 if ((f = res->ob_type->tp_descr_get) == NULL) 524 Py_INCREF(res); 525 else 526 res = f(res, self, (PyObject *)(self->ob_type)); 527 } 528 return res; 529} 530 531static PyObject * 532lookup_method(PyObject *self, char *attrstr, PyObject **attrobj) 533{ 534 PyObject *res = lookup_maybe(self, attrstr, attrobj); 535 if (res == NULL && !PyErr_Occurred()) 536 PyErr_SetObject(PyExc_AttributeError, *attrobj); 537 return res; 538} 539 540/* A variation of PyObject_CallMethod that uses lookup_method() 541 instead of PyObject_GetAttrString(). This uses the same convention 542 as lookup_method to cache the interned name string object. */ 543 544static PyObject * 545call_method(PyObject *o, char *name, PyObject **nameobj, char *format, ...) 546{ 547 va_list va; 548 PyObject *args, *func = 0, *retval; 549 va_start(va, format); 550 551 func = lookup_maybe(o, name, nameobj); 552 if (func == NULL) { 553 va_end(va); 554 if (!PyErr_Occurred()) 555 PyErr_SetObject(PyExc_AttributeError, *nameobj); 556 return NULL; 557 } 558 559 if (format && *format) 560 args = Py_VaBuildValue(format, va); 561 else 562 args = PyTuple_New(0); 563 564 va_end(va); 565 566 if (args == NULL) 567 return NULL; 568 569 assert(PyTuple_Check(args)); 570 retval = PyObject_Call(func, args, NULL); 571 572 Py_DECREF(args); 573 Py_DECREF(func); 574 575 return retval; 576} 577 578/* Clone of call_method() that returns NotImplemented when the lookup fails. */ 579 580static PyObject * 581call_maybe(PyObject *o, char *name, PyObject **nameobj, char *format, ...) 582{ 583 va_list va; 584 PyObject *args, *func = 0, *retval; 585 va_start(va, format); 586 587 func = lookup_maybe(o, name, nameobj); 588 if (func == NULL) { 589 va_end(va); 590 if (!PyErr_Occurred()) { 591 Py_INCREF(Py_NotImplemented); 592 return Py_NotImplemented; 593 } 594 return NULL; 595 } 596 597 if (format && *format) 598 args = Py_VaBuildValue(format, va); 599 else 600 args = PyTuple_New(0); 601 602 va_end(va); 603 604 if (args == NULL) 605 return NULL; 606 607 assert(PyTuple_Check(args)); 608 retval = PyObject_Call(func, args, NULL); 609 610 Py_DECREF(args); 611 Py_DECREF(func); 612 613 return retval; 614} 615 616/* Method resolution order algorithm from "Putting Metaclasses to Work" 617 by Forman and Danforth (Addison-Wesley 1999). */ 618 619static int 620conservative_merge(PyObject *left, PyObject *right) 621{ 622 int left_size; 623 int right_size; 624 int i, j, r, ok; 625 PyObject *temp, *rr; 626 627 assert(PyList_Check(left)); 628 assert(PyList_Check(right)); 629 630 again: 631 left_size = PyList_GET_SIZE(left); 632 right_size = PyList_GET_SIZE(right); 633 for (i = 0; i < left_size; i++) { 634 for (j = 0; j < right_size; j++) { 635 if (PyList_GET_ITEM(left, i) == 636 PyList_GET_ITEM(right, j)) { 637 /* found a merge point */ 638 temp = PyList_New(0); 639 if (temp == NULL) 640 return -1; 641 for (r = 0; r < j; r++) { 642 rr = PyList_GET_ITEM(right, r); 643 ok = PySequence_Contains(left, rr); 644 if (ok < 0) { 645 Py_DECREF(temp); 646 return -1; 647 } 648 if (!ok) { 649 ok = PyList_Append(temp, rr); 650 if (ok < 0) { 651 Py_DECREF(temp); 652 return -1; 653 } 654 } 655 } 656 ok = PyList_SetSlice(left, i, i, temp); 657 Py_DECREF(temp); 658 if (ok < 0) 659 return -1; 660 ok = PyList_SetSlice(right, 0, j+1, NULL); 661 if (ok < 0) 662 return -1; 663 goto again; 664 } 665 } 666 } 667 return PyList_SetSlice(left, left_size, left_size, right); 668} 669 670static int 671serious_order_disagreements(PyObject *left, PyObject *right) 672{ 673 return 0; /* XXX later -- for now, we cheat: "don't do that" */ 674} 675 676static int 677fill_classic_mro(PyObject *mro, PyObject *cls) 678{ 679 PyObject *bases, *base; 680 int i, n; 681 682 assert(PyList_Check(mro)); 683 assert(PyClass_Check(cls)); 684 i = PySequence_Contains(mro, cls); 685 if (i < 0) 686 return -1; 687 if (!i) { 688 if (PyList_Append(mro, cls) < 0) 689 return -1; 690 } 691 bases = ((PyClassObject *)cls)->cl_bases; 692 assert(bases && PyTuple_Check(bases)); 693 n = PyTuple_GET_SIZE(bases); 694 for (i = 0; i < n; i++) { 695 base = PyTuple_GET_ITEM(bases, i); 696 if (fill_classic_mro(mro, base) < 0) 697 return -1; 698 } 699 return 0; 700} 701 702static PyObject * 703classic_mro(PyObject *cls) 704{ 705 PyObject *mro; 706 707 assert(PyClass_Check(cls)); 708 mro = PyList_New(0); 709 if (mro != NULL) { 710 if (fill_classic_mro(mro, cls) == 0) 711 return mro; 712 Py_DECREF(mro); 713 } 714 return NULL; 715} 716 717static PyObject * 718mro_implementation(PyTypeObject *type) 719{ 720 int i, n, ok; 721 PyObject *bases, *result; 722 723 if(type->tp_dict == NULL) { 724 if(PyType_Ready(type) < 0) 725 return NULL; 726 } 727 728 bases = type->tp_bases; 729 n = PyTuple_GET_SIZE(bases); 730 result = Py_BuildValue("[O]", (PyObject *)type); 731 if (result == NULL) 732 return NULL; 733 for (i = 0; i < n; i++) { 734 PyObject *base = PyTuple_GET_ITEM(bases, i); 735 PyObject *parentMRO; 736 if (PyType_Check(base)) 737 parentMRO = PySequence_List( 738 ((PyTypeObject*)base)->tp_mro); 739 else 740 parentMRO = classic_mro(base); 741 if (parentMRO == NULL) { 742 Py_DECREF(result); 743 return NULL; 744 } 745 if (serious_order_disagreements(result, parentMRO)) { 746 Py_DECREF(result); 747 return NULL; 748 } 749 ok = conservative_merge(result, parentMRO); 750 Py_DECREF(parentMRO); 751 if (ok < 0) { 752 Py_DECREF(result); 753 return NULL; 754 } 755 } 756 return result; 757} 758 759static PyObject * 760mro_external(PyObject *self) 761{ 762 PyTypeObject *type = (PyTypeObject *)self; 763 764 return mro_implementation(type); 765} 766 767static int 768mro_internal(PyTypeObject *type) 769{ 770 PyObject *mro, *result, *tuple; 771 772 if (type->ob_type == &PyType_Type) { 773 result = mro_implementation(type); 774 } 775 else { 776 static PyObject *mro_str; 777 mro = lookup_method((PyObject *)type, "mro", &mro_str); 778 if (mro == NULL) 779 return -1; 780 result = PyObject_CallObject(mro, NULL); 781 Py_DECREF(mro); 782 } 783 if (result == NULL) 784 return -1; 785 tuple = PySequence_Tuple(result); 786 Py_DECREF(result); 787 type->tp_mro = tuple; 788 return 0; 789} 790 791 792/* Calculate the best base amongst multiple base classes. 793 This is the first one that's on the path to the "solid base". */ 794 795static PyTypeObject * 796best_base(PyObject *bases) 797{ 798 int i, n; 799 PyTypeObject *base, *winner, *candidate, *base_i; 800 PyObject *base_proto; 801 802 assert(PyTuple_Check(bases)); 803 n = PyTuple_GET_SIZE(bases); 804 assert(n > 0); 805 base = NULL; 806 winner = NULL; 807 for (i = 0; i < n; i++) { 808 base_proto = PyTuple_GET_ITEM(bases, i); 809 if (PyClass_Check(base_proto)) 810 continue; 811 if (!PyType_Check(base_proto)) { 812 PyErr_SetString( 813 PyExc_TypeError, 814 "bases must be types"); 815 return NULL; 816 } 817 base_i = (PyTypeObject *)base_proto; 818 if (base_i->tp_dict == NULL) { 819 if (PyType_Ready(base_i) < 0) 820 return NULL; 821 } 822 candidate = solid_base(base_i); 823 if (winner == NULL) { 824 winner = candidate; 825 base = base_i; 826 } 827 else if (PyType_IsSubtype(winner, candidate)) 828 ; 829 else if (PyType_IsSubtype(candidate, winner)) { 830 winner = candidate; 831 base = base_i; 832 } 833 else { 834 PyErr_SetString( 835 PyExc_TypeError, 836 "multiple bases have " 837 "instance lay-out conflict"); 838 return NULL; 839 } 840 } 841 if (base == NULL) 842 PyErr_SetString(PyExc_TypeError, 843 "a new-style class can't have only classic bases"); 844 return base; 845} 846 847static int 848extra_ivars(PyTypeObject *type, PyTypeObject *base) 849{ 850 size_t t_size = type->tp_basicsize; 851 size_t b_size = base->tp_basicsize; 852 853 assert(t_size >= b_size); /* Else type smaller than base! */ 854 if (type->tp_itemsize || base->tp_itemsize) { 855 /* If itemsize is involved, stricter rules */ 856 return t_size != b_size || 857 type->tp_itemsize != base->tp_itemsize; 858 } 859 if (type->tp_weaklistoffset && base->tp_weaklistoffset == 0 && 860 type->tp_weaklistoffset + sizeof(PyObject *) == t_size) 861 t_size -= sizeof(PyObject *); 862 if (type->tp_dictoffset && base->tp_dictoffset == 0 && 863 type->tp_dictoffset + sizeof(PyObject *) == t_size) 864 t_size -= sizeof(PyObject *); 865 866 return t_size != b_size; 867} 868 869static PyTypeObject * 870solid_base(PyTypeObject *type) 871{ 872 PyTypeObject *base; 873 874 if (type->tp_base) 875 base = solid_base(type->tp_base); 876 else 877 base = &PyBaseObject_Type; 878 if (extra_ivars(type, base)) 879 return type; 880 else 881 return base; 882} 883 884static void object_dealloc(PyObject *); 885static int object_init(PyObject *, PyObject *, PyObject *); 886static int update_slot(PyTypeObject *, PyObject *); 887static void fixup_slot_dispatchers(PyTypeObject *); 888 889static PyObject * 890subtype_dict(PyObject *obj, void *context) 891{ 892 PyObject **dictptr = _PyObject_GetDictPtr(obj); 893 PyObject *dict; 894 895 if (dictptr == NULL) { 896 PyErr_SetString(PyExc_AttributeError, 897 "This object has no __dict__"); 898 return NULL; 899 } 900 dict = *dictptr; 901 if (dict == NULL) 902 *dictptr = dict = PyDict_New(); 903 Py_XINCREF(dict); 904 return dict; 905} 906 907static int 908subtype_setdict(PyObject *obj, PyObject *value, void *context) 909{ 910 PyObject **dictptr = _PyObject_GetDictPtr(obj); 911 PyObject *dict; 912 913 if (dictptr == NULL) { 914 PyErr_SetString(PyExc_AttributeError, 915 "This object has no __dict__"); 916 return -1; 917 } 918 if (value != NULL && !PyDict_Check(value)) { 919 PyErr_SetString(PyExc_TypeError, 920 "__dict__ must be set to a dictionary"); 921 return -1; 922 } 923 dict = *dictptr; 924 Py_XINCREF(value); 925 *dictptr = value; 926 Py_XDECREF(dict); 927 return 0; 928} 929 930static PyObject * 931subtype_getweakref(PyObject *obj, void *context) 932{ 933 PyObject **weaklistptr; 934 PyObject *result; 935 936 if (obj->ob_type->tp_weaklistoffset == 0) { 937 PyErr_SetString(PyExc_AttributeError, 938 "This object has no __weaklist__"); 939 return NULL; 940 } 941 assert(obj->ob_type->tp_weaklistoffset > 0); 942 assert(obj->ob_type->tp_weaklistoffset + sizeof(PyObject *) <= 943 (size_t)(obj->ob_type->tp_basicsize)); 944 weaklistptr = (PyObject **) 945 ((char *)obj + obj->ob_type->tp_weaklistoffset); 946 if (*weaklistptr == NULL) 947 result = Py_None; 948 else 949 result = *weaklistptr; 950 Py_INCREF(result); 951 return result; 952} 953 954static PyGetSetDef subtype_getsets[] = { 955 /* Not all objects have these attributes! 956 The descriptor's __get__ method may raise AttributeError. */ 957 {"__dict__", subtype_dict, subtype_setdict, 958 PyDoc_STR("dictionary for instance variables (if defined)")}, 959 {"__weakref__", subtype_getweakref, NULL, 960 PyDoc_STR("list of weak references to the object (if defined)")}, 961 {0} 962}; 963 964/* bozo: __getstate__ that raises TypeError */ 965 966static PyObject * 967bozo_func(PyObject *self, PyObject *args) 968{ 969 PyErr_SetString(PyExc_TypeError, 970 "a class that defines __slots__ without " 971 "defining __getstate__ cannot be pickled"); 972 return NULL; 973} 974 975static PyMethodDef bozo_ml = {"__getstate__", bozo_func, METH_VARARGS}; 976 977static PyObject *bozo_obj = NULL; 978 979static int 980valid_identifier(PyObject *s) 981{ 982 unsigned char *p; 983 int i, n; 984 985 if (!PyString_Check(s)) { 986 PyErr_SetString(PyExc_TypeError, 987 "__slots__ must be strings"); 988 return 0; 989 } 990 p = (unsigned char *) PyString_AS_STRING(s); 991 n = PyString_GET_SIZE(s); 992 /* We must reject an empty name. As a hack, we bump the 993 length to 1 so that the loop will balk on the trailing \0. */ 994 if (n == 0) 995 n = 1; 996 for (i = 0; i < n; i++, p++) { 997 if (!(i == 0 ? isalpha(*p) : isalnum(*p)) && *p != '_') { 998 PyErr_SetString(PyExc_TypeError, 999 "__slots__ must be identifiers"); 1000 return 0; 1001 } 1002 } 1003 return 1; 1004} 1005 1006static PyObject * 1007type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds) 1008{ 1009 PyObject *name, *bases, *dict; 1010 static char *kwlist[] = {"name", "bases", "dict", 0}; 1011 static char buffer[256]; 1012 PyObject *slots, *tmp, *newslots; 1013 PyTypeObject *type, *base, *tmptype, *winner; 1014 etype *et; 1015 PyMemberDef *mp; 1016 int i, nbases, nslots, slotoffset, add_dict, add_weak; 1017 int j, may_add_dict, may_add_weak; 1018 1019 assert(args != NULL && PyTuple_Check(args)); 1020 assert(kwds == NULL || PyDict_Check(kwds)); 1021 1022 /* Special case: type(x) should return x->ob_type */ 1023 { 1024 const int nargs = PyTuple_GET_SIZE(args); 1025 const int nkwds = kwds == NULL ? 0 : PyDict_Size(kwds); 1026 1027 if (PyType_CheckExact(metatype) && nargs == 1 && nkwds == 0) { 1028 PyObject *x = PyTuple_GET_ITEM(args, 0); 1029 Py_INCREF(x->ob_type); 1030 return (PyObject *) x->ob_type; 1031 } 1032 1033 /* SF bug 475327 -- if that didn't trigger, we need 3 1034 arguments. but PyArg_ParseTupleAndKeywords below may give 1035 a msg saying type() needs exactly 3. */ 1036 if (nargs + nkwds != 3) { 1037 PyErr_SetString(PyExc_TypeError, 1038 "type() takes 1 or 3 arguments"); 1039 return NULL; 1040 } 1041 } 1042 1043 /* Check arguments: (name, bases, dict) */ 1044 if (!PyArg_ParseTupleAndKeywords(args, kwds, "SO!O!:type", kwlist, 1045 &name, 1046 &PyTuple_Type, &bases, 1047 &PyDict_Type, &dict)) 1048 return NULL; 1049 1050 /* Determine the proper metatype to deal with this, 1051 and check for metatype conflicts while we're at it. 1052 Note that if some other metatype wins to contract, 1053 it's possible that its instances are not types. */ 1054 nbases = PyTuple_GET_SIZE(bases); 1055 winner = metatype; 1056 for (i = 0; i < nbases; i++) { 1057 tmp = PyTuple_GET_ITEM(bases, i); 1058 tmptype = tmp->ob_type; 1059 if (tmptype == &PyClass_Type) 1060 continue; /* Special case classic classes */ 1061 if (PyType_IsSubtype(winner, tmptype)) 1062 continue; 1063 if (PyType_IsSubtype(tmptype, winner)) { 1064 winner = tmptype; 1065 continue; 1066 } 1067 PyErr_SetString(PyExc_TypeError, 1068 "metatype conflict among bases"); 1069 return NULL; 1070 } 1071 if (winner != metatype) { 1072 if (winner->tp_new != type_new) /* Pass it to the winner */ 1073 return winner->tp_new(winner, args, kwds); 1074 metatype = winner; 1075 } 1076 1077 /* Adjust for empty tuple bases */ 1078 if (nbases == 0) { 1079 bases = Py_BuildValue("(O)", &PyBaseObject_Type); 1080 if (bases == NULL) 1081 return NULL; 1082 nbases = 1; 1083 } 1084 else 1085 Py_INCREF(bases); 1086 1087 /* XXX From here until type is allocated, "return NULL" leaks bases! */ 1088 1089 /* Calculate best base, and check that all bases are type objects */ 1090 base = best_base(bases); 1091 if (base == NULL) 1092 return NULL; 1093 if (!PyType_HasFeature(base, Py_TPFLAGS_BASETYPE)) { 1094 PyErr_Format(PyExc_TypeError, 1095 "type '%.100s' is not an acceptable base type", 1096 base->tp_name); 1097 return NULL; 1098 } 1099 1100 /* Check for a __slots__ sequence variable in dict, and count it */ 1101 slots = PyDict_GetItemString(dict, "__slots__"); 1102 nslots = 0; 1103 add_dict = 0; 1104 add_weak = 0; 1105 may_add_dict = base->tp_dictoffset == 0; 1106 may_add_weak = base->tp_weaklistoffset == 0 && base->tp_itemsize == 0; 1107 if (slots == NULL) { 1108 if (may_add_dict) { 1109 add_dict++; 1110 } 1111 if (may_add_weak) { 1112 add_weak++; 1113 } 1114 } 1115 else { 1116 /* Have slots */ 1117 1118 /* Make it into a tuple */ 1119 if (PyString_Check(slots)) 1120 slots = Py_BuildValue("(O)", slots); 1121 else 1122 slots = PySequence_Tuple(slots); 1123 if (slots == NULL) 1124 return NULL; 1125 assert(PyTuple_Check(slots)); 1126 1127 /* Are slots allowed? */ 1128 nslots = PyTuple_GET_SIZE(slots); 1129 if (nslots > 0 && base->tp_itemsize != 0) { 1130 PyErr_Format(PyExc_TypeError, 1131 "nonempty __slots__ " 1132 "not supported for subtype of '%s'", 1133 base->tp_name); 1134 bad_slots: 1135 Py_DECREF(slots); 1136 return NULL; 1137 } 1138 1139 /* Check for valid slot names and two special cases */ 1140 for (i = 0; i < nslots; i++) { 1141 PyObject *tmp = PyTuple_GET_ITEM(slots, i); 1142 char *s; 1143 if (!valid_identifier(tmp)) 1144 goto bad_slots; 1145 assert(PyString_Check(tmp)); 1146 s = PyString_AS_STRING(tmp); 1147 if (strcmp(s, "__dict__") == 0) { 1148 if (!may_add_dict || add_dict) { 1149 PyErr_SetString(PyExc_TypeError, 1150 "__dict__ slot disallowed: " 1151 "we already got one"); 1152 goto bad_slots; 1153 } 1154 add_dict++; 1155 } 1156 if (strcmp(s, "__weakref__") == 0) { 1157 if (!may_add_weak || add_weak) { 1158 PyErr_SetString(PyExc_TypeError, 1159 "__weakref__ slot disallowed: " 1160 "either we already got one, " 1161 "or __itemsize__ != 0"); 1162 goto bad_slots; 1163 } 1164 add_weak++; 1165 } 1166 } 1167 1168 /* Copy slots into yet another tuple, demangling names */ 1169 newslots = PyTuple_New(nslots - add_dict - add_weak); 1170 if (newslots == NULL) 1171 goto bad_slots; 1172 for (i = j = 0; i < nslots; i++) { 1173 char *s; 1174 tmp = PyTuple_GET_ITEM(slots, i); 1175 s = PyString_AS_STRING(tmp); 1176 if ((add_dict && strcmp(s, "__dict__") == 0) || 1177 (add_weak && strcmp(s, "__weakref__") == 0)) 1178 continue; 1179 if (_Py_Mangle(PyString_AS_STRING(name), 1180 PyString_AS_STRING(tmp), 1181 buffer, sizeof(buffer))) 1182 { 1183 tmp = PyString_FromString(buffer); 1184 } else { 1185 Py_INCREF(tmp); 1186 } 1187 PyTuple_SET_ITEM(newslots, j, tmp); 1188 j++; 1189 } 1190 assert(j == nslots - add_dict - add_weak); 1191 nslots = j; 1192 Py_DECREF(slots); 1193 slots = newslots; 1194 1195 /* See if *this* class defines __getstate__ */ 1196 if (PyDict_GetItemString(dict, "__getstate__") == NULL) { 1197 /* If not, provide a bozo that raises TypeError */ 1198 if (bozo_obj == NULL) { 1199 bozo_obj = PyCFunction_New(&bozo_ml, NULL); 1200 if (bozo_obj == NULL) 1201 goto bad_slots; 1202 } 1203 if (PyDict_SetItemString(dict, 1204 "__getstate__", 1205 bozo_obj) < 0) 1206 { 1207 Py_DECREF(bozo_obj); 1208 goto bad_slots; 1209 } 1210 } 1211 1212 /* Secondary bases may provide weakrefs or dict */ 1213 if (nbases > 1 && 1214 ((may_add_dict && !add_dict) || 1215 (may_add_weak && !add_weak))) { 1216 for (i = 0; i < nbases; i++) { 1217 tmp = PyTuple_GET_ITEM(bases, i); 1218 if (tmp == (PyObject *)base) 1219 continue; /* Skip primary base */ 1220 if (PyClass_Check(tmp)) { 1221 /* Classic base class provides both */ 1222 if (may_add_dict && !add_dict) 1223 add_dict++; 1224 if (may_add_weak && !add_weak) 1225 add_weak++; 1226 break; 1227 } 1228 assert(PyType_Check(tmp)); 1229 tmptype = (PyTypeObject *)tmp; 1230 if (may_add_dict && !add_dict && 1231 tmptype->tp_dictoffset != 0) 1232 add_dict++; 1233 if (may_add_weak && !add_weak && 1234 tmptype->tp_weaklistoffset != 0) 1235 add_weak++; 1236 if (may_add_dict && !add_dict) 1237 continue; 1238 if (may_add_weak && !add_weak) 1239 continue; 1240 /* Nothing more to check */ 1241 break; 1242 } 1243 } 1244 } 1245 1246 /* XXX From here until type is safely allocated, 1247 "return NULL" may leak slots! */ 1248 1249 /* Allocate the type object */ 1250 type = (PyTypeObject *)metatype->tp_alloc(metatype, nslots); 1251 if (type == NULL) { 1252 Py_XDECREF(slots); 1253 return NULL; 1254 } 1255 1256 /* Keep name and slots alive in the extended type object */ 1257 et = (etype *)type; 1258 Py_INCREF(name); 1259 et->name = name; 1260 et->slots = slots; 1261 1262 /* Initialize tp_flags */ 1263 type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | 1264 Py_TPFLAGS_BASETYPE; 1265 if (base->tp_flags & Py_TPFLAGS_HAVE_GC) 1266 type->tp_flags |= Py_TPFLAGS_HAVE_GC; 1267 1268 /* It's a new-style number unless it specifically inherits any 1269 old-style numeric behavior */ 1270 if ((base->tp_flags & Py_TPFLAGS_CHECKTYPES) || 1271 (base->tp_as_number == NULL)) 1272 type->tp_flags |= Py_TPFLAGS_CHECKTYPES; 1273 1274 /* Initialize essential fields */ 1275 type->tp_as_number = &et->as_number; 1276 type->tp_as_sequence = &et->as_sequence; 1277 type->tp_as_mapping = &et->as_mapping; 1278 type->tp_as_buffer = &et->as_buffer; 1279 type->tp_name = PyString_AS_STRING(name); 1280 1281 /* Set tp_base and tp_bases */ 1282 type->tp_bases = bases; 1283 Py_INCREF(base); 1284 type->tp_base = base; 1285 1286 /* Initialize tp_dict from passed-in dict */ 1287 type->tp_dict = dict = PyDict_Copy(dict); 1288 if (dict == NULL) { 1289 Py_DECREF(type); 1290 return NULL; 1291 } 1292 1293 /* Set __module__ in the dict */ 1294 if (PyDict_GetItemString(dict, "__module__") == NULL) { 1295 tmp = PyEval_GetGlobals(); 1296 if (tmp != NULL) { 1297 tmp = PyDict_GetItemString(tmp, "__name__"); 1298 if (tmp != NULL) { 1299 if (PyDict_SetItemString(dict, "__module__", 1300 tmp) < 0) 1301 return NULL; 1302 } 1303 } 1304 } 1305 1306 /* Set tp_doc to a copy of dict['__doc__'], if the latter is there 1307 and is a string. The __doc__ accessor will first look for tp_doc; 1308 if that fails, it will still look into __dict__. 1309 */ 1310 { 1311 PyObject *doc = PyDict_GetItemString(dict, "__doc__"); 1312 if (doc != NULL && PyString_Check(doc)) { 1313 const size_t n = (size_t)PyString_GET_SIZE(doc); 1314 type->tp_doc = (char *)PyObject_MALLOC(n+1); 1315 if (type->tp_doc == NULL) { 1316 Py_DECREF(type); 1317 return NULL; 1318 } 1319 memcpy(type->tp_doc, PyString_AS_STRING(doc), n+1); 1320 } 1321 } 1322 1323 /* Special-case __new__: if it's a plain function, 1324 make it a static function */ 1325 tmp = PyDict_GetItemString(dict, "__new__"); 1326 if (tmp != NULL && PyFunction_Check(tmp)) { 1327 tmp = PyStaticMethod_New(tmp); 1328 if (tmp == NULL) { 1329 Py_DECREF(type); 1330 return NULL; 1331 } 1332 PyDict_SetItemString(dict, "__new__", tmp); 1333 Py_DECREF(tmp); 1334 } 1335 1336 /* Add descriptors for custom slots from __slots__, or for __dict__ */ 1337 mp = et->members; 1338 slotoffset = base->tp_basicsize; 1339 if (slots != NULL) { 1340 for (i = 0; i < nslots; i++, mp++) { 1341 mp->name = PyString_AS_STRING( 1342 PyTuple_GET_ITEM(slots, i)); 1343 mp->type = T_OBJECT_EX; 1344 mp->offset = slotoffset; 1345 if (base->tp_weaklistoffset == 0 && 1346 strcmp(mp->name, "__weakref__") == 0) { 1347 add_weak++; 1348 mp->type = T_OBJECT; 1349 mp->flags = READONLY; 1350 type->tp_weaklistoffset = slotoffset; 1351 } 1352 slotoffset += sizeof(PyObject *); 1353 } 1354 } 1355 if (add_dict) { 1356 if (base->tp_itemsize) 1357 type->tp_dictoffset = -(long)sizeof(PyObject *); 1358 else 1359 type->tp_dictoffset = slotoffset; 1360 slotoffset += sizeof(PyObject *); 1361 } 1362 if (add_weak) { 1363 assert(!base->tp_itemsize); 1364 type->tp_weaklistoffset = slotoffset; 1365 slotoffset += sizeof(PyObject *); 1366 } 1367 type->tp_basicsize = slotoffset; 1368 type->tp_itemsize = base->tp_itemsize; 1369 type->tp_members = et->members; 1370 type->tp_getset = subtype_getsets; 1371 1372 /* Special case some slots */ 1373 if (type->tp_dictoffset != 0 || nslots > 0) { 1374 if (base->tp_getattr == NULL && base->tp_getattro == NULL) 1375 type->tp_getattro = PyObject_GenericGetAttr; 1376 if (base->tp_setattr == NULL && base->tp_setattro == NULL) 1377 type->tp_setattro = PyObject_GenericSetAttr; 1378 } 1379 type->tp_dealloc = subtype_dealloc; 1380 1381 /* Enable GC unless there are really no instance variables possible */ 1382 if (!(type->tp_basicsize == sizeof(PyObject) && 1383 type->tp_itemsize == 0)) 1384 type->tp_flags |= Py_TPFLAGS_HAVE_GC; 1385 1386 /* Always override allocation strategy to use regular heap */ 1387 type->tp_alloc = PyType_GenericAlloc; 1388 if (type->tp_flags & Py_TPFLAGS_HAVE_GC) { 1389 type->tp_free = PyObject_GC_Del; 1390 type->tp_traverse = subtype_traverse; 1391 type->tp_clear = subtype_clear; 1392 } 1393 else 1394 type->tp_free = PyObject_Del; 1395 1396 /* Initialize the rest */ 1397 if (PyType_Ready(type) < 0) { 1398 Py_DECREF(type); 1399 return NULL; 1400 } 1401 1402 /* Put the proper slots in place */ 1403 fixup_slot_dispatchers(type); 1404 1405 return (PyObject *)type; 1406} 1407 1408/* Internal API to look for a name through the MRO. 1409 This returns a borrowed reference, and doesn't set an exception! */ 1410PyObject * 1411_PyType_Lookup(PyTypeObject *type, PyObject *name) 1412{ 1413 int i, n; 1414 PyObject *mro, *res, *base, *dict; 1415 1416 /* Look in tp_dict of types in MRO */ 1417 mro = type->tp_mro; 1418 1419 /* If mro is NULL, the type is either not yet initialized 1420 by PyType_Ready(), or already cleared by type_clear(). 1421 Either way the safest thing to do is to return NULL. */ 1422 if (mro == NULL) 1423 return NULL; 1424 1425 assert(PyTuple_Check(mro)); 1426 n = PyTuple_GET_SIZE(mro); 1427 for (i = 0; i < n; i++) { 1428 base = PyTuple_GET_ITEM(mro, i); 1429 if (PyClass_Check(base)) 1430 dict = ((PyClassObject *)base)->cl_dict; 1431 else { 1432 assert(PyType_Check(base)); 1433 dict = ((PyTypeObject *)base)->tp_dict; 1434 } 1435 assert(dict && PyDict_Check(dict)); 1436 res = PyDict_GetItem(dict, name); 1437 if (res != NULL) 1438 return res; 1439 } 1440 return NULL; 1441} 1442 1443/* This is similar to PyObject_GenericGetAttr(), 1444 but uses _PyType_Lookup() instead of just looking in type->tp_dict. */ 1445static PyObject * 1446type_getattro(PyTypeObject *type, PyObject *name) 1447{ 1448 PyTypeObject *metatype = type->ob_type; 1449 PyObject *meta_attribute, *attribute; 1450 descrgetfunc meta_get; 1451 1452 /* Initialize this type (we'll assume the metatype is initialized) */ 1453 if (type->tp_dict == NULL) { 1454 if (PyType_Ready(type) < 0) 1455 return NULL; 1456 } 1457 1458 /* No readable descriptor found yet */ 1459 meta_get = NULL; 1460 1461 /* Look for the attribute in the metatype */ 1462 meta_attribute = _PyType_Lookup(metatype, name); 1463 1464 if (meta_attribute != NULL) { 1465 meta_get = meta_attribute->ob_type->tp_descr_get; 1466 1467 if (meta_get != NULL && PyDescr_IsData(meta_attribute)) { 1468 /* Data descriptors implement tp_descr_set to intercept 1469 * writes. Assume the attribute is not overridden in 1470 * type's tp_dict (and bases): call the descriptor now. 1471 */ 1472 return meta_get(meta_attribute, (PyObject *)type, 1473 (PyObject *)metatype); 1474 } 1475 } 1476 1477 /* No data descriptor found on metatype. Look in tp_dict of this 1478 * type and its bases */ 1479 attribute = _PyType_Lookup(type, name); 1480 if (attribute != NULL) { 1481 /* Implement descriptor functionality, if any */ 1482 descrgetfunc local_get = attribute->ob_type->tp_descr_get; 1483 if (local_get != NULL) { 1484 /* NULL 2nd argument indicates the descriptor was 1485 * found on the target object itself (or a base) */ 1486 return local_get(attribute, (PyObject *)NULL, 1487 (PyObject *)type); 1488 } 1489 1490 Py_INCREF(attribute); 1491 return attribute; 1492 } 1493 1494 /* No attribute found in local __dict__ (or bases): use the 1495 * descriptor from the metatype, if any */ 1496 if (meta_get != NULL) 1497 return meta_get(meta_attribute, (PyObject *)type, 1498 (PyObject *)metatype); 1499 1500 /* If an ordinary attribute was found on the metatype, return it now */ 1501 if (meta_attribute != NULL) { 1502 Py_INCREF(meta_attribute); 1503 return meta_attribute; 1504 } 1505 1506 /* Give up */ 1507 PyErr_Format(PyExc_AttributeError, 1508 "type object '%.50s' has no attribute '%.400s'", 1509 type->tp_name, PyString_AS_STRING(name)); 1510 return NULL; 1511} 1512 1513static int 1514type_setattro(PyTypeObject *type, PyObject *name, PyObject *value) 1515{ 1516 if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) { 1517 PyErr_Format( 1518 PyExc_TypeError, 1519 "can't set attributes of built-in/extension type '%s'", 1520 type->tp_name); 1521 return -1; 1522 } 1523 if (PyObject_GenericSetAttr((PyObject *)type, name, value) < 0) 1524 return -1; 1525 return update_slot(type, name); 1526} 1527 1528static void 1529type_dealloc(PyTypeObject *type) 1530{ 1531 etype *et; 1532 1533 /* Assert this is a heap-allocated type object */ 1534 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 1535 _PyObject_GC_UNTRACK(type); 1536 PyObject_ClearWeakRefs((PyObject *)type); 1537 et = (etype *)type; 1538 Py_XDECREF(type->tp_base); 1539 Py_XDECREF(type->tp_dict); 1540 Py_XDECREF(type->tp_bases); 1541 Py_XDECREF(type->tp_mro); 1542 Py_XDECREF(type->tp_cache); 1543 Py_XDECREF(type->tp_subclasses); 1544 PyObject_Free(type->tp_doc); 1545 Py_XDECREF(et->name); 1546 Py_XDECREF(et->slots); 1547 type->ob_type->tp_free((PyObject *)type); 1548} 1549 1550static PyObject * 1551type_subclasses(PyTypeObject *type, PyObject *args_ignored) 1552{ 1553 PyObject *list, *raw, *ref; 1554 int i, n; 1555 1556 list = PyList_New(0); 1557 if (list == NULL) 1558 return NULL; 1559 raw = type->tp_subclasses; 1560 if (raw == NULL) 1561 return list; 1562 assert(PyList_Check(raw)); 1563 n = PyList_GET_SIZE(raw); 1564 for (i = 0; i < n; i++) { 1565 ref = PyList_GET_ITEM(raw, i); 1566 assert(PyWeakref_CheckRef(ref)); 1567 ref = PyWeakref_GET_OBJECT(ref); 1568 if (ref != Py_None) { 1569 if (PyList_Append(list, ref) < 0) { 1570 Py_DECREF(list); 1571 return NULL; 1572 } 1573 } 1574 } 1575 return list; 1576} 1577 1578static PyMethodDef type_methods[] = { 1579 {"mro", (PyCFunction)mro_external, METH_NOARGS, 1580 PyDoc_STR("mro() -> list\nreturn a type's method resolution order")}, 1581 {"__subclasses__", (PyCFunction)type_subclasses, METH_NOARGS, 1582 PyDoc_STR("__subclasses__() -> list of immediate subclasses")}, 1583 {0} 1584}; 1585 1586PyDoc_STRVAR(type_doc, 1587"type(object) -> the object's type\n" 1588"type(name, bases, dict) -> a new type"); 1589 1590static int 1591type_traverse(PyTypeObject *type, visitproc visit, void *arg) 1592{ 1593 int err; 1594 1595 /* Because of type_is_gc(), the collector only calls this 1596 for heaptypes. */ 1597 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 1598 1599#define VISIT(SLOT) \ 1600 if (SLOT) { \ 1601 err = visit((PyObject *)(SLOT), arg); \ 1602 if (err) \ 1603 return err; \ 1604 } 1605 1606 VISIT(type->tp_dict); 1607 VISIT(type->tp_cache); 1608 VISIT(type->tp_mro); 1609 VISIT(type->tp_bases); 1610 VISIT(type->tp_base); 1611 1612 /* There's no need to visit type->tp_subclasses or 1613 ((etype *)type)->slots, because they can't be involved 1614 in cycles; tp_subclasses is a list of weak references, 1615 and slots is a tuple of strings. */ 1616 1617#undef VISIT 1618 1619 return 0; 1620} 1621 1622static int 1623type_clear(PyTypeObject *type) 1624{ 1625 PyObject *tmp; 1626 1627 /* Because of type_is_gc(), the collector only calls this 1628 for heaptypes. */ 1629 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE); 1630 1631#define CLEAR(SLOT) \ 1632 if (SLOT) { \ 1633 tmp = (PyObject *)(SLOT); \ 1634 SLOT = NULL; \ 1635 Py_DECREF(tmp); \ 1636 } 1637 1638 /* The only field we need to clear is tp_mro, which is part of a 1639 hard cycle (its first element is the class itself) that won't 1640 be broken otherwise (it's a tuple and tuples don't have a 1641 tp_clear handler). None of the other fields need to be 1642 cleared, and here's why: 1643 1644 tp_dict: 1645 It is a dict, so the collector will call its tp_clear. 1646 1647 tp_cache: 1648 Not used; if it were, it would be a dict. 1649 1650 tp_bases, tp_base: 1651 If these are involved in a cycle, there must be at least 1652 one other, mutable object in the cycle, e.g. a base 1653 class's dict; the cycle will be broken that way. 1654 1655 tp_subclasses: 1656 A list of weak references can't be part of a cycle; and 1657 lists have their own tp_clear. 1658 1659 slots (in etype): 1660 A tuple of strings can't be part of a cycle. 1661 */ 1662 1663 CLEAR(type->tp_mro); 1664 1665#undef CLEAR 1666 1667 return 0; 1668} 1669 1670static int 1671type_is_gc(PyTypeObject *type) 1672{ 1673 return type->tp_flags & Py_TPFLAGS_HEAPTYPE; 1674} 1675 1676PyTypeObject PyType_Type = { 1677 PyObject_HEAD_INIT(&PyType_Type) 1678 0, /* ob_size */ 1679 "type", /* tp_name */ 1680 sizeof(etype), /* tp_basicsize */ 1681 sizeof(PyMemberDef), /* tp_itemsize */ 1682 (destructor)type_dealloc, /* tp_dealloc */ 1683 0, /* tp_print */ 1684 0, /* tp_getattr */ 1685 0, /* tp_setattr */ 1686 type_compare, /* tp_compare */ 1687 (reprfunc)type_repr, /* tp_repr */ 1688 0, /* tp_as_number */ 1689 0, /* tp_as_sequence */ 1690 0, /* tp_as_mapping */ 1691 (hashfunc)_Py_HashPointer, /* tp_hash */ 1692 (ternaryfunc)type_call, /* tp_call */ 1693 0, /* tp_str */ 1694 (getattrofunc)type_getattro, /* tp_getattro */ 1695 (setattrofunc)type_setattro, /* tp_setattro */ 1696 0, /* tp_as_buffer */ 1697 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | 1698 Py_TPFLAGS_BASETYPE, /* tp_flags */ 1699 type_doc, /* tp_doc */ 1700 (traverseproc)type_traverse, /* tp_traverse */ 1701 (inquiry)type_clear, /* tp_clear */ 1702 0, /* tp_richcompare */ 1703 offsetof(PyTypeObject, tp_weaklist), /* tp_weaklistoffset */ 1704 0, /* tp_iter */ 1705 0, /* tp_iternext */ 1706 type_methods, /* tp_methods */ 1707 type_members, /* tp_members */ 1708 type_getsets, /* tp_getset */ 1709 0, /* tp_base */ 1710 0, /* tp_dict */ 1711 0, /* tp_descr_get */ 1712 0, /* tp_descr_set */ 1713 offsetof(PyTypeObject, tp_dict), /* tp_dictoffset */ 1714 0, /* tp_init */ 1715 0, /* tp_alloc */ 1716 type_new, /* tp_new */ 1717 PyObject_GC_Del, /* tp_free */ 1718 (inquiry)type_is_gc, /* tp_is_gc */ 1719}; 1720 1721 1722/* The base type of all types (eventually)... except itself. */ 1723 1724static int 1725object_init(PyObject *self, PyObject *args, PyObject *kwds) 1726{ 1727 return 0; 1728} 1729 1730static void 1731object_dealloc(PyObject *self) 1732{ 1733 self->ob_type->tp_free(self); 1734} 1735 1736static PyObject * 1737object_repr(PyObject *self) 1738{ 1739 PyTypeObject *type; 1740 PyObject *mod, *name, *rtn; 1741 1742 type = self->ob_type; 1743 mod = type_module(type, NULL); 1744 if (mod == NULL) 1745 PyErr_Clear(); 1746 else if (!PyString_Check(mod)) { 1747 Py_DECREF(mod); 1748 mod = NULL; 1749 } 1750 name = type_name(type, NULL); 1751 if (name == NULL) 1752 return NULL; 1753 if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) 1754 rtn = PyString_FromFormat("<%s.%s object at %p>", 1755 PyString_AS_STRING(mod), 1756 PyString_AS_STRING(name), 1757 self); 1758 else 1759 rtn = PyString_FromFormat("<%s object at %p>", 1760 type->tp_name, self); 1761 Py_XDECREF(mod); 1762 Py_DECREF(name); 1763 return rtn; 1764} 1765 1766static PyObject * 1767object_str(PyObject *self) 1768{ 1769 unaryfunc f; 1770 1771 f = self->ob_type->tp_repr; 1772 if (f == NULL) 1773 f = object_repr; 1774 return f(self); 1775} 1776 1777static long 1778object_hash(PyObject *self) 1779{ 1780 return _Py_HashPointer(self); 1781} 1782 1783static PyObject * 1784object_get_class(PyObject *self, void *closure) 1785{ 1786 Py_INCREF(self->ob_type); 1787 return (PyObject *)(self->ob_type); 1788} 1789 1790static int 1791equiv_structs(PyTypeObject *a, PyTypeObject *b) 1792{ 1793 return a == b || 1794 (a != NULL && 1795 b != NULL && 1796 a->tp_basicsize == b->tp_basicsize && 1797 a->tp_itemsize == b->tp_itemsize && 1798 a->tp_dictoffset == b->tp_dictoffset && 1799 a->tp_weaklistoffset == b->tp_weaklistoffset && 1800 ((a->tp_flags & Py_TPFLAGS_HAVE_GC) == 1801 (b->tp_flags & Py_TPFLAGS_HAVE_GC))); 1802} 1803 1804static int 1805same_slots_added(PyTypeObject *a, PyTypeObject *b) 1806{ 1807 PyTypeObject *base = a->tp_base; 1808 int size; 1809 1810 if (base != b->tp_base) 1811 return 0; 1812 if (equiv_structs(a, base) && equiv_structs(b, base)) 1813 return 1; 1814 size = base->tp_basicsize; 1815 if (a->tp_dictoffset == size && b->tp_dictoffset == size) 1816 size += sizeof(PyObject *); 1817 if (a->tp_weaklistoffset == size && b->tp_weaklistoffset == size) 1818 size += sizeof(PyObject *); 1819 return size == a->tp_basicsize && size == b->tp_basicsize; 1820} 1821 1822static int 1823object_set_class(PyObject *self, PyObject *value, void *closure) 1824{ 1825 PyTypeObject *old = self->ob_type; 1826 PyTypeObject *new, *newbase, *oldbase; 1827 1828 if (value == NULL) { 1829 PyErr_SetString(PyExc_TypeError, 1830 "can't delete __class__ attribute"); 1831 return -1; 1832 } 1833 if (!PyType_Check(value)) { 1834 PyErr_Format(PyExc_TypeError, 1835 "__class__ must be set to new-style class, not '%s' object", 1836 value->ob_type->tp_name); 1837 return -1; 1838 } 1839 new = (PyTypeObject *)value; 1840 if (!(new->tp_flags & Py_TPFLAGS_HEAPTYPE) || 1841 !(old->tp_flags & Py_TPFLAGS_HEAPTYPE)) 1842 { 1843 PyErr_Format(PyExc_TypeError, 1844 "__class__ assignment: only for heap types"); 1845 return -1; 1846 } 1847 if (new->tp_dealloc != old->tp_dealloc || 1848 new->tp_free != old->tp_free) 1849 { 1850 PyErr_Format(PyExc_TypeError, 1851 "__class__ assignment: " 1852 "'%s' deallocator differs from '%s'", 1853 new->tp_name, 1854 old->tp_name); 1855 return -1; 1856 } 1857 newbase = new; 1858 oldbase = old; 1859 while (equiv_structs(newbase, newbase->tp_base)) 1860 newbase = newbase->tp_base; 1861 while (equiv_structs(oldbase, oldbase->tp_base)) 1862 oldbase = oldbase->tp_base; 1863 if (newbase != oldbase && 1864 (newbase->tp_base != oldbase->tp_base || 1865 !same_slots_added(newbase, oldbase))) { 1866 PyErr_Format(PyExc_TypeError, 1867 "__class__ assignment: " 1868 "'%s' object layout differs from '%s'", 1869 new->tp_name, 1870 old->tp_name); 1871 return -1; 1872 } 1873 Py_INCREF(new); 1874 self->ob_type = new; 1875 Py_DECREF(old); 1876 return 0; 1877} 1878 1879static PyGetSetDef object_getsets[] = { 1880 {"__class__", object_get_class, object_set_class, 1881 PyDoc_STR("the object's class")}, 1882 {0} 1883}; 1884 1885static PyObject * 1886object_reduce(PyObject *self, PyObject *args) 1887{ 1888 /* Call copy_reg._reduce(self) */ 1889 static PyObject *copy_reg_str; 1890 PyObject *copy_reg, *res; 1891 1892 if (!copy_reg_str) { 1893 copy_reg_str = PyString_InternFromString("copy_reg"); 1894 if (copy_reg_str == NULL) 1895 return NULL; 1896 } 1897 copy_reg = PyImport_Import(copy_reg_str); 1898 if (!copy_reg) 1899 return NULL; 1900 res = PyEval_CallMethod(copy_reg, "_reduce", "(O)", self); 1901 Py_DECREF(copy_reg); 1902 return res; 1903} 1904 1905static PyMethodDef object_methods[] = { 1906 {"__reduce__", object_reduce, METH_NOARGS, 1907 PyDoc_STR("helper for pickle")}, 1908 {0} 1909}; 1910 1911PyTypeObject PyBaseObject_Type = { 1912 PyObject_HEAD_INIT(&PyType_Type) 1913 0, /* ob_size */ 1914 "object", /* tp_name */ 1915 sizeof(PyObject), /* tp_basicsize */ 1916 0, /* tp_itemsize */ 1917 (destructor)object_dealloc, /* tp_dealloc */ 1918 0, /* tp_print */ 1919 0, /* tp_getattr */ 1920 0, /* tp_setattr */ 1921 0, /* tp_compare */ 1922 object_repr, /* tp_repr */ 1923 0, /* tp_as_number */ 1924 0, /* tp_as_sequence */ 1925 0, /* tp_as_mapping */ 1926 object_hash, /* tp_hash */ 1927 0, /* tp_call */ 1928 object_str, /* tp_str */ 1929 PyObject_GenericGetAttr, /* tp_getattro */ 1930 PyObject_GenericSetAttr, /* tp_setattro */ 1931 0, /* tp_as_buffer */ 1932 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 1933 PyDoc_STR("The most base type"), /* tp_doc */ 1934 0, /* tp_traverse */ 1935 0, /* tp_clear */ 1936 0, /* tp_richcompare */ 1937 0, /* tp_weaklistoffset */ 1938 0, /* tp_iter */ 1939 0, /* tp_iternext */ 1940 object_methods, /* tp_methods */ 1941 0, /* tp_members */ 1942 object_getsets, /* tp_getset */ 1943 0, /* tp_base */ 1944 0, /* tp_dict */ 1945 0, /* tp_descr_get */ 1946 0, /* tp_descr_set */ 1947 0, /* tp_dictoffset */ 1948 object_init, /* tp_init */ 1949 PyType_GenericAlloc, /* tp_alloc */ 1950 PyType_GenericNew, /* tp_new */ 1951 PyObject_Del, /* tp_free */ 1952}; 1953 1954 1955/* Initialize the __dict__ in a type object */ 1956 1957static PyObject * 1958create_specialmethod(PyMethodDef *meth, PyObject *(*func)(PyObject *)) 1959{ 1960 PyObject *cfunc; 1961 PyObject *result; 1962 1963 cfunc = PyCFunction_New(meth, NULL); 1964 if (cfunc == NULL) 1965 return NULL; 1966 result = func(cfunc); 1967 Py_DECREF(cfunc); 1968 return result; 1969} 1970 1971static int 1972add_methods(PyTypeObject *type, PyMethodDef *meth) 1973{ 1974 PyObject *dict = type->tp_dict; 1975 1976 for (; meth->ml_name != NULL; meth++) { 1977 PyObject *descr; 1978 if (PyDict_GetItemString(dict, meth->ml_name)) 1979 continue; 1980 if (meth->ml_flags & METH_CLASS) { 1981 if (meth->ml_flags & METH_STATIC) { 1982 PyErr_SetString(PyExc_ValueError, 1983 "method cannot be both class and static"); 1984 return -1; 1985 } 1986 descr = create_specialmethod(meth, PyClassMethod_New); 1987 } 1988 else if (meth->ml_flags & METH_STATIC) { 1989 descr = create_specialmethod(meth, PyStaticMethod_New); 1990 } 1991 else { 1992 descr = PyDescr_NewMethod(type, meth); 1993 } 1994 if (descr == NULL) 1995 return -1; 1996 if (PyDict_SetItemString(dict, meth->ml_name, descr) < 0) 1997 return -1; 1998 Py_DECREF(descr); 1999 } 2000 return 0; 2001} 2002 2003static int 2004add_members(PyTypeObject *type, PyMemberDef *memb) 2005{ 2006 PyObject *dict = type->tp_dict; 2007 2008 for (; memb->name != NULL; memb++) { 2009 PyObject *descr; 2010 if (PyDict_GetItemString(dict, memb->name)) 2011 continue; 2012 descr = PyDescr_NewMember(type, memb); 2013 if (descr == NULL) 2014 return -1; 2015 if (PyDict_SetItemString(dict, memb->name, descr) < 0) 2016 return -1; 2017 Py_DECREF(descr); 2018 } 2019 return 0; 2020} 2021 2022static int 2023add_getset(PyTypeObject *type, PyGetSetDef *gsp) 2024{ 2025 PyObject *dict = type->tp_dict; 2026 2027 for (; gsp->name != NULL; gsp++) { 2028 PyObject *descr; 2029 if (PyDict_GetItemString(dict, gsp->name)) 2030 continue; 2031 descr = PyDescr_NewGetSet(type, gsp); 2032 2033 if (descr == NULL) 2034 return -1; 2035 if (PyDict_SetItemString(dict, gsp->name, descr) < 0) 2036 return -1; 2037 Py_DECREF(descr); 2038 } 2039 return 0; 2040} 2041 2042static void 2043inherit_special(PyTypeObject *type, PyTypeObject *base) 2044{ 2045 int oldsize, newsize; 2046 2047 /* Special flag magic */ 2048 if (!type->tp_as_buffer && base->tp_as_buffer) { 2049 type->tp_flags &= ~Py_TPFLAGS_HAVE_GETCHARBUFFER; 2050 type->tp_flags |= 2051 base->tp_flags & Py_TPFLAGS_HAVE_GETCHARBUFFER; 2052 } 2053 if (!type->tp_as_sequence && base->tp_as_sequence) { 2054 type->tp_flags &= ~Py_TPFLAGS_HAVE_SEQUENCE_IN; 2055 type->tp_flags |= base->tp_flags & Py_TPFLAGS_HAVE_SEQUENCE_IN; 2056 } 2057 if ((type->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS) != 2058 (base->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS)) { 2059 if ((!type->tp_as_number && base->tp_as_number) || 2060 (!type->tp_as_sequence && base->tp_as_sequence)) { 2061 type->tp_flags &= ~Py_TPFLAGS_HAVE_INPLACEOPS; 2062 if (!type->tp_as_number && !type->tp_as_sequence) { 2063 type->tp_flags |= base->tp_flags & 2064 Py_TPFLAGS_HAVE_INPLACEOPS; 2065 } 2066 } 2067 /* Wow */ 2068 } 2069 if (!type->tp_as_number && base->tp_as_number) { 2070 type->tp_flags &= ~Py_TPFLAGS_CHECKTYPES; 2071 type->tp_flags |= base->tp_flags & Py_TPFLAGS_CHECKTYPES; 2072 } 2073 2074 /* Copying basicsize is connected to the GC flags */ 2075 oldsize = base->tp_basicsize; 2076 newsize = type->tp_basicsize ? type->tp_basicsize : oldsize; 2077 if (!(type->tp_flags & Py_TPFLAGS_HAVE_GC) && 2078 (base->tp_flags & Py_TPFLAGS_HAVE_GC) && 2079 (type->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE/*GC slots exist*/) && 2080 (!type->tp_traverse && !type->tp_clear)) { 2081 type->tp_flags |= Py_TPFLAGS_HAVE_GC; 2082 if (type->tp_traverse == NULL) 2083 type->tp_traverse = base->tp_traverse; 2084 if (type->tp_clear == NULL) 2085 type->tp_clear = base->tp_clear; 2086 } 2087 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) { 2088 /* The condition below could use some explanation. 2089 It appears that tp_new is not inherited for static types 2090 whose base class is 'object'; this seems to be a precaution 2091 so that old extension types don't suddenly become 2092 callable (object.__new__ wouldn't insure the invariants 2093 that the extension type's own factory function ensures). 2094 Heap types, of course, are under our control, so they do 2095 inherit tp_new; static extension types that specify some 2096 other built-in type as the default are considered 2097 new-style-aware so they also inherit object.__new__. */ 2098 if (base != &PyBaseObject_Type || 2099 (type->tp_flags & Py_TPFLAGS_HEAPTYPE)) { 2100 if (type->tp_new == NULL) 2101 type->tp_new = base->tp_new; 2102 } 2103 } 2104 type->tp_basicsize = newsize; 2105 2106 /* Copy other non-function slots */ 2107 2108#undef COPYVAL 2109#define COPYVAL(SLOT) \ 2110 if (type->SLOT == 0) type->SLOT = base->SLOT 2111 2112 COPYVAL(tp_itemsize); 2113 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_WEAKREFS) { 2114 COPYVAL(tp_weaklistoffset); 2115 } 2116 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) { 2117 COPYVAL(tp_dictoffset); 2118 } 2119} 2120 2121static void 2122inherit_slots(PyTypeObject *type, PyTypeObject *base) 2123{ 2124 PyTypeObject *basebase; 2125 2126#undef SLOTDEFINED 2127#undef COPYSLOT 2128#undef COPYNUM 2129#undef COPYSEQ 2130#undef COPYMAP 2131#undef COPYBUF 2132 2133#define SLOTDEFINED(SLOT) \ 2134 (base->SLOT != 0 && \ 2135 (basebase == NULL || base->SLOT != basebase->SLOT)) 2136 2137#define COPYSLOT(SLOT) \ 2138 if (!type->SLOT && SLOTDEFINED(SLOT)) type->SLOT = base->SLOT 2139 2140#define COPYNUM(SLOT) COPYSLOT(tp_as_number->SLOT) 2141#define COPYSEQ(SLOT) COPYSLOT(tp_as_sequence->SLOT) 2142#define COPYMAP(SLOT) COPYSLOT(tp_as_mapping->SLOT) 2143#define COPYBUF(SLOT) COPYSLOT(tp_as_buffer->SLOT) 2144 2145 /* This won't inherit indirect slots (from tp_as_number etc.) 2146 if type doesn't provide the space. */ 2147 2148 if (type->tp_as_number != NULL && base->tp_as_number != NULL) { 2149 basebase = base->tp_base; 2150 if (basebase->tp_as_number == NULL) 2151 basebase = NULL; 2152 COPYNUM(nb_add); 2153 COPYNUM(nb_subtract); 2154 COPYNUM(nb_multiply); 2155 COPYNUM(nb_divide); 2156 COPYNUM(nb_remainder); 2157 COPYNUM(nb_divmod); 2158 COPYNUM(nb_power); 2159 COPYNUM(nb_negative); 2160 COPYNUM(nb_positive); 2161 COPYNUM(nb_absolute); 2162 COPYNUM(nb_nonzero); 2163 COPYNUM(nb_invert); 2164 COPYNUM(nb_lshift); 2165 COPYNUM(nb_rshift); 2166 COPYNUM(nb_and); 2167 COPYNUM(nb_xor); 2168 COPYNUM(nb_or); 2169 COPYNUM(nb_coerce); 2170 COPYNUM(nb_int); 2171 COPYNUM(nb_long); 2172 COPYNUM(nb_float); 2173 COPYNUM(nb_oct); 2174 COPYNUM(nb_hex); 2175 COPYNUM(nb_inplace_add); 2176 COPYNUM(nb_inplace_subtract); 2177 COPYNUM(nb_inplace_multiply); 2178 COPYNUM(nb_inplace_divide); 2179 COPYNUM(nb_inplace_remainder); 2180 COPYNUM(nb_inplace_power); 2181 COPYNUM(nb_inplace_lshift); 2182 COPYNUM(nb_inplace_rshift); 2183 COPYNUM(nb_inplace_and); 2184 COPYNUM(nb_inplace_xor); 2185 COPYNUM(nb_inplace_or); 2186 if (base->tp_flags & Py_TPFLAGS_CHECKTYPES) { 2187 COPYNUM(nb_true_divide); 2188 COPYNUM(nb_floor_divide); 2189 COPYNUM(nb_inplace_true_divide); 2190 COPYNUM(nb_inplace_floor_divide); 2191 } 2192 } 2193 2194 if (type->tp_as_sequence != NULL && base->tp_as_sequence != NULL) { 2195 basebase = base->tp_base; 2196 if (basebase->tp_as_sequence == NULL) 2197 basebase = NULL; 2198 COPYSEQ(sq_length); 2199 COPYSEQ(sq_concat); 2200 COPYSEQ(sq_repeat); 2201 COPYSEQ(sq_item); 2202 COPYSEQ(sq_slice); 2203 COPYSEQ(sq_ass_item); 2204 COPYSEQ(sq_ass_slice); 2205 COPYSEQ(sq_contains); 2206 COPYSEQ(sq_inplace_concat); 2207 COPYSEQ(sq_inplace_repeat); 2208 } 2209 2210 if (type->tp_as_mapping != NULL && base->tp_as_mapping != NULL) { 2211 basebase = base->tp_base; 2212 if (basebase->tp_as_mapping == NULL) 2213 basebase = NULL; 2214 COPYMAP(mp_length); 2215 COPYMAP(mp_subscript); 2216 COPYMAP(mp_ass_subscript); 2217 } 2218 2219 if (type->tp_as_buffer != NULL && base->tp_as_buffer != NULL) { 2220 basebase = base->tp_base; 2221 if (basebase->tp_as_buffer == NULL) 2222 basebase = NULL; 2223 COPYBUF(bf_getreadbuffer); 2224 COPYBUF(bf_getwritebuffer); 2225 COPYBUF(bf_getsegcount); 2226 COPYBUF(bf_getcharbuffer); 2227 } 2228 2229 basebase = base->tp_base; 2230 2231 COPYSLOT(tp_dealloc); 2232 COPYSLOT(tp_print); 2233 if (type->tp_getattr == NULL && type->tp_getattro == NULL) { 2234 type->tp_getattr = base->tp_getattr; 2235 type->tp_getattro = base->tp_getattro; 2236 } 2237 if (type->tp_setattr == NULL && type->tp_setattro == NULL) { 2238 type->tp_setattr = base->tp_setattr; 2239 type->tp_setattro = base->tp_setattro; 2240 } 2241 /* tp_compare see tp_richcompare */ 2242 COPYSLOT(tp_repr); 2243 /* tp_hash see tp_richcompare */ 2244 COPYSLOT(tp_call); 2245 COPYSLOT(tp_str); 2246 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE) { 2247 if (type->tp_compare == NULL && 2248 type->tp_richcompare == NULL && 2249 type->tp_hash == NULL) 2250 { 2251 type->tp_compare = base->tp_compare; 2252 type->tp_richcompare = base->tp_richcompare; 2253 type->tp_hash = base->tp_hash; 2254 } 2255 } 2256 else { 2257 COPYSLOT(tp_compare); 2258 } 2259 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_ITER) { 2260 COPYSLOT(tp_iter); 2261 COPYSLOT(tp_iternext); 2262 } 2263 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) { 2264 COPYSLOT(tp_descr_get); 2265 COPYSLOT(tp_descr_set); 2266 COPYSLOT(tp_dictoffset); 2267 COPYSLOT(tp_init); 2268 COPYSLOT(tp_alloc); 2269 COPYSLOT(tp_free); 2270 COPYSLOT(tp_is_gc); 2271 } 2272} 2273 2274static int add_operators(PyTypeObject *); 2275static int add_subclass(PyTypeObject *base, PyTypeObject *type); 2276 2277int 2278PyType_Ready(PyTypeObject *type) 2279{ 2280 PyObject *dict, *bases; 2281 PyTypeObject *base; 2282 int i, n; 2283 2284 if (type->tp_flags & Py_TPFLAGS_READY) { 2285 assert(type->tp_dict != NULL); 2286 return 0; 2287 } 2288 assert((type->tp_flags & Py_TPFLAGS_READYING) == 0); 2289 2290 type->tp_flags |= Py_TPFLAGS_READYING; 2291 2292 /* Initialize tp_base (defaults to BaseObject unless that's us) */ 2293 base = type->tp_base; 2294 if (base == NULL && type != &PyBaseObject_Type) 2295 base = type->tp_base = &PyBaseObject_Type; 2296 2297 /* Initialize the base class */ 2298 if (base && base->tp_dict == NULL) { 2299 if (PyType_Ready(base) < 0) 2300 goto error; 2301 } 2302 2303 /* Initialize ob_type if NULL. This means extensions that want to be 2304 compilable separately on Windows can call PyType_Ready() instead of 2305 initializing the ob_type field of their type objects. */ 2306 if (type->ob_type == NULL) 2307 type->ob_type = base->ob_type; 2308 2309 /* Initialize tp_bases */ 2310 bases = type->tp_bases; 2311 if (bases == NULL) { 2312 if (base == NULL) 2313 bases = PyTuple_New(0); 2314 else 2315 bases = Py_BuildValue("(O)", base); 2316 if (bases == NULL) 2317 goto error; 2318 type->tp_bases = bases; 2319 } 2320 2321 /* Initialize tp_dict */ 2322 dict = type->tp_dict; 2323 if (dict == NULL) { 2324 dict = PyDict_New(); 2325 if (dict == NULL) 2326 goto error; 2327 type->tp_dict = dict; 2328 } 2329 2330 /* Add type-specific descriptors to tp_dict */ 2331 if (add_operators(type) < 0) 2332 goto error; 2333 if (type->tp_methods != NULL) { 2334 if (add_methods(type, type->tp_methods) < 0) 2335 goto error; 2336 } 2337 if (type->tp_members != NULL) { 2338 if (add_members(type, type->tp_members) < 0) 2339 goto error; 2340 } 2341 if (type->tp_getset != NULL) { 2342 if (add_getset(type, type->tp_getset) < 0) 2343 goto error; 2344 } 2345 2346 /* Calculate method resolution order */ 2347 if (mro_internal(type) < 0) { 2348 goto error; 2349 } 2350 2351 /* Inherit special flags from dominant base */ 2352 if (type->tp_base != NULL) 2353 inherit_special(type, type->tp_base); 2354 2355 /* Initialize tp_dict properly */ 2356 bases = type->tp_mro; 2357 assert(bases != NULL); 2358 assert(PyTuple_Check(bases)); 2359 n = PyTuple_GET_SIZE(bases); 2360 for (i = 1; i < n; i++) { 2361 PyObject *b = PyTuple_GET_ITEM(bases, i); 2362 if (PyType_Check(b)) 2363 inherit_slots(type, (PyTypeObject *)b); 2364 } 2365 2366 /* if the type dictionary doesn't contain a __doc__, set it from 2367 the tp_doc slot. 2368 */ 2369 if (PyDict_GetItemString(type->tp_dict, "__doc__") == NULL) { 2370 if (type->tp_doc != NULL) { 2371 PyObject *doc = PyString_FromString(type->tp_doc); 2372 PyDict_SetItemString(type->tp_dict, "__doc__", doc); 2373 Py_DECREF(doc); 2374 } else { 2375 PyDict_SetItemString(type->tp_dict, 2376 "__doc__", Py_None); 2377 } 2378 } 2379 2380 /* Some more special stuff */ 2381 base = type->tp_base; 2382 if (base != NULL) { 2383 if (type->tp_as_number == NULL) 2384 type->tp_as_number = base->tp_as_number; 2385 if (type->tp_as_sequence == NULL) 2386 type->tp_as_sequence = base->tp_as_sequence; 2387 if (type->tp_as_mapping == NULL) 2388 type->tp_as_mapping = base->tp_as_mapping; 2389 } 2390 2391 /* Link into each base class's list of subclasses */ 2392 bases = type->tp_bases; 2393 n = PyTuple_GET_SIZE(bases); 2394 for (i = 0; i < n; i++) { 2395 PyObject *b = PyTuple_GET_ITEM(bases, i); 2396 if (PyType_Check(b) && 2397 add_subclass((PyTypeObject *)b, type) < 0) 2398 goto error; 2399 } 2400 2401 /* All done -- set the ready flag */ 2402 assert(type->tp_dict != NULL); 2403 type->tp_flags = 2404 (type->tp_flags & ~Py_TPFLAGS_READYING) | Py_TPFLAGS_READY; 2405 return 0; 2406 2407 error: 2408 type->tp_flags &= ~Py_TPFLAGS_READYING; 2409 return -1; 2410} 2411 2412static int 2413add_subclass(PyTypeObject *base, PyTypeObject *type) 2414{ 2415 int i; 2416 PyObject *list, *ref, *new; 2417 2418 list = base->tp_subclasses; 2419 if (list == NULL) { 2420 base->tp_subclasses = list = PyList_New(0); 2421 if (list == NULL) 2422 return -1; 2423 } 2424 assert(PyList_Check(list)); 2425 new = PyWeakref_NewRef((PyObject *)type, NULL); 2426 i = PyList_GET_SIZE(list); 2427 while (--i >= 0) { 2428 ref = PyList_GET_ITEM(list, i); 2429 assert(PyWeakref_CheckRef(ref)); 2430 if (PyWeakref_GET_OBJECT(ref) == Py_None) 2431 return PyList_SetItem(list, i, new); 2432 } 2433 i = PyList_Append(list, new); 2434 Py_DECREF(new); 2435 return i; 2436} 2437 2438 2439/* Generic wrappers for overloadable 'operators' such as __getitem__ */ 2440 2441/* There's a wrapper *function* for each distinct function typedef used 2442 for type object slots (e.g. binaryfunc, ternaryfunc, etc.). There's a 2443 wrapper *table* for each distinct operation (e.g. __len__, __add__). 2444 Most tables have only one entry; the tables for binary operators have two 2445 entries, one regular and one with reversed arguments. */ 2446 2447static PyObject * 2448wrap_inquiry(PyObject *self, PyObject *args, void *wrapped) 2449{ 2450 inquiry func = (inquiry)wrapped; 2451 int res; 2452 2453 if (!PyArg_ParseTuple(args, "")) 2454 return NULL; 2455 res = (*func)(self); 2456 if (res == -1 && PyErr_Occurred()) 2457 return NULL; 2458 return PyInt_FromLong((long)res); 2459} 2460 2461static PyObject * 2462wrap_binaryfunc(PyObject *self, PyObject *args, void *wrapped) 2463{ 2464 binaryfunc func = (binaryfunc)wrapped; 2465 PyObject *other; 2466 2467 if (!PyArg_ParseTuple(args, "O", &other)) 2468 return NULL; 2469 return (*func)(self, other); 2470} 2471 2472static PyObject * 2473wrap_binaryfunc_l(PyObject *self, PyObject *args, void *wrapped) 2474{ 2475 binaryfunc func = (binaryfunc)wrapped; 2476 PyObject *other; 2477 2478 if (!PyArg_ParseTuple(args, "O", &other)) 2479 return NULL; 2480 if (!(self->ob_type->tp_flags & Py_TPFLAGS_CHECKTYPES) && 2481 !PyType_IsSubtype(other->ob_type, self->ob_type)) { 2482 Py_INCREF(Py_NotImplemented); 2483 return Py_NotImplemented; 2484 } 2485 return (*func)(self, other); 2486} 2487 2488static PyObject * 2489wrap_binaryfunc_r(PyObject *self, PyObject *args, void *wrapped) 2490{ 2491 binaryfunc func = (binaryfunc)wrapped; 2492 PyObject *other; 2493 2494 if (!PyArg_ParseTuple(args, "O", &other)) 2495 return NULL; 2496 if (!(self->ob_type->tp_flags & Py_TPFLAGS_CHECKTYPES) && 2497 !PyType_IsSubtype(other->ob_type, self->ob_type)) { 2498 Py_INCREF(Py_NotImplemented); 2499 return Py_NotImplemented; 2500 } 2501 return (*func)(other, self); 2502} 2503 2504static PyObject * 2505wrap_coercefunc(PyObject *self, PyObject *args, void *wrapped) 2506{ 2507 coercion func = (coercion)wrapped; 2508 PyObject *other, *res; 2509 int ok; 2510 2511 if (!PyArg_ParseTuple(args, "O", &other)) 2512 return NULL; 2513 ok = func(&self, &other); 2514 if (ok < 0) 2515 return NULL; 2516 if (ok > 0) { 2517 Py_INCREF(Py_NotImplemented); 2518 return Py_NotImplemented; 2519 } 2520 res = PyTuple_New(2); 2521 if (res == NULL) { 2522 Py_DECREF(self); 2523 Py_DECREF(other); 2524 return NULL; 2525 } 2526 PyTuple_SET_ITEM(res, 0, self); 2527 PyTuple_SET_ITEM(res, 1, other); 2528 return res; 2529} 2530 2531static PyObject * 2532wrap_ternaryfunc(PyObject *self, PyObject *args, void *wrapped) 2533{ 2534 ternaryfunc func = (ternaryfunc)wrapped; 2535 PyObject *other; 2536 PyObject *third = Py_None; 2537 2538 /* Note: This wrapper only works for __pow__() */ 2539 2540 if (!PyArg_ParseTuple(args, "O|O", &other, &third)) 2541 return NULL; 2542 return (*func)(self, other, third); 2543} 2544 2545static PyObject * 2546wrap_ternaryfunc_r(PyObject *self, PyObject *args, void *wrapped) 2547{ 2548 ternaryfunc func = (ternaryfunc)wrapped; 2549 PyObject *other; 2550 PyObject *third = Py_None; 2551 2552 /* Note: This wrapper only works for __pow__() */ 2553 2554 if (!PyArg_ParseTuple(args, "O|O", &other, &third)) 2555 return NULL; 2556 return (*func)(other, self, third); 2557} 2558 2559static PyObject * 2560wrap_unaryfunc(PyObject *self, PyObject *args, void *wrapped) 2561{ 2562 unaryfunc func = (unaryfunc)wrapped; 2563 2564 if (!PyArg_ParseTuple(args, "")) 2565 return NULL; 2566 return (*func)(self); 2567} 2568 2569static PyObject * 2570wrap_intargfunc(PyObject *self, PyObject *args, void *wrapped) 2571{ 2572 intargfunc func = (intargfunc)wrapped; 2573 int i; 2574 2575 if (!PyArg_ParseTuple(args, "i", &i)) 2576 return NULL; 2577 return (*func)(self, i); 2578} 2579 2580static int 2581getindex(PyObject *self, PyObject *arg) 2582{ 2583 int i; 2584 2585 i = PyInt_AsLong(arg); 2586 if (i == -1 && PyErr_Occurred()) 2587 return -1; 2588 if (i < 0) { 2589 PySequenceMethods *sq = self->ob_type->tp_as_sequence; 2590 if (sq && sq->sq_length) { 2591 int n = (*sq->sq_length)(self); 2592 if (n < 0) 2593 return -1; 2594 i += n; 2595 } 2596 } 2597 return i; 2598} 2599 2600static PyObject * 2601wrap_sq_item(PyObject *self, PyObject *args, void *wrapped) 2602{ 2603 intargfunc func = (intargfunc)wrapped; 2604 PyObject *arg; 2605 int i; 2606 2607 if (PyTuple_GET_SIZE(args) == 1) { 2608 arg = PyTuple_GET_ITEM(args, 0); 2609 i = getindex(self, arg); 2610 if (i == -1 && PyErr_Occurred()) 2611 return NULL; 2612 return (*func)(self, i); 2613 } 2614 PyArg_ParseTuple(args, "O", &arg); 2615 assert(PyErr_Occurred()); 2616 return NULL; 2617} 2618 2619static PyObject * 2620wrap_intintargfunc(PyObject *self, PyObject *args, void *wrapped) 2621{ 2622 intintargfunc func = (intintargfunc)wrapped; 2623 int i, j; 2624 2625 if (!PyArg_ParseTuple(args, "ii", &i, &j)) 2626 return NULL; 2627 return (*func)(self, i, j); 2628} 2629 2630static PyObject * 2631wrap_sq_setitem(PyObject *self, PyObject *args, void *wrapped) 2632{ 2633 intobjargproc func = (intobjargproc)wrapped; 2634 int i, res; 2635 PyObject *arg, *value; 2636 2637 if (!PyArg_ParseTuple(args, "OO", &arg, &value)) 2638 return NULL; 2639 i = getindex(self, arg); 2640 if (i == -1 && PyErr_Occurred()) 2641 return NULL; 2642 res = (*func)(self, i, value); 2643 if (res == -1 && PyErr_Occurred()) 2644 return NULL; 2645 Py_INCREF(Py_None); 2646 return Py_None; 2647} 2648 2649static PyObject * 2650wrap_sq_delitem(PyObject *self, PyObject *args, void *wrapped) 2651{ 2652 intobjargproc func = (intobjargproc)wrapped; 2653 int i, res; 2654 PyObject *arg; 2655 2656 if (!PyArg_ParseTuple(args, "O", &arg)) 2657 return NULL; 2658 i = getindex(self, arg); 2659 if (i == -1 && PyErr_Occurred()) 2660 return NULL; 2661 res = (*func)(self, i, NULL); 2662 if (res == -1 && PyErr_Occurred()) 2663 return NULL; 2664 Py_INCREF(Py_None); 2665 return Py_None; 2666} 2667 2668static PyObject * 2669wrap_intintobjargproc(PyObject *self, PyObject *args, void *wrapped) 2670{ 2671 intintobjargproc func = (intintobjargproc)wrapped; 2672 int i, j, res; 2673 PyObject *value; 2674 2675 if (!PyArg_ParseTuple(args, "iiO", &i, &j, &value)) 2676 return NULL; 2677 res = (*func)(self, i, j, value); 2678 if (res == -1 && PyErr_Occurred()) 2679 return NULL; 2680 Py_INCREF(Py_None); 2681 return Py_None; 2682} 2683 2684static PyObject * 2685wrap_delslice(PyObject *self, PyObject *args, void *wrapped) 2686{ 2687 intintobjargproc func = (intintobjargproc)wrapped; 2688 int i, j, res; 2689 2690 if (!PyArg_ParseTuple(args, "ii", &i, &j)) 2691 return NULL; 2692 res = (*func)(self, i, j, NULL); 2693 if (res == -1 && PyErr_Occurred()) 2694 return NULL; 2695 Py_INCREF(Py_None); 2696 return Py_None; 2697} 2698 2699/* XXX objobjproc is a misnomer; should be objargpred */ 2700static PyObject * 2701wrap_objobjproc(PyObject *self, PyObject *args, void *wrapped) 2702{ 2703 objobjproc func = (objobjproc)wrapped; 2704 int res; 2705 PyObject *value; 2706 2707 if (!PyArg_ParseTuple(args, "O", &value)) 2708 return NULL; 2709 res = (*func)(self, value); 2710 if (res == -1 && PyErr_Occurred()) 2711 return NULL; 2712 return PyInt_FromLong((long)res); 2713} 2714 2715static PyObject * 2716wrap_objobjargproc(PyObject *self, PyObject *args, void *wrapped) 2717{ 2718 objobjargproc func = (objobjargproc)wrapped; 2719 int res; 2720 PyObject *key, *value; 2721 2722 if (!PyArg_ParseTuple(args, "OO", &key, &value)) 2723 return NULL; 2724 res = (*func)(self, key, value); 2725 if (res == -1 && PyErr_Occurred()) 2726 return NULL; 2727 Py_INCREF(Py_None); 2728 return Py_None; 2729} 2730 2731static PyObject * 2732wrap_delitem(PyObject *self, PyObject *args, void *wrapped) 2733{ 2734 objobjargproc func = (objobjargproc)wrapped; 2735 int res; 2736 PyObject *key; 2737 2738 if (!PyArg_ParseTuple(args, "O", &key)) 2739 return NULL; 2740 res = (*func)(self, key, NULL); 2741 if (res == -1 && PyErr_Occurred()) 2742 return NULL; 2743 Py_INCREF(Py_None); 2744 return Py_None; 2745} 2746 2747static PyObject * 2748wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped) 2749{ 2750 cmpfunc func = (cmpfunc)wrapped; 2751 int res; 2752 PyObject *other; 2753 2754 if (!PyArg_ParseTuple(args, "O", &other)) 2755 return NULL; 2756 if (other->ob_type->tp_compare != func && 2757 !PyType_IsSubtype(other->ob_type, self->ob_type)) { 2758 PyErr_Format( 2759 PyExc_TypeError, 2760 "%s.__cmp__(x,y) requires y to be a '%s', not a '%s'", 2761 self->ob_type->tp_name, 2762 self->ob_type->tp_name, 2763 other->ob_type->tp_name); 2764 return NULL; 2765 } 2766 res = (*func)(self, other); 2767 if (PyErr_Occurred()) 2768 return NULL; 2769 return PyInt_FromLong((long)res); 2770} 2771 2772static PyObject * 2773wrap_setattr(PyObject *self, PyObject *args, void *wrapped) 2774{ 2775 setattrofunc func = (setattrofunc)wrapped; 2776 int res; 2777 PyObject *name, *value; 2778 2779 if (!PyArg_ParseTuple(args, "OO", &name, &value)) 2780 return NULL; 2781 res = (*func)(self, name, value); 2782 if (res < 0) 2783 return NULL; 2784 Py_INCREF(Py_None); 2785 return Py_None; 2786} 2787 2788static PyObject * 2789wrap_delattr(PyObject *self, PyObject *args, void *wrapped) 2790{ 2791 setattrofunc func = (setattrofunc)wrapped; 2792 int res; 2793 PyObject *name; 2794 2795 if (!PyArg_ParseTuple(args, "O", &name)) 2796 return NULL; 2797 res = (*func)(self, name, NULL); 2798 if (res < 0) 2799 return NULL; 2800 Py_INCREF(Py_None); 2801 return Py_None; 2802} 2803 2804static PyObject * 2805wrap_hashfunc(PyObject *self, PyObject *args, void *wrapped) 2806{ 2807 hashfunc func = (hashfunc)wrapped; 2808 long res; 2809 2810 if (!PyArg_ParseTuple(args, "")) 2811 return NULL; 2812 res = (*func)(self); 2813 if (res == -1 && PyErr_Occurred()) 2814 return NULL; 2815 return PyInt_FromLong(res); 2816} 2817 2818static PyObject * 2819wrap_call(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds) 2820{ 2821 ternaryfunc func = (ternaryfunc)wrapped; 2822 2823 return (*func)(self, args, kwds); 2824} 2825 2826static PyObject * 2827wrap_richcmpfunc(PyObject *self, PyObject *args, void *wrapped, int op) 2828{ 2829 richcmpfunc func = (richcmpfunc)wrapped; 2830 PyObject *other; 2831 2832 if (!PyArg_ParseTuple(args, "O", &other)) 2833 return NULL; 2834 return (*func)(self, other, op); 2835} 2836 2837#undef RICHCMP_WRAPPER 2838#define RICHCMP_WRAPPER(NAME, OP) \ 2839static PyObject * \ 2840richcmp_##NAME(PyObject *self, PyObject *args, void *wrapped) \ 2841{ \ 2842 return wrap_richcmpfunc(self, args, wrapped, OP); \ 2843} 2844 2845RICHCMP_WRAPPER(lt, Py_LT) 2846RICHCMP_WRAPPER(le, Py_LE) 2847RICHCMP_WRAPPER(eq, Py_EQ) 2848RICHCMP_WRAPPER(ne, Py_NE) 2849RICHCMP_WRAPPER(gt, Py_GT) 2850RICHCMP_WRAPPER(ge, Py_GE) 2851 2852static PyObject * 2853wrap_next(PyObject *self, PyObject *args, void *wrapped) 2854{ 2855 unaryfunc func = (unaryfunc)wrapped; 2856 PyObject *res; 2857 2858 if (!PyArg_ParseTuple(args, "")) 2859 return NULL; 2860 res = (*func)(self); 2861 if (res == NULL && !PyErr_Occurred()) 2862 PyErr_SetNone(PyExc_StopIteration); 2863 return res; 2864} 2865 2866static PyObject * 2867wrap_descr_get(PyObject *self, PyObject *args, void *wrapped) 2868{ 2869 descrgetfunc func = (descrgetfunc)wrapped; 2870 PyObject *obj; 2871 PyObject *type = NULL; 2872 2873 if (!PyArg_ParseTuple(args, "O|O", &obj, &type)) 2874 return NULL; 2875 return (*func)(self, obj, type); 2876} 2877 2878static PyObject * 2879wrap_descr_set(PyObject *self, PyObject *args, void *wrapped) 2880{ 2881 descrsetfunc func = (descrsetfunc)wrapped; 2882 PyObject *obj, *value; 2883 int ret; 2884 2885 if (!PyArg_ParseTuple(args, "OO", &obj, &value)) 2886 return NULL; 2887 ret = (*func)(self, obj, value); 2888 if (ret < 0) 2889 return NULL; 2890 Py_INCREF(Py_None); 2891 return Py_None; 2892} 2893 2894static PyObject * 2895wrap_descr_delete(PyObject *self, PyObject *args, void *wrapped) 2896{ 2897 descrsetfunc func = (descrsetfunc)wrapped; 2898 PyObject *obj; 2899 int ret; 2900 2901 if (!PyArg_ParseTuple(args, "O", &obj)) 2902 return NULL; 2903 ret = (*func)(self, obj, NULL); 2904 if (ret < 0) 2905 return NULL; 2906 Py_INCREF(Py_None); 2907 return Py_None; 2908} 2909 2910static PyObject * 2911wrap_init(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds) 2912{ 2913 initproc func = (initproc)wrapped; 2914 2915 if (func(self, args, kwds) < 0) 2916 return NULL; 2917 Py_INCREF(Py_None); 2918 return Py_None; 2919} 2920 2921static PyObject * 2922tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds) 2923{ 2924 PyTypeObject *type, *subtype, *staticbase; 2925 PyObject *arg0, *res; 2926 2927 if (self == NULL || !PyType_Check(self)) 2928 Py_FatalError("__new__() called with non-type 'self'"); 2929 type = (PyTypeObject *)self; 2930 if (!PyTuple_Check(args) || PyTuple_GET_SIZE(args) < 1) { 2931 PyErr_Format(PyExc_TypeError, 2932 "%s.__new__(): not enough arguments", 2933 type->tp_name); 2934 return NULL; 2935 } 2936 arg0 = PyTuple_GET_ITEM(args, 0); 2937 if (!PyType_Check(arg0)) { 2938 PyErr_Format(PyExc_TypeError, 2939 "%s.__new__(X): X is not a type object (%s)", 2940 type->tp_name, 2941 arg0->ob_type->tp_name); 2942 return NULL; 2943 } 2944 subtype = (PyTypeObject *)arg0; 2945 if (!PyType_IsSubtype(subtype, type)) { 2946 PyErr_Format(PyExc_TypeError, 2947 "%s.__new__(%s): %s is not a subtype of %s", 2948 type->tp_name, 2949 subtype->tp_name, 2950 subtype->tp_name, 2951 type->tp_name); 2952 return NULL; 2953 } 2954 2955 /* Check that the use doesn't do something silly and unsafe like 2956 object.__new__(dict). To do this, we check that the 2957 most derived base that's not a heap type is this type. */ 2958 staticbase = subtype; 2959 while (staticbase && (staticbase->tp_flags & Py_TPFLAGS_HEAPTYPE)) 2960 staticbase = staticbase->tp_base; 2961 if (staticbase->tp_new != type->tp_new) { 2962 PyErr_Format(PyExc_TypeError, 2963 "%s.__new__(%s) is not safe, use %s.__new__()", 2964 type->tp_name, 2965 subtype->tp_name, 2966 staticbase == NULL ? "?" : staticbase->tp_name); 2967 return NULL; 2968 } 2969 2970 args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args)); 2971 if (args == NULL) 2972 return NULL; 2973 res = type->tp_new(subtype, args, kwds); 2974 Py_DECREF(args); 2975 return res; 2976} 2977 2978static struct PyMethodDef tp_new_methoddef[] = { 2979 {"__new__", (PyCFunction)tp_new_wrapper, METH_KEYWORDS, 2980 PyDoc_STR("T.__new__(S, ...) -> " 2981 "a new object with type S, a subtype of T")}, 2982 {0} 2983}; 2984 2985static int 2986add_tp_new_wrapper(PyTypeObject *type) 2987{ 2988 PyObject *func; 2989 2990 if (PyDict_GetItemString(type->tp_dict, "__new__") != NULL) 2991 return 0; 2992 func = PyCFunction_New(tp_new_methoddef, (PyObject *)type); 2993 if (func == NULL) 2994 return -1; 2995 return PyDict_SetItemString(type->tp_dict, "__new__", func); 2996} 2997 2998/* Slot wrappers that call the corresponding __foo__ slot. See comments 2999 below at override_slots() for more explanation. */ 3000 3001#define SLOT0(FUNCNAME, OPSTR) \ 3002static PyObject * \ 3003FUNCNAME(PyObject *self) \ 3004{ \ 3005 static PyObject *cache_str; \ 3006 return call_method(self, OPSTR, &cache_str, "()"); \ 3007} 3008 3009#define SLOT1(FUNCNAME, OPSTR, ARG1TYPE, ARGCODES) \ 3010static PyObject * \ 3011FUNCNAME(PyObject *self, ARG1TYPE arg1) \ 3012{ \ 3013 static PyObject *cache_str; \ 3014 return call_method(self, OPSTR, &cache_str, "(" ARGCODES ")", arg1); \ 3015} 3016 3017 3018#define SLOT1BINFULL(FUNCNAME, TESTFUNC, SLOTNAME, OPSTR, ROPSTR) \ 3019static PyObject * \ 3020FUNCNAME(PyObject *self, PyObject *other) \ 3021{ \ 3022 static PyObject *cache_str, *rcache_str; \ 3023 int do_other = self->ob_type != other->ob_type && \ 3024 other->ob_type->tp_as_number != NULL && \ 3025 other->ob_type->tp_as_number->SLOTNAME == TESTFUNC; \ 3026 if (self->ob_type->tp_as_number != NULL && \ 3027 self->ob_type->tp_as_number->SLOTNAME == TESTFUNC) { \ 3028 PyObject *r; \ 3029 if (do_other && \ 3030 PyType_IsSubtype(other->ob_type, self->ob_type)) { \ 3031 r = call_maybe( \ 3032 other, ROPSTR, &rcache_str, "(O)", self); \ 3033 if (r != Py_NotImplemented) \ 3034 return r; \ 3035 Py_DECREF(r); \ 3036 do_other = 0; \ 3037 } \ 3038 r = call_maybe( \ 3039 self, OPSTR, &cache_str, "(O)", other); \ 3040 if (r != Py_NotImplemented || \ 3041 other->ob_type == self->ob_type) \ 3042 return r; \ 3043 Py_DECREF(r); \ 3044 } \ 3045 if (do_other) { \ 3046 return call_maybe( \ 3047 other, ROPSTR, &rcache_str, "(O)", self); \ 3048 } \ 3049 Py_INCREF(Py_NotImplemented); \ 3050 return Py_NotImplemented; \ 3051} 3052 3053#define SLOT1BIN(FUNCNAME, SLOTNAME, OPSTR, ROPSTR) \ 3054 SLOT1BINFULL(FUNCNAME, FUNCNAME, SLOTNAME, OPSTR, ROPSTR) 3055 3056#define SLOT2(FUNCNAME, OPSTR, ARG1TYPE, ARG2TYPE, ARGCODES) \ 3057static PyObject * \ 3058FUNCNAME(PyObject *self, ARG1TYPE arg1, ARG2TYPE arg2) \ 3059{ \ 3060 static PyObject *cache_str; \ 3061 return call_method(self, OPSTR, &cache_str, \ 3062 "(" ARGCODES ")", arg1, arg2); \ 3063} 3064 3065static int 3066slot_sq_length(PyObject *self) 3067{ 3068 static PyObject *len_str; 3069 PyObject *res = call_method(self, "__len__", &len_str, "()"); 3070 int len; 3071 3072 if (res == NULL) 3073 return -1; 3074 len = (int)PyInt_AsLong(res); 3075 Py_DECREF(res); 3076 if (len == -1 && PyErr_Occurred()) 3077 return -1; 3078 if (len < 0) { 3079 PyErr_SetString(PyExc_ValueError, 3080 "__len__() should return >= 0"); 3081 return -1; 3082 } 3083 return len; 3084} 3085 3086SLOT1(slot_sq_concat, "__add__", PyObject *, "O") 3087SLOT1(slot_sq_repeat, "__mul__", int, "i") 3088 3089/* Super-optimized version of slot_sq_item. 3090 Other slots could do the same... */ 3091static PyObject * 3092slot_sq_item(PyObject *self, int i) 3093{ 3094 static PyObject *getitem_str; 3095 PyObject *func, *args = NULL, *ival = NULL, *retval = NULL; 3096 descrgetfunc f; 3097 3098 if (getitem_str == NULL) { 3099 getitem_str = PyString_InternFromString("__getitem__"); 3100 if (getitem_str == NULL) 3101 return NULL; 3102 } 3103 func = _PyType_Lookup(self->ob_type, getitem_str); 3104 if (func != NULL) { 3105 if ((f = func->ob_type->tp_descr_get) == NULL) 3106 Py_INCREF(func); 3107 else 3108 func = f(func, self, (PyObject *)(self->ob_type)); 3109 ival = PyInt_FromLong(i); 3110 if (ival != NULL) { 3111 args = PyTuple_New(1); 3112 if (args != NULL) { 3113 PyTuple_SET_ITEM(args, 0, ival); 3114 retval = PyObject_Call(func, args, NULL); 3115 Py_XDECREF(args); 3116 Py_XDECREF(func); 3117 return retval; 3118 } 3119 } 3120 } 3121 else { 3122 PyErr_SetObject(PyExc_AttributeError, getitem_str); 3123 } 3124 Py_XDECREF(args); 3125 Py_XDECREF(ival); 3126 Py_XDECREF(func); 3127 return NULL; 3128} 3129 3130SLOT2(slot_sq_slice, "__getslice__", int, int, "ii") 3131 3132static int 3133slot_sq_ass_item(PyObject *self, int index, PyObject *value) 3134{ 3135 PyObject *res; 3136 static PyObject *delitem_str, *setitem_str; 3137 3138 if (value == NULL) 3139 res = call_method(self, "__delitem__", &delitem_str, 3140 "(i)", index); 3141 else 3142 res = call_method(self, "__setitem__", &setitem_str, 3143 "(iO)", index, value); 3144 if (res == NULL) 3145 return -1; 3146 Py_DECREF(res); 3147 return 0; 3148} 3149 3150static int 3151slot_sq_ass_slice(PyObject *self, int i, int j, PyObject *value) 3152{ 3153 PyObject *res; 3154 static PyObject *delslice_str, *setslice_str; 3155 3156 if (value == NULL) 3157 res = call_method(self, "__delslice__", &delslice_str, 3158 "(ii)", i, j); 3159 else 3160 res = call_method(self, "__setslice__", &setslice_str, 3161 "(iiO)", i, j, value); 3162 if (res == NULL) 3163 return -1; 3164 Py_DECREF(res); 3165 return 0; 3166} 3167 3168static int 3169slot_sq_contains(PyObject *self, PyObject *value) 3170{ 3171 PyObject *func, *res, *args; 3172 static PyObject *contains_str; 3173 3174 func = lookup_maybe(self, "__contains__", &contains_str); 3175 3176 if (func != NULL) { 3177 args = Py_BuildValue("(O)", value); 3178 if (args == NULL) 3179 res = NULL; 3180 else { 3181 res = PyObject_Call(func, args, NULL); 3182 Py_DECREF(args); 3183 } 3184 Py_DECREF(func); 3185 if (res == NULL) 3186 return -1; 3187 return PyObject_IsTrue(res); 3188 } 3189 else if (PyErr_Occurred()) 3190 return -1; 3191 else { 3192 return _PySequence_IterSearch(self, value, 3193 PY_ITERSEARCH_CONTAINS); 3194 } 3195} 3196 3197SLOT1(slot_sq_inplace_concat, "__iadd__", PyObject *, "O") 3198SLOT1(slot_sq_inplace_repeat, "__imul__", int, "i") 3199 3200#define slot_mp_length slot_sq_length 3201 3202SLOT1(slot_mp_subscript, "__getitem__", PyObject *, "O") 3203 3204static int 3205slot_mp_ass_subscript(PyObject *self, PyObject *key, PyObject *value) 3206{ 3207 PyObject *res; 3208 static PyObject *delitem_str, *setitem_str; 3209 3210 if (value == NULL) 3211 res = call_method(self, "__delitem__", &delitem_str, 3212 "(O)", key); 3213 else 3214 res = call_method(self, "__setitem__", &setitem_str, 3215 "(OO)", key, value); 3216 if (res == NULL) 3217 return -1; 3218 Py_DECREF(res); 3219 return 0; 3220} 3221 3222SLOT1BIN(slot_nb_add, nb_add, "__add__", "__radd__") 3223SLOT1BIN(slot_nb_subtract, nb_subtract, "__sub__", "__rsub__") 3224SLOT1BIN(slot_nb_multiply, nb_multiply, "__mul__", "__rmul__") 3225SLOT1BIN(slot_nb_divide, nb_divide, "__div__", "__rdiv__") 3226SLOT1BIN(slot_nb_remainder, nb_remainder, "__mod__", "__rmod__") 3227SLOT1BIN(slot_nb_divmod, nb_divmod, "__divmod__", "__rdivmod__") 3228 3229static PyObject *slot_nb_power(PyObject *, PyObject *, PyObject *); 3230 3231SLOT1BINFULL(slot_nb_power_binary, slot_nb_power, 3232 nb_power, "__pow__", "__rpow__") 3233 3234static PyObject * 3235slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus) 3236{ 3237 static PyObject *pow_str; 3238 3239 if (modulus == Py_None) 3240 return slot_nb_power_binary(self, other); 3241 /* Three-arg power doesn't use __rpow__. But ternary_op 3242 can call this when the second argument's type uses 3243 slot_nb_power, so check before calling self.__pow__. */ 3244 if (self->ob_type->tp_as_number != NULL && 3245 self->ob_type->tp_as_number->nb_power == slot_nb_power) { 3246 return call_method(self, "__pow__", &pow_str, 3247 "(OO)", other, modulus); 3248 } 3249 Py_INCREF(Py_NotImplemented); 3250 return Py_NotImplemented; 3251} 3252 3253SLOT0(slot_nb_negative, "__neg__") 3254SLOT0(slot_nb_positive, "__pos__") 3255SLOT0(slot_nb_absolute, "__abs__") 3256 3257static int 3258slot_nb_nonzero(PyObject *self) 3259{ 3260 PyObject *func, *res; 3261 static PyObject *nonzero_str, *len_str; 3262 3263 func = lookup_maybe(self, "__nonzero__", &nonzero_str); 3264 if (func == NULL) { 3265 if (PyErr_Occurred()) 3266 return -1; 3267 func = lookup_maybe(self, "__len__", &len_str); 3268 if (func == NULL) { 3269 if (PyErr_Occurred()) 3270 return -1; 3271 else 3272 return 1; 3273 } 3274 } 3275 res = PyObject_CallObject(func, NULL); 3276 Py_DECREF(func); 3277 if (res == NULL) 3278 return -1; 3279 return PyObject_IsTrue(res); 3280} 3281 3282SLOT0(slot_nb_invert, "__invert__") 3283SLOT1BIN(slot_nb_lshift, nb_lshift, "__lshift__", "__rlshift__") 3284SLOT1BIN(slot_nb_rshift, nb_rshift, "__rshift__", "__rrshift__") 3285SLOT1BIN(slot_nb_and, nb_and, "__and__", "__rand__") 3286SLOT1BIN(slot_nb_xor, nb_xor, "__xor__", "__rxor__") 3287SLOT1BIN(slot_nb_or, nb_or, "__or__", "__ror__") 3288 3289static int 3290slot_nb_coerce(PyObject **a, PyObject **b) 3291{ 3292 static PyObject *coerce_str; 3293 PyObject *self = *a, *other = *b; 3294 3295 if (self->ob_type->tp_as_number != NULL && 3296 self->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) { 3297 PyObject *r; 3298 r = call_maybe( 3299 self, "__coerce__", &coerce_str, "(O)", other); 3300 if (r == NULL) 3301 return -1; 3302 if (r == Py_NotImplemented) { 3303 Py_DECREF(r); 3304 } 3305 else { 3306 if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) { 3307 PyErr_SetString(PyExc_TypeError, 3308 "__coerce__ didn't return a 2-tuple"); 3309 Py_DECREF(r); 3310 return -1; 3311 } 3312 *a = PyTuple_GET_ITEM(r, 0); 3313 Py_INCREF(*a); 3314 *b = PyTuple_GET_ITEM(r, 1); 3315 Py_INCREF(*b); 3316 Py_DECREF(r); 3317 return 0; 3318 } 3319 } 3320 if (other->ob_type->tp_as_number != NULL && 3321 other->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) { 3322 PyObject *r; 3323 r = call_maybe( 3324 other, "__coerce__", &coerce_str, "(O)", self); 3325 if (r == NULL) 3326 return -1; 3327 if (r == Py_NotImplemented) { 3328 Py_DECREF(r); 3329 return 1; 3330 } 3331 if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) { 3332 PyErr_SetString(PyExc_TypeError, 3333 "__coerce__ didn't return a 2-tuple"); 3334 Py_DECREF(r); 3335 return -1; 3336 } 3337 *a = PyTuple_GET_ITEM(r, 1); 3338 Py_INCREF(*a); 3339 *b = PyTuple_GET_ITEM(r, 0); 3340 Py_INCREF(*b); 3341 Py_DECREF(r); 3342 return 0; 3343 } 3344 return 1; 3345} 3346 3347SLOT0(slot_nb_int, "__int__") 3348SLOT0(slot_nb_long, "__long__") 3349SLOT0(slot_nb_float, "__float__") 3350SLOT0(slot_nb_oct, "__oct__") 3351SLOT0(slot_nb_hex, "__hex__") 3352SLOT1(slot_nb_inplace_add, "__iadd__", PyObject *, "O") 3353SLOT1(slot_nb_inplace_subtract, "__isub__", PyObject *, "O") 3354SLOT1(slot_nb_inplace_multiply, "__imul__", PyObject *, "O") 3355SLOT1(slot_nb_inplace_divide, "__idiv__", PyObject *, "O") 3356SLOT1(slot_nb_inplace_remainder, "__imod__", PyObject *, "O") 3357SLOT2(slot_nb_inplace_power, "__ipow__", PyObject *, PyObject *, "OO") 3358SLOT1(slot_nb_inplace_lshift, "__ilshift__", PyObject *, "O") 3359SLOT1(slot_nb_inplace_rshift, "__irshift__", PyObject *, "O") 3360SLOT1(slot_nb_inplace_and, "__iand__", PyObject *, "O") 3361SLOT1(slot_nb_inplace_xor, "__ixor__", PyObject *, "O") 3362SLOT1(slot_nb_inplace_or, "__ior__", PyObject *, "O") 3363SLOT1BIN(slot_nb_floor_divide, nb_floor_divide, 3364 "__floordiv__", "__rfloordiv__") 3365SLOT1BIN(slot_nb_true_divide, nb_true_divide, "__truediv__", "__rtruediv__") 3366SLOT1(slot_nb_inplace_floor_divide, "__ifloordiv__", PyObject *, "O") 3367SLOT1(slot_nb_inplace_true_divide, "__itruediv__", PyObject *, "O") 3368 3369static int 3370half_compare(PyObject *self, PyObject *other) 3371{ 3372 PyObject *func, *args, *res; 3373 static PyObject *cmp_str; 3374 int c; 3375 3376 func = lookup_method(self, "__cmp__", &cmp_str); 3377 if (func == NULL) { 3378 PyErr_Clear(); 3379 } 3380 else { 3381 args = Py_BuildValue("(O)", other); 3382 if (args == NULL) 3383 res = NULL; 3384 else { 3385 res = PyObject_Call(func, args, NULL); 3386 Py_DECREF(args); 3387 } 3388 Py_DECREF(func); 3389 if (res != Py_NotImplemented) { 3390 if (res == NULL) 3391 return -2; 3392 c = PyInt_AsLong(res); 3393 Py_DECREF(res); 3394 if (c == -1 && PyErr_Occurred()) 3395 return -2; 3396 return (c < 0) ? -1 : (c > 0) ? 1 : 0; 3397 } 3398 Py_DECREF(res); 3399 } 3400 return 2; 3401} 3402 3403/* This slot is published for the benefit of try_3way_compare in object.c */ 3404int 3405_PyObject_SlotCompare(PyObject *self, PyObject *other) 3406{ 3407 int c; 3408 3409 if (self->ob_type->tp_compare == _PyObject_SlotCompare) { 3410 c = half_compare(self, other); 3411 if (c <= 1) 3412 return c; 3413 } 3414 if (other->ob_type->tp_compare == _PyObject_SlotCompare) { 3415 c = half_compare(other, self); 3416 if (c < -1) 3417 return -2; 3418 if (c <= 1) 3419 return -c; 3420 } 3421 return (void *)self < (void *)other ? -1 : 3422 (void *)self > (void *)other ? 1 : 0; 3423} 3424 3425static PyObject * 3426slot_tp_repr(PyObject *self) 3427{ 3428 PyObject *func, *res; 3429 static PyObject *repr_str; 3430 3431 func = lookup_method(self, "__repr__", &repr_str); 3432 if (func != NULL) { 3433 res = PyEval_CallObject(func, NULL); 3434 Py_DECREF(func); 3435 return res; 3436 } 3437 PyErr_Clear(); 3438 return PyString_FromFormat("<%s object at %p>", 3439 self->ob_type->tp_name, self); 3440} 3441 3442static PyObject * 3443slot_tp_str(PyObject *self) 3444{ 3445 PyObject *func, *res; 3446 static PyObject *str_str; 3447 3448 func = lookup_method(self, "__str__", &str_str); 3449 if (func != NULL) { 3450 res = PyEval_CallObject(func, NULL); 3451 Py_DECREF(func); 3452 return res; 3453 } 3454 else { 3455 PyErr_Clear(); 3456 return slot_tp_repr(self); 3457 } 3458} 3459 3460static long 3461slot_tp_hash(PyObject *self) 3462{ 3463 PyObject *func, *res; 3464 static PyObject *hash_str, *eq_str, *cmp_str; 3465 3466 long h; 3467 3468 func = lookup_method(self, "__hash__", &hash_str); 3469 3470 if (func != NULL) { 3471 res = PyEval_CallObject(func, NULL); 3472 Py_DECREF(func); 3473 if (res == NULL) 3474 return -1; 3475 h = PyInt_AsLong(res); 3476 } 3477 else { 3478 PyErr_Clear(); 3479 func = lookup_method(self, "__eq__", &eq_str); 3480 if (func == NULL) { 3481 PyErr_Clear(); 3482 func = lookup_method(self, "__cmp__", &cmp_str); 3483 } 3484 if (func != NULL) { 3485 Py_DECREF(func); 3486 PyErr_SetString(PyExc_TypeError, "unhashable type"); 3487 return -1; 3488 } 3489 PyErr_Clear(); 3490 h = _Py_HashPointer((void *)self); 3491 } 3492 if (h == -1 && !PyErr_Occurred()) 3493 h = -2; 3494 return h; 3495} 3496 3497static PyObject * 3498slot_tp_call(PyObject *self, PyObject *args, PyObject *kwds) 3499{ 3500 static PyObject *call_str; 3501 PyObject *meth = lookup_method(self, "__call__", &call_str); 3502 PyObject *res; 3503 3504 if (meth == NULL) 3505 return NULL; 3506 res = PyObject_Call(meth, args, kwds); 3507 Py_DECREF(meth); 3508 return res; 3509} 3510 3511/* There are two slot dispatch functions for tp_getattro. 3512 3513 - slot_tp_getattro() is used when __getattribute__ is overridden 3514 but no __getattr__ hook is present; 3515 3516 - slot_tp_getattr_hook() is used when a __getattr__ hook is present. 3517 3518 The code in update_one_slot() always installs slot_tp_getattr_hook(); this 3519 detects the absence of __getattr__ and then installs the simpler slot if 3520 necessary. */ 3521 3522static PyObject * 3523slot_tp_getattro(PyObject *self, PyObject *name) 3524{ 3525 static PyObject *getattribute_str = NULL; 3526 return call_method(self, "__getattribute__", &getattribute_str, 3527 "(O)", name); 3528} 3529 3530static PyObject * 3531slot_tp_getattr_hook(PyObject *self, PyObject *name) 3532{ 3533 PyTypeObject *tp = self->ob_type; 3534 PyObject *getattr, *getattribute, *res; 3535 static PyObject *getattribute_str = NULL; 3536 static PyObject *getattr_str = NULL; 3537 3538 if (getattr_str == NULL) { 3539 getattr_str = PyString_InternFromString("__getattr__"); 3540 if (getattr_str == NULL) 3541 return NULL; 3542 } 3543 if (getattribute_str == NULL) { 3544 getattribute_str = 3545 PyString_InternFromString("__getattribute__"); 3546 if (getattribute_str == NULL) 3547 return NULL; 3548 } 3549 getattr = _PyType_Lookup(tp, getattr_str); 3550 if (getattr == NULL) { 3551 /* No __getattr__ hook: use a simpler dispatcher */ 3552 tp->tp_getattro = slot_tp_getattro; 3553 return slot_tp_getattro(self, name); 3554 } 3555 getattribute = _PyType_Lookup(tp, getattribute_str); 3556 if (getattribute == NULL || 3557 (getattribute->ob_type == &PyWrapperDescr_Type && 3558 ((PyWrapperDescrObject *)getattribute)->d_wrapped == 3559 (void *)PyObject_GenericGetAttr)) 3560 res = PyObject_GenericGetAttr(self, name); 3561 else 3562 res = PyObject_CallFunction(getattribute, "OO", self, name); 3563 if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) { 3564 PyErr_Clear(); 3565 res = PyObject_CallFunction(getattr, "OO", self, name); 3566 } 3567 return res; 3568} 3569 3570static int 3571slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value) 3572{ 3573 PyObject *res; 3574 static PyObject *delattr_str, *setattr_str; 3575 3576 if (value == NULL) 3577 res = call_method(self, "__delattr__", &delattr_str, 3578 "(O)", name); 3579 else 3580 res = call_method(self, "__setattr__", &setattr_str, 3581 "(OO)", name, value); 3582 if (res == NULL) 3583 return -1; 3584 Py_DECREF(res); 3585 return 0; 3586} 3587 3588/* Map rich comparison operators to their __xx__ namesakes */ 3589static char *name_op[] = { 3590 "__lt__", 3591 "__le__", 3592 "__eq__", 3593 "__ne__", 3594 "__gt__", 3595 "__ge__", 3596}; 3597 3598static PyObject * 3599half_richcompare(PyObject *self, PyObject *other, int op) 3600{ 3601 PyObject *func, *args, *res; 3602 static PyObject *op_str[6]; 3603 3604 func = lookup_method(self, name_op[op], &op_str[op]); 3605 if (func == NULL) { 3606 PyErr_Clear(); 3607 Py_INCREF(Py_NotImplemented); 3608 return Py_NotImplemented; 3609 } 3610 args = Py_BuildValue("(O)", other); 3611 if (args == NULL) 3612 res = NULL; 3613 else { 3614 res = PyObject_Call(func, args, NULL); 3615 Py_DECREF(args); 3616 } 3617 Py_DECREF(func); 3618 return res; 3619} 3620 3621/* Map rich comparison operators to their swapped version, e.g. LT --> GT */ 3622static int swapped_op[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE}; 3623 3624static PyObject * 3625slot_tp_richcompare(PyObject *self, PyObject *other, int op) 3626{ 3627 PyObject *res; 3628 3629 if (self->ob_type->tp_richcompare == slot_tp_richcompare) { 3630 res = half_richcompare(self, other, op); 3631 if (res != Py_NotImplemented) 3632 return res; 3633 Py_DECREF(res); 3634 } 3635 if (other->ob_type->tp_richcompare == slot_tp_richcompare) { 3636 res = half_richcompare(other, self, swapped_op[op]); 3637 if (res != Py_NotImplemented) { 3638 return res; 3639 } 3640 Py_DECREF(res); 3641 } 3642 Py_INCREF(Py_NotImplemented); 3643 return Py_NotImplemented; 3644} 3645 3646static PyObject * 3647slot_tp_iter(PyObject *self) 3648{ 3649 PyObject *func, *res; 3650 static PyObject *iter_str, *getitem_str; 3651 3652 func = lookup_method(self, "__iter__", &iter_str); 3653 if (func != NULL) { 3654 res = PyObject_CallObject(func, NULL); 3655 Py_DECREF(func); 3656 return res; 3657 } 3658 PyErr_Clear(); 3659 func = lookup_method(self, "__getitem__", &getitem_str); 3660 if (func == NULL) { 3661 PyErr_SetString(PyExc_TypeError, 3662 "iteration over non-sequence"); 3663 return NULL; 3664 } 3665 Py_DECREF(func); 3666 return PySeqIter_New(self); 3667} 3668 3669static PyObject * 3670slot_tp_iternext(PyObject *self) 3671{ 3672 static PyObject *next_str; 3673 return call_method(self, "next", &next_str, "()"); 3674} 3675 3676static PyObject * 3677slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type) 3678{ 3679 PyTypeObject *tp = self->ob_type; 3680 PyObject *get; 3681 static PyObject *get_str = NULL; 3682 3683 if (get_str == NULL) { 3684 get_str = PyString_InternFromString("__get__"); 3685 if (get_str == NULL) 3686 return NULL; 3687 } 3688 get = _PyType_Lookup(tp, get_str); 3689 if (get == NULL) { 3690 /* Avoid further slowdowns */ 3691 if (tp->tp_descr_get == slot_tp_descr_get) 3692 tp->tp_descr_get = NULL; 3693 Py_INCREF(self); 3694 return self; 3695 } 3696 if (obj == NULL) 3697 obj = Py_None; 3698 if (type == NULL) 3699 type = Py_None; 3700 return PyObject_CallFunction(get, "OOO", self, obj, type); 3701} 3702 3703static int 3704slot_tp_descr_set(PyObject *self, PyObject *target, PyObject *value) 3705{ 3706 PyObject *res; 3707 static PyObject *del_str, *set_str; 3708 3709 if (value == NULL) 3710 res = call_method(self, "__delete__", &del_str, 3711 "(O)", target); 3712 else 3713 res = call_method(self, "__set__", &set_str, 3714 "(OO)", target, value); 3715 if (res == NULL) 3716 return -1; 3717 Py_DECREF(res); 3718 return 0; 3719} 3720 3721static int 3722slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds) 3723{ 3724 static PyObject *init_str; 3725 PyObject *meth = lookup_method(self, "__init__", &init_str); 3726 PyObject *res; 3727 3728 if (meth == NULL) 3729 return -1; 3730 res = PyObject_Call(meth, args, kwds); 3731 Py_DECREF(meth); 3732 if (res == NULL) 3733 return -1; 3734 Py_DECREF(res); 3735 return 0; 3736} 3737 3738static PyObject * 3739slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 3740{ 3741 static PyObject *new_str; 3742 PyObject *func; 3743 PyObject *newargs, *x; 3744 int i, n; 3745 3746 if (new_str == NULL) { 3747 new_str = PyString_InternFromString("__new__"); 3748 if (new_str == NULL) 3749 return NULL; 3750 } 3751 func = PyObject_GetAttr((PyObject *)type, new_str); 3752 if (func == NULL) 3753 return NULL; 3754 assert(PyTuple_Check(args)); 3755 n = PyTuple_GET_SIZE(args); 3756 newargs = PyTuple_New(n+1); 3757 if (newargs == NULL) 3758 return NULL; 3759 Py_INCREF(type); 3760 PyTuple_SET_ITEM(newargs, 0, (PyObject *)type); 3761 for (i = 0; i < n; i++) { 3762 x = PyTuple_GET_ITEM(args, i); 3763 Py_INCREF(x); 3764 PyTuple_SET_ITEM(newargs, i+1, x); 3765 } 3766 x = PyObject_Call(func, newargs, kwds); 3767 Py_DECREF(newargs); 3768 Py_DECREF(func); 3769 return x; 3770} 3771 3772static void 3773slot_tp_del(PyObject *self) 3774{ 3775 static PyObject *del_str = NULL; 3776 PyObject *del, *res; 3777 PyObject *error_type, *error_value, *error_traceback; 3778 3779 /* Temporarily resurrect the object. */ 3780 assert(self->ob_refcnt == 0); 3781 self->ob_refcnt = 1; 3782 3783 /* Save the current exception, if any. */ 3784 PyErr_Fetch(&error_type, &error_value, &error_traceback); 3785 3786 /* Execute __del__ method, if any. */ 3787 del = lookup_maybe(self, "__del__", &del_str); 3788 if (del != NULL) { 3789 res = PyEval_CallObject(del, NULL); 3790 if (res == NULL) 3791 PyErr_WriteUnraisable(del); 3792 else 3793 Py_DECREF(res); 3794 Py_DECREF(del); 3795 } 3796 3797 /* Restore the saved exception. */ 3798 PyErr_Restore(error_type, error_value, error_traceback); 3799 3800 /* Undo the temporary resurrection; can't use DECREF here, it would 3801 * cause a recursive call. 3802 */ 3803 assert(self->ob_refcnt > 0); 3804 if (--self->ob_refcnt == 0) 3805 return; /* this is the normal path out */ 3806 3807 /* __del__ resurrected it! Make it look like the original Py_DECREF 3808 * never happened. 3809 */ 3810 { 3811 int refcnt = self->ob_refcnt; 3812 _Py_NewReference(self); 3813 self->ob_refcnt = refcnt; 3814 } 3815 assert(!PyType_IS_GC(self->ob_type) || 3816 _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); 3817 /* If Py_REF_DEBUG, the original decref dropped _Py_RefTotal, but 3818 * _Py_NewReference bumped it again, so that's a wash. 3819 * If Py_TRACE_REFS, _Py_NewReference re-added self to the object 3820 * chain, so no more to do there either. 3821 * If COUNT_ALLOCS, the original decref bumped tp_frees, and 3822 * _Py_NewReference bumped tp_allocs: both of those need to be 3823 * undone. 3824 */ 3825#ifdef COUNT_ALLOCS 3826 --self->ob_type->tp_frees; 3827 --self->ob_type->tp_allocs; 3828#endif 3829} 3830 3831 3832/* Table mapping __foo__ names to tp_foo offsets and slot_tp_foo wrapper 3833 functions. The offsets here are relative to the 'etype' structure, which 3834 incorporates the additional structures used for numbers, sequences and 3835 mappings. Note that multiple names may map to the same slot (e.g. __eq__, 3836 __ne__ etc. all map to tp_richcompare) and one name may map to multiple 3837 slots (e.g. __str__ affects tp_str as well as tp_repr). The table is 3838 terminated with an all-zero entry. (This table is further initialized and 3839 sorted in init_slotdefs() below.) */ 3840 3841typedef struct wrapperbase slotdef; 3842 3843#undef TPSLOT 3844#undef FLSLOT 3845#undef ETSLOT 3846#undef SQSLOT 3847#undef MPSLOT 3848#undef NBSLOT 3849#undef UNSLOT 3850#undef IBSLOT 3851#undef BINSLOT 3852#undef RBINSLOT 3853 3854#define TPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 3855 {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \ 3856 PyDoc_STR(DOC)} 3857#define FLSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC, FLAGS) \ 3858 {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \ 3859 PyDoc_STR(DOC), FLAGS} 3860#define ETSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 3861 {NAME, offsetof(etype, SLOT), (void *)(FUNCTION), WRAPPER, \ 3862 PyDoc_STR(DOC)} 3863#define SQSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 3864 ETSLOT(NAME, as_sequence.SLOT, FUNCTION, WRAPPER, DOC) 3865#define MPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 3866 ETSLOT(NAME, as_mapping.SLOT, FUNCTION, WRAPPER, DOC) 3867#define NBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 3868 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, DOC) 3869#define UNSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 3870 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \ 3871 "x." NAME "() <==> " DOC) 3872#define IBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \ 3873 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \ 3874 "x." NAME "(y) <==> x" DOC "y") 3875#define BINSLOT(NAME, SLOT, FUNCTION, DOC) \ 3876 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \ 3877 "x." NAME "(y) <==> x" DOC "y") 3878#define RBINSLOT(NAME, SLOT, FUNCTION, DOC) \ 3879 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \ 3880 "x." NAME "(y) <==> y" DOC "x") 3881 3882static slotdef slotdefs[] = { 3883 SQSLOT("__len__", sq_length, slot_sq_length, wrap_inquiry, 3884 "x.__len__() <==> len(x)"), 3885 SQSLOT("__add__", sq_concat, slot_sq_concat, wrap_binaryfunc, 3886 "x.__add__(y) <==> x+y"), 3887 SQSLOT("__mul__", sq_repeat, slot_sq_repeat, wrap_intargfunc, 3888 "x.__mul__(n) <==> x*n"), 3889 SQSLOT("__rmul__", sq_repeat, slot_sq_repeat, wrap_intargfunc, 3890 "x.__rmul__(n) <==> n*x"), 3891 SQSLOT("__getitem__", sq_item, slot_sq_item, wrap_sq_item, 3892 "x.__getitem__(y) <==> x[y]"), 3893 SQSLOT("__getslice__", sq_slice, slot_sq_slice, wrap_intintargfunc, 3894 "x.__getslice__(i, j) <==> x[i:j]"), 3895 SQSLOT("__setitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_setitem, 3896 "x.__setitem__(i, y) <==> x[i]=y"), 3897 SQSLOT("__delitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_delitem, 3898 "x.__delitem__(y) <==> del x[y]"), 3899 SQSLOT("__setslice__", sq_ass_slice, slot_sq_ass_slice, 3900 wrap_intintobjargproc, 3901 "x.__setslice__(i, j, y) <==> x[i:j]=y"), 3902 SQSLOT("__delslice__", sq_ass_slice, slot_sq_ass_slice, wrap_delslice, 3903 "x.__delslice__(i, j) <==> del x[i:j]"), 3904 SQSLOT("__contains__", sq_contains, slot_sq_contains, wrap_objobjproc, 3905 "x.__contains__(y) <==> y in x"), 3906 SQSLOT("__iadd__", sq_inplace_concat, slot_sq_inplace_concat, 3907 wrap_binaryfunc, "x.__iadd__(y) <==> x+=y"), 3908 SQSLOT("__imul__", sq_inplace_repeat, slot_sq_inplace_repeat, 3909 wrap_intargfunc, "x.__imul__(y) <==> x*=y"), 3910 3911 MPSLOT("__len__", mp_length, slot_mp_length, wrap_inquiry, 3912 "x.__len__() <==> len(x)"), 3913 MPSLOT("__getitem__", mp_subscript, slot_mp_subscript, 3914 wrap_binaryfunc, 3915 "x.__getitem__(y) <==> x[y]"), 3916 MPSLOT("__setitem__", mp_ass_subscript, slot_mp_ass_subscript, 3917 wrap_objobjargproc, 3918 "x.__setitem__(i, y) <==> x[i]=y"), 3919 MPSLOT("__delitem__", mp_ass_subscript, slot_mp_ass_subscript, 3920 wrap_delitem, 3921 "x.__delitem__(y) <==> del x[y]"), 3922 3923 BINSLOT("__add__", nb_add, slot_nb_add, 3924 "+"), 3925 RBINSLOT("__radd__", nb_add, slot_nb_add, 3926 "+"), 3927 BINSLOT("__sub__", nb_subtract, slot_nb_subtract, 3928 "-"), 3929 RBINSLOT("__rsub__", nb_subtract, slot_nb_subtract, 3930 "-"), 3931 BINSLOT("__mul__", nb_multiply, slot_nb_multiply, 3932 "*"), 3933 RBINSLOT("__rmul__", nb_multiply, slot_nb_multiply, 3934 "*"), 3935 BINSLOT("__div__", nb_divide, slot_nb_divide, 3936 "/"), 3937 RBINSLOT("__rdiv__", nb_divide, slot_nb_divide, 3938 "/"), 3939 BINSLOT("__mod__", nb_remainder, slot_nb_remainder, 3940 "%"), 3941 RBINSLOT("__rmod__", nb_remainder, slot_nb_remainder, 3942 "%"), 3943 BINSLOT("__divmod__", nb_divmod, slot_nb_divmod, 3944 "divmod(x, y)"), 3945 RBINSLOT("__rdivmod__", nb_divmod, slot_nb_divmod, 3946 "divmod(y, x)"), 3947 NBSLOT("__pow__", nb_power, slot_nb_power, wrap_ternaryfunc, 3948 "x.__pow__(y[, z]) <==> pow(x, y[, z])"), 3949 NBSLOT("__rpow__", nb_power, slot_nb_power, wrap_ternaryfunc_r, 3950 "y.__rpow__(x[, z]) <==> pow(x, y[, z])"), 3951 UNSLOT("__neg__", nb_negative, slot_nb_negative, wrap_unaryfunc, "-x"), 3952 UNSLOT("__pos__", nb_positive, slot_nb_positive, wrap_unaryfunc, "+x"), 3953 UNSLOT("__abs__", nb_absolute, slot_nb_absolute, wrap_unaryfunc, 3954 "abs(x)"), 3955 UNSLOT("__nonzero__", nb_nonzero, slot_nb_nonzero, wrap_inquiry, 3956 "x != 0"), 3957 UNSLOT("__invert__", nb_invert, slot_nb_invert, wrap_unaryfunc, "~x"), 3958 BINSLOT("__lshift__", nb_lshift, slot_nb_lshift, "<<"), 3959 RBINSLOT("__rlshift__", nb_lshift, slot_nb_lshift, "<<"), 3960 BINSLOT("__rshift__", nb_rshift, slot_nb_rshift, ">>"), 3961 RBINSLOT("__rrshift__", nb_rshift, slot_nb_rshift, ">>"), 3962 BINSLOT("__and__", nb_and, slot_nb_and, "&"), 3963 RBINSLOT("__rand__", nb_and, slot_nb_and, "&"), 3964 BINSLOT("__xor__", nb_xor, slot_nb_xor, "^"), 3965 RBINSLOT("__rxor__", nb_xor, slot_nb_xor, "^"), 3966 BINSLOT("__or__", nb_or, slot_nb_or, "|"), 3967 RBINSLOT("__ror__", nb_or, slot_nb_or, "|"), 3968 NBSLOT("__coerce__", nb_coerce, slot_nb_coerce, wrap_coercefunc, 3969 "x.__coerce__(y) <==> coerce(x, y)"), 3970 UNSLOT("__int__", nb_int, slot_nb_int, wrap_unaryfunc, 3971 "int(x)"), 3972 UNSLOT("__long__", nb_long, slot_nb_long, wrap_unaryfunc, 3973 "long(x)"), 3974 UNSLOT("__float__", nb_float, slot_nb_float, wrap_unaryfunc, 3975 "float(x)"), 3976 UNSLOT("__oct__", nb_oct, slot_nb_oct, wrap_unaryfunc, 3977 "oct(x)"), 3978 UNSLOT("__hex__", nb_hex, slot_nb_hex, wrap_unaryfunc, 3979 "hex(x)"), 3980 IBSLOT("__iadd__", nb_inplace_add, slot_nb_inplace_add, 3981 wrap_binaryfunc, "+"), 3982 IBSLOT("__isub__", nb_inplace_subtract, slot_nb_inplace_subtract, 3983 wrap_binaryfunc, "-"), 3984 IBSLOT("__imul__", nb_inplace_multiply, slot_nb_inplace_multiply, 3985 wrap_binaryfunc, "*"), 3986 IBSLOT("__idiv__", nb_inplace_divide, slot_nb_inplace_divide, 3987 wrap_binaryfunc, "/"), 3988 IBSLOT("__imod__", nb_inplace_remainder, slot_nb_inplace_remainder, 3989 wrap_binaryfunc, "%"), 3990 IBSLOT("__ipow__", nb_inplace_power, slot_nb_inplace_power, 3991 wrap_ternaryfunc, "**"), 3992 IBSLOT("__ilshift__", nb_inplace_lshift, slot_nb_inplace_lshift, 3993 wrap_binaryfunc, "<<"), 3994 IBSLOT("__irshift__", nb_inplace_rshift, slot_nb_inplace_rshift, 3995 wrap_binaryfunc, ">>"), 3996 IBSLOT("__iand__", nb_inplace_and, slot_nb_inplace_and, 3997 wrap_binaryfunc, "&"), 3998 IBSLOT("__ixor__", nb_inplace_xor, slot_nb_inplace_xor, 3999 wrap_binaryfunc, "^"), 4000 IBSLOT("__ior__", nb_inplace_or, slot_nb_inplace_or, 4001 wrap_binaryfunc, "|"), 4002 BINSLOT("__floordiv__", nb_floor_divide, slot_nb_floor_divide, "//"), 4003 RBINSLOT("__rfloordiv__", nb_floor_divide, slot_nb_floor_divide, "//"), 4004 BINSLOT("__truediv__", nb_true_divide, slot_nb_true_divide, "/"), 4005 RBINSLOT("__rtruediv__", nb_true_divide, slot_nb_true_divide, "/"), 4006 IBSLOT("__ifloordiv__", nb_inplace_floor_divide, 4007 slot_nb_inplace_floor_divide, wrap_binaryfunc, "//"), 4008 IBSLOT("__itruediv__", nb_inplace_true_divide, 4009 slot_nb_inplace_true_divide, wrap_binaryfunc, "/"), 4010 4011 TPSLOT("__str__", tp_str, slot_tp_str, wrap_unaryfunc, 4012 "x.__str__() <==> str(x)"), 4013 TPSLOT("__str__", tp_print, NULL, NULL, ""), 4014 TPSLOT("__repr__", tp_repr, slot_tp_repr, wrap_unaryfunc, 4015 "x.__repr__() <==> repr(x)"), 4016 TPSLOT("__repr__", tp_print, NULL, NULL, ""), 4017 TPSLOT("__cmp__", tp_compare, _PyObject_SlotCompare, wrap_cmpfunc, 4018 "x.__cmp__(y) <==> cmp(x,y)"), 4019 TPSLOT("__hash__", tp_hash, slot_tp_hash, wrap_hashfunc, 4020 "x.__hash__() <==> hash(x)"), 4021 FLSLOT("__call__", tp_call, slot_tp_call, (wrapperfunc)wrap_call, 4022 "x.__call__(...) <==> x(...)", PyWrapperFlag_KEYWORDS), 4023 TPSLOT("__getattribute__", tp_getattro, slot_tp_getattr_hook, 4024 wrap_binaryfunc, "x.__getattribute__('name') <==> x.name"), 4025 TPSLOT("__getattribute__", tp_getattr, NULL, NULL, ""), 4026 TPSLOT("__getattr__", tp_getattro, slot_tp_getattr_hook, NULL, ""), 4027 TPSLOT("__getattr__", tp_getattr, NULL, NULL, ""), 4028 TPSLOT("__setattr__", tp_setattro, slot_tp_setattro, wrap_setattr, 4029 "x.__setattr__('name', value) <==> x.name = value"), 4030 TPSLOT("__setattr__", tp_setattr, NULL, NULL, ""), 4031 TPSLOT("__delattr__", tp_setattro, slot_tp_setattro, wrap_delattr, 4032 "x.__delattr__('name') <==> del x.name"), 4033 TPSLOT("__delattr__", tp_setattr, NULL, NULL, ""), 4034 TPSLOT("__lt__", tp_richcompare, slot_tp_richcompare, richcmp_lt, 4035 "x.__lt__(y) <==> x<y"), 4036 TPSLOT("__le__", tp_richcompare, slot_tp_richcompare, richcmp_le, 4037 "x.__le__(y) <==> x<=y"), 4038 TPSLOT("__eq__", tp_richcompare, slot_tp_richcompare, richcmp_eq, 4039 "x.__eq__(y) <==> x==y"), 4040 TPSLOT("__ne__", tp_richcompare, slot_tp_richcompare, richcmp_ne, 4041 "x.__ne__(y) <==> x!=y"), 4042 TPSLOT("__gt__", tp_richcompare, slot_tp_richcompare, richcmp_gt, 4043 "x.__gt__(y) <==> x>y"), 4044 TPSLOT("__ge__", tp_richcompare, slot_tp_richcompare, richcmp_ge, 4045 "x.__ge__(y) <==> x>=y"), 4046 TPSLOT("__iter__", tp_iter, slot_tp_iter, wrap_unaryfunc, 4047 "x.__iter__() <==> iter(x)"), 4048 TPSLOT("next", tp_iternext, slot_tp_iternext, wrap_next, 4049 "x.next() -> the next value, or raise StopIteration"), 4050 TPSLOT("__get__", tp_descr_get, slot_tp_descr_get, wrap_descr_get, 4051 "descr.__get__(obj[, type]) -> value"), 4052 TPSLOT("__set__", tp_descr_set, slot_tp_descr_set, wrap_descr_set, 4053 "descr.__set__(obj, value)"), 4054 TPSLOT("__delete__", tp_descr_set, slot_tp_descr_set, 4055 wrap_descr_delete, "descr.__delete__(obj)"), 4056 FLSLOT("__init__", tp_init, slot_tp_init, (wrapperfunc)wrap_init, 4057 "x.__init__(...) initializes x; " 4058 "see x.__class__.__doc__ for signature", 4059 PyWrapperFlag_KEYWORDS), 4060 TPSLOT("__new__", tp_new, slot_tp_new, NULL, ""), 4061 TPSLOT("__del__", tp_del, slot_tp_del, NULL, ""), 4062 {NULL} 4063}; 4064 4065/* Given a type pointer and an offset gotten from a slotdef entry, return a 4066 pointer to the actual slot. This is not quite the same as simply adding 4067 the offset to the type pointer, since it takes care to indirect through the 4068 proper indirection pointer (as_buffer, etc.); it returns NULL if the 4069 indirection pointer is NULL. */ 4070static void ** 4071slotptr(PyTypeObject *type, int offset) 4072{ 4073 char *ptr; 4074 4075 /* Note: this depends on the order of the members of etype! */ 4076 assert(offset >= 0); 4077 assert(offset < offsetof(etype, as_buffer)); 4078 if (offset >= offsetof(etype, as_sequence)) { 4079 ptr = (void *)type->tp_as_sequence; 4080 offset -= offsetof(etype, as_sequence); 4081 } 4082 else if (offset >= offsetof(etype, as_mapping)) { 4083 ptr = (void *)type->tp_as_mapping; 4084 offset -= offsetof(etype, as_mapping); 4085 } 4086 else if (offset >= offsetof(etype, as_number)) { 4087 ptr = (void *)type->tp_as_number; 4088 offset -= offsetof(etype, as_number); 4089 } 4090 else { 4091 ptr = (void *)type; 4092 } 4093 if (ptr != NULL) 4094 ptr += offset; 4095 return (void **)ptr; 4096} 4097 4098/* Length of array of slotdef pointers used to store slots with the 4099 same __name__. There should be at most MAX_EQUIV-1 slotdef entries with 4100 the same __name__, for any __name__. Since that's a static property, it is 4101 appropriate to declare fixed-size arrays for this. */ 4102#define MAX_EQUIV 10 4103 4104/* Return a slot pointer for a given name, but ONLY if the attribute has 4105 exactly one slot function. The name must be an interned string. */ 4106static void ** 4107resolve_slotdups(PyTypeObject *type, PyObject *name) 4108{ 4109 /* XXX Maybe this could be optimized more -- but is it worth it? */ 4110 4111 /* pname and ptrs act as a little cache */ 4112 static PyObject *pname; 4113 static slotdef *ptrs[MAX_EQUIV]; 4114 slotdef *p, **pp; 4115 void **res, **ptr; 4116 4117 if (pname != name) { 4118 /* Collect all slotdefs that match name into ptrs. */ 4119 pname = name; 4120 pp = ptrs; 4121 for (p = slotdefs; p->name_strobj; p++) { 4122 if (p->name_strobj == name) 4123 *pp++ = p; 4124 } 4125 *pp = NULL; 4126 } 4127 4128 /* Look in all matching slots of the type; if exactly one of these has 4129 a filled-in slot, return its value. Otherwise return NULL. */ 4130 res = NULL; 4131 for (pp = ptrs; *pp; pp++) { 4132 ptr = slotptr(type, (*pp)->offset); 4133 if (ptr == NULL || *ptr == NULL) 4134 continue; 4135 if (res != NULL) 4136 return NULL; 4137 res = ptr; 4138 } 4139 return res; 4140} 4141 4142/* Common code for update_these_slots() and fixup_slot_dispatchers(). This 4143 does some incredibly complex thinking and then sticks something into the 4144 slot. (It sees if the adjacent slotdefs for the same slot have conflicting 4145 interests, and then stores a generic wrapper or a specific function into 4146 the slot.) Return a pointer to the next slotdef with a different offset, 4147 because that's convenient for fixup_slot_dispatchers(). */ 4148static slotdef * 4149update_one_slot(PyTypeObject *type, slotdef *p) 4150{ 4151 PyObject *descr; 4152 PyWrapperDescrObject *d; 4153 void *generic = NULL, *specific = NULL; 4154 int use_generic = 0; 4155 int offset = p->offset; 4156 void **ptr = slotptr(type, offset); 4157 4158 if (ptr == NULL) { 4159 do { 4160 ++p; 4161 } while (p->offset == offset); 4162 return p; 4163 } 4164 do { 4165 descr = _PyType_Lookup(type, p->name_strobj); 4166 if (descr == NULL) 4167 continue; 4168 if (descr->ob_type == &PyWrapperDescr_Type) { 4169 void **tptr = resolve_slotdups(type, p->name_strobj); 4170 if (tptr == NULL || tptr == ptr) 4171 generic = p->function; 4172 d = (PyWrapperDescrObject *)descr; 4173 if (d->d_base->wrapper == p->wrapper && 4174 PyType_IsSubtype(type, d->d_type)) 4175 { 4176 if (specific == NULL || 4177 specific == d->d_wrapped) 4178 specific = d->d_wrapped; 4179 else 4180 use_generic = 1; 4181 } 4182 } 4183 else if (descr->ob_type == &PyCFunction_Type && 4184 PyCFunction_GET_FUNCTION(descr) == 4185 (PyCFunction)tp_new_wrapper && 4186 strcmp(p->name, "__new__") == 0) 4187 { 4188 /* The __new__ wrapper is not a wrapper descriptor, 4189 so must be special-cased differently. 4190 If we don't do this, creating an instance will 4191 always use slot_tp_new which will look up 4192 __new__ in the MRO which will call tp_new_wrapper 4193 which will look through the base classes looking 4194 for a static base and call its tp_new (usually 4195 PyType_GenericNew), after performing various 4196 sanity checks and constructing a new argument 4197 list. Cut all that nonsense short -- this speeds 4198 up instance creation tremendously. */ 4199 specific = type->tp_new; 4200 /* XXX I'm not 100% sure that there isn't a hole 4201 in this reasoning that requires additional 4202 sanity checks. I'll buy the first person to 4203 point out a bug in this reasoning a beer. */ 4204 } 4205 else { 4206 use_generic = 1; 4207 generic = p->function; 4208 } 4209 } while ((++p)->offset == offset); 4210 if (specific && !use_generic) 4211 *ptr = specific; 4212 else 4213 *ptr = generic; 4214 return p; 4215} 4216 4217static int recurse_down_subclasses(PyTypeObject *type, slotdef **pp, 4218 PyObject *name); 4219 4220/* In the type, update the slots whose slotdefs are gathered in the pp0 array, 4221 and then do the same for all this type's subtypes. */ 4222static int 4223update_these_slots(PyTypeObject *type, slotdef **pp0, PyObject *name) 4224{ 4225 slotdef **pp; 4226 4227 for (pp = pp0; *pp; pp++) 4228 update_one_slot(type, *pp); 4229 return recurse_down_subclasses(type, pp0, name); 4230} 4231 4232/* Update the slots whose slotdefs are gathered in the pp array in all (direct 4233 or indirect) subclasses of type. */ 4234static int 4235recurse_down_subclasses(PyTypeObject *type, slotdef **pp, PyObject *name) 4236{ 4237 PyTypeObject *subclass; 4238 PyObject *ref, *subclasses, *dict; 4239 int i, n; 4240 4241 subclasses = type->tp_subclasses; 4242 if (subclasses == NULL) 4243 return 0; 4244 assert(PyList_Check(subclasses)); 4245 n = PyList_GET_SIZE(subclasses); 4246 for (i = 0; i < n; i++) { 4247 ref = PyList_GET_ITEM(subclasses, i); 4248 assert(PyWeakref_CheckRef(ref)); 4249 subclass = (PyTypeObject *)PyWeakref_GET_OBJECT(ref); 4250 assert(subclass != NULL); 4251 if ((PyObject *)subclass == Py_None) 4252 continue; 4253 assert(PyType_Check(subclass)); 4254 /* Avoid recursing down into unaffected classes */ 4255 dict = subclass->tp_dict; 4256 if (dict != NULL && PyDict_Check(dict) && 4257 PyDict_GetItem(dict, name) != NULL) 4258 continue; 4259 if (update_these_slots(subclass, pp, name) < 0) 4260 return -1; 4261 } 4262 return 0; 4263} 4264 4265/* Comparison function for qsort() to compare slotdefs by their offset, and 4266 for equal offset by their address (to force a stable sort). */ 4267static int 4268slotdef_cmp(const void *aa, const void *bb) 4269{ 4270 const slotdef *a = (const slotdef *)aa, *b = (const slotdef *)bb; 4271 int c = a->offset - b->offset; 4272 if (c != 0) 4273 return c; 4274 else 4275 return a - b; 4276} 4277 4278/* Initialize the slotdefs table by adding interned string objects for the 4279 names and sorting the entries. */ 4280static void 4281init_slotdefs(void) 4282{ 4283 slotdef *p; 4284 static int initialized = 0; 4285 4286 if (initialized) 4287 return; 4288 for (p = slotdefs; p->name; p++) { 4289 p->name_strobj = PyString_InternFromString(p->name); 4290 if (!p->name_strobj) 4291 Py_FatalError("Out of memory interning slotdef names"); 4292 } 4293 qsort((void *)slotdefs, (size_t)(p-slotdefs), sizeof(slotdef), 4294 slotdef_cmp); 4295 initialized = 1; 4296} 4297 4298/* Update the slots after assignment to a class (type) attribute. */ 4299static int 4300update_slot(PyTypeObject *type, PyObject *name) 4301{ 4302 slotdef *ptrs[MAX_EQUIV]; 4303 slotdef *p; 4304 slotdef **pp; 4305 int offset; 4306 4307 init_slotdefs(); 4308 pp = ptrs; 4309 for (p = slotdefs; p->name; p++) { 4310 /* XXX assume name is interned! */ 4311 if (p->name_strobj == name) 4312 *pp++ = p; 4313 } 4314 *pp = NULL; 4315 for (pp = ptrs; *pp; pp++) { 4316 p = *pp; 4317 offset = p->offset; 4318 while (p > slotdefs && (p-1)->offset == offset) 4319 --p; 4320 *pp = p; 4321 } 4322 if (ptrs[0] == NULL) 4323 return 0; /* Not an attribute that affects any slots */ 4324 return update_these_slots(type, ptrs, name); 4325} 4326 4327/* Store the proper functions in the slot dispatches at class (type) 4328 definition time, based upon which operations the class overrides in its 4329 dict. */ 4330static void 4331fixup_slot_dispatchers(PyTypeObject *type) 4332{ 4333 slotdef *p; 4334 4335 init_slotdefs(); 4336 for (p = slotdefs; p->name; ) 4337 p = update_one_slot(type, p); 4338} 4339 4340/* This function is called by PyType_Ready() to populate the type's 4341 dictionary with method descriptors for function slots. For each 4342 function slot (like tp_repr) that's defined in the type, one or more 4343 corresponding descriptors are added in the type's tp_dict dictionary 4344 under the appropriate name (like __repr__). Some function slots 4345 cause more than one descriptor to be added (for example, the nb_add 4346 slot adds both __add__ and __radd__ descriptors) and some function 4347 slots compete for the same descriptor (for example both sq_item and 4348 mp_subscript generate a __getitem__ descriptor). 4349 4350 In the latter case, the first slotdef entry encoutered wins. Since 4351 slotdef entries are sorted by the offset of the slot in the etype 4352 struct, this gives us some control over disambiguating between 4353 competing slots: the members of struct etype are listed from most 4354 general to least general, so the most general slot is preferred. In 4355 particular, because as_mapping comes before as_sequence, for a type 4356 that defines both mp_subscript and sq_item, mp_subscript wins. 4357 4358 This only adds new descriptors and doesn't overwrite entries in 4359 tp_dict that were previously defined. The descriptors contain a 4360 reference to the C function they must call, so that it's safe if they 4361 are copied into a subtype's __dict__ and the subtype has a different 4362 C function in its slot -- calling the method defined by the 4363 descriptor will call the C function that was used to create it, 4364 rather than the C function present in the slot when it is called. 4365 (This is important because a subtype may have a C function in the 4366 slot that calls the method from the dictionary, and we want to avoid 4367 infinite recursion here.) */ 4368 4369static int 4370add_operators(PyTypeObject *type) 4371{ 4372 PyObject *dict = type->tp_dict; 4373 slotdef *p; 4374 PyObject *descr; 4375 void **ptr; 4376 4377 init_slotdefs(); 4378 for (p = slotdefs; p->name; p++) { 4379 if (p->wrapper == NULL) 4380 continue; 4381 ptr = slotptr(type, p->offset); 4382 if (!ptr || !*ptr) 4383 continue; 4384 if (PyDict_GetItem(dict, p->name_strobj)) 4385 continue; 4386 descr = PyDescr_NewWrapper(type, p, *ptr); 4387 if (descr == NULL) 4388 return -1; 4389 if (PyDict_SetItem(dict, p->name_strobj, descr) < 0) 4390 return -1; 4391 Py_DECREF(descr); 4392 } 4393 if (type->tp_new != NULL) { 4394 if (add_tp_new_wrapper(type) < 0) 4395 return -1; 4396 } 4397 return 0; 4398} 4399 4400 4401/* Cooperative 'super' */ 4402 4403typedef struct { 4404 PyObject_HEAD 4405 PyTypeObject *type; 4406 PyObject *obj; 4407} superobject; 4408 4409static PyMemberDef super_members[] = { 4410 {"__thisclass__", T_OBJECT, offsetof(superobject, type), READONLY, 4411 "the class invoking super()"}, 4412 {"__self__", T_OBJECT, offsetof(superobject, obj), READONLY, 4413 "the instance invoking super(); may be None"}, 4414 {0} 4415}; 4416 4417static void 4418super_dealloc(PyObject *self) 4419{ 4420 superobject *su = (superobject *)self; 4421 4422 _PyObject_GC_UNTRACK(self); 4423 Py_XDECREF(su->obj); 4424 Py_XDECREF(su->type); 4425 self->ob_type->tp_free(self); 4426} 4427 4428static PyObject * 4429super_repr(PyObject *self) 4430{ 4431 superobject *su = (superobject *)self; 4432 4433 if (su->obj) 4434 return PyString_FromFormat( 4435 "<super: <class '%s'>, <%s object>>", 4436 su->type ? su->type->tp_name : "NULL", 4437 su->obj->ob_type->tp_name); 4438 else 4439 return PyString_FromFormat( 4440 "<super: <class '%s'>, NULL>", 4441 su->type ? su->type->tp_name : "NULL"); 4442} 4443 4444static PyObject * 4445super_getattro(PyObject *self, PyObject *name) 4446{ 4447 superobject *su = (superobject *)self; 4448 4449 if (su->obj != NULL) { 4450 PyObject *mro, *res, *tmp, *dict; 4451 PyTypeObject *starttype; 4452 descrgetfunc f; 4453 int i, n; 4454 4455 starttype = su->obj->ob_type; 4456 mro = starttype->tp_mro; 4457 4458 if (mro == NULL) 4459 n = 0; 4460 else { 4461 assert(PyTuple_Check(mro)); 4462 n = PyTuple_GET_SIZE(mro); 4463 } 4464 for (i = 0; i < n; i++) { 4465 if ((PyObject *)(su->type) == PyTuple_GET_ITEM(mro, i)) 4466 break; 4467 } 4468 if (i >= n && PyType_Check(su->obj)) { 4469 starttype = (PyTypeObject *)(su->obj); 4470 mro = starttype->tp_mro; 4471 if (mro == NULL) 4472 n = 0; 4473 else { 4474 assert(PyTuple_Check(mro)); 4475 n = PyTuple_GET_SIZE(mro); 4476 } 4477 for (i = 0; i < n; i++) { 4478 if ((PyObject *)(su->type) == 4479 PyTuple_GET_ITEM(mro, i)) 4480 break; 4481 } 4482 } 4483 i++; 4484 res = NULL; 4485 for (; i < n; i++) { 4486 tmp = PyTuple_GET_ITEM(mro, i); 4487 if (PyType_Check(tmp)) 4488 dict = ((PyTypeObject *)tmp)->tp_dict; 4489 else if (PyClass_Check(tmp)) 4490 dict = ((PyClassObject *)tmp)->cl_dict; 4491 else 4492 continue; 4493 res = PyDict_GetItem(dict, name); 4494 if (res != NULL && !PyDescr_IsData(res)) { 4495 Py_INCREF(res); 4496 f = res->ob_type->tp_descr_get; 4497 if (f != NULL) { 4498 tmp = f(res, su->obj, 4499 (PyObject *)starttype); 4500 Py_DECREF(res); 4501 res = tmp; 4502 } 4503 return res; 4504 } 4505 } 4506 } 4507 return PyObject_GenericGetAttr(self, name); 4508} 4509 4510static int 4511supercheck(PyTypeObject *type, PyObject *obj) 4512{ 4513 if (!PyType_IsSubtype(obj->ob_type, type) && 4514 !(PyType_Check(obj) && 4515 PyType_IsSubtype((PyTypeObject *)obj, type))) { 4516 PyErr_SetString(PyExc_TypeError, 4517 "super(type, obj): " 4518 "obj must be an instance or subtype of type"); 4519 return -1; 4520 } 4521 else 4522 return 0; 4523} 4524 4525static PyObject * 4526super_descr_get(PyObject *self, PyObject *obj, PyObject *type) 4527{ 4528 superobject *su = (superobject *)self; 4529 superobject *new; 4530 4531 if (obj == NULL || obj == Py_None || su->obj != NULL) { 4532 /* Not binding to an object, or already bound */ 4533 Py_INCREF(self); 4534 return self; 4535 } 4536 if (su->ob_type != &PySuper_Type) 4537 /* If su is an instance of a subclass of super, 4538 call its type */ 4539 return PyObject_CallFunction((PyObject *)su->ob_type, 4540 "OO", su->type, obj); 4541 else { 4542 /* Inline the common case */ 4543 if (supercheck(su->type, obj) < 0) 4544 return NULL; 4545 new = (superobject *)PySuper_Type.tp_new(&PySuper_Type, 4546 NULL, NULL); 4547 if (new == NULL) 4548 return NULL; 4549 Py_INCREF(su->type); 4550 Py_INCREF(obj); 4551 new->type = su->type; 4552 new->obj = obj; 4553 return (PyObject *)new; 4554 } 4555} 4556 4557static int 4558super_init(PyObject *self, PyObject *args, PyObject *kwds) 4559{ 4560 superobject *su = (superobject *)self; 4561 PyTypeObject *type; 4562 PyObject *obj = NULL; 4563 4564 if (!PyArg_ParseTuple(args, "O!|O:super", &PyType_Type, &type, &obj)) 4565 return -1; 4566 if (obj == Py_None) 4567 obj = NULL; 4568 if (obj != NULL && supercheck(type, obj) < 0) 4569 return -1; 4570 Py_INCREF(type); 4571 Py_XINCREF(obj); 4572 su->type = type; 4573 su->obj = obj; 4574 return 0; 4575} 4576 4577PyDoc_STRVAR(super_doc, 4578"super(type) -> unbound super object\n" 4579"super(type, obj) -> bound super object; requires isinstance(obj, type)\n" 4580"super(type, type2) -> bound super object; requires issubclass(type2, type)\n" 4581"Typical use to call a cooperative superclass method:\n" 4582"class C(B):\n" 4583" def meth(self, arg):\n" 4584" super(C, self).meth(arg)"); 4585 4586static int 4587super_traverse(PyObject *self, visitproc visit, void *arg) 4588{ 4589 superobject *su = (superobject *)self; 4590 int err; 4591 4592#define VISIT(SLOT) \ 4593 if (SLOT) { \ 4594 err = visit((PyObject *)(SLOT), arg); \ 4595 if (err) \ 4596 return err; \ 4597 } 4598 4599 VISIT(su->obj); 4600 VISIT(su->type); 4601 4602#undef VISIT 4603 4604 return 0; 4605} 4606 4607PyTypeObject PySuper_Type = { 4608 PyObject_HEAD_INIT(&PyType_Type) 4609 0, /* ob_size */ 4610 "super", /* tp_name */ 4611 sizeof(superobject), /* tp_basicsize */ 4612 0, /* tp_itemsize */ 4613 /* methods */ 4614 super_dealloc, /* tp_dealloc */ 4615 0, /* tp_print */ 4616 0, /* tp_getattr */ 4617 0, /* tp_setattr */ 4618 0, /* tp_compare */ 4619 super_repr, /* tp_repr */ 4620 0, /* tp_as_number */ 4621 0, /* tp_as_sequence */ 4622 0, /* tp_as_mapping */ 4623 0, /* tp_hash */ 4624 0, /* tp_call */ 4625 0, /* tp_str */ 4626 super_getattro, /* tp_getattro */ 4627 0, /* tp_setattro */ 4628 0, /* tp_as_buffer */ 4629 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | 4630 Py_TPFLAGS_BASETYPE, /* tp_flags */ 4631 super_doc, /* tp_doc */ 4632 super_traverse, /* tp_traverse */ 4633 0, /* tp_clear */ 4634 0, /* tp_richcompare */ 4635 0, /* tp_weaklistoffset */ 4636 0, /* tp_iter */ 4637 0, /* tp_iternext */ 4638 0, /* tp_methods */ 4639 super_members, /* tp_members */ 4640 0, /* tp_getset */ 4641 0, /* tp_base */ 4642 0, /* tp_dict */ 4643 super_descr_get, /* tp_descr_get */ 4644 0, /* tp_descr_set */ 4645 0, /* tp_dictoffset */ 4646 super_init, /* tp_init */ 4647 PyType_GenericAlloc, /* tp_alloc */ 4648 PyType_GenericNew, /* tp_new */ 4649 PyObject_GC_Del, /* tp_free */ 4650}; 4651