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