?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merged release21-maint changes.
[python/dscho.git] / Objects / typeobject.c
blob37d94918dce3209719d28e132566681466d80cec
1
2 /* Type object implementation */
3
4 #include "Python.h"
5 #include "structmember.h"
6
7 static struct memberlist type_members[] = {
8 {"__name__", T_STRING, offsetof(PyTypeObject, tp_name), READONLY},
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 {"__doc__", T_STRING, offsetof(PyTypeObject, tp_doc), READONLY},
13 {"__weaklistoffset__", T_LONG,
14 offsetof(PyTypeObject, tp_weaklistoffset), READONLY},
15 {"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY},
16 {"__dictoffset__", T_LONG,
17 offsetof(PyTypeObject, tp_dictoffset), READONLY},
18 {"__bases__", T_OBJECT, offsetof(PyTypeObject, tp_bases), READONLY},
19 {"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY},
20 {0}
21 };
22
23 static PyObject *
24 type_module(PyTypeObject *type, void *context)
25 {
26 return PyString_FromString("__builtin__");
27 }
28
29 static PyObject *
30 type_dict(PyTypeObject *type, void *context)
31 {
32 if (type->tp_dict == NULL) {
33 Py_INCREF(Py_None);
34 return Py_None;
35 }
36 if (type->tp_flags & Py_TPFLAGS_DYNAMICTYPE) {
37 Py_INCREF(type->tp_dict);
38 return type->tp_dict;
39 }
40 return PyDictProxy_New(type->tp_dict);
41 }
42
43 static PyObject *
44 type_defined(PyTypeObject *type, void *context)
45 {
46 if (type->tp_defined == NULL) {
47 Py_INCREF(Py_None);
48 return Py_None;
49 }
50 if (type->tp_flags & Py_TPFLAGS_DYNAMICTYPE) {
51 Py_INCREF(type->tp_defined);
52 return type->tp_defined;
53 }
54 return PyDictProxy_New(type->tp_defined);
55 }
56
57 static PyObject *
58 type_dynamic(PyTypeObject *type, void *context)
59 {
60 PyObject *res;
61
62 res = (type->tp_flags & Py_TPFLAGS_DYNAMICTYPE) ? Py_True : Py_False;
63 Py_INCREF(res);
64 return res;
65 }
66
67 struct getsetlist type_getsets[] = {
68 {"__module__", (getter)type_module, NULL, NULL},
69 {"__dict__", (getter)type_dict, NULL, NULL},
70 {"__defined__", (getter)type_defined, NULL, NULL},
71 {"__dynamic__", (getter)type_dynamic, NULL, NULL},
72 {0}
73 };
74
75 static int
76 type_compare(PyObject *v, PyObject *w)
77 {
78 /* This is called with type objects only. So we
79 can just compare the addresses. */
80 Py_uintptr_t vv = (Py_uintptr_t)v;
81 Py_uintptr_t ww = (Py_uintptr_t)w;
82 return (vv < ww) ? -1 : (vv > ww) ? 1 : 0;
83 }
84
85 static PyObject *
86 type_repr(PyTypeObject *type)
87 {
88 char buf[100];
89 sprintf(buf, "<type '%.80s'>", type->tp_name);
90 return PyString_FromString(buf);
91 }
92
93 static PyObject *
94 type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
95 {
96 PyObject *obj;
97
98 if (type->tp_new == NULL) {
99 PyErr_Format(PyExc_TypeError,
100 "cannot create '%.100s' instances",
101 type->tp_name);
102 return NULL;
103 }
104
105 obj = type->tp_new(type, args, NULL);
106 if (obj != NULL) {
107 type = obj->ob_type;
108 if (type->tp_init != NULL &&
109 type->tp_init(obj, args, kwds) < 0) {
110 Py_DECREF(obj);
111 obj = NULL;
112 }
113 }
114 return obj;
115 }
116
117 PyObject *
118 PyType_GenericAlloc(PyTypeObject *type, int nitems)
119 {
120 int size;
121 void *mem;
122 PyObject *obj;
123
124 /* Inline PyObject_New() so we can zero the memory */
125 size = _PyObject_VAR_SIZE(type, nitems);
126 mem = PyObject_MALLOC(size);
127 if (mem == NULL)
128 return PyErr_NoMemory();
129 memset(mem, '\0', size);
130 if (PyType_IS_GC(type))
131 obj = PyObject_FROM_GC(mem);
132 else
133 obj = (PyObject *)mem;
134 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE)
135 Py_INCREF(type);
136 if (type->tp_itemsize == 0)
137 PyObject_INIT(obj, type);
138 else
139 (void) PyObject_INIT_VAR((PyVarObject *)obj, type, nitems);
140 if (PyType_IS_GC(type))
141 PyObject_GC_Init(obj);
142 return obj;
143 }
144
145 PyObject *
146 PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
147 {
148 return type->tp_alloc(type, 0);
149 }
150
151 /* Helper for subtyping */
152
153 static void
154 subtype_dealloc(PyObject *self)
155 {
156 int dictoffset = self->ob_type->tp_dictoffset;
157 PyTypeObject *type, *base;
158 destructor f;
159
160 /* This exists so we can DECREF self->ob_type */
161
162 /* Find the nearest base with a different tp_dealloc */
163 type = self->ob_type;
164 base = type->tp_base;
165 while ((f = base->tp_dealloc) == subtype_dealloc) {
166 base = base->tp_base;
167 assert(base);
168 }
169
170 /* If we added a dict, DECREF it */
171 if (dictoffset && !base->tp_dictoffset) {
172 PyObject **dictptr = (PyObject **) ((char *)self + dictoffset);
173 PyObject *dict = *dictptr;
174 if (dict != NULL) {
175 Py_DECREF(dict);
176 *dictptr = NULL;
177 }
178 }
179
180 /* Finalize GC if the base doesn't do GC and we do */
181 if (PyType_IS_GC(type) && !PyType_IS_GC(base))
182 PyObject_GC_Fini(self);
183
184 /* Call the base tp_dealloc() */
185 assert(f);
186 f(self);
187
188 /* Can't reference self beyond this point */
189 if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
190 Py_DECREF(type);
191 }
192 }
193
194 staticforward void override_slots(PyTypeObject *type, PyObject *dict);
195 staticforward PyTypeObject *solid_base(PyTypeObject *type);
196
197 typedef struct {
198 PyTypeObject type;
199 PyNumberMethods as_number;
200 PySequenceMethods as_sequence;
201 PyMappingMethods as_mapping;
202 PyBufferProcs as_buffer;
203 PyObject *name, *slots;
204 struct memberlist members[1];
205 } etype;
206
207 /* type test with subclassing support */
208
209 int
210 PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
211 {
212 PyObject *mro;
213
214 mro = a->tp_mro;
215 if (mro != NULL) {
216 /* Deal with multiple inheritance without recursion
217 by walking the MRO tuple */
218 int i, n;
219 assert(PyTuple_Check(mro));
220 n = PyTuple_GET_SIZE(mro);
221 for (i = 0; i < n; i++) {
222 if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
223 return 1;
224 }
225 return 0;
226 }
227 else {
228 /* a is not completely initilized yet; follow tp_base */
229 do {
230 if (a == b)
231 return 1;
232 a = a->tp_base;
233 } while (a != NULL);
234 return b == &PyBaseObject_Type;
235 }
236 }
237
238 /* Method resolution order algorithm from "Putting Metaclasses to Work"
239 by Forman and Danforth (Addison-Wesley 1999). */
240
241 static int
242 conservative_merge(PyObject *left, PyObject *right)
243 {
244 int left_size;
245 int right_size;
246 int i, j, r, ok;
247 PyObject *temp, *rr;
248
249 assert(PyList_Check(left));
250 assert(PyList_Check(right));
251
252 again:
253 left_size = PyList_GET_SIZE(left);
254 right_size = PyList_GET_SIZE(right);
255 for (i = 0; i < left_size; i++) {
256 for (j = 0; j < right_size; j++) {
257 if (PyList_GET_ITEM(left, i) ==
258 PyList_GET_ITEM(right, j)) {
259 /* found a merge point */
260 temp = PyList_New(0);
261 if (temp == NULL)
262 return -1;
263 for (r = 0; r < j; r++) {
264 rr = PyList_GET_ITEM(right, r);
265 ok = PySequence_Contains(left, rr);
266 if (ok < 0) {
267 Py_DECREF(temp);
268 return -1;
269 }
270 if (!ok) {
271 ok = PyList_Append(temp, rr);
272 if (ok < 0) {
273 Py_DECREF(temp);
274 return -1;
275 }
276 }
277 }
278 ok = PyList_SetSlice(left, i, i, temp);
279 Py_DECREF(temp);
280 if (ok < 0)
281 return -1;
282 ok = PyList_SetSlice(right, 0, j+1, NULL);
283 if (ok < 0)
284 return -1;
285 goto again;
286 }
287 }
288 }
289 return PyList_SetSlice(left, left_size, left_size, right);
290 }
291
292 static int
293 serious_order_disagreements(PyObject *left, PyObject *right)
294 {
295 return 0; /* XXX later -- for now, we cheat: "don't do that" */
296 }
297
298 static PyObject *
299 mro_implementation(PyTypeObject *type)
300 {
301 int i, n, ok;
302 PyObject *bases, *result;
303
304 bases = type->tp_bases;
305 n = PyTuple_GET_SIZE(bases);
306 result = Py_BuildValue("[O]", (PyObject *)type);
307 if (result == NULL)
308 return NULL;
309 for (i = 0; i < n; i++) {
310 PyTypeObject *base =
311 (PyTypeObject *) PyTuple_GET_ITEM(bases, i);
312 PyObject *parentMRO = PySequence_List(base->tp_mro);
313 if (parentMRO == NULL) {
314 Py_DECREF(result);
315 return NULL;
316 }
317 if (serious_order_disagreements(result, parentMRO)) {
318 Py_DECREF(result);
319 return NULL;
320 }
321 ok = conservative_merge(result, parentMRO);
322 Py_DECREF(parentMRO);
323 if (ok < 0) {
324 Py_DECREF(result);
325 return NULL;
326 }
327 }
328 return result;
329 }
330
331 static PyObject *
332 mro_external(PyObject *self, PyObject *args)
333 {
334 PyTypeObject *type = (PyTypeObject *)self;
335
336 if (!PyArg_ParseTuple(args, ""))
337 return NULL;
338 return mro_implementation(type);
339 }
340
341 static int
342 mro_internal(PyTypeObject *type)
343 {
344 PyObject *mro, *result, *tuple;
345
346 if (type->ob_type == &PyType_Type) {
347 result = mro_implementation(type);
348 }
349 else {
350 mro = PyObject_GetAttrString((PyObject *)type, "mro");
351 if (mro == NULL)
352 return -1;
353 result = PyObject_CallObject(mro, NULL);
354 Py_DECREF(mro);
355 }
356 if (result == NULL)
357 return -1;
358 tuple = PySequence_Tuple(result);
359 Py_DECREF(result);
360 type->tp_mro = tuple;
361 return 0;
362 }
363
364
365 /* Calculate the best base amongst multiple base classes.
366 This is the first one that's on the path to the "solid base". */
367
368 static PyTypeObject *
369 best_base(PyObject *bases)
370 {
371 int i, n;
372 PyTypeObject *base, *winner, *candidate, *base_i;
373
374 assert(PyTuple_Check(bases));
375 n = PyTuple_GET_SIZE(bases);
376 assert(n > 0);
377 base = (PyTypeObject *)PyTuple_GET_ITEM(bases, 0);
378 winner = &PyBaseObject_Type;
379 for (i = 0; i < n; i++) {
380 base_i = (PyTypeObject *)PyTuple_GET_ITEM(bases, i);
381 if (!PyType_Check((PyObject *)base_i)) {
382 PyErr_SetString(
383 PyExc_TypeError,
384 "bases must be types");
385 return NULL;
386 }
387 if (base_i->tp_dict == NULL) {
388 if (PyType_Ready(base_i) < 0)
389 return NULL;
390 }
391 candidate = solid_base(base_i);
392 if (PyType_IsSubtype(winner, candidate))
393 ;
394 else if (PyType_IsSubtype(candidate, winner)) {
395 winner = candidate;
396 base = base_i;
397 }
398 else {
399 PyErr_SetString(
400 PyExc_TypeError,
401 "multiple bases have "
402 "instance lay-out conflict");
403 return NULL;
404 }
405 }
406 assert(base != NULL);
407 return base;
408 }
409
410 static int
411 extra_ivars(PyTypeObject *type, PyTypeObject *base)
412 {
413 int t_size = PyType_BASICSIZE(type);
414 int b_size = PyType_BASICSIZE(base);
415
416 assert(t_size >= b_size); /* type smaller than base! */
417 if (type->tp_itemsize || base->tp_itemsize) {
418 /* If itemsize is involved, stricter rules */
419 return t_size != b_size ||
420 type->tp_itemsize != base->tp_itemsize;
421 }
422 if (t_size == b_size)
423 return 0;
424 if (type->tp_dictoffset != 0 && base->tp_dictoffset == 0 &&
425 type->tp_dictoffset == b_size &&
426 (size_t)t_size == b_size + sizeof(PyObject *))
427 return 0; /* "Forgive" adding a __dict__ only */
428 return 1;
429 }
430
431 static PyTypeObject *
432 solid_base(PyTypeObject *type)
433 {
434 PyTypeObject *base;
435
436 if (type->tp_base)
437 base = solid_base(type->tp_base);
438 else
439 base = &PyBaseObject_Type;
440 if (extra_ivars(type, base))
441 return type;
442 else
443 return base;
444 }
445
446 staticforward void object_dealloc(PyObject *);
447 staticforward int object_init(PyObject *, PyObject *, PyObject *);
448
449 static PyObject *
450 type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
451 {
452 PyObject *name, *bases, *dict;
453 static char *kwlist[] = {"name", "bases", "dict", 0};
454 PyObject *slots, *tmp;
455 PyTypeObject *type, *base, *tmptype;
456 etype *et;
457 struct memberlist *mp;
458 int i, nbases, nslots, slotoffset, dynamic;
459
460 if (metatype == &PyType_Type &&
461 PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
462 (kwds == NULL || (PyDict_Check(kwds) && PyDict_Size(kwds) == 0))) {
463 /* type(x) -> x.__class__ */
464 PyObject *x = PyTuple_GET_ITEM(args, 0);
465 Py_INCREF(x->ob_type);
466 return (PyObject *) x->ob_type;
467 }
468
469 /* Check arguments */
470 if (!PyArg_ParseTupleAndKeywords(args, kwds, "SO!O!:type", kwlist,
471 &name,
472 &PyTuple_Type, &bases,
473 &PyDict_Type, &dict))
474 return NULL;
475
476 /* Determine the proper metatype to deal with this,
477 and check for metatype conflicts while we're at it.
478 Note that if some other metatype wins to contract,
479 it's possible that its instances are not types. */
480 nbases = PyTuple_GET_SIZE(bases);
481 for (i = 0; i < nbases; i++) {
482 tmp = PyTuple_GET_ITEM(bases, i);
483 tmptype = tmp->ob_type;
484 if (PyType_IsSubtype(metatype, tmptype))
485 continue;
486 if (PyType_IsSubtype(tmptype, metatype)) {
487 metatype = tmptype;
488 continue;
489 }
490 PyErr_SetString(PyExc_TypeError,
491 "metatype conflict among bases");
492 return NULL;
493 }
494 if (metatype->tp_new != type_new) /* Pass it to the winner */
495 return metatype->tp_new(metatype, args, kwds);
496
497 /* Adjust for empty tuple bases */
498 if (nbases == 0) {
499 bases = Py_BuildValue("(O)", &PyBaseObject_Type);
500 if (bases == NULL)
501 return NULL;
502 nbases = 1;
503 }
504 else
505 Py_INCREF(bases);
506
507 /* XXX From here until type is allocated, "return NULL" leaks bases! */
508
509 /* Calculate best base, and check that all bases are type objects */
510 base = best_base(bases);
511 if (base == NULL)
512 return NULL;
513 if (!PyType_HasFeature(base, Py_TPFLAGS_BASETYPE)) {
514 PyErr_Format(PyExc_TypeError,
515 "type '%.100s' is not an acceptable base type",
516 base->tp_name);
517 return NULL;
518 }
519
520 /* Should this be a dynamic class (i.e. modifiable __dict__)? */
521 tmp = PyDict_GetItemString(dict, "__dynamic__");
522 if (tmp != NULL) {
523 /* The class author has a preference */
524 dynamic = PyObject_IsTrue(tmp);
525 Py_DECREF(tmp);
526 if (dynamic < 0)
527 return NULL;
528 }
529 else {
530 /* Make a new class dynamic if any of its bases is dynamic.
531 This is not always the same as inheriting the __dynamic__
532 class attribute! */
533 dynamic = 0;
534 for (i = 0; i < nbases; i++) {
535 tmptype = (PyTypeObject *)PyTuple_GET_ITEM(bases, i);
536 if (tmptype->tp_flags & Py_TPFLAGS_DYNAMICTYPE) {
537 dynamic = 1;
538 break;
539 }
540 }
541 }
542
543 /* Check for a __slots__ sequence variable in dict, and count it */
544 slots = PyDict_GetItemString(dict, "__slots__");
545 nslots = 0;
546 if (slots != NULL) {
547 /* Make it into a tuple */
548 if (PyString_Check(slots))
549 slots = Py_BuildValue("(O)", slots);
550 else
551 slots = PySequence_Tuple(slots);
552 if (slots == NULL)
553 return NULL;
554 nslots = PyTuple_GET_SIZE(slots);
555 for (i = 0; i < nslots; i++) {
556 if (!PyString_Check(PyTuple_GET_ITEM(slots, i))) {
557 PyErr_SetString(PyExc_TypeError,
558 "__slots__ must be a sequence of strings");
559 Py_DECREF(slots);
560 return NULL;
561 }
562 }
563 }
564 if (slots == NULL && base->tp_dictoffset == 0 &&
565 (base->tp_setattro == PyObject_GenericSetAttr ||
566 base->tp_setattro == NULL))
567 nslots = 1;
568
569 /* XXX From here until type is safely allocated,
570 "return NULL" may leak slots! */
571
572 /* Allocate the type object */
573 type = (PyTypeObject *)metatype->tp_alloc(metatype, nslots);
574 if (type == NULL)
575 return NULL;
576
577 /* Keep name and slots alive in the extended type object */
578 et = (etype *)type;
579 Py_INCREF(name);
580 et->name = name;
581 et->slots = slots;
582
583 /* Initialize tp_flags */
584 type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE |
585 Py_TPFLAGS_BASETYPE;
586 if (dynamic)
587 type->tp_flags |= Py_TPFLAGS_DYNAMICTYPE;
588
589 /* It's a new-style number unless it specifically inherits any
590 old-style numeric behavior */
591 if ((base->tp_flags & Py_TPFLAGS_CHECKTYPES) ||
592 (base->tp_as_number == NULL))
593 type->tp_flags |= Py_TPFLAGS_CHECKTYPES;
594
595 /* Initialize essential fields */
596 type->tp_as_number = &et->as_number;
597 type->tp_as_sequence = &et->as_sequence;
598 type->tp_as_mapping = &et->as_mapping;
599 type->tp_as_buffer = &et->as_buffer;
600 type->tp_name = PyString_AS_STRING(name);
601
602 /* Set tp_base and tp_bases */
603 type->tp_bases = bases;
604 Py_INCREF(base);
605 type->tp_base = base;
606
607 /* Initialize tp_defined from passed-in dict */
608 type->tp_defined = dict = PyDict_Copy(dict);
609 if (dict == NULL) {
610 Py_DECREF(type);
611 return NULL;
612 }
613
614 /* Special-case __new__: if it's a plain function,
615 make it a static function */
616 tmp = PyDict_GetItemString(dict, "__new__");
617 if (tmp != NULL && PyFunction_Check(tmp)) {
618 tmp = PyStaticMethod_New(tmp);
619 if (tmp == NULL) {
620 Py_DECREF(type);
621 return NULL;
622 }
623 PyDict_SetItemString(dict, "__new__", tmp);
624 Py_DECREF(tmp);
625 }
626
627 /* Add descriptors for custom slots from __slots__, or for __dict__ */
628 mp = et->members;
629 slotoffset = PyType_BASICSIZE(base);
630 if (slots != NULL) {
631 for (i = 0; i < nslots; i++, mp++) {
632 mp->name = PyString_AS_STRING(
633 PyTuple_GET_ITEM(slots, i));
634 mp->type = T_OBJECT;
635 mp->offset = slotoffset;
636 slotoffset += sizeof(PyObject *);
637 }
638 }
639 else if (nslots) {
640 type->tp_dictoffset = slotoffset;
641 mp->name = "__dict__";
642 mp->type = T_OBJECT;
643 mp->offset = slotoffset;
644 mp->readonly = 1;
645 slotoffset += sizeof(PyObject *);
646 }
647 type->tp_basicsize = slotoffset;
648 type->tp_members = et->members;
649
650 /* Special case some slots */
651 if (type->tp_dictoffset != 0 || nslots > 0) {
652 if (base->tp_getattr == NULL && base->tp_getattro == NULL)
653 type->tp_getattro = PyObject_GenericGetAttr;
654 if (base->tp_setattr == NULL && base->tp_setattro == NULL)
655 type->tp_setattro = PyObject_GenericSetAttr;
656 }
657 type->tp_dealloc = subtype_dealloc;
658
659 /* Always override allocation strategy to use regular heap */
660 type->tp_alloc = PyType_GenericAlloc;
661 type->tp_free = _PyObject_Del;
662
663 /* Initialize the rest */
664 if (PyType_Ready(type) < 0) {
665 Py_DECREF(type);
666 return NULL;
667 }
668
669 /* Override slots that deserve it */
670 override_slots(type, type->tp_defined);
671
672 return (PyObject *)type;
673 }
674
675 /* Internal API to look for a name through the MRO.
676 This returns a borrowed reference, and doesn't set an exception! */
677 PyObject *
678 _PyType_Lookup(PyTypeObject *type, PyObject *name)
679 {
680 int i, n;
681 PyObject *mro, *res, *dict;
682
683 /* For static types, look in tp_dict */
684 if (!(type->tp_flags & Py_TPFLAGS_DYNAMICTYPE)) {
685 dict = type->tp_dict;
686 assert(dict && PyDict_Check(dict));
687 return PyDict_GetItem(dict, name);
688 }
689
690 /* For dynamic types, look in tp_defined of types in MRO */
691 mro = type->tp_mro;
692 assert(PyTuple_Check(mro));
693 n = PyTuple_GET_SIZE(mro);
694 for (i = 0; i < n; i++) {
695 type = (PyTypeObject *) PyTuple_GET_ITEM(mro, i);
696 assert(PyType_Check(type));
697 dict = type->tp_defined;
698 assert(dict && PyDict_Check(dict));
699 res = PyDict_GetItem(dict, name);
700 if (res != NULL)
701 return res;
702 }
703 return NULL;
704 }
705
706 /* This is similar to PyObject_GenericGetAttr(),
707 but uses _PyType_Lookup() instead of just looking in type->tp_dict. */
708 static PyObject *
709 type_getattro(PyTypeObject *type, PyObject *name)
710 {
711 PyTypeObject *metatype = type->ob_type;
712 PyObject *descr, *res;
713 descrgetfunc f;
714
715 /* Initialize this type (we'll assume the metatype is initialized) */
716 if (type->tp_dict == NULL) {
717 if (PyType_Ready(type) < 0)
718 return NULL;
719 }
720
721 /* Get a descriptor from the metatype */
722 descr = _PyType_Lookup(metatype, name);
723 f = NULL;
724 if (descr != NULL) {
725 f = descr->ob_type->tp_descr_get;
726 if (f != NULL && PyDescr_IsData(descr))
727 return f(descr,
728 (PyObject *)type, (PyObject *)metatype);
729 }
730
731 /* Look in tp_defined of this type and its bases */
732 res = _PyType_Lookup(type, name);
733 if (res != NULL) {
734 f = res->ob_type->tp_descr_get;
735 if (f != NULL)
736 return f(res, (PyObject *)NULL, (PyObject *)type);
737 Py_INCREF(res);
738 return res;
739 }
740
741 /* Use the descriptor from the metatype */
742 if (f != NULL) {
743 res = f(descr, (PyObject *)type, (PyObject *)metatype);
744 return res;
745 }
746 if (descr != NULL) {
747 Py_INCREF(descr);
748 return descr;
749 }
750
751 /* Give up */
752 PyErr_Format(PyExc_AttributeError,
753 "type object '%.50s' has no attribute '%.400s'",
754 type->tp_name, PyString_AS_STRING(name));
755 return NULL;
756 }
757
758 static int
759 type_setattro(PyTypeObject *type, PyObject *name, PyObject *value)
760 {
761 if (type->tp_flags & Py_TPFLAGS_DYNAMICTYPE)
762 return PyObject_GenericSetAttr((PyObject *)type, name, value);
763 PyErr_SetString(PyExc_TypeError, "can't set type attributes");
764 return -1;
765 }
766
767 static void
768 type_dealloc(PyTypeObject *type)
769 {
770 etype *et;
771
772 /* Assert this is a heap-allocated type object */
773 assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
774 et = (etype *)type;
775 Py_XDECREF(type->tp_base);
776 Py_XDECREF(type->tp_dict);
777 Py_XDECREF(type->tp_bases);
778 Py_XDECREF(type->tp_mro);
779 Py_XDECREF(type->tp_defined);
780 /* XXX more? */
781 Py_XDECREF(et->name);
782 Py_XDECREF(et->slots);
783 type->ob_type->tp_free((PyObject *)type);
784 }
785
786 static PyMethodDef type_methods[] = {
787 {"mro", mro_external, METH_VARARGS,
788 "mro() -> list\nreturn a type's method resolution order"},
789 {0}
790 };
791
792 static char type_doc[] =
793 "type(object) -> the object's type\n"
794 "type(name, bases, dict) -> a new type";
795
796 PyTypeObject PyType_Type = {
797 PyObject_HEAD_INIT(&PyType_Type)
798 0, /* ob_size */
799 "type", /* tp_name */
800 sizeof(etype), /* tp_basicsize */
801 sizeof(struct memberlist), /* tp_itemsize */
802 (destructor)type_dealloc, /* tp_dealloc */
803 0, /* tp_print */
804 0, /* tp_getattr */
805 0, /* tp_setattr */
806 type_compare, /* tp_compare */
807 (reprfunc)type_repr, /* tp_repr */
808 0, /* tp_as_number */
809 0, /* tp_as_sequence */
810 0, /* tp_as_mapping */
811 (hashfunc)_Py_HashPointer, /* tp_hash */
812 (ternaryfunc)type_call, /* tp_call */
813 0, /* tp_str */
814 (getattrofunc)type_getattro, /* tp_getattro */
815 (setattrofunc)type_setattro, /* tp_setattro */
816 0, /* tp_as_buffer */
817 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
818 type_doc, /* tp_doc */
819 0, /* tp_traverse */
820 0, /* tp_clear */
821 0, /* tp_richcompare */
822 0, /* tp_weaklistoffset */
823 0, /* tp_iter */
824 0, /* tp_iternext */
825 type_methods, /* tp_methods */
826 type_members, /* tp_members */
827 type_getsets, /* tp_getset */
828 0, /* tp_base */
829 0, /* tp_dict */
830 0, /* tp_descr_get */
831 0, /* tp_descr_set */
832 offsetof(PyTypeObject, tp_dict), /* tp_dictoffset */
833 0, /* tp_init */
834 0, /* tp_alloc */
835 type_new, /* tp_new */
836 };
837
838
839 /* The base type of all types (eventually)... except itself. */
840
841 static int
842 object_init(PyObject *self, PyObject *args, PyObject *kwds)
843 {
844 return 0;
845 }
846
847 static void
848 object_dealloc(PyObject *self)
849 {
850 self->ob_type->tp_free(self);
851 }
852
853 static void
854 object_free(PyObject *self)
855 {
856 PyObject_Del(self);
857 }
858
859 static struct memberlist object_members[] = {
860 {"__class__", T_OBJECT, offsetof(PyObject, ob_type), READONLY},
861 {0}
862 };
863
864 PyTypeObject PyBaseObject_Type = {
865 PyObject_HEAD_INIT(&PyType_Type)
866 0, /* ob_size */
867 "object", /* tp_name */
868 sizeof(PyObject), /* tp_basicsize */
869 0, /* tp_itemsize */
870 (destructor)object_dealloc, /* tp_dealloc */
871 0, /* tp_print */
872 0, /* tp_getattr */
873 0, /* tp_setattr */
874 0, /* tp_compare */
875 0, /* tp_repr */
876 0, /* tp_as_number */
877 0, /* tp_as_sequence */
878 0, /* tp_as_mapping */
879 0, /* tp_hash */
880 0, /* tp_call */
881 0, /* tp_str */
882 PyObject_GenericGetAttr, /* tp_getattro */
883 PyObject_GenericSetAttr, /* tp_setattro */
884 0, /* tp_as_buffer */
885 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
886 "The most base type", /* tp_doc */
887 0, /* tp_traverse */
888 0, /* tp_clear */
889 0, /* tp_richcompare */
890 0, /* tp_weaklistoffset */
891 0, /* tp_iter */
892 0, /* tp_iternext */
893 0, /* tp_methods */
894 object_members, /* tp_members */
895 0, /* tp_getset */
896 0, /* tp_base */
897 0, /* tp_dict */
898 0, /* tp_descr_get */
899 0, /* tp_descr_set */
900 0, /* tp_dictoffset */
901 object_init, /* tp_init */
902 PyType_GenericAlloc, /* tp_alloc */
903 PyType_GenericNew, /* tp_new */
904 object_free, /* tp_free */
905 };
906
907
908 /* Initialize the __dict__ in a type object */
909
910 static int
911 add_methods(PyTypeObject *type, PyMethodDef *meth)
912 {
913 PyObject *dict = type->tp_defined;
914
915 for (; meth->ml_name != NULL; meth++) {
916 PyObject *descr;
917 if (PyDict_GetItemString(dict, meth->ml_name))
918 continue;
919 descr = PyDescr_NewMethod(type, meth);
920 if (descr == NULL)
921 return -1;
922 if (PyDict_SetItemString(dict,meth->ml_name,descr) < 0)
923 return -1;
924 Py_DECREF(descr);
925 }
926 return 0;
927 }
928
929 static int
930 add_members(PyTypeObject *type, struct memberlist *memb)
931 {
932 PyObject *dict = type->tp_defined;
933
934 for (; memb->name != NULL; memb++) {
935 PyObject *descr;
936 if (PyDict_GetItemString(dict, memb->name))
937 continue;
938 descr = PyDescr_NewMember(type, memb);
939 if (descr == NULL)
940 return -1;
941 if (PyDict_SetItemString(dict, memb->name, descr) < 0)
942 return -1;
943 Py_DECREF(descr);
944 }
945 return 0;
946 }
947
948 static int
949 add_getset(PyTypeObject *type, struct getsetlist *gsp)
950 {
951 PyObject *dict = type->tp_defined;
952
953 for (; gsp->name != NULL; gsp++) {
954 PyObject *descr;
955 if (PyDict_GetItemString(dict, gsp->name))
956 continue;
957 descr = PyDescr_NewGetSet(type, gsp);
958
959 if (descr == NULL)
960 return -1;
961 if (PyDict_SetItemString(dict, gsp->name, descr) < 0)
962 return -1;
963 Py_DECREF(descr);
964 }
965 return 0;
966 }
967
968 static void
969 inherit_special(PyTypeObject *type, PyTypeObject *base)
970 {
971 int oldsize, newsize;
972
973 /* Special flag magic */
974 if (!type->tp_as_buffer && base->tp_as_buffer) {
975 type->tp_flags &= ~Py_TPFLAGS_HAVE_GETCHARBUFFER;
976 type->tp_flags |=
977 base->tp_flags & Py_TPFLAGS_HAVE_GETCHARBUFFER;
978 }
979 if (!type->tp_as_sequence && base->tp_as_sequence) {
980 type->tp_flags &= ~Py_TPFLAGS_HAVE_SEQUENCE_IN;
981 type->tp_flags |= base->tp_flags & Py_TPFLAGS_HAVE_SEQUENCE_IN;
982 }
983 if ((type->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS) !=
984 (base->tp_flags & Py_TPFLAGS_HAVE_INPLACEOPS)) {
985 if ((!type->tp_as_number && base->tp_as_number) ||
986 (!type->tp_as_sequence && base->tp_as_sequence)) {
987 type->tp_flags &= ~Py_TPFLAGS_HAVE_INPLACEOPS;
988 if (!type->tp_as_number && !type->tp_as_sequence) {
989 type->tp_flags |= base->tp_flags &
990 Py_TPFLAGS_HAVE_INPLACEOPS;
991 }
992 }
993 /* Wow */
994 }
995 if (!type->tp_as_number && base->tp_as_number) {
996 type->tp_flags &= ~Py_TPFLAGS_CHECKTYPES;
997 type->tp_flags |= base->tp_flags & Py_TPFLAGS_CHECKTYPES;
998 }
999
1000 /* Copying basicsize is connected to the GC flags */
1001 oldsize = PyType_BASICSIZE(base);
1002 newsize = type->tp_basicsize ? PyType_BASICSIZE(type) : oldsize;
1003 if (!(type->tp_flags & Py_TPFLAGS_GC) &&
1004 (base->tp_flags & Py_TPFLAGS_GC) &&
1005 (type->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE/*GC slots exist*/) &&
1006 (!type->tp_traverse && !type->tp_clear)) {
1007 type->tp_flags |= Py_TPFLAGS_GC;
1008 if (type->tp_traverse == NULL)
1009 type->tp_traverse = base->tp_traverse;
1010 if (type->tp_clear == NULL)
1011 type->tp_clear = base->tp_clear;
1012 }
1013 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) {
1014 if (base != &PyBaseObject_Type ||
1015 (type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
1016 if (type->tp_new == NULL)
1017 type->tp_new = base->tp_new;
1018 }
1019 }
1020 PyType_SET_BASICSIZE(type, newsize);
1021 }
1022
1023 static void
1024 inherit_slots(PyTypeObject *type, PyTypeObject *base)
1025 {
1026 PyTypeObject *basebase;
1027
1028 #undef SLOTDEFINED
1029 #undef COPYSLOT
1030 #undef COPYNUM
1031 #undef COPYSEQ
1032 #undef COPYMAP
1033
1034 #define SLOTDEFINED(SLOT) \
1035 (base->SLOT != 0 && \
1036 (basebase == NULL || base->SLOT != basebase->SLOT))
1037
1038 #define COPYSLOT(SLOT) \
1039 if (!type->SLOT && SLOTDEFINED(SLOT)) type->SLOT = base->SLOT
1040
1041 #define COPYNUM(SLOT) COPYSLOT(tp_as_number->SLOT)
1042 #define COPYSEQ(SLOT) COPYSLOT(tp_as_sequence->SLOT)
1043 #define COPYMAP(SLOT) COPYSLOT(tp_as_mapping->SLOT)
1044
1045 /* This won't inherit indirect slots (from tp_as_number etc.)
1046 if type doesn't provide the space. */
1047
1048 if (type->tp_as_number != NULL && base->tp_as_number != NULL) {
1049 basebase = base->tp_base;
1050 if (basebase->tp_as_number == NULL)
1051 basebase = NULL;
1052 COPYNUM(nb_add);
1053 COPYNUM(nb_subtract);
1054 COPYNUM(nb_multiply);
1055 COPYNUM(nb_divide);
1056 COPYNUM(nb_remainder);
1057 COPYNUM(nb_divmod);
1058 COPYNUM(nb_power);
1059 COPYNUM(nb_negative);
1060 COPYNUM(nb_positive);
1061 COPYNUM(nb_absolute);
1062 COPYNUM(nb_nonzero);
1063 COPYNUM(nb_invert);
1064 COPYNUM(nb_lshift);
1065 COPYNUM(nb_rshift);
1066 COPYNUM(nb_and);
1067 COPYNUM(nb_xor);
1068 COPYNUM(nb_or);
1069 COPYNUM(nb_coerce);
1070 COPYNUM(nb_int);
1071 COPYNUM(nb_long);
1072 COPYNUM(nb_float);
1073 COPYNUM(nb_oct);
1074 COPYNUM(nb_hex);
1075 COPYNUM(nb_inplace_add);
1076 COPYNUM(nb_inplace_subtract);
1077 COPYNUM(nb_inplace_multiply);
1078 COPYNUM(nb_inplace_divide);
1079 COPYNUM(nb_inplace_remainder);
1080 COPYNUM(nb_inplace_power);
1081 COPYNUM(nb_inplace_lshift);
1082 COPYNUM(nb_inplace_rshift);
1083 COPYNUM(nb_inplace_and);
1084 COPYNUM(nb_inplace_xor);
1085 COPYNUM(nb_inplace_or);
1086 if (base->tp_flags & Py_TPFLAGS_CHECKTYPES) {
1087 COPYNUM(nb_true_divide);
1088 COPYNUM(nb_floor_divide);
1089 COPYNUM(nb_inplace_true_divide);
1090 COPYNUM(nb_inplace_floor_divide);
1091 }
1092 }
1093
1094 if (type->tp_as_sequence != NULL && base->tp_as_sequence != NULL) {
1095 basebase = base->tp_base;
1096 if (basebase->tp_as_sequence == NULL)
1097 basebase = NULL;
1098 COPYSEQ(sq_length);
1099 COPYSEQ(sq_concat);
1100 COPYSEQ(sq_repeat);
1101 COPYSEQ(sq_item);
1102 COPYSEQ(sq_slice);
1103 COPYSEQ(sq_ass_item);
1104 COPYSEQ(sq_ass_slice);
1105 COPYSEQ(sq_contains);
1106 COPYSEQ(sq_inplace_concat);
1107 COPYSEQ(sq_inplace_repeat);
1108 }
1109
1110 if (type->tp_as_mapping != NULL && base->tp_as_mapping != NULL) {
1111 basebase = base->tp_base;
1112 if (basebase->tp_as_mapping == NULL)
1113 basebase = NULL;
1114 COPYMAP(mp_length);
1115 COPYMAP(mp_subscript);
1116 COPYMAP(mp_ass_subscript);
1117 }
1118
1119 basebase = base->tp_base;
1120
1121 COPYSLOT(tp_itemsize);
1122 COPYSLOT(tp_dealloc);
1123 COPYSLOT(tp_print);
1124 if (type->tp_getattr == NULL && type->tp_getattro == NULL) {
1125 type->tp_getattr = base->tp_getattr;
1126 type->tp_getattro = base->tp_getattro;
1127 }
1128 if (type->tp_setattr == NULL && type->tp_setattro == NULL) {
1129 type->tp_setattr = base->tp_setattr;
1130 type->tp_setattro = base->tp_setattro;
1131 }
1132 /* tp_compare see tp_richcompare */
1133 COPYSLOT(tp_repr);
1134 COPYSLOT(tp_hash);
1135 COPYSLOT(tp_call);
1136 COPYSLOT(tp_str);
1137 COPYSLOT(tp_as_buffer);
1138 COPYSLOT(tp_flags);
1139 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_RICHCOMPARE) {
1140 if (type->tp_compare == NULL && type->tp_richcompare == NULL) {
1141 type->tp_compare = base->tp_compare;
1142 type->tp_richcompare = base->tp_richcompare;
1143 }
1144 }
1145 else {
1146 COPYSLOT(tp_compare);
1147 }
1148 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_WEAKREFS) {
1149 COPYSLOT(tp_weaklistoffset);
1150 }
1151 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_ITER) {
1152 COPYSLOT(tp_iter);
1153 COPYSLOT(tp_iternext);
1154 }
1155 if (type->tp_flags & base->tp_flags & Py_TPFLAGS_HAVE_CLASS) {
1156 COPYSLOT(tp_descr_get);
1157 COPYSLOT(tp_descr_set);
1158 COPYSLOT(tp_dictoffset);
1159 COPYSLOT(tp_init);
1160 COPYSLOT(tp_alloc);
1161 COPYSLOT(tp_free);
1162 }
1163 }
1164
1165 staticforward int add_operators(PyTypeObject *);
1166
1167 int
1168 PyType_Ready(PyTypeObject *type)
1169 {
1170 PyObject *dict, *bases, *x;
1171 PyTypeObject *base;
1172 int i, n;
1173
1174 if (type->tp_flags & Py_TPFLAGS_READY) {
1175 assert(type->tp_dict != NULL);
1176 return 0;
1177 }
1178 assert((type->tp_flags & Py_TPFLAGS_READYING) == 0);
1179 assert(type->tp_dict == NULL);
1180
1181 type->tp_flags |= Py_TPFLAGS_READYING;
1182
1183 /* Initialize tp_base (defaults to BaseObject unless that's us) */
1184 base = type->tp_base;
1185 if (base == NULL && type != &PyBaseObject_Type)
1186 base = type->tp_base = &PyBaseObject_Type;
1187
1188 /* Initialize tp_bases */
1189 bases = type->tp_bases;
1190 if (bases == NULL) {
1191 if (base == NULL)
1192 bases = PyTuple_New(0);
1193 else
1194 bases = Py_BuildValue("(O)", base);
1195 if (bases == NULL)
1196 goto error;
1197 type->tp_bases = bases;
1198 }
1199
1200 /* Initialize the base class */
1201 if (base && base->tp_dict == NULL) {
1202 if (PyType_Ready(base) < 0)
1203 goto error;
1204 }
1205
1206 /* Initialize tp_defined */
1207 dict = type->tp_defined;
1208 if (dict == NULL) {
1209 dict = PyDict_New();
1210 if (dict == NULL)
1211 goto error;
1212 type->tp_defined = dict;
1213 }
1214
1215 /* Add type-specific descriptors to tp_defined */
1216 if (add_operators(type) < 0)
1217 goto error;
1218 if (type->tp_methods != NULL) {
1219 if (add_methods(type, type->tp_methods) < 0)
1220 goto error;
1221 }
1222 if (type->tp_members != NULL) {
1223 if (add_members(type, type->tp_members) < 0)
1224 goto error;
1225 }
1226 if (type->tp_getset != NULL) {
1227 if (add_getset(type, type->tp_getset) < 0)
1228 goto error;
1229 }
1230
1231 /* Temporarily make tp_dict the same object as tp_defined.
1232 (This is needed to call mro(), and can stay this way for
1233 dynamic types). */
1234 Py_INCREF(type->tp_defined);
1235 type->tp_dict = type->tp_defined;
1236
1237 /* Calculate method resolution order */
1238 if (mro_internal(type) < 0) {
1239 goto error;
1240 }
1241
1242 /* Inherit special flags from dominant base */
1243 if (type->tp_base != NULL)
1244 inherit_special(type, type->tp_base);
1245
1246 /* Initialize tp_dict properly */
1247 if (!PyType_HasFeature(type, Py_TPFLAGS_DYNAMICTYPE)) {
1248 /* For a static type, tp_dict is the consolidation
1249 of the tp_defined of its bases in MRO. */
1250 Py_DECREF(type->tp_dict);
1251 type->tp_dict = PyDict_Copy(type->tp_defined);
1252 if (type->tp_dict == NULL)
1253 goto error;
1254 bases = type->tp_mro;
1255 assert(bases != NULL);
1256 assert(PyTuple_Check(bases));
1257 n = PyTuple_GET_SIZE(bases);
1258 for (i = 1; i < n; i++) {
1259 base = (PyTypeObject *)PyTuple_GET_ITEM(bases, i);
1260 assert(PyType_Check(base));
1261 x = base->tp_defined;
1262 if (x != NULL && PyDict_Merge(type->tp_dict, x, 0) < 0)
1263 goto error;
1264 inherit_slots(type, base);
1265 }
1266 }
1267
1268 /* Some more special stuff */
1269 base = type->tp_base;
1270 if (base != NULL) {
1271 if (type->tp_as_number == NULL)
1272 type->tp_as_number = base->tp_as_number;
1273 if (type->tp_as_sequence == NULL)
1274 type->tp_as_sequence = base->tp_as_sequence;
1275 if (type->tp_as_mapping == NULL)
1276 type->tp_as_mapping = base->tp_as_mapping;
1277 }
1278
1279 /* All done -- set the ready flag */
1280 assert(type->tp_dict != NULL);
1281 type->tp_flags =
1282 (type->tp_flags & ~Py_TPFLAGS_READYING) | Py_TPFLAGS_READY;
1283 return 0;
1284
1285 error:
1286 type->tp_flags &= ~Py_TPFLAGS_READYING;
1287 return -1;
1288 }
1289
1290
1291 /* Generic wrappers for overloadable 'operators' such as __getitem__ */
1292
1293 /* There's a wrapper *function* for each distinct function typedef used
1294 for type object slots (e.g. binaryfunc, ternaryfunc, etc.). There's a
1295 wrapper *table* for each distinct operation (e.g. __len__, __add__).
1296 Most tables have only one entry; the tables for binary operators have two
1297 entries, one regular and one with reversed arguments. */
1298
1299 static PyObject *
1300 wrap_inquiry(PyObject *self, PyObject *args, void *wrapped)
1301 {
1302 inquiry func = (inquiry)wrapped;
1303 int res;
1304
1305 if (!PyArg_ParseTuple(args, ""))
1306 return NULL;
1307 res = (*func)(self);
1308 if (res == -1 && PyErr_Occurred())
1309 return NULL;
1310 return PyInt_FromLong((long)res);
1311 }
1312
1313 static struct wrapperbase tab_len[] = {
1314 {"__len__", (wrapperfunc)wrap_inquiry, "x.__len__() <==> len(x)"},
1315 {0}
1316 };
1317
1318 static PyObject *
1319 wrap_binaryfunc(PyObject *self, PyObject *args, void *wrapped)
1320 {
1321 binaryfunc func = (binaryfunc)wrapped;
1322 PyObject *other;
1323
1324 if (!PyArg_ParseTuple(args, "O", &other))
1325 return NULL;
1326 return (*func)(self, other);
1327 }
1328
1329 static PyObject *
1330 wrap_binaryfunc_r(PyObject *self, PyObject *args, void *wrapped)
1331 {
1332 binaryfunc func = (binaryfunc)wrapped;
1333 PyObject *other;
1334
1335 if (!PyArg_ParseTuple(args, "O", &other))
1336 return NULL;
1337 return (*func)(other, self);
1338 }
1339
1340 #undef BINARY
1341 #define BINARY(NAME, OP) \
1342 static struct wrapperbase tab_##NAME[] = { \
1343 {"__" #NAME "__", \
1344 (wrapperfunc)wrap_binaryfunc, \
1345 "x.__" #NAME "__(y) <==> " #OP}, \
1346 {"__r" #NAME "__", \
1347 (wrapperfunc)wrap_binaryfunc_r, \
1348 "y.__r" #NAME "__(x) <==> " #OP}, \
1349 {0} \
1350 }
1351
1352 BINARY(add, "x+y");
1353 BINARY(sub, "x-y");
1354 BINARY(mul, "x*y");
1355 BINARY(div, "x/y");
1356 BINARY(mod, "x%y");
1357 BINARY(divmod, "divmod(x,y)");
1358 BINARY(lshift, "x<<y");
1359 BINARY(rshift, "x>>y");
1360 BINARY(and, "x&y");
1361 BINARY(xor, "x^y");
1362 BINARY(or, "x|y");
1363
1364 static PyObject *
1365 wrap_ternaryfunc(PyObject *self, PyObject *args, void *wrapped)
1366 {
1367 ternaryfunc func = (ternaryfunc)wrapped;
1368 PyObject *other;
1369 PyObject *third = Py_None;
1370
1371 /* Note: This wrapper only works for __pow__() */
1372
1373 if (!PyArg_ParseTuple(args, "O|O", &other, &third))
1374 return NULL;
1375 return (*func)(self, other, third);
1376 }
1377
1378 #undef TERNARY
1379 #define TERNARY(NAME, OP) \
1380 static struct wrapperbase tab_##NAME[] = { \
1381 {"__" #NAME "__", \
1382 (wrapperfunc)wrap_ternaryfunc, \
1383 "x.__" #NAME "__(y, z) <==> " #OP}, \
1384 {"__r" #NAME "__", \
1385 (wrapperfunc)wrap_ternaryfunc, \
1386 "y.__r" #NAME "__(x, z) <==> " #OP}, \
1387 {0} \
1388 }
1389
1390 TERNARY(pow, "(x**y) % z");
1391
1392 #undef UNARY
1393 #define UNARY(NAME, OP) \
1394 static struct wrapperbase tab_##NAME[] = { \
1395 {"__" #NAME "__", \
1396 (wrapperfunc)wrap_unaryfunc, \
1397 "x.__" #NAME "__() <==> " #OP}, \
1398 {0} \
1399 }
1400
1401 static PyObject *
1402 wrap_unaryfunc(PyObject *self, PyObject *args, void *wrapped)
1403 {
1404 unaryfunc func = (unaryfunc)wrapped;
1405
1406 if (!PyArg_ParseTuple(args, ""))
1407 return NULL;
1408 return (*func)(self);
1409 }
1410
1411 UNARY(neg, "-x");
1412 UNARY(pos, "+x");
1413 UNARY(abs, "abs(x)");
1414 UNARY(nonzero, "x != 0");
1415 UNARY(invert, "~x");
1416 UNARY(int, "int(x)");
1417 UNARY(long, "long(x)");
1418 UNARY(float, "float(x)");
1419 UNARY(oct, "oct(x)");
1420 UNARY(hex, "hex(x)");
1421
1422 #undef IBINARY
1423 #define IBINARY(NAME, OP) \
1424 static struct wrapperbase tab_##NAME[] = { \
1425 {"__" #NAME "__", \
1426 (wrapperfunc)wrap_binaryfunc, \
1427 "x.__" #NAME "__(y) <==> " #OP}, \
1428 {0} \
1429 }
1430
1431 IBINARY(iadd, "x+=y");
1432 IBINARY(isub, "x-=y");
1433 IBINARY(imul, "x*=y");
1434 IBINARY(idiv, "x/=y");
1435 IBINARY(imod, "x%=y");
1436 IBINARY(ilshift, "x<<=y");
1437 IBINARY(irshift, "x>>=y");
1438 IBINARY(iand, "x&=y");
1439 IBINARY(ixor, "x^=y");
1440 IBINARY(ior, "x|=y");
1441
1442 #undef ITERNARY
1443 #define ITERNARY(NAME, OP) \
1444 static struct wrapperbase tab_##NAME[] = { \
1445 {"__" #NAME "__", \
1446 (wrapperfunc)wrap_ternaryfunc, \
1447 "x.__" #NAME "__(y) <==> " #OP}, \
1448 {0} \
1449 }
1450
1451 ITERNARY(ipow, "x = (x**y) % z");
1452
1453 static struct wrapperbase tab_getitem[] = {
1454 {"__getitem__", (wrapperfunc)wrap_binaryfunc,
1455 "x.__getitem__(y) <==> x[y]"},
1456 {0}
1457 };
1458
1459 static PyObject *
1460 wrap_intargfunc(PyObject *self, PyObject *args, void *wrapped)
1461 {
1462 intargfunc func = (intargfunc)wrapped;
1463 int i;
1464
1465 if (!PyArg_ParseTuple(args, "i", &i))
1466 return NULL;
1467 return (*func)(self, i);
1468 }
1469
1470 static struct wrapperbase tab_mul_int[] = {
1471 {"__mul__", (wrapperfunc)wrap_intargfunc, "x.__mul__(n) <==> x*n"},
1472 {"__rmul__", (wrapperfunc)wrap_intargfunc, "x.__rmul__(n) <==> n*x"},
1473 {0}
1474 };
1475
1476 static struct wrapperbase tab_concat[] = {
1477 {"__add__", (wrapperfunc)wrap_binaryfunc, "x.__add__(y) <==> x+y"},
1478 {0}
1479 };
1480
1481 static struct wrapperbase tab_imul_int[] = {
1482 {"__imul__", (wrapperfunc)wrap_intargfunc, "x.__imul__(n) <==> x*=n"},
1483 {0}
1484 };
1485
1486 static struct wrapperbase tab_getitem_int[] = {
1487 {"__getitem__", (wrapperfunc)wrap_intargfunc,
1488 "x.__getitem__(i) <==> x[i]"},
1489 {0}
1490 };
1491
1492 static PyObject *
1493 wrap_intintargfunc(PyObject *self, PyObject *args, void *wrapped)
1494 {
1495 intintargfunc func = (intintargfunc)wrapped;
1496 int i, j;
1497
1498 if (!PyArg_ParseTuple(args, "ii", &i, &j))
1499 return NULL;
1500 return (*func)(self, i, j);
1501 }
1502
1503 static struct wrapperbase tab_getslice[] = {
1504 {"__getslice__", (wrapperfunc)wrap_intintargfunc,
1505 "x.__getslice__(i, j) <==> x[i:j]"},
1506 {0}
1507 };
1508
1509 static PyObject *
1510 wrap_intobjargproc(PyObject *self, PyObject *args, void *wrapped)
1511 {
1512 intobjargproc func = (intobjargproc)wrapped;
1513 int i, res;
1514 PyObject *value;
1515
1516 if (!PyArg_ParseTuple(args, "iO", &i, &value))
1517 return NULL;
1518 res = (*func)(self, i, value);
1519 if (res == -1 && PyErr_Occurred())
1520 return NULL;
1521 Py_INCREF(Py_None);
1522 return Py_None;
1523 }
1524
1525 static PyObject *
1526 wrap_delitem_int(PyObject *self, PyObject *args, void *wrapped)
1527 {
1528 intobjargproc func = (intobjargproc)wrapped;
1529 int i, res;
1530
1531 if (!PyArg_ParseTuple(args, "i", &i))
1532 return NULL;
1533 res = (*func)(self, i, NULL);
1534 if (res == -1 && PyErr_Occurred())
1535 return NULL;
1536 Py_INCREF(Py_None);
1537 return Py_None;
1538 }
1539
1540 static struct wrapperbase tab_setitem_int[] = {
1541 {"__setitem__", (wrapperfunc)wrap_intobjargproc,
1542 "x.__setitem__(i, y) <==> x[i]=y"},
1543 {"__delitem__", (wrapperfunc)wrap_delitem_int,
1544 "x.__delitem__(y) <==> del x[y]"},
1545 {0}
1546 };
1547
1548 static PyObject *
1549 wrap_intintobjargproc(PyObject *self, PyObject *args, void *wrapped)
1550 {
1551 intintobjargproc func = (intintobjargproc)wrapped;
1552 int i, j, res;
1553 PyObject *value;
1554
1555 if (!PyArg_ParseTuple(args, "iiO", &i, &j, &value))
1556 return NULL;
1557 res = (*func)(self, i, j, value);
1558 if (res == -1 && PyErr_Occurred())
1559 return NULL;
1560 Py_INCREF(Py_None);
1561 return Py_None;
1562 }
1563
1564 static struct wrapperbase tab_setslice[] = {
1565 {"__setslice__", (wrapperfunc)wrap_intintobjargproc,
1566 "x.__setslice__(i, j, y) <==> x[i:j]=y"},
1567 {0}
1568 };
1569
1570 /* XXX objobjproc is a misnomer; should be objargpred */
1571 static PyObject *
1572 wrap_objobjproc(PyObject *self, PyObject *args, void *wrapped)
1573 {
1574 objobjproc func = (objobjproc)wrapped;
1575 int res;
1576 PyObject *value;
1577
1578 if (!PyArg_ParseTuple(args, "O", &value))
1579 return NULL;
1580 res = (*func)(self, value);
1581 if (res == -1 && PyErr_Occurred())
1582 return NULL;
1583 return PyInt_FromLong((long)res);
1584 }
1585
1586 static struct wrapperbase tab_contains[] = {
1587 {"__contains__", (wrapperfunc)wrap_objobjproc,
1588 "x.__contains__(y) <==> y in x"},
1589 {0}
1590 };
1591
1592 static PyObject *
1593 wrap_objobjargproc(PyObject *self, PyObject *args, void *wrapped)
1594 {
1595 objobjargproc func = (objobjargproc)wrapped;
1596 int res;
1597 PyObject *key, *value;
1598
1599 if (!PyArg_ParseTuple(args, "OO", &key, &value))
1600 return NULL;
1601 res = (*func)(self, key, value);
1602 if (res == -1 && PyErr_Occurred())
1603 return NULL;
1604 Py_INCREF(Py_None);
1605 return Py_None;
1606 }
1607
1608 static PyObject *
1609 wrap_delitem(PyObject *self, PyObject *args, void *wrapped)
1610 {
1611 objobjargproc func = (objobjargproc)wrapped;
1612 int res;
1613 PyObject *key;
1614
1615 if (!PyArg_ParseTuple(args, "O", &key))
1616 return NULL;
1617 res = (*func)(self, key, NULL);
1618 if (res == -1 && PyErr_Occurred())
1619 return NULL;
1620 Py_INCREF(Py_None);
1621 return Py_None;
1622 }
1623
1624 static struct wrapperbase tab_setitem[] = {
1625 {"__setitem__", (wrapperfunc)wrap_objobjargproc,
1626 "x.__setitem__(y, z) <==> x[y]=z"},
1627 {"__delitem__", (wrapperfunc)wrap_delitem,
1628 "x.__delitem__(y) <==> del x[y]"},
1629 {0}
1630 };
1631
1632 static PyObject *
1633 wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
1634 {
1635 cmpfunc func = (cmpfunc)wrapped;
1636 int res;
1637 PyObject *other;
1638
1639 if (!PyArg_ParseTuple(args, "O", &other))
1640 return NULL;
1641 res = (*func)(self, other);
1642 if (PyErr_Occurred())
1643 return NULL;
1644 return PyInt_FromLong((long)res);
1645 }
1646
1647 static struct wrapperbase tab_cmp[] = {
1648 {"__cmp__", (wrapperfunc)wrap_cmpfunc,
1649 "x.__cmp__(y) <==> cmp(x,y)"},
1650 {0}
1651 };
1652
1653 static struct wrapperbase tab_repr[] = {
1654 {"__repr__", (wrapperfunc)wrap_unaryfunc,
1655 "x.__repr__() <==> repr(x)"},
1656 {0}
1657 };
1658
1659 static struct wrapperbase tab_getattr[] = {
1660 {"__getattr__", (wrapperfunc)wrap_binaryfunc,
1661 "x.__getattr__('name') <==> x.name"},
1662 {0}
1663 };
1664
1665 static PyObject *
1666 wrap_setattr(PyObject *self, PyObject *args, void *wrapped)
1667 {
1668 setattrofunc func = (setattrofunc)wrapped;
1669 int res;
1670 PyObject *name, *value;
1671
1672 if (!PyArg_ParseTuple(args, "OO", &name, &value))
1673 return NULL;
1674 res = (*func)(self, name, value);
1675 if (res < 0)
1676 return NULL;
1677 Py_INCREF(Py_None);
1678 return Py_None;
1679 }
1680
1681 static PyObject *
1682 wrap_delattr(PyObject *self, PyObject *args, void *wrapped)
1683 {
1684 setattrofunc func = (setattrofunc)wrapped;
1685 int res;
1686 PyObject *name;
1687
1688 if (!PyArg_ParseTuple(args, "O", &name))
1689 return NULL;
1690 res = (*func)(self, name, NULL);
1691 if (res < 0)
1692 return NULL;
1693 Py_INCREF(Py_None);
1694 return Py_None;
1695 }
1696
1697 static struct wrapperbase tab_setattr[] = {
1698 {"__setattr__", (wrapperfunc)wrap_setattr,
1699 "x.__setattr__('name', value) <==> x.name = value"},
1700 {"__delattr__", (wrapperfunc)wrap_delattr,
1701 "x.__delattr__('name') <==> del x.name"},
1702 {0}
1703 };
1704
1705 static PyObject *
1706 wrap_hashfunc(PyObject *self, PyObject *args, void *wrapped)
1707 {
1708 hashfunc func = (hashfunc)wrapped;
1709 long res;
1710
1711 if (!PyArg_ParseTuple(args, ""))
1712 return NULL;
1713 res = (*func)(self);
1714 if (res == -1 && PyErr_Occurred())
1715 return NULL;
1716 return PyInt_FromLong(res);
1717 }
1718
1719 static struct wrapperbase tab_hash[] = {
1720 {"__hash__", (wrapperfunc)wrap_hashfunc,
1721 "x.__hash__() <==> hash(x)"},
1722 {0}
1723 };
1724
1725 static PyObject *
1726 wrap_call(PyObject *self, PyObject *args, void *wrapped)
1727 {
1728 ternaryfunc func = (ternaryfunc)wrapped;
1729
1730 /* XXX What about keyword arguments? */
1731 return (*func)(self, args, NULL);
1732 }
1733
1734 static struct wrapperbase tab_call[] = {
1735 {"__call__", (wrapperfunc)wrap_call,
1736 "x.__call__(...) <==> x(...)"},
1737 {0}
1738 };
1739
1740 static struct wrapperbase tab_str[] = {
1741 {"__str__", (wrapperfunc)wrap_unaryfunc,
1742 "x.__str__() <==> str(x)"},
1743 {0}
1744 };
1745
1746 static PyObject *
1747 wrap_richcmpfunc(PyObject *self, PyObject *args, void *wrapped, int op)
1748 {
1749 richcmpfunc func = (richcmpfunc)wrapped;
1750 PyObject *other;
1751
1752 if (!PyArg_ParseTuple(args, "O", &other))
1753 return NULL;
1754 return (*func)(self, other, op);
1755 }
1756
1757 #undef RICHCMP_WRAPPER
1758 #define RICHCMP_WRAPPER(NAME, OP) \
1759 static PyObject * \
1760 richcmp_##NAME(PyObject *self, PyObject *args, void *wrapped) \
1761 { \
1762 return wrap_richcmpfunc(self, args, wrapped, OP); \
1763 }
1764
1765 RICHCMP_WRAPPER(lt, Py_LT)
1766 RICHCMP_WRAPPER(le, Py_LE)
1767 RICHCMP_WRAPPER(eq, Py_EQ)
1768 RICHCMP_WRAPPER(ne, Py_NE)
1769 RICHCMP_WRAPPER(gt, Py_GT)
1770 RICHCMP_WRAPPER(ge, Py_GE)
1771
1772 #undef RICHCMP_ENTRY
1773 #define RICHCMP_ENTRY(NAME, EXPR) \
1774 {"__" #NAME "__", (wrapperfunc)richcmp_##NAME, \
1775 "x.__" #NAME "__(y) <==> " EXPR}
1776
1777 static struct wrapperbase tab_richcmp[] = {
1778 RICHCMP_ENTRY(lt, "x<y"),
1779 RICHCMP_ENTRY(le, "x<=y"),
1780 RICHCMP_ENTRY(eq, "x==y"),
1781 RICHCMP_ENTRY(ne, "x!=y"),
1782 RICHCMP_ENTRY(gt, "x>y"),
1783 RICHCMP_ENTRY(ge, "x>=y"),
1784 {0}
1785 };
1786
1787 static struct wrapperbase tab_iter[] = {
1788 {"__iter__", (wrapperfunc)wrap_unaryfunc, "x.__iter__() <==> iter(x)"},
1789 {0}
1790 };
1791
1792 static PyObject *
1793 wrap_next(PyObject *self, PyObject *args, void *wrapped)
1794 {
1795 unaryfunc func = (unaryfunc)wrapped;
1796 PyObject *res;
1797
1798 if (!PyArg_ParseTuple(args, ""))
1799 return NULL;
1800 res = (*func)(self);
1801 if (res == NULL && !PyErr_Occurred())
1802 PyErr_SetNone(PyExc_StopIteration);
1803 return res;
1804 }
1805
1806 static struct wrapperbase tab_next[] = {
1807 {"next", (wrapperfunc)wrap_next,
1808 "x.next() -> the next value, or raise StopIteration"},
1809 {0}
1810 };
1811
1812 static PyObject *
1813 wrap_descr_get(PyObject *self, PyObject *args, void *wrapped)
1814 {
1815 descrgetfunc func = (descrgetfunc)wrapped;
1816 PyObject *obj;
1817 PyObject *type = NULL;
1818
1819 if (!PyArg_ParseTuple(args, "O|O", &obj, &type))
1820 return NULL;
1821 if (type == NULL)
1822 type = (PyObject *)obj->ob_type;
1823 return (*func)(self, obj, type);
1824 }
1825
1826 static struct wrapperbase tab_descr_get[] = {
1827 {"__get__", (wrapperfunc)wrap_descr_get,
1828 "descr.__get__(obj, type) -> value"},
1829 {0}
1830 };
1831
1832 static PyObject *
1833 wrap_descrsetfunc(PyObject *self, PyObject *args, void *wrapped)
1834 {
1835 descrsetfunc func = (descrsetfunc)wrapped;
1836 PyObject *obj, *value;
1837 int ret;
1838
1839 if (!PyArg_ParseTuple(args, "OO", &obj, &value))
1840 return NULL;
1841 ret = (*func)(self, obj, value);
1842 if (ret < 0)
1843 return NULL;
1844 Py_INCREF(Py_None);
1845 return Py_None;
1846 }
1847
1848 static struct wrapperbase tab_descr_set[] = {
1849 {"__set__", (wrapperfunc)wrap_descrsetfunc,
1850 "descr.__set__(obj, value)"},
1851 {0}
1852 };
1853
1854 static PyObject *
1855 wrap_init(PyObject *self, PyObject *args, void *wrapped)
1856 {
1857 initproc func = (initproc)wrapped;
1858
1859 /* XXX What about keyword arguments? */
1860 if (func(self, args, NULL) < 0)
1861 return NULL;
1862 Py_INCREF(Py_None);
1863 return Py_None;
1864 }
1865
1866 static struct wrapperbase tab_init[] = {
1867 {"__init__", (wrapperfunc)wrap_init,
1868 "x.__init__(...) initializes x; "
1869 "see x.__type__.__doc__ for signature"},
1870 {0}
1871 };
1872
1873 static PyObject *
1874 tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds)
1875 {
1876 PyTypeObject *type, *subtype;
1877 PyObject *arg0, *res;
1878
1879 if (self == NULL || !PyType_Check(self))
1880 Py_FatalError("__new__() called with non-type 'self'");
1881 type = (PyTypeObject *)self;
1882 if (!PyTuple_Check(args) || PyTuple_GET_SIZE(args) < 1) {
1883 PyErr_SetString(PyExc_TypeError,
1884 "T.__new__(): not enough arguments");
1885 return NULL;
1886 }
1887 arg0 = PyTuple_GET_ITEM(args, 0);
1888 if (!PyType_Check(arg0)) {
1889 PyErr_SetString(PyExc_TypeError,
1890 "T.__new__(S): S is not a type object");
1891 return NULL;
1892 }
1893 subtype = (PyTypeObject *)arg0;
1894 if (!PyType_IsSubtype(subtype, type)) {
1895 PyErr_SetString(PyExc_TypeError,
1896 "T.__new__(S): S is not a subtype of T");
1897 return NULL;
1898 }
1899 args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
1900 if (args == NULL)
1901 return NULL;
1902 res = type->tp_new(subtype, args, kwds);
1903 Py_DECREF(args);
1904 return res;
1905 }
1906
1907 static struct PyMethodDef tp_new_methoddef[] = {
1908 {"__new__", (PyCFunction)tp_new_wrapper, METH_KEYWORDS,
1909 "T.__new__(S, ...) -> a new object with type S, a subtype of T"},
1910 {0}
1911 };
1912
1913 static int
1914 add_tp_new_wrapper(PyTypeObject *type)
1915 {
1916 PyObject *func;
1917
1918 if (PyDict_GetItemString(type->tp_defined, "__new__") != NULL)
1919 return 0;
1920 func = PyCFunction_New(tp_new_methoddef, (PyObject *)type);
1921 if (func == NULL)
1922 return -1;
1923 return PyDict_SetItemString(type->tp_defined, "__new__", func);
1924 }
1925
1926 static int
1927 add_wrappers(PyTypeObject *type, struct wrapperbase *wraps, void *wrapped)
1928 {
1929 PyObject *dict = type->tp_defined;
1930
1931 for (; wraps->name != NULL; wraps++) {
1932 PyObject *descr;
1933 if (PyDict_GetItemString(dict, wraps->name))
1934 continue;
1935 descr = PyDescr_NewWrapper(type, wraps, wrapped);
1936 if (descr == NULL)
1937 return -1;
1938 if (PyDict_SetItemString(dict, wraps->name, descr) < 0)
1939 return -1;
1940 Py_DECREF(descr);
1941 }
1942 return 0;
1943 }
1944
1945 /* This function is called by PyType_Ready() to populate the type's
1946 dictionary with method descriptors for function slots. For each
1947 function slot (like tp_repr) that's defined in the type, one or
1948 more corresponding descriptors are added in the type's tp_defined
1949 dictionary under the appropriate name (like __repr__). Some
1950 function slots cause more than one descriptor to be added (for
1951 example, the nb_add slot adds both __add__ and __radd__
1952 descriptors) and some function slots compete for the same
1953 descriptor (for example both sq_item and mp_subscript generate a
1954 __getitem__ descriptor). This only adds new descriptors and
1955 doesn't overwrite entries in tp_defined that were previously
1956 defined. The descriptors contain a reference to the C function
1957 they must call, so that it's safe if they are copied into a
1958 subtype's __dict__ and the subtype has a different C function in
1959 its slot -- calling the method defined by the descriptor will call
1960 the C function that was used to create it, rather than the C
1961 function present in the slot when it is called. (This is important
1962 because a subtype may have a C function in the slot that calls the
1963 method from the dictionary, and we want to avoid infinite recursion
1964 here.) */
1965
1966 static int
1967 add_operators(PyTypeObject *type)
1968 {
1969 PySequenceMethods *sq;
1970 PyMappingMethods *mp;
1971 PyNumberMethods *nb;
1972
1973 #undef ADD
1974 #define ADD(SLOT, TABLE) \
1975 if (SLOT) { \
1976 if (add_wrappers(type, TABLE, (void *)(SLOT)) < 0) \
1977 return -1; \
1978 }
1979
1980 if ((sq = type->tp_as_sequence) != NULL) {
1981 ADD(sq->sq_length, tab_len);
1982 ADD(sq->sq_concat, tab_concat);
1983 ADD(sq->sq_repeat, tab_mul_int);
1984 ADD(sq->sq_item, tab_getitem_int);
1985 ADD(sq->sq_slice, tab_getslice);
1986 ADD(sq->sq_ass_item, tab_setitem_int);
1987 ADD(sq->sq_ass_slice, tab_setslice);
1988 ADD(sq->sq_contains, tab_contains);
1989 ADD(sq->sq_inplace_concat, tab_iadd);
1990 ADD(sq->sq_inplace_repeat, tab_imul_int);
1991 }
1992
1993 if ((mp = type->tp_as_mapping) != NULL) {
1994 if (sq->sq_length == NULL)
1995 ADD(mp->mp_length, tab_len);
1996 ADD(mp->mp_subscript, tab_getitem);
1997 ADD(mp->mp_ass_subscript, tab_setitem);
1998 }
1999
2000 /* We don't support "old-style numbers" because their binary
2001 operators require that both arguments have the same type;
2002 the wrappers here only work for new-style numbers. */
2003 if ((type->tp_flags & Py_TPFLAGS_CHECKTYPES) &&
2004 (nb = type->tp_as_number) != NULL) {
2005 ADD(nb->nb_add, tab_add);
2006 ADD(nb->nb_subtract, tab_sub);
2007 ADD(nb->nb_multiply, tab_mul);
2008 ADD(nb->nb_divide, tab_div);
2009 ADD(nb->nb_remainder, tab_mod);
2010 ADD(nb->nb_divmod, tab_divmod);
2011 ADD(nb->nb_power, tab_pow);
2012 ADD(nb->nb_negative, tab_neg);
2013 ADD(nb->nb_positive, tab_pos);
2014 ADD(nb->nb_absolute, tab_abs);
2015 ADD(nb->nb_nonzero, tab_nonzero);
2016 ADD(nb->nb_invert, tab_invert);
2017 ADD(nb->nb_lshift, tab_lshift);
2018 ADD(nb->nb_rshift, tab_rshift);
2019 ADD(nb->nb_and, tab_and);
2020 ADD(nb->nb_xor, tab_xor);
2021 ADD(nb->nb_or, tab_or);
2022 /* We don't support coerce() -- see above comment */
2023 ADD(nb->nb_int, tab_int);
2024 ADD(nb->nb_long, tab_long);
2025 ADD(nb->nb_float, tab_float);
2026 ADD(nb->nb_oct, tab_oct);
2027 ADD(nb->nb_hex, tab_hex);
2028 ADD(nb->nb_inplace_add, tab_iadd);
2029 ADD(nb->nb_inplace_subtract, tab_isub);
2030 ADD(nb->nb_inplace_multiply, tab_imul);
2031 ADD(nb->nb_inplace_divide, tab_idiv);
2032 ADD(nb->nb_inplace_remainder, tab_imod);
2033 ADD(nb->nb_inplace_power, tab_ipow);
2034 ADD(nb->nb_inplace_lshift, tab_ilshift);
2035 ADD(nb->nb_inplace_rshift, tab_irshift);
2036 ADD(nb->nb_inplace_and, tab_iand);
2037 ADD(nb->nb_inplace_xor, tab_ixor);
2038 ADD(nb->nb_inplace_or, tab_ior);
2039 }
2040
2041 ADD(type->tp_getattro, tab_getattr);
2042 ADD(type->tp_setattro, tab_setattr);
2043 ADD(type->tp_compare, tab_cmp);
2044 ADD(type->tp_repr, tab_repr);
2045 ADD(type->tp_hash, tab_hash);
2046 ADD(type->tp_call, tab_call);
2047 ADD(type->tp_str, tab_str);
2048 ADD(type->tp_richcompare, tab_richcmp);
2049 ADD(type->tp_iter, tab_iter);
2050 ADD(type->tp_iternext, tab_next);
2051 ADD(type->tp_descr_get, tab_descr_get);
2052 ADD(type->tp_descr_set, tab_descr_set);
2053 ADD(type->tp_init, tab_init);
2054
2055 if (type->tp_new != NULL) {
2056 if (add_tp_new_wrapper(type) < 0)
2057 return -1;
2058 }
2059
2060 return 0;
2061 }
2062
2063 /* Slot wrappers that call the corresponding __foo__ slot. See comments
2064 below at override_slots() for more explanation. */
2065
2066 #define SLOT0(FUNCNAME, OPSTR) \
2067 static PyObject * \
2068 FUNCNAME(PyObject *self) \
2069 { \
2070 return PyObject_CallMethod(self, OPSTR, ""); \
2071 }
2072
2073 #define SLOT1(FUNCNAME, OPSTR, ARG1TYPE, ARGCODES) \
2074 static PyObject * \
2075 FUNCNAME(PyObject *self, ARG1TYPE arg1) \
2076 { \
2077 return PyObject_CallMethod(self, OPSTR, ARGCODES, arg1); \
2078 }
2079
2080
2081 #define SLOT1BINFULL(FUNCNAME, TESTFUNC, SLOTNAME, OPSTR, ROPSTR) \
2082 static PyObject * \
2083 FUNCNAME(PyObject *self, PyObject *other) \
2084 { \
2085 if (self->ob_type->tp_as_number != NULL && \
2086 self->ob_type->tp_as_number->SLOTNAME == TESTFUNC) { \
2087 PyObject *r; \
2088 r = PyObject_CallMethod( \
2089 self, OPSTR, "O", other); \
2090 if (r != Py_NotImplemented || \
2091 other->ob_type == self->ob_type) \
2092 return r; \
2093 Py_DECREF(r); \
2094 } \
2095 if (other->ob_type->tp_as_number != NULL && \
2096 other->ob_type->tp_as_number->SLOTNAME == TESTFUNC) { \
2097 return PyObject_CallMethod( \
2098 other, ROPSTR, "O", self); \
2099 } \
2100 Py_INCREF(Py_NotImplemented); \
2101 return Py_NotImplemented; \
2102 }
2103
2104 #define SLOT1BIN(FUNCNAME, SLOTNAME, OPSTR, ROPSTR) \
2105 SLOT1BINFULL(FUNCNAME, FUNCNAME, SLOTNAME, OPSTR, ROPSTR)
2106
2107 #define SLOT2(FUNCNAME, OPSTR, ARG1TYPE, ARG2TYPE, ARGCODES) \
2108 static PyObject * \
2109 FUNCNAME(PyObject *self, ARG1TYPE arg1, ARG2TYPE arg2) \
2110 { \
2111 return PyObject_CallMethod(self, OPSTR, ARGCODES, arg1, arg2); \
2112 }
2113
2114 static int
2115 slot_sq_length(PyObject *self)
2116 {
2117 PyObject *res = PyObject_CallMethod(self, "__len__", "");
2118
2119 if (res == NULL)
2120 return -1;
2121 return (int)PyInt_AsLong(res);
2122 }
2123
2124 SLOT1(slot_sq_concat, "__add__", PyObject *, "O")
2125 SLOT1(slot_sq_repeat, "__mul__", int, "i")
2126 SLOT1(slot_sq_item, "__getitem__", int, "i")
2127 SLOT2(slot_sq_slice, "__getslice__", int, int, "ii")
2128
2129 static int
2130 slot_sq_ass_item(PyObject *self, int index, PyObject *value)
2131 {
2132 PyObject *res;
2133
2134 if (value == NULL)
2135 res = PyObject_CallMethod(self, "__delitem__", "i", index);
2136 else
2137 res = PyObject_CallMethod(self, "__setitem__",
2138 "iO", index, value);
2139 if (res == NULL)
2140 return -1;
2141 Py_DECREF(res);
2142 return 0;
2143 }
2144
2145 static int
2146 slot_sq_ass_slice(PyObject *self, int i, int j, PyObject *value)
2147 {
2148 PyObject *res;
2149
2150 if (value == NULL)
2151 res = PyObject_CallMethod(self, "__delslice__", "ii", i, j);
2152 else
2153 res = PyObject_CallMethod(self, "__setslice__",
2154 "iiO", i, j, value);
2155 if (res == NULL)
2156 return -1;
2157 Py_DECREF(res);
2158 return 0;
2159 }
2160
2161 static int
2162 slot_sq_contains(PyObject *self, PyObject *value)
2163 {
2164 PyObject *res = PyObject_CallMethod(self, "__contains__", "O", value);
2165 int r;
2166
2167 if (res == NULL)
2168 return -1;
2169 r = PyInt_AsLong(res);
2170 Py_DECREF(res);
2171 return r;
2172 }
2173
2174 SLOT1(slot_sq_inplace_concat, "__iadd__", PyObject *, "O")
2175 SLOT1(slot_sq_inplace_repeat, "__imul__", int, "i")
2176
2177 #define slot_mp_length slot_sq_length
2178
2179 SLOT1(slot_mp_subscript, "__getitem__", PyObject *, "O")
2180
2181 static int
2182 slot_mp_ass_subscript(PyObject *self, PyObject *key, PyObject *value)
2183 {
2184 PyObject *res;
2185
2186 if (value == NULL)
2187 res = PyObject_CallMethod(self, "__delitem__", "O", key);
2188 else
2189 res = PyObject_CallMethod(self, "__setitem__",
2190 "OO", key, value);
2191 if (res == NULL)
2192 return -1;
2193 Py_DECREF(res);
2194 return 0;
2195 }
2196
2197 SLOT1BIN(slot_nb_add, nb_add, "__add__", "__radd__")
2198 SLOT1BIN(slot_nb_subtract, nb_subtract, "__sub__", "__rsub__")
2199 SLOT1BIN(slot_nb_multiply, nb_multiply, "__mul__", "__rmul__")
2200 SLOT1BIN(slot_nb_divide, nb_divide, "__div__", "__rdiv__")
2201 SLOT1BIN(slot_nb_remainder, nb_remainder, "__mod__", "__rmod__")
2202 SLOT1BIN(slot_nb_divmod, nb_divmod, "__divmod__", "__rdivmod__")
2203
2204 staticforward PyObject *slot_nb_power(PyObject *, PyObject *, PyObject *);
2205
2206 SLOT1BINFULL(slot_nb_power_binary, slot_nb_power,
2207 nb_power, "__pow__", "__rpow__")
2208
2209 static PyObject *
2210 slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus)
2211 {
2212 if (modulus == Py_None)
2213 return slot_nb_power_binary(self, other);
2214 /* Three-arg power doesn't use __rpow__ */
2215 return PyObject_CallMethod(self, "__pow__", "OO", other, modulus);
2216 }
2217
2218 SLOT0(slot_nb_negative, "__neg__")
2219 SLOT0(slot_nb_positive, "__pos__")
2220 SLOT0(slot_nb_absolute, "__abs__")
2221
2222 static int
2223 slot_nb_nonzero(PyObject *self)
2224 {
2225 PyObject *res = PyObject_CallMethod(self, "__nonzero__", "");
2226
2227 if (res == NULL)
2228 return -1;
2229 return (int)PyInt_AsLong(res);
2230 }
2231
2232 SLOT0(slot_nb_invert, "__invert__")
2233 SLOT1BIN(slot_nb_lshift, nb_lshift, "__lshift__", "__rlshift__")
2234 SLOT1BIN(slot_nb_rshift, nb_rshift, "__rshift__", "__rrshift__")
2235 SLOT1BIN(slot_nb_and, nb_and, "__and__", "__rand__")
2236 SLOT1BIN(slot_nb_xor, nb_xor, "__xor__", "__rxor__")
2237 SLOT1BIN(slot_nb_or, nb_or, "__or__", "__ror__")
2238 /* Not coerce() */
2239 SLOT0(slot_nb_int, "__int__")
2240 SLOT0(slot_nb_long, "__long__")
2241 SLOT0(slot_nb_float, "__float__")
2242 SLOT0(slot_nb_oct, "__oct__")
2243 SLOT0(slot_nb_hex, "__hex__")
2244 SLOT1(slot_nb_inplace_add, "__iadd__", PyObject *, "O")
2245 SLOT1(slot_nb_inplace_subtract, "__isub__", PyObject *, "O")
2246 SLOT1(slot_nb_inplace_multiply, "__imul__", PyObject *, "O")
2247 SLOT1(slot_nb_inplace_divide, "__idiv__", PyObject *, "O")
2248 SLOT1(slot_nb_inplace_remainder, "__imod__", PyObject *, "O")
2249 SLOT2(slot_nb_inplace_power, "__ipow__", PyObject *, PyObject *, "OO")
2250 SLOT1(slot_nb_inplace_lshift, "__ilshift__", PyObject *, "O")
2251 SLOT1(slot_nb_inplace_rshift, "__irshift__", PyObject *, "O")
2252 SLOT1(slot_nb_inplace_and, "__iand__", PyObject *, "O")
2253 SLOT1(slot_nb_inplace_xor, "__ixor__", PyObject *, "O")
2254 SLOT1(slot_nb_inplace_or, "__ior__", PyObject *, "O")
2255 SLOT1BIN(slot_nb_floor_divide, nb_floor_divide,
2256 "__floordiv__", "__rfloordiv__")
2257 SLOT1BIN(slot_nb_true_divide, nb_true_divide, "__truediv__", "__rtruediv__")
2258 SLOT1(slot_nb_inplace_floor_divide, "__ifloordiv__", PyObject *, "O")
2259 SLOT1(slot_nb_inplace_true_divide, "__itruediv__", PyObject *, "O")
2260
2261 static int
2262 slot_tp_compare(PyObject *self, PyObject *other)
2263 {
2264 PyObject *res = PyObject_CallMethod(self, "__cmp__", "O", other);
2265 long r;
2266
2267 if (res == NULL)
2268 return -1;
2269 r = PyInt_AsLong(res);
2270 Py_DECREF(res);
2271 return (int)r;
2272 }
2273
2274 SLOT0(slot_tp_repr, "__repr__")
2275
2276 static long
2277 slot_tp_hash(PyObject *self)
2278 {
2279 PyObject *res = PyObject_CallMethod(self, "__hash__", "");
2280 long h;
2281
2282 if (res == NULL)
2283 return -1;
2284 h = PyInt_AsLong(res);
2285 if (h == -1 && !PyErr_Occurred())
2286 h = -2;
2287 return h;
2288 }
2289
2290 static PyObject *
2291 slot_tp_call(PyObject *self, PyObject *args, PyObject *kwds)
2292 {
2293 PyObject *meth = PyObject_GetAttrString(self, "__call__");
2294 PyObject *res;
2295
2296 if (meth == NULL)
2297 return NULL;
2298 res = PyObject_Call(meth, args, kwds);
2299 Py_DECREF(meth);
2300 return res;
2301 }
2302
2303 SLOT0(slot_tp_str, "__str__")
2304
2305 static PyObject *
2306 slot_tp_getattro(PyObject *self, PyObject *name)
2307 {
2308 PyTypeObject *tp = self->ob_type;
2309 PyObject *dict = NULL;
2310 PyObject *getattr;
2311
2312 if (tp->tp_flags & Py_TPFLAGS_HEAPTYPE)
2313 dict = tp->tp_dict;
2314 if (dict == NULL) {
2315 PyErr_Format(PyExc_SystemError,
2316 "'%.100s' type object has no __dict__???",
2317 tp->tp_name);
2318 return NULL;
2319 }
2320 getattr = PyDict_GetItemString(dict, "__getattr__");
2321 if (getattr == NULL) {
2322 PyErr_SetString(PyExc_AttributeError, "__getattr__");
2323 return NULL;
2324 }
2325 return PyObject_CallFunction(getattr, "OO", self, name);
2326 }
2327
2328 static int
2329 slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value)
2330 {
2331 PyObject *res;
2332
2333 if (value == NULL)
2334 res = PyObject_CallMethod(self, "__delattr__", "O", name);
2335 else
2336 res = PyObject_CallMethod(self, "__setattr__",
2337 "OO", name, value);
2338 if (res == NULL)
2339 return -1;
2340 Py_DECREF(res);
2341 return 0;
2342 }
2343
2344 /* Map rich comparison operators to their __xx__ namesakes */
2345 static char *name_op[] = {
2346 "__lt__",
2347 "__le__",
2348 "__eq__",
2349 "__ne__",
2350 "__gt__",
2351 "__ge__",
2352 };
2353
2354 static PyObject *
2355 slot_tp_richcompare(PyObject *self, PyObject *other, int op)
2356 {
2357 PyObject *meth = PyObject_GetAttrString(self, name_op[op]);
2358 PyObject *res;
2359
2360 if (meth == NULL)
2361 return NULL;
2362 res = PyObject_CallFunction(meth, "O", other);
2363 Py_DECREF(meth);
2364 return res;
2365 }
2366
2367 SLOT0(slot_tp_iter, "__iter__")
2368
2369 static PyObject *
2370 slot_tp_iternext(PyObject *self)
2371 {
2372 return PyObject_CallMethod(self, "next", "");
2373 }
2374
2375 SLOT2(slot_tp_descr_get, "__get__", PyObject *, PyObject *, "OO")
2376
2377 static int
2378 slot_tp_descr_set(PyObject *self, PyObject *target, PyObject *value)
2379 {
2380 PyObject *res = PyObject_CallMethod(self, "__set__",
2381 "OO", target, value);
2382 if (res == NULL)
2383 return -1;
2384 Py_DECREF(res);
2385 return 0;
2386 }
2387
2388 static int
2389 slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
2390 {
2391 PyObject *meth = PyObject_GetAttrString(self, "__init__");
2392 PyObject *res;
2393
2394 if (meth == NULL)
2395 return -1;
2396 res = PyObject_Call(meth, args, kwds);
2397 Py_DECREF(meth);
2398 if (res == NULL)
2399 return -1;
2400 Py_DECREF(res);
2401 return 0;
2402 }
2403
2404 static PyObject *
2405 slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2406 {
2407 PyObject *func = PyObject_GetAttrString((PyObject *)type, "__new__");
2408 PyObject *newargs, *x;
2409 int i, n;
2410
2411 if (func == NULL)
2412 return NULL;
2413 assert(PyTuple_Check(args));
2414 n = PyTuple_GET_SIZE(args);
2415 newargs = PyTuple_New(n+1);
2416 if (newargs == NULL)
2417 return NULL;
2418 Py_INCREF(type);
2419 PyTuple_SET_ITEM(newargs, 0, (PyObject *)type);
2420 for (i = 0; i < n; i++) {
2421 x = PyTuple_GET_ITEM(args, i);
2422 Py_INCREF(x);
2423 PyTuple_SET_ITEM(newargs, i+1, x);
2424 }
2425 x = PyObject_Call(func, newargs, kwds);
2426 Py_DECREF(func);
2427 return x;
2428 }
2429
2430 /* This is called at the very end of type_new() (even after
2431 PyType_Ready()) to complete the initialization of dynamic types.
2432 The dict argument is the dictionary argument passed to type_new(),
2433 which is the local namespace of the class statement, in other
2434 words, it contains the methods. For each special method (like
2435 __repr__) defined in the dictionary, the corresponding function
2436 slot in the type object (like tp_repr) is set to a special function
2437 whose name is 'slot_' followed by the slot name and whose signature
2438 is whatever is required for that slot. These slot functions look
2439 up the corresponding method in the type's dictionary and call it.
2440 The slot functions have to take care of the various peculiarities
2441 of the mapping between slots and special methods, such as mapping
2442 one slot to multiple methods (tp_richcompare <--> __le__, __lt__
2443 etc.) or mapping multiple slots to a single method (sq_item,
2444 mp_subscript <--> __getitem__). */
2445
2446 static void
2447 override_slots(PyTypeObject *type, PyObject *dict)
2448 {
2449 PySequenceMethods *sq = type->tp_as_sequence;
2450 PyMappingMethods *mp = type->tp_as_mapping;
2451 PyNumberMethods *nb = type->tp_as_number;
2452
2453 #define SQSLOT(OPNAME, SLOTNAME, FUNCNAME) \
2454 if (PyDict_GetItemString(dict, OPNAME)) { \
2455 sq->SLOTNAME = FUNCNAME; \
2456 }
2457
2458 #define MPSLOT(OPNAME, SLOTNAME, FUNCNAME) \
2459 if (PyDict_GetItemString(dict, OPNAME)) { \
2460 mp->SLOTNAME = FUNCNAME; \
2461 }
2462
2463 #define NBSLOT(OPNAME, SLOTNAME, FUNCNAME) \
2464 if (PyDict_GetItemString(dict, OPNAME)) { \
2465 nb->SLOTNAME = FUNCNAME; \
2466 }
2467
2468 #define TPSLOT(OPNAME, SLOTNAME, FUNCNAME) \
2469 if (PyDict_GetItemString(dict, OPNAME)) { \
2470 type->SLOTNAME = FUNCNAME; \
2471 }
2472
2473 SQSLOT("__len__", sq_length, slot_sq_length);
2474 SQSLOT("__add__", sq_concat, slot_sq_concat);
2475 SQSLOT("__mul__", sq_repeat, slot_sq_repeat);
2476 SQSLOT("__getitem__", sq_item, slot_sq_item);
2477 SQSLOT("__getslice__", sq_slice, slot_sq_slice);
2478 SQSLOT("__setitem__", sq_ass_item, slot_sq_ass_item);
2479 SQSLOT("__delitem__", sq_ass_item, slot_sq_ass_item);
2480 SQSLOT("__setslice__", sq_ass_slice, slot_sq_ass_slice);
2481 SQSLOT("__delslice__", sq_ass_slice, slot_sq_ass_slice);
2482 SQSLOT("__contains__", sq_contains, slot_sq_contains);
2483 SQSLOT("__iadd__", sq_inplace_concat, slot_sq_inplace_concat);
2484 SQSLOT("__imul__", sq_inplace_repeat, slot_sq_inplace_repeat);
2485
2486 MPSLOT("__len__", mp_length, slot_mp_length);
2487 MPSLOT("__getitem__", mp_subscript, slot_mp_subscript);
2488 MPSLOT("__setitem__", mp_ass_subscript, slot_mp_ass_subscript);
2489 MPSLOT("__delitem__", mp_ass_subscript, slot_mp_ass_subscript);
2490
2491 NBSLOT("__add__", nb_add, slot_nb_add);
2492 NBSLOT("__sub__", nb_subtract, slot_nb_subtract);
2493 NBSLOT("__mul__", nb_multiply, slot_nb_multiply);
2494 NBSLOT("__div__", nb_divide, slot_nb_divide);
2495 NBSLOT("__mod__", nb_remainder, slot_nb_remainder);
2496 NBSLOT("__divmod__", nb_divmod, slot_nb_divmod);
2497 NBSLOT("__pow__", nb_power, slot_nb_power);
2498 NBSLOT("__neg__", nb_negative, slot_nb_negative);
2499 NBSLOT("__pos__", nb_positive, slot_nb_positive);
2500 NBSLOT("__abs__", nb_absolute, slot_nb_absolute);
2501 NBSLOT("__nonzero__", nb_nonzero, slot_nb_nonzero);
2502 NBSLOT("__invert__", nb_invert, slot_nb_invert);
2503 NBSLOT("__lshift__", nb_lshift, slot_nb_lshift);
2504 NBSLOT("__rshift__", nb_rshift, slot_nb_rshift);
2505 NBSLOT("__and__", nb_and, slot_nb_and);
2506 NBSLOT("__xor__", nb_xor, slot_nb_xor);
2507 NBSLOT("__or__", nb_or, slot_nb_or);
2508 /* Not coerce() */
2509 NBSLOT("__int__", nb_int, slot_nb_int);
2510 NBSLOT("__long__", nb_long, slot_nb_long);
2511 NBSLOT("__float__", nb_float, slot_nb_float);
2512 NBSLOT("__oct__", nb_oct, slot_nb_oct);
2513 NBSLOT("__hex__", nb_hex, slot_nb_hex);
2514 NBSLOT("__iadd__", nb_inplace_add, slot_nb_inplace_add);
2515 NBSLOT("__isub__", nb_inplace_subtract, slot_nb_inplace_subtract);
2516 NBSLOT("__imul__", nb_inplace_multiply, slot_nb_inplace_multiply);
2517 NBSLOT("__idiv__", nb_inplace_divide, slot_nb_inplace_divide);
2518 NBSLOT("__imod__", nb_inplace_remainder, slot_nb_inplace_remainder);
2519 NBSLOT("__ipow__", nb_inplace_power, slot_nb_inplace_power);
2520 NBSLOT("__ilshift__", nb_inplace_lshift, slot_nb_inplace_lshift);
2521 NBSLOT("__irshift__", nb_inplace_rshift, slot_nb_inplace_rshift);
2522 NBSLOT("__iand__", nb_inplace_and, slot_nb_inplace_and);
2523 NBSLOT("__ixor__", nb_inplace_xor, slot_nb_inplace_xor);
2524 NBSLOT("__ior__", nb_inplace_or, slot_nb_inplace_or);
2525 NBSLOT("__floordiv__", nb_floor_divide, slot_nb_floor_divide);
2526 NBSLOT("__truediv__", nb_true_divide, slot_nb_true_divide);
2527 NBSLOT("__ifloordiv__", nb_inplace_floor_divide,
2528 slot_nb_inplace_floor_divide);
2529 NBSLOT("__itruediv__", nb_inplace_true_divide,
2530 slot_nb_inplace_true_divide);
2531
2532 if (PyDict_GetItemString(dict, "__str__") ||
2533 PyDict_GetItemString(dict, "__repr__"))
2534 type->tp_print = NULL;
2535
2536 TPSLOT("__cmp__", tp_compare, slot_tp_compare);
2537 TPSLOT("__repr__", tp_repr, slot_tp_repr);
2538 TPSLOT("__hash__", tp_hash, slot_tp_hash);
2539 TPSLOT("__call__", tp_call, slot_tp_call);
2540 TPSLOT("__str__", tp_str, slot_tp_str);
2541 TPSLOT("__getattr__", tp_getattro, slot_tp_getattro);
2542 TPSLOT("__setattr__", tp_setattro, slot_tp_setattro);
2543 TPSLOT("__lt__", tp_richcompare, slot_tp_richcompare);
2544 TPSLOT("__le__", tp_richcompare, slot_tp_richcompare);
2545 TPSLOT("__eq__", tp_richcompare, slot_tp_richcompare);
2546 TPSLOT("__ne__", tp_richcompare, slot_tp_richcompare);
2547 TPSLOT("__gt__", tp_richcompare, slot_tp_richcompare);
2548 TPSLOT("__ge__", tp_richcompare, slot_tp_richcompare);
2549 TPSLOT("__iter__", tp_iter, slot_tp_iter);
2550 TPSLOT("next", tp_iternext, slot_tp_iternext);
2551 TPSLOT("__get__", tp_descr_get, slot_tp_descr_get);
2552 TPSLOT("__set__", tp_descr_set, slot_tp_descr_set);
2553 TPSLOT("__init__", tp_init, slot_tp_init);
2554 TPSLOT("__new__", tp_new, slot_tp_new);
2555 }