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