1 /* Type object implementation */
4 #include "structmember.h"
9 /* Support type attribute cache */
11 /* The cache can keep references to the names alive for longer than
12 they normally would. This is why the maximum size is limited to
13 MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large
14 strings are used as attribute names. */
15 #define MCACHE_MAX_ATTR_SIZE 100
16 #define MCACHE_SIZE_EXP 10
17 #define MCACHE_HASH(version, name_hash) \
18 (((unsigned int)(version) * (unsigned int)(name_hash)) \
19 >> (8*sizeof(unsigned int) - MCACHE_SIZE_EXP))
20 #define MCACHE_HASH_METHOD(type, name) \
21 MCACHE_HASH((type)->tp_version_tag, \
22 ((PyStringObject *)(name))->ob_shash)
23 #define MCACHE_CACHEABLE_NAME(name) \
24 PyString_CheckExact(name) && \
25 PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
27 struct method_cache_entry
{
29 PyObject
*name
; /* reference to exactly a str or None */
30 PyObject
*value
; /* borrowed */
33 static struct method_cache_entry method_cache
[1 << MCACHE_SIZE_EXP
];
34 static unsigned int next_version_tag
= 0;
37 PyType_ClearCache(void)
40 unsigned int cur_version_tag
= next_version_tag
- 1;
42 for (i
= 0; i
< (1 << MCACHE_SIZE_EXP
); i
++) {
43 method_cache
[i
].version
= 0;
44 Py_CLEAR(method_cache
[i
].name
);
45 method_cache
[i
].value
= NULL
;
48 /* mark all version tags as invalid */
49 PyType_Modified(&PyBaseObject_Type
);
50 return cur_version_tag
;
54 PyType_Modified(PyTypeObject
*type
)
56 /* Invalidate any cached data for the specified type and all
57 subclasses. This function is called after the base
58 classes, mro, or attributes of the type are altered.
62 - Py_TPFLAGS_VALID_VERSION_TAG is never set if
63 Py_TPFLAGS_HAVE_VERSION_TAG is not set (e.g. on type
64 objects coming from non-recompiled extension modules)
66 - before Py_TPFLAGS_VALID_VERSION_TAG can be set on a type,
67 it must first be set on all super types.
69 This function clears the Py_TPFLAGS_VALID_VERSION_TAG of a
70 type (so it must first clear it on all subclasses). The
71 tp_version_tag value is meaningless unless this flag is set.
72 We don't assign new version tags eagerly, but only as
78 if (!PyType_HasFeature(type
, Py_TPFLAGS_VALID_VERSION_TAG
))
81 raw
= type
->tp_subclasses
;
83 n
= PyList_GET_SIZE(raw
);
84 for (i
= 0; i
< n
; i
++) {
85 ref
= PyList_GET_ITEM(raw
, i
);
86 ref
= PyWeakref_GET_OBJECT(ref
);
88 PyType_Modified((PyTypeObject
*)ref
);
92 type
->tp_flags
&= ~Py_TPFLAGS_VALID_VERSION_TAG
;
96 type_mro_modified(PyTypeObject
*type
, PyObject
*bases
) {
98 Check that all base classes or elements of the mro of type are
99 able to be cached. This function is called after the base
100 classes or mro of the type are altered.
102 Unset HAVE_VERSION_TAG and VALID_VERSION_TAG if the type
103 inherits from an old-style class, either directly or if it
104 appears in the MRO of a new-style class. No support either for
105 custom MROs that include types that are not officially super
108 Called from mro_internal, which will subsequently be called on
109 each subclass when their mro is recursively updated.
114 if (!PyType_HasFeature(type
, Py_TPFLAGS_HAVE_VERSION_TAG
))
117 n
= PyTuple_GET_SIZE(bases
);
118 for (i
= 0; i
< n
; i
++) {
119 PyObject
*b
= PyTuple_GET_ITEM(bases
, i
);
122 if (!PyType_Check(b
) ) {
127 cls
= (PyTypeObject
*)b
;
129 if (!PyType_HasFeature(cls
, Py_TPFLAGS_HAVE_VERSION_TAG
) ||
130 !PyType_IsSubtype(type
, cls
)) {
137 type
->tp_flags
&= ~(Py_TPFLAGS_HAVE_VERSION_TAG
|
138 Py_TPFLAGS_VALID_VERSION_TAG
);
142 assign_version_tag(PyTypeObject
*type
)
144 /* Ensure that the tp_version_tag is valid and set
145 Py_TPFLAGS_VALID_VERSION_TAG. To respect the invariant, this
146 must first be done on all super classes. Return 0 if this
147 cannot be done, 1 if Py_TPFLAGS_VALID_VERSION_TAG.
152 if (PyType_HasFeature(type
, Py_TPFLAGS_VALID_VERSION_TAG
))
154 if (!PyType_HasFeature(type
, Py_TPFLAGS_HAVE_VERSION_TAG
))
156 if (!PyType_HasFeature(type
, Py_TPFLAGS_READY
))
159 type
->tp_version_tag
= next_version_tag
++;
160 /* for stress-testing: next_version_tag &= 0xFF; */
162 if (type
->tp_version_tag
== 0) {
163 /* wrap-around or just starting Python - clear the whole
164 cache by filling names with references to Py_None.
165 Values are also set to NULL for added protection, as they
166 are borrowed reference */
167 for (i
= 0; i
< (1 << MCACHE_SIZE_EXP
); i
++) {
168 method_cache
[i
].value
= NULL
;
169 Py_XDECREF(method_cache
[i
].name
);
170 method_cache
[i
].name
= Py_None
;
173 /* mark all version tags as invalid */
174 PyType_Modified(&PyBaseObject_Type
);
177 bases
= type
->tp_bases
;
178 n
= PyTuple_GET_SIZE(bases
);
179 for (i
= 0; i
< n
; i
++) {
180 PyObject
*b
= PyTuple_GET_ITEM(bases
, i
);
181 assert(PyType_Check(b
));
182 if (!assign_version_tag((PyTypeObject
*)b
))
185 type
->tp_flags
|= Py_TPFLAGS_VALID_VERSION_TAG
;
190 static PyMemberDef type_members
[] = {
191 {"__basicsize__", T_INT
, offsetof(PyTypeObject
,tp_basicsize
),READONLY
},
192 {"__itemsize__", T_INT
, offsetof(PyTypeObject
, tp_itemsize
), READONLY
},
193 {"__flags__", T_LONG
, offsetof(PyTypeObject
, tp_flags
), READONLY
},
194 {"__weakrefoffset__", T_LONG
,
195 offsetof(PyTypeObject
, tp_weaklistoffset
), READONLY
},
196 {"__base__", T_OBJECT
, offsetof(PyTypeObject
, tp_base
), READONLY
},
197 {"__dictoffset__", T_LONG
,
198 offsetof(PyTypeObject
, tp_dictoffset
), READONLY
},
199 {"__mro__", T_OBJECT
, offsetof(PyTypeObject
, tp_mro
), READONLY
},
204 type_name(PyTypeObject
*type
, void *context
)
208 if (type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
) {
209 PyHeapTypeObject
* et
= (PyHeapTypeObject
*)type
;
211 Py_INCREF(et
->ht_name
);
215 s
= strrchr(type
->tp_name
, '.');
220 return PyString_FromString(s
);
225 type_set_name(PyTypeObject
*type
, PyObject
*value
, void *context
)
227 PyHeapTypeObject
* et
;
229 if (!(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)) {
230 PyErr_Format(PyExc_TypeError
,
231 "can't set %s.__name__", type
->tp_name
);
235 PyErr_Format(PyExc_TypeError
,
236 "can't delete %s.__name__", type
->tp_name
);
239 if (!PyString_Check(value
)) {
240 PyErr_Format(PyExc_TypeError
,
241 "can only assign string to %s.__name__, not '%s'",
242 type
->tp_name
, Py_TYPE(value
)->tp_name
);
245 if (strlen(PyString_AS_STRING(value
))
246 != (size_t)PyString_GET_SIZE(value
)) {
247 PyErr_Format(PyExc_ValueError
,
248 "__name__ must not contain null bytes");
252 et
= (PyHeapTypeObject
*)type
;
256 Py_DECREF(et
->ht_name
);
259 type
->tp_name
= PyString_AS_STRING(value
);
265 type_module(PyTypeObject
*type
, void *context
)
270 if (type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
) {
271 mod
= PyDict_GetItemString(type
->tp_dict
, "__module__");
273 PyErr_Format(PyExc_AttributeError
, "__module__");
280 s
= strrchr(type
->tp_name
, '.');
282 return PyString_FromStringAndSize(
283 type
->tp_name
, (Py_ssize_t
)(s
- type
->tp_name
));
284 return PyString_FromString("__builtin__");
289 type_set_module(PyTypeObject
*type
, PyObject
*value
, void *context
)
291 if (!(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)) {
292 PyErr_Format(PyExc_TypeError
,
293 "can't set %s.__module__", type
->tp_name
);
297 PyErr_Format(PyExc_TypeError
,
298 "can't delete %s.__module__", type
->tp_name
);
302 PyType_Modified(type
);
304 return PyDict_SetItemString(type
->tp_dict
, "__module__", value
);
308 type_abstractmethods(PyTypeObject
*type
, void *context
)
310 PyObject
*mod
= PyDict_GetItemString(type
->tp_dict
,
311 "__abstractmethods__");
313 PyErr_Format(PyExc_AttributeError
, "__abstractmethods__");
321 type_set_abstractmethods(PyTypeObject
*type
, PyObject
*value
, void *context
)
323 /* __abstractmethods__ should only be set once on a type, in
324 abc.ABCMeta.__new__, so this function doesn't do anything
325 special to update subclasses.
327 int res
= PyDict_SetItemString(type
->tp_dict
,
328 "__abstractmethods__", value
);
330 PyType_Modified(type
);
331 if (value
&& PyObject_IsTrue(value
)) {
332 type
->tp_flags
|= Py_TPFLAGS_IS_ABSTRACT
;
335 type
->tp_flags
&= ~Py_TPFLAGS_IS_ABSTRACT
;
342 type_get_bases(PyTypeObject
*type
, void *context
)
344 Py_INCREF(type
->tp_bases
);
345 return type
->tp_bases
;
348 static PyTypeObject
*best_base(PyObject
*);
349 static int mro_internal(PyTypeObject
*);
350 static int compatible_for_assignment(PyTypeObject
*, PyTypeObject
*, char *);
351 static int add_subclass(PyTypeObject
*, PyTypeObject
*);
352 static void remove_subclass(PyTypeObject
*, PyTypeObject
*);
353 static void update_all_slots(PyTypeObject
*);
355 typedef int (*update_callback
)(PyTypeObject
*, void *);
356 static int update_subclasses(PyTypeObject
*type
, PyObject
*name
,
357 update_callback callback
, void *data
);
358 static int recurse_down_subclasses(PyTypeObject
*type
, PyObject
*name
,
359 update_callback callback
, void *data
);
362 mro_subclasses(PyTypeObject
*type
, PyObject
* temp
)
364 PyTypeObject
*subclass
;
365 PyObject
*ref
, *subclasses
, *old_mro
;
368 subclasses
= type
->tp_subclasses
;
369 if (subclasses
== NULL
)
371 assert(PyList_Check(subclasses
));
372 n
= PyList_GET_SIZE(subclasses
);
373 for (i
= 0; i
< n
; i
++) {
374 ref
= PyList_GET_ITEM(subclasses
, i
);
375 assert(PyWeakref_CheckRef(ref
));
376 subclass
= (PyTypeObject
*)PyWeakref_GET_OBJECT(ref
);
377 assert(subclass
!= NULL
);
378 if ((PyObject
*)subclass
== Py_None
)
380 assert(PyType_Check(subclass
));
381 old_mro
= subclass
->tp_mro
;
382 if (mro_internal(subclass
) < 0) {
383 subclass
->tp_mro
= old_mro
;
388 tuple
= PyTuple_Pack(2, subclass
, old_mro
);
392 if (PyList_Append(temp
, tuple
) < 0)
396 if (mro_subclasses(subclass
, temp
) < 0)
403 type_set_bases(PyTypeObject
*type
, PyObject
*value
, void *context
)
408 PyTypeObject
*new_base
, *old_base
;
409 PyObject
*old_bases
, *old_mro
;
411 if (!(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)) {
412 PyErr_Format(PyExc_TypeError
,
413 "can't set %s.__bases__", type
->tp_name
);
417 PyErr_Format(PyExc_TypeError
,
418 "can't delete %s.__bases__", type
->tp_name
);
421 if (!PyTuple_Check(value
)) {
422 PyErr_Format(PyExc_TypeError
,
423 "can only assign tuple to %s.__bases__, not %s",
424 type
->tp_name
, Py_TYPE(value
)->tp_name
);
427 if (PyTuple_GET_SIZE(value
) == 0) {
428 PyErr_Format(PyExc_TypeError
,
429 "can only assign non-empty tuple to %s.__bases__, not ()",
433 for (i
= 0; i
< PyTuple_GET_SIZE(value
); i
++) {
434 ob
= PyTuple_GET_ITEM(value
, i
);
435 if (!PyClass_Check(ob
) && !PyType_Check(ob
)) {
438 "%s.__bases__ must be tuple of old- or new-style classes, not '%s'",
439 type
->tp_name
, Py_TYPE(ob
)->tp_name
);
442 if (PyType_Check(ob
)) {
443 if (PyType_IsSubtype((PyTypeObject
*)ob
, type
)) {
444 PyErr_SetString(PyExc_TypeError
,
445 "a __bases__ item causes an inheritance cycle");
451 new_base
= best_base(value
);
457 if (!compatible_for_assignment(type
->tp_base
, new_base
, "__bases__"))
463 old_bases
= type
->tp_bases
;
464 old_base
= type
->tp_base
;
465 old_mro
= type
->tp_mro
;
467 type
->tp_bases
= value
;
468 type
->tp_base
= new_base
;
470 if (mro_internal(type
) < 0) {
474 temp
= PyList_New(0);
478 r
= mro_subclasses(type
, temp
);
481 for (i
= 0; i
< PyList_Size(temp
); i
++) {
484 PyArg_UnpackTuple(PyList_GET_ITEM(temp
, i
),
485 "", 2, 2, &cls
, &mro
);
497 /* any base that was in __bases__ but now isn't, we
498 need to remove |type| from its tp_subclasses.
499 conversely, any class now in __bases__ that wasn't
500 needs to have |type| added to its subclasses. */
502 /* for now, sod that: just remove from all old_bases,
503 add to all new_bases */
505 for (i
= PyTuple_GET_SIZE(old_bases
) - 1; i
>= 0; i
--) {
506 ob
= PyTuple_GET_ITEM(old_bases
, i
);
507 if (PyType_Check(ob
)) {
509 (PyTypeObject
*)ob
, type
);
513 for (i
= PyTuple_GET_SIZE(value
) - 1; i
>= 0; i
--) {
514 ob
= PyTuple_GET_ITEM(value
, i
);
515 if (PyType_Check(ob
)) {
516 if (add_subclass((PyTypeObject
*)ob
, type
) < 0)
521 update_all_slots(type
);
523 Py_DECREF(old_bases
);
530 Py_DECREF(type
->tp_bases
);
531 Py_DECREF(type
->tp_base
);
532 if (type
->tp_mro
!= old_mro
) {
533 Py_DECREF(type
->tp_mro
);
536 type
->tp_bases
= old_bases
;
537 type
->tp_base
= old_base
;
538 type
->tp_mro
= old_mro
;
544 type_dict(PyTypeObject
*type
, void *context
)
546 if (type
->tp_dict
== NULL
) {
550 return PyDictProxy_New(type
->tp_dict
);
554 type_get_doc(PyTypeObject
*type
, void *context
)
557 if (!(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
) && type
->tp_doc
!= NULL
)
558 return PyString_FromString(type
->tp_doc
);
559 result
= PyDict_GetItemString(type
->tp_dict
, "__doc__");
560 if (result
== NULL
) {
564 else if (Py_TYPE(result
)->tp_descr_get
) {
565 result
= Py_TYPE(result
)->tp_descr_get(result
, NULL
,
574 static PyGetSetDef type_getsets
[] = {
575 {"__name__", (getter
)type_name
, (setter
)type_set_name
, NULL
},
576 {"__bases__", (getter
)type_get_bases
, (setter
)type_set_bases
, NULL
},
577 {"__module__", (getter
)type_module
, (setter
)type_set_module
, NULL
},
578 {"__abstractmethods__", (getter
)type_abstractmethods
,
579 (setter
)type_set_abstractmethods
, NULL
},
580 {"__dict__", (getter
)type_dict
, NULL
, NULL
},
581 {"__doc__", (getter
)type_get_doc
, NULL
, NULL
},
586 type_compare(PyObject
*v
, PyObject
*w
)
588 /* This is called with type objects only. So we
589 can just compare the addresses. */
590 Py_uintptr_t vv
= (Py_uintptr_t
)v
;
591 Py_uintptr_t ww
= (Py_uintptr_t
)w
;
592 return (vv
< ww
) ? -1 : (vv
> ww
) ? 1 : 0;
596 type_richcompare(PyObject
*v
, PyObject
*w
, int op
)
602 /* Make sure both arguments are types. */
603 if (!PyType_Check(v
) || !PyType_Check(w
)) {
604 result
= Py_NotImplemented
;
608 /* Py3K warning if comparison isn't == or != */
609 if (Py_Py3kWarningFlag
&& op
!= Py_EQ
&& op
!= Py_NE
&&
610 PyErr_WarnEx(PyExc_DeprecationWarning
,
611 "type inequality comparisons not supported "
616 /* Compare addresses */
617 vv
= (Py_uintptr_t
)v
;
618 ww
= (Py_uintptr_t
)w
;
620 case Py_LT
: c
= vv
< ww
; break;
621 case Py_LE
: c
= vv
<= ww
; break;
622 case Py_EQ
: c
= vv
== ww
; break;
623 case Py_NE
: c
= vv
!= ww
; break;
624 case Py_GT
: c
= vv
> ww
; break;
625 case Py_GE
: c
= vv
>= ww
; break;
627 result
= Py_NotImplemented
;
630 result
= c
? Py_True
: Py_False
;
632 /* incref and return */
639 type_repr(PyTypeObject
*type
)
641 PyObject
*mod
, *name
, *rtn
;
644 mod
= type_module(type
, NULL
);
647 else if (!PyString_Check(mod
)) {
651 name
= type_name(type
, NULL
);
655 if (type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)
660 if (mod
!= NULL
&& strcmp(PyString_AS_STRING(mod
), "__builtin__")) {
661 rtn
= PyString_FromFormat("<%s '%s.%s'>",
663 PyString_AS_STRING(mod
),
664 PyString_AS_STRING(name
));
667 rtn
= PyString_FromFormat("<%s '%s'>", kind
, type
->tp_name
);
675 type_call(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
679 if (type
->tp_new
== NULL
) {
680 PyErr_Format(PyExc_TypeError
,
681 "cannot create '%.100s' instances",
686 obj
= type
->tp_new(type
, args
, kwds
);
688 /* Ugly exception: when the call was type(something),
689 don't call tp_init on the result. */
690 if (type
== &PyType_Type
&&
691 PyTuple_Check(args
) && PyTuple_GET_SIZE(args
) == 1 &&
693 (PyDict_Check(kwds
) && PyDict_Size(kwds
) == 0)))
695 /* If the returned object is not an instance of type,
696 it won't be initialized. */
697 if (!PyType_IsSubtype(obj
->ob_type
, type
))
700 if (PyType_HasFeature(type
, Py_TPFLAGS_HAVE_CLASS
) &&
701 type
->tp_init
!= NULL
&&
702 type
->tp_init(obj
, args
, kwds
) < 0) {
711 PyType_GenericAlloc(PyTypeObject
*type
, Py_ssize_t nitems
)
714 const size_t size
= _PyObject_VAR_SIZE(type
, nitems
+1);
715 /* note that we need to add one, for the sentinel */
717 if (PyType_IS_GC(type
))
718 obj
= _PyObject_GC_Malloc(size
);
720 obj
= (PyObject
*)PyObject_MALLOC(size
);
723 return PyErr_NoMemory();
725 memset(obj
, '\0', size
);
727 if (type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)
730 if (type
->tp_itemsize
== 0)
731 PyObject_INIT(obj
, type
);
733 (void) PyObject_INIT_VAR((PyVarObject
*)obj
, type
, nitems
);
735 if (PyType_IS_GC(type
))
736 _PyObject_GC_TRACK(obj
);
741 PyType_GenericNew(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
743 return type
->tp_alloc(type
, 0);
746 /* Helpers for subtyping */
749 traverse_slots(PyTypeObject
*type
, PyObject
*self
, visitproc visit
, void *arg
)
755 mp
= PyHeapType_GET_MEMBERS((PyHeapTypeObject
*)type
);
756 for (i
= 0; i
< n
; i
++, mp
++) {
757 if (mp
->type
== T_OBJECT_EX
) {
758 char *addr
= (char *)self
+ mp
->offset
;
759 PyObject
*obj
= *(PyObject
**)addr
;
761 int err
= visit(obj
, arg
);
771 subtype_traverse(PyObject
*self
, visitproc visit
, void *arg
)
773 PyTypeObject
*type
, *base
;
774 traverseproc basetraverse
;
776 /* Find the nearest base with a different tp_traverse,
777 and traverse slots while we're at it */
778 type
= Py_TYPE(self
);
780 while ((basetraverse
= base
->tp_traverse
) == subtype_traverse
) {
782 int err
= traverse_slots(base
, self
, visit
, arg
);
786 base
= base
->tp_base
;
790 if (type
->tp_dictoffset
!= base
->tp_dictoffset
) {
791 PyObject
**dictptr
= _PyObject_GetDictPtr(self
);
792 if (dictptr
&& *dictptr
)
796 if (type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)
797 /* For a heaptype, the instances count as references
798 to the type. Traverse the type so the collector
799 can find cycles involving this link. */
803 return basetraverse(self
, visit
, arg
);
808 clear_slots(PyTypeObject
*type
, PyObject
*self
)
814 mp
= PyHeapType_GET_MEMBERS((PyHeapTypeObject
*)type
);
815 for (i
= 0; i
< n
; i
++, mp
++) {
816 if (mp
->type
== T_OBJECT_EX
&& !(mp
->flags
& READONLY
)) {
817 char *addr
= (char *)self
+ mp
->offset
;
818 PyObject
*obj
= *(PyObject
**)addr
;
820 *(PyObject
**)addr
= NULL
;
828 subtype_clear(PyObject
*self
)
830 PyTypeObject
*type
, *base
;
833 /* Find the nearest base with a different tp_clear
834 and clear slots while we're at it */
835 type
= Py_TYPE(self
);
837 while ((baseclear
= base
->tp_clear
) == subtype_clear
) {
839 clear_slots(base
, self
);
840 base
= base
->tp_base
;
844 /* There's no need to clear the instance dict (if any);
845 the collector will call its tp_clear handler. */
848 return baseclear(self
);
853 subtype_dealloc(PyObject
*self
)
855 PyTypeObject
*type
, *base
;
856 destructor basedealloc
;
858 /* Extract the type; we expect it to be a heap type */
859 type
= Py_TYPE(self
);
860 assert(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
);
862 /* Test whether the type has GC exactly once */
864 if (!PyType_IS_GC(type
)) {
865 /* It's really rare to find a dynamic type that doesn't have
866 GC; it can only happen when deriving from 'object' and not
867 adding any slots or instance variables. This allows
868 certain simplifications: there's no need to call
869 clear_slots(), or DECREF the dict, or clear weakrefs. */
871 /* Maybe call finalizer; exit early if resurrected */
874 if (self
->ob_refcnt
> 0)
878 /* Find the nearest base with a different tp_dealloc */
880 while ((basedealloc
= base
->tp_dealloc
) == subtype_dealloc
) {
881 assert(Py_SIZE(base
) == 0);
882 base
= base
->tp_base
;
886 /* Call the base tp_dealloc() */
890 /* Can't reference self beyond this point */
897 /* We get here only if the type has GC */
899 /* UnTrack and re-Track around the trashcan macro, alas */
900 /* See explanation at end of function for full disclosure */
901 PyObject_GC_UnTrack(self
);
902 ++_PyTrash_delete_nesting
;
903 Py_TRASHCAN_SAFE_BEGIN(self
);
904 --_PyTrash_delete_nesting
;
905 /* DO NOT restore GC tracking at this point. weakref callbacks
906 * (if any, and whether directly here or indirectly in something we
907 * call) may trigger GC, and if self is tracked at that point, it
908 * will look like trash to GC and GC will try to delete self again.
911 /* Find the nearest base with a different tp_dealloc */
913 while ((basedealloc
= base
->tp_dealloc
) == subtype_dealloc
) {
914 base
= base
->tp_base
;
918 /* If we added a weaklist, we clear it. Do this *before* calling
919 the finalizer (__del__), clearing slots, or clearing the instance
922 if (type
->tp_weaklistoffset
&& !base
->tp_weaklistoffset
)
923 PyObject_ClearWeakRefs(self
);
925 /* Maybe call finalizer; exit early if resurrected */
927 _PyObject_GC_TRACK(self
);
929 if (self
->ob_refcnt
> 0)
930 goto endlabel
; /* resurrected */
932 _PyObject_GC_UNTRACK(self
);
933 /* New weakrefs could be created during the finalizer call.
934 If this occurs, clear them out without calling their
935 finalizers since they might rely on part of the object
936 being finalized that has already been destroyed. */
937 if (type
->tp_weaklistoffset
&& !base
->tp_weaklistoffset
) {
938 /* Modeled after GET_WEAKREFS_LISTPTR() */
939 PyWeakReference
**list
= (PyWeakReference
**) \
940 PyObject_GET_WEAKREFS_LISTPTR(self
);
942 _PyWeakref_ClearRef(*list
);
946 /* Clear slots up to the nearest base with a different tp_dealloc */
948 while ((basedealloc
= base
->tp_dealloc
) == subtype_dealloc
) {
950 clear_slots(base
, self
);
951 base
= base
->tp_base
;
955 /* If we added a dict, DECREF it */
956 if (type
->tp_dictoffset
&& !base
->tp_dictoffset
) {
957 PyObject
**dictptr
= _PyObject_GetDictPtr(self
);
958 if (dictptr
!= NULL
) {
959 PyObject
*dict
= *dictptr
;
967 /* Call the base tp_dealloc(); first retrack self if
968 * basedealloc knows about gc.
970 if (PyType_IS_GC(base
))
971 _PyObject_GC_TRACK(self
);
975 /* Can't reference self beyond this point */
979 ++_PyTrash_delete_nesting
;
980 Py_TRASHCAN_SAFE_END(self
);
981 --_PyTrash_delete_nesting
;
983 /* Explanation of the weirdness around the trashcan macros:
985 Q. What do the trashcan macros do?
987 A. Read the comment titled "Trashcan mechanism" in object.h.
988 For one, this explains why there must be a call to GC-untrack
989 before the trashcan begin macro. Without understanding the
990 trashcan code, the answers to the following questions don't make
993 Q. Why do we GC-untrack before the trashcan and then immediately
994 GC-track again afterward?
996 A. In the case that the base class is GC-aware, the base class
997 probably GC-untracks the object. If it does that using the
998 UNTRACK macro, this will crash when the object is already
999 untracked. Because we don't know what the base class does, the
1000 only safe thing is to make sure the object is tracked when we
1001 call the base class dealloc. But... The trashcan begin macro
1002 requires that the object is *untracked* before it is called. So
1009 Q. Why did the last question say "immediately GC-track again"?
1010 It's nowhere near immediately.
1012 A. Because the code *used* to re-track immediately. Bad Idea.
1013 self has a refcount of 0, and if gc ever gets its hands on it
1014 (which can happen if any weakref callback gets invoked), it
1015 looks like trash to gc too, and gc also tries to delete self
1016 then. But we're already deleting self. Double dealloction is
1019 Q. Why the bizarre (net-zero) manipulation of
1020 _PyTrash_delete_nesting around the trashcan macros?
1022 A. Some base classes (e.g. list) also use the trashcan mechanism.
1023 The following scenario used to be possible:
1025 - suppose the trashcan level is one below the trashcan limit
1027 - subtype_dealloc() is called
1029 - the trashcan limit is not yet reached, so the trashcan level
1030 is incremented and the code between trashcan begin and end is
1033 - this destroys much of the object's contents, including its
1036 - basedealloc() is called; this is really list_dealloc(), or
1037 some other type which also uses the trashcan macros
1039 - the trashcan limit is now reached, so the object is put on the
1040 trashcan's to-be-deleted-later list
1042 - basedealloc() returns
1044 - subtype_dealloc() decrefs the object's type
1046 - subtype_dealloc() returns
1048 - later, the trashcan code starts deleting the objects from its
1049 to-be-deleted-later list
1051 - subtype_dealloc() is called *AGAIN* for the same object
1053 - at the very least (if the destroyed slots and __dict__ don't
1054 cause problems) the object's type gets decref'ed a second
1055 time, which is *BAD*!!!
1057 The remedy is to make sure that if the code between trashcan
1058 begin and end in subtype_dealloc() is called, the code between
1059 trashcan begin and end in basedealloc() will also be called.
1060 This is done by decrementing the level after passing into the
1061 trashcan block, and incrementing it just before leaving the
1064 But now it's possible that a chain of objects consisting solely
1065 of objects whose deallocator is subtype_dealloc() will defeat
1066 the trashcan mechanism completely: the decremented level means
1067 that the effective level never reaches the limit. Therefore, we
1068 *increment* the level *before* entering the trashcan block, and
1069 matchingly decrement it after leaving. This means the trashcan
1070 code will trigger a little early, but that's no big deal.
1072 Q. Are there any live examples of code in need of all this
1075 A. Yes. See SF bug 668433 for code that crashed (when Python was
1076 compiled in debug mode) before the trashcan level manipulations
1077 were added. For more discussion, see SF patches 581742, 575073
1082 static PyTypeObject
*solid_base(PyTypeObject
*type
);
1084 /* type test with subclassing support */
1087 PyType_IsSubtype(PyTypeObject
*a
, PyTypeObject
*b
)
1091 if (!(a
->tp_flags
& Py_TPFLAGS_HAVE_CLASS
))
1092 return b
== a
|| b
== &PyBaseObject_Type
;
1096 /* Deal with multiple inheritance without recursion
1097 by walking the MRO tuple */
1099 assert(PyTuple_Check(mro
));
1100 n
= PyTuple_GET_SIZE(mro
);
1101 for (i
= 0; i
< n
; i
++) {
1102 if (PyTuple_GET_ITEM(mro
, i
) == (PyObject
*)b
)
1108 /* a is not completely initilized yet; follow tp_base */
1113 } while (a
!= NULL
);
1114 return b
== &PyBaseObject_Type
;
1118 /* Internal routines to do a method lookup in the type
1119 without looking in the instance dictionary
1120 (so we can't use PyObject_GetAttr) but still binding
1121 it to the instance. The arguments are the object,
1122 the method name as a C string, and the address of a
1123 static variable used to cache the interned Python string.
1127 - lookup_maybe() returns NULL without raising an exception
1128 when the _PyType_Lookup() call fails;
1130 - lookup_method() always raises an exception upon errors.
1134 lookup_maybe(PyObject
*self
, char *attrstr
, PyObject
**attrobj
)
1138 if (*attrobj
== NULL
) {
1139 *attrobj
= PyString_InternFromString(attrstr
);
1140 if (*attrobj
== NULL
)
1143 res
= _PyType_Lookup(Py_TYPE(self
), *attrobj
);
1146 if ((f
= Py_TYPE(res
)->tp_descr_get
) == NULL
)
1149 res
= f(res
, self
, (PyObject
*)(Py_TYPE(self
)));
1155 lookup_method(PyObject
*self
, char *attrstr
, PyObject
**attrobj
)
1157 PyObject
*res
= lookup_maybe(self
, attrstr
, attrobj
);
1158 if (res
== NULL
&& !PyErr_Occurred())
1159 PyErr_SetObject(PyExc_AttributeError
, *attrobj
);
1163 /* A variation of PyObject_CallMethod that uses lookup_method()
1164 instead of PyObject_GetAttrString(). This uses the same convention
1165 as lookup_method to cache the interned name string object. */
1168 call_method(PyObject
*o
, char *name
, PyObject
**nameobj
, char *format
, ...)
1171 PyObject
*args
, *func
= 0, *retval
;
1172 va_start(va
, format
);
1174 func
= lookup_maybe(o
, name
, nameobj
);
1177 if (!PyErr_Occurred())
1178 PyErr_SetObject(PyExc_AttributeError
, *nameobj
);
1182 if (format
&& *format
)
1183 args
= Py_VaBuildValue(format
, va
);
1185 args
= PyTuple_New(0);
1192 assert(PyTuple_Check(args
));
1193 retval
= PyObject_Call(func
, args
, NULL
);
1201 /* Clone of call_method() that returns NotImplemented when the lookup fails. */
1204 call_maybe(PyObject
*o
, char *name
, PyObject
**nameobj
, char *format
, ...)
1207 PyObject
*args
, *func
= 0, *retval
;
1208 va_start(va
, format
);
1210 func
= lookup_maybe(o
, name
, nameobj
);
1213 if (!PyErr_Occurred()) {
1214 Py_INCREF(Py_NotImplemented
);
1215 return Py_NotImplemented
;
1220 if (format
&& *format
)
1221 args
= Py_VaBuildValue(format
, va
);
1223 args
= PyTuple_New(0);
1230 assert(PyTuple_Check(args
));
1231 retval
= PyObject_Call(func
, args
, NULL
);
1240 fill_classic_mro(PyObject
*mro
, PyObject
*cls
)
1242 PyObject
*bases
, *base
;
1245 assert(PyList_Check(mro
));
1246 assert(PyClass_Check(cls
));
1247 i
= PySequence_Contains(mro
, cls
);
1251 if (PyList_Append(mro
, cls
) < 0)
1254 bases
= ((PyClassObject
*)cls
)->cl_bases
;
1255 assert(bases
&& PyTuple_Check(bases
));
1256 n
= PyTuple_GET_SIZE(bases
);
1257 for (i
= 0; i
< n
; i
++) {
1258 base
= PyTuple_GET_ITEM(bases
, i
);
1259 if (fill_classic_mro(mro
, base
) < 0)
1266 classic_mro(PyObject
*cls
)
1270 assert(PyClass_Check(cls
));
1271 mro
= PyList_New(0);
1273 if (fill_classic_mro(mro
, cls
) == 0)
1281 Method resolution order algorithm C3 described in
1282 "A Monotonic Superclass Linearization for Dylan",
1283 by Kim Barrett, Bob Cassel, Paul Haahr,
1284 David A. Moon, Keith Playford, and P. Tucker Withington.
1287 Some notes about the rules implied by C3:
1290 It isn't legal to repeat a class in a list of base classes.
1292 The next three properties are the 3 constraints in "C3".
1294 Local precendece order.
1295 If A precedes B in C's MRO, then A will precede B in the MRO of all
1299 The MRO of a class must be an extension without reordering of the
1300 MRO of each of its superclasses.
1302 Extended Precedence Graph (EPG).
1303 Linearization is consistent if there is a path in the EPG from
1304 each class to all its successors in the linearization. See
1305 the paper for definition of EPG.
1309 tail_contains(PyObject
*list
, int whence
, PyObject
*o
) {
1311 size
= PyList_GET_SIZE(list
);
1313 for (j
= whence
+1; j
< size
; j
++) {
1314 if (PyList_GET_ITEM(list
, j
) == o
)
1321 class_name(PyObject
*cls
)
1323 PyObject
*name
= PyObject_GetAttrString(cls
, "__name__");
1327 name
= PyObject_Repr(cls
);
1331 if (!PyString_Check(name
)) {
1339 check_duplicates(PyObject
*list
)
1342 /* Let's use a quadratic time algorithm,
1343 assuming that the bases lists is short.
1345 n
= PyList_GET_SIZE(list
);
1346 for (i
= 0; i
< n
; i
++) {
1347 PyObject
*o
= PyList_GET_ITEM(list
, i
);
1348 for (j
= i
+ 1; j
< n
; j
++) {
1349 if (PyList_GET_ITEM(list
, j
) == o
) {
1351 PyErr_Format(PyExc_TypeError
,
1352 "duplicate base class %s",
1353 o
? PyString_AS_STRING(o
) : "?");
1362 /* Raise a TypeError for an MRO order disagreement.
1364 It's hard to produce a good error message. In the absence of better
1365 insight into error reporting, report the classes that were candidates
1366 to be put next into the MRO. There is some conflict between the
1367 order in which they should be put in the MRO, but it's hard to
1368 diagnose what constraint can't be satisfied.
1372 set_mro_error(PyObject
*to_merge
, int *remain
)
1374 Py_ssize_t i
, n
, off
, to_merge_size
;
1377 PyObject
*set
= PyDict_New();
1380 to_merge_size
= PyList_GET_SIZE(to_merge
);
1381 for (i
= 0; i
< to_merge_size
; i
++) {
1382 PyObject
*L
= PyList_GET_ITEM(to_merge
, i
);
1383 if (remain
[i
] < PyList_GET_SIZE(L
)) {
1384 PyObject
*c
= PyList_GET_ITEM(L
, remain
[i
]);
1385 if (PyDict_SetItem(set
, c
, Py_None
) < 0) {
1391 n
= PyDict_Size(set
);
1393 off
= PyOS_snprintf(buf
, sizeof(buf
), "Cannot create a \
1394 consistent method resolution\norder (MRO) for bases");
1396 while (PyDict_Next(set
, &i
, &k
, &v
) && (size_t)off
< sizeof(buf
)) {
1397 PyObject
*name
= class_name(k
);
1398 off
+= PyOS_snprintf(buf
+ off
, sizeof(buf
) - off
, " %s",
1399 name
? PyString_AS_STRING(name
) : "?");
1401 if (--n
&& (size_t)(off
+1) < sizeof(buf
)) {
1406 PyErr_SetString(PyExc_TypeError
, buf
);
1411 pmerge(PyObject
*acc
, PyObject
* to_merge
) {
1412 Py_ssize_t i
, j
, to_merge_size
, empty_cnt
;
1416 to_merge_size
= PyList_GET_SIZE(to_merge
);
1418 /* remain stores an index into each sublist of to_merge.
1419 remain[i] is the index of the next base in to_merge[i]
1420 that is not included in acc.
1422 remain
= (int *)PyMem_MALLOC(SIZEOF_INT
*to_merge_size
);
1425 for (i
= 0; i
< to_merge_size
; i
++)
1430 for (i
= 0; i
< to_merge_size
; i
++) {
1431 PyObject
*candidate
;
1433 PyObject
*cur_list
= PyList_GET_ITEM(to_merge
, i
);
1435 if (remain
[i
] >= PyList_GET_SIZE(cur_list
)) {
1440 /* Choose next candidate for MRO.
1442 The input sequences alone can determine the choice.
1443 If not, choose the class which appears in the MRO
1444 of the earliest direct superclass of the new class.
1447 candidate
= PyList_GET_ITEM(cur_list
, remain
[i
]);
1448 for (j
= 0; j
< to_merge_size
; j
++) {
1449 PyObject
*j_lst
= PyList_GET_ITEM(to_merge
, j
);
1450 if (tail_contains(j_lst
, remain
[j
], candidate
)) {
1451 goto skip
; /* continue outer loop */
1454 ok
= PyList_Append(acc
, candidate
);
1459 for (j
= 0; j
< to_merge_size
; j
++) {
1460 PyObject
*j_lst
= PyList_GET_ITEM(to_merge
, j
);
1461 if (remain
[j
] < PyList_GET_SIZE(j_lst
) &&
1462 PyList_GET_ITEM(j_lst
, remain
[j
]) == candidate
) {
1470 if (empty_cnt
== to_merge_size
) {
1474 set_mro_error(to_merge
, remain
);
1480 mro_implementation(PyTypeObject
*type
)
1484 PyObject
*bases
, *result
;
1485 PyObject
*to_merge
, *bases_aslist
;
1487 if (type
->tp_dict
== NULL
) {
1488 if (PyType_Ready(type
) < 0)
1492 /* Find a superclass linearization that honors the constraints
1493 of the explicit lists of bases and the constraints implied by
1496 to_merge is a list of lists, where each list is a superclass
1497 linearization implied by a base class. The last element of
1498 to_merge is the declared list of bases.
1501 bases
= type
->tp_bases
;
1502 n
= PyTuple_GET_SIZE(bases
);
1504 to_merge
= PyList_New(n
+1);
1505 if (to_merge
== NULL
)
1508 for (i
= 0; i
< n
; i
++) {
1509 PyObject
*base
= PyTuple_GET_ITEM(bases
, i
);
1510 PyObject
*parentMRO
;
1511 if (PyType_Check(base
))
1512 parentMRO
= PySequence_List(
1513 ((PyTypeObject
*)base
)->tp_mro
);
1515 parentMRO
= classic_mro(base
);
1516 if (parentMRO
== NULL
) {
1517 Py_DECREF(to_merge
);
1521 PyList_SET_ITEM(to_merge
, i
, parentMRO
);
1524 bases_aslist
= PySequence_List(bases
);
1525 if (bases_aslist
== NULL
) {
1526 Py_DECREF(to_merge
);
1529 /* This is just a basic sanity check. */
1530 if (check_duplicates(bases_aslist
) < 0) {
1531 Py_DECREF(to_merge
);
1532 Py_DECREF(bases_aslist
);
1535 PyList_SET_ITEM(to_merge
, n
, bases_aslist
);
1537 result
= Py_BuildValue("[O]", (PyObject
*)type
);
1538 if (result
== NULL
) {
1539 Py_DECREF(to_merge
);
1543 ok
= pmerge(result
, to_merge
);
1544 Py_DECREF(to_merge
);
1554 mro_external(PyObject
*self
)
1556 PyTypeObject
*type
= (PyTypeObject
*)self
;
1558 return mro_implementation(type
);
1562 mro_internal(PyTypeObject
*type
)
1564 PyObject
*mro
, *result
, *tuple
;
1567 if (Py_TYPE(type
) == &PyType_Type
) {
1568 result
= mro_implementation(type
);
1571 static PyObject
*mro_str
;
1573 mro
= lookup_method((PyObject
*)type
, "mro", &mro_str
);
1576 result
= PyObject_CallObject(mro
, NULL
);
1581 tuple
= PySequence_Tuple(result
);
1588 PyTypeObject
*solid
;
1590 solid
= solid_base(type
);
1592 len
= PyTuple_GET_SIZE(tuple
);
1594 for (i
= 0; i
< len
; i
++) {
1596 cls
= PyTuple_GET_ITEM(tuple
, i
);
1597 if (PyClass_Check(cls
))
1599 else if (!PyType_Check(cls
)) {
1600 PyErr_Format(PyExc_TypeError
,
1601 "mro() returned a non-class ('%.500s')",
1602 Py_TYPE(cls
)->tp_name
);
1606 t
= (PyTypeObject
*)cls
;
1607 if (!PyType_IsSubtype(solid
, solid_base(t
))) {
1608 PyErr_Format(PyExc_TypeError
,
1609 "mro() returned base with unsuitable layout ('%.500s')",
1616 type
->tp_mro
= tuple
;
1618 type_mro_modified(type
, type
->tp_mro
);
1619 /* corner case: the old-style super class might have been hidden
1620 from the custom MRO */
1621 type_mro_modified(type
, type
->tp_bases
);
1623 PyType_Modified(type
);
1629 /* Calculate the best base amongst multiple base classes.
1630 This is the first one that's on the path to the "solid base". */
1632 static PyTypeObject
*
1633 best_base(PyObject
*bases
)
1636 PyTypeObject
*base
, *winner
, *candidate
, *base_i
;
1637 PyObject
*base_proto
;
1639 assert(PyTuple_Check(bases
));
1640 n
= PyTuple_GET_SIZE(bases
);
1644 for (i
= 0; i
< n
; i
++) {
1645 base_proto
= PyTuple_GET_ITEM(bases
, i
);
1646 if (PyClass_Check(base_proto
))
1648 if (!PyType_Check(base_proto
)) {
1651 "bases must be types");
1654 base_i
= (PyTypeObject
*)base_proto
;
1655 if (base_i
->tp_dict
== NULL
) {
1656 if (PyType_Ready(base_i
) < 0)
1659 candidate
= solid_base(base_i
);
1660 if (winner
== NULL
) {
1664 else if (PyType_IsSubtype(winner
, candidate
))
1666 else if (PyType_IsSubtype(candidate
, winner
)) {
1673 "multiple bases have "
1674 "instance lay-out conflict");
1679 PyErr_SetString(PyExc_TypeError
,
1680 "a new-style class can't have only classic bases");
1685 extra_ivars(PyTypeObject
*type
, PyTypeObject
*base
)
1687 size_t t_size
= type
->tp_basicsize
;
1688 size_t b_size
= base
->tp_basicsize
;
1690 assert(t_size
>= b_size
); /* Else type smaller than base! */
1691 if (type
->tp_itemsize
|| base
->tp_itemsize
) {
1692 /* If itemsize is involved, stricter rules */
1693 return t_size
!= b_size
||
1694 type
->tp_itemsize
!= base
->tp_itemsize
;
1696 if (type
->tp_weaklistoffset
&& base
->tp_weaklistoffset
== 0 &&
1697 type
->tp_weaklistoffset
+ sizeof(PyObject
*) == t_size
&&
1698 type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)
1699 t_size
-= sizeof(PyObject
*);
1700 if (type
->tp_dictoffset
&& base
->tp_dictoffset
== 0 &&
1701 type
->tp_dictoffset
+ sizeof(PyObject
*) == t_size
&&
1702 type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)
1703 t_size
-= sizeof(PyObject
*);
1705 return t_size
!= b_size
;
1708 static PyTypeObject
*
1709 solid_base(PyTypeObject
*type
)
1714 base
= solid_base(type
->tp_base
);
1716 base
= &PyBaseObject_Type
;
1717 if (extra_ivars(type
, base
))
1723 static void object_dealloc(PyObject
*);
1724 static int object_init(PyObject
*, PyObject
*, PyObject
*);
1725 static int update_slot(PyTypeObject
*, PyObject
*);
1726 static void fixup_slot_dispatchers(PyTypeObject
*);
1729 * Helpers for __dict__ descriptor. We don't want to expose the dicts
1730 * inherited from various builtin types. The builtin base usually provides
1731 * its own __dict__ descriptor, so we use that when we can.
1733 static PyTypeObject
*
1734 get_builtin_base_with_dict(PyTypeObject
*type
)
1736 while (type
->tp_base
!= NULL
) {
1737 if (type
->tp_dictoffset
!= 0 &&
1738 !(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
))
1740 type
= type
->tp_base
;
1746 get_dict_descriptor(PyTypeObject
*type
)
1748 static PyObject
*dict_str
;
1751 if (dict_str
== NULL
) {
1752 dict_str
= PyString_InternFromString("__dict__");
1753 if (dict_str
== NULL
)
1756 descr
= _PyType_Lookup(type
, dict_str
);
1757 if (descr
== NULL
|| !PyDescr_IsData(descr
))
1764 raise_dict_descr_error(PyObject
*obj
)
1766 PyErr_Format(PyExc_TypeError
,
1767 "this __dict__ descriptor does not support "
1768 "'%.200s' objects", obj
->ob_type
->tp_name
);
1772 subtype_dict(PyObject
*obj
, void *context
)
1778 base
= get_builtin_base_with_dict(obj
->ob_type
);
1781 PyObject
*descr
= get_dict_descriptor(base
);
1782 if (descr
== NULL
) {
1783 raise_dict_descr_error(obj
);
1786 func
= descr
->ob_type
->tp_descr_get
;
1788 raise_dict_descr_error(obj
);
1791 return func(descr
, obj
, (PyObject
*)(obj
->ob_type
));
1794 dictptr
= _PyObject_GetDictPtr(obj
);
1795 if (dictptr
== NULL
) {
1796 PyErr_SetString(PyExc_AttributeError
,
1797 "This object has no __dict__");
1802 *dictptr
= dict
= PyDict_New();
1808 subtype_setdict(PyObject
*obj
, PyObject
*value
, void *context
)
1814 base
= get_builtin_base_with_dict(obj
->ob_type
);
1817 PyObject
*descr
= get_dict_descriptor(base
);
1818 if (descr
== NULL
) {
1819 raise_dict_descr_error(obj
);
1822 func
= descr
->ob_type
->tp_descr_set
;
1824 raise_dict_descr_error(obj
);
1827 return func(descr
, obj
, value
);
1830 dictptr
= _PyObject_GetDictPtr(obj
);
1831 if (dictptr
== NULL
) {
1832 PyErr_SetString(PyExc_AttributeError
,
1833 "This object has no __dict__");
1836 if (value
!= NULL
&& !PyDict_Check(value
)) {
1837 PyErr_Format(PyExc_TypeError
,
1838 "__dict__ must be set to a dictionary, "
1839 "not a '%.200s'", Py_TYPE(value
)->tp_name
);
1850 subtype_getweakref(PyObject
*obj
, void *context
)
1852 PyObject
**weaklistptr
;
1855 if (Py_TYPE(obj
)->tp_weaklistoffset
== 0) {
1856 PyErr_SetString(PyExc_AttributeError
,
1857 "This object has no __weakref__");
1860 assert(Py_TYPE(obj
)->tp_weaklistoffset
> 0);
1861 assert(Py_TYPE(obj
)->tp_weaklistoffset
+ sizeof(PyObject
*) <=
1862 (size_t)(Py_TYPE(obj
)->tp_basicsize
));
1863 weaklistptr
= (PyObject
**)
1864 ((char *)obj
+ Py_TYPE(obj
)->tp_weaklistoffset
);
1865 if (*weaklistptr
== NULL
)
1868 result
= *weaklistptr
;
1873 /* Three variants on the subtype_getsets list. */
1875 static PyGetSetDef subtype_getsets_full
[] = {
1876 {"__dict__", subtype_dict
, subtype_setdict
,
1877 PyDoc_STR("dictionary for instance variables (if defined)")},
1878 {"__weakref__", subtype_getweakref
, NULL
,
1879 PyDoc_STR("list of weak references to the object (if defined)")},
1883 static PyGetSetDef subtype_getsets_dict_only
[] = {
1884 {"__dict__", subtype_dict
, subtype_setdict
,
1885 PyDoc_STR("dictionary for instance variables (if defined)")},
1889 static PyGetSetDef subtype_getsets_weakref_only
[] = {
1890 {"__weakref__", subtype_getweakref
, NULL
,
1891 PyDoc_STR("list of weak references to the object (if defined)")},
1896 valid_identifier(PyObject
*s
)
1901 if (!PyString_Check(s
)) {
1902 PyErr_Format(PyExc_TypeError
,
1903 "__slots__ items must be strings, not '%.200s'",
1904 Py_TYPE(s
)->tp_name
);
1907 p
= (unsigned char *) PyString_AS_STRING(s
);
1908 n
= PyString_GET_SIZE(s
);
1909 /* We must reject an empty name. As a hack, we bump the
1910 length to 1 so that the loop will balk on the trailing \0. */
1913 for (i
= 0; i
< n
; i
++, p
++) {
1914 if (!(i
== 0 ? isalpha(*p
) : isalnum(*p
)) && *p
!= '_') {
1915 PyErr_SetString(PyExc_TypeError
,
1916 "__slots__ must be identifiers");
1923 #ifdef Py_USING_UNICODE
1924 /* Replace Unicode objects in slots. */
1927 _unicode_to_string(PyObject
*slots
, Py_ssize_t nslots
)
1929 PyObject
*tmp
= NULL
;
1930 PyObject
*slot_name
, *new_name
;
1933 for (i
= 0; i
< nslots
; i
++) {
1934 if (PyUnicode_Check(slot_name
= PyTuple_GET_ITEM(slots
, i
))) {
1936 tmp
= PySequence_List(slots
);
1940 new_name
= _PyUnicode_AsDefaultEncodedString(slot_name
,
1942 if (new_name
== NULL
) {
1946 Py_INCREF(new_name
);
1947 PyList_SET_ITEM(tmp
, i
, new_name
);
1948 Py_DECREF(slot_name
);
1952 slots
= PyList_AsTuple(tmp
);
1961 object_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
);
1964 type_init(PyObject
*cls
, PyObject
*args
, PyObject
*kwds
)
1968 assert(args
!= NULL
&& PyTuple_Check(args
));
1969 assert(kwds
== NULL
|| PyDict_Check(kwds
));
1971 if (kwds
!= NULL
&& PyDict_Check(kwds
) && PyDict_Size(kwds
) != 0) {
1972 PyErr_SetString(PyExc_TypeError
,
1973 "type.__init__() takes no keyword arguments");
1977 if (args
!= NULL
&& PyTuple_Check(args
) &&
1978 (PyTuple_GET_SIZE(args
) != 1 && PyTuple_GET_SIZE(args
) != 3)) {
1979 PyErr_SetString(PyExc_TypeError
,
1980 "type.__init__() takes 1 or 3 arguments");
1984 /* Call object.__init__(self) now. */
1985 /* XXX Could call super(type, cls).__init__() but what's the point? */
1986 args
= PyTuple_GetSlice(args
, 0, 0);
1987 res
= object_init(cls
, args
, NULL
);
1993 type_new(PyTypeObject
*metatype
, PyObject
*args
, PyObject
*kwds
)
1995 PyObject
*name
, *bases
, *dict
;
1996 static char *kwlist
[] = {"name", "bases", "dict", 0};
1997 PyObject
*slots
, *tmp
, *newslots
;
1998 PyTypeObject
*type
, *base
, *tmptype
, *winner
;
1999 PyHeapTypeObject
*et
;
2001 Py_ssize_t i
, nbases
, nslots
, slotoffset
, add_dict
, add_weak
;
2002 int j
, may_add_dict
, may_add_weak
;
2004 assert(args
!= NULL
&& PyTuple_Check(args
));
2005 assert(kwds
== NULL
|| PyDict_Check(kwds
));
2007 /* Special case: type(x) should return x->ob_type */
2009 const Py_ssize_t nargs
= PyTuple_GET_SIZE(args
);
2010 const Py_ssize_t nkwds
= kwds
== NULL
? 0 : PyDict_Size(kwds
);
2012 if (PyType_CheckExact(metatype
) && nargs
== 1 && nkwds
== 0) {
2013 PyObject
*x
= PyTuple_GET_ITEM(args
, 0);
2014 Py_INCREF(Py_TYPE(x
));
2015 return (PyObject
*) Py_TYPE(x
);
2018 /* SF bug 475327 -- if that didn't trigger, we need 3
2019 arguments. but PyArg_ParseTupleAndKeywords below may give
2020 a msg saying type() needs exactly 3. */
2021 if (nargs
+ nkwds
!= 3) {
2022 PyErr_SetString(PyExc_TypeError
,
2023 "type() takes 1 or 3 arguments");
2028 /* Check arguments: (name, bases, dict) */
2029 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "SO!O!:type", kwlist
,
2031 &PyTuple_Type
, &bases
,
2032 &PyDict_Type
, &dict
))
2035 /* Determine the proper metatype to deal with this,
2036 and check for metatype conflicts while we're at it.
2037 Note that if some other metatype wins to contract,
2038 it's possible that its instances are not types. */
2039 nbases
= PyTuple_GET_SIZE(bases
);
2041 for (i
= 0; i
< nbases
; i
++) {
2042 tmp
= PyTuple_GET_ITEM(bases
, i
);
2043 tmptype
= tmp
->ob_type
;
2044 if (tmptype
== &PyClass_Type
)
2045 continue; /* Special case classic classes */
2046 if (PyType_IsSubtype(winner
, tmptype
))
2048 if (PyType_IsSubtype(tmptype
, winner
)) {
2052 PyErr_SetString(PyExc_TypeError
,
2053 "metaclass conflict: "
2054 "the metaclass of a derived class "
2055 "must be a (non-strict) subclass "
2056 "of the metaclasses of all its bases");
2059 if (winner
!= metatype
) {
2060 if (winner
->tp_new
!= type_new
) /* Pass it to the winner */
2061 return winner
->tp_new(winner
, args
, kwds
);
2065 /* Adjust for empty tuple bases */
2067 bases
= PyTuple_Pack(1, &PyBaseObject_Type
);
2075 /* XXX From here until type is allocated, "return NULL" leaks bases! */
2077 /* Calculate best base, and check that all bases are type objects */
2078 base
= best_base(bases
);
2083 if (!PyType_HasFeature(base
, Py_TPFLAGS_BASETYPE
)) {
2084 PyErr_Format(PyExc_TypeError
,
2085 "type '%.100s' is not an acceptable base type",
2091 /* Check for a __slots__ sequence variable in dict, and count it */
2092 slots
= PyDict_GetItemString(dict
, "__slots__");
2096 may_add_dict
= base
->tp_dictoffset
== 0;
2097 may_add_weak
= base
->tp_weaklistoffset
== 0 && base
->tp_itemsize
== 0;
2098 if (slots
== NULL
) {
2109 /* Make it into a tuple */
2110 if (PyString_Check(slots
) || PyUnicode_Check(slots
))
2111 slots
= PyTuple_Pack(1, slots
);
2113 slots
= PySequence_Tuple(slots
);
2114 if (slots
== NULL
) {
2118 assert(PyTuple_Check(slots
));
2120 /* Are slots allowed? */
2121 nslots
= PyTuple_GET_SIZE(slots
);
2122 if (nslots
> 0 && base
->tp_itemsize
!= 0) {
2123 PyErr_Format(PyExc_TypeError
,
2124 "nonempty __slots__ "
2125 "not supported for subtype of '%s'",
2133 #ifdef Py_USING_UNICODE
2134 tmp
= _unicode_to_string(slots
, nslots
);
2142 /* Check for valid slot names and two special cases */
2143 for (i
= 0; i
< nslots
; i
++) {
2144 PyObject
*tmp
= PyTuple_GET_ITEM(slots
, i
);
2146 if (!valid_identifier(tmp
))
2148 assert(PyString_Check(tmp
));
2149 s
= PyString_AS_STRING(tmp
);
2150 if (strcmp(s
, "__dict__") == 0) {
2151 if (!may_add_dict
|| add_dict
) {
2152 PyErr_SetString(PyExc_TypeError
,
2153 "__dict__ slot disallowed: "
2154 "we already got one");
2159 if (strcmp(s
, "__weakref__") == 0) {
2160 if (!may_add_weak
|| add_weak
) {
2161 PyErr_SetString(PyExc_TypeError
,
2162 "__weakref__ slot disallowed: "
2163 "either we already got one, "
2164 "or __itemsize__ != 0");
2171 /* Copy slots into a list, mangle names and sort them.
2172 Sorted names are needed for __class__ assignment.
2173 Convert them back to tuple at the end.
2175 newslots
= PyList_New(nslots
- add_dict
- add_weak
);
2176 if (newslots
== NULL
)
2178 for (i
= j
= 0; i
< nslots
; i
++) {
2180 tmp
= PyTuple_GET_ITEM(slots
, i
);
2181 s
= PyString_AS_STRING(tmp
);
2182 if ((add_dict
&& strcmp(s
, "__dict__") == 0) ||
2183 (add_weak
&& strcmp(s
, "__weakref__") == 0))
2185 tmp
=_Py_Mangle(name
, tmp
);
2188 PyList_SET_ITEM(newslots
, j
, tmp
);
2191 assert(j
== nslots
- add_dict
- add_weak
);
2194 if (PyList_Sort(newslots
) == -1) {
2196 Py_DECREF(newslots
);
2199 slots
= PyList_AsTuple(newslots
);
2200 Py_DECREF(newslots
);
2201 if (slots
== NULL
) {
2206 /* Secondary bases may provide weakrefs or dict */
2208 ((may_add_dict
&& !add_dict
) ||
2209 (may_add_weak
&& !add_weak
))) {
2210 for (i
= 0; i
< nbases
; i
++) {
2211 tmp
= PyTuple_GET_ITEM(bases
, i
);
2212 if (tmp
== (PyObject
*)base
)
2213 continue; /* Skip primary base */
2214 if (PyClass_Check(tmp
)) {
2215 /* Classic base class provides both */
2216 if (may_add_dict
&& !add_dict
)
2218 if (may_add_weak
&& !add_weak
)
2222 assert(PyType_Check(tmp
));
2223 tmptype
= (PyTypeObject
*)tmp
;
2224 if (may_add_dict
&& !add_dict
&&
2225 tmptype
->tp_dictoffset
!= 0)
2227 if (may_add_weak
&& !add_weak
&&
2228 tmptype
->tp_weaklistoffset
!= 0)
2230 if (may_add_dict
&& !add_dict
)
2232 if (may_add_weak
&& !add_weak
)
2234 /* Nothing more to check */
2240 /* XXX From here until type is safely allocated,
2241 "return NULL" may leak slots! */
2243 /* Allocate the type object */
2244 type
= (PyTypeObject
*)metatype
->tp_alloc(metatype
, nslots
);
2251 /* Keep name and slots alive in the extended type object */
2252 et
= (PyHeapTypeObject
*)type
;
2255 et
->ht_slots
= slots
;
2257 /* Initialize tp_flags */
2258 type
->tp_flags
= Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HEAPTYPE
|
2259 Py_TPFLAGS_BASETYPE
;
2260 if (base
->tp_flags
& Py_TPFLAGS_HAVE_GC
)
2261 type
->tp_flags
|= Py_TPFLAGS_HAVE_GC
;
2263 /* It's a new-style number unless it specifically inherits any
2264 old-style numeric behavior */
2265 if ((base
->tp_flags
& Py_TPFLAGS_CHECKTYPES
) ||
2266 (base
->tp_as_number
== NULL
))
2267 type
->tp_flags
|= Py_TPFLAGS_CHECKTYPES
;
2269 /* Initialize essential fields */
2270 type
->tp_as_number
= &et
->as_number
;
2271 type
->tp_as_sequence
= &et
->as_sequence
;
2272 type
->tp_as_mapping
= &et
->as_mapping
;
2273 type
->tp_as_buffer
= &et
->as_buffer
;
2274 type
->tp_name
= PyString_AS_STRING(name
);
2276 /* Set tp_base and tp_bases */
2277 type
->tp_bases
= bases
;
2279 type
->tp_base
= base
;
2281 /* Initialize tp_dict from passed-in dict */
2282 type
->tp_dict
= dict
= PyDict_Copy(dict
);
2288 /* Set __module__ in the dict */
2289 if (PyDict_GetItemString(dict
, "__module__") == NULL
) {
2290 tmp
= PyEval_GetGlobals();
2292 tmp
= PyDict_GetItemString(tmp
, "__name__");
2294 if (PyDict_SetItemString(dict
, "__module__",
2301 /* Set tp_doc to a copy of dict['__doc__'], if the latter is there
2302 and is a string. The __doc__ accessor will first look for tp_doc;
2303 if that fails, it will still look into __dict__.
2306 PyObject
*doc
= PyDict_GetItemString(dict
, "__doc__");
2307 if (doc
!= NULL
&& PyString_Check(doc
)) {
2308 const size_t n
= (size_t)PyString_GET_SIZE(doc
);
2309 char *tp_doc
= (char *)PyObject_MALLOC(n
+1);
2310 if (tp_doc
== NULL
) {
2314 memcpy(tp_doc
, PyString_AS_STRING(doc
), n
+1);
2315 type
->tp_doc
= tp_doc
;
2319 /* Special-case __new__: if it's a plain function,
2320 make it a static function */
2321 tmp
= PyDict_GetItemString(dict
, "__new__");
2322 if (tmp
!= NULL
&& PyFunction_Check(tmp
)) {
2323 tmp
= PyStaticMethod_New(tmp
);
2328 PyDict_SetItemString(dict
, "__new__", tmp
);
2332 /* Add descriptors for custom slots from __slots__, or for __dict__ */
2333 mp
= PyHeapType_GET_MEMBERS(et
);
2334 slotoffset
= base
->tp_basicsize
;
2335 if (slots
!= NULL
) {
2336 for (i
= 0; i
< nslots
; i
++, mp
++) {
2337 mp
->name
= PyString_AS_STRING(
2338 PyTuple_GET_ITEM(slots
, i
));
2339 mp
->type
= T_OBJECT_EX
;
2340 mp
->offset
= slotoffset
;
2342 /* __dict__ and __weakref__ are already filtered out */
2343 assert(strcmp(mp
->name
, "__dict__") != 0);
2344 assert(strcmp(mp
->name
, "__weakref__") != 0);
2346 slotoffset
+= sizeof(PyObject
*);
2350 if (base
->tp_itemsize
)
2351 type
->tp_dictoffset
= -(long)sizeof(PyObject
*);
2353 type
->tp_dictoffset
= slotoffset
;
2354 slotoffset
+= sizeof(PyObject
*);
2357 assert(!base
->tp_itemsize
);
2358 type
->tp_weaklistoffset
= slotoffset
;
2359 slotoffset
+= sizeof(PyObject
*);
2361 type
->tp_basicsize
= slotoffset
;
2362 type
->tp_itemsize
= base
->tp_itemsize
;
2363 type
->tp_members
= PyHeapType_GET_MEMBERS(et
);
2365 if (type
->tp_weaklistoffset
&& type
->tp_dictoffset
)
2366 type
->tp_getset
= subtype_getsets_full
;
2367 else if (type
->tp_weaklistoffset
&& !type
->tp_dictoffset
)
2368 type
->tp_getset
= subtype_getsets_weakref_only
;
2369 else if (!type
->tp_weaklistoffset
&& type
->tp_dictoffset
)
2370 type
->tp_getset
= subtype_getsets_dict_only
;
2372 type
->tp_getset
= NULL
;
2374 /* Special case some slots */
2375 if (type
->tp_dictoffset
!= 0 || nslots
> 0) {
2376 if (base
->tp_getattr
== NULL
&& base
->tp_getattro
== NULL
)
2377 type
->tp_getattro
= PyObject_GenericGetAttr
;
2378 if (base
->tp_setattr
== NULL
&& base
->tp_setattro
== NULL
)
2379 type
->tp_setattro
= PyObject_GenericSetAttr
;
2381 type
->tp_dealloc
= subtype_dealloc
;
2383 /* Enable GC unless there are really no instance variables possible */
2384 if (!(type
->tp_basicsize
== sizeof(PyObject
) &&
2385 type
->tp_itemsize
== 0))
2386 type
->tp_flags
|= Py_TPFLAGS_HAVE_GC
;
2388 /* Always override allocation strategy to use regular heap */
2389 type
->tp_alloc
= PyType_GenericAlloc
;
2390 if (type
->tp_flags
& Py_TPFLAGS_HAVE_GC
) {
2391 type
->tp_free
= PyObject_GC_Del
;
2392 type
->tp_traverse
= subtype_traverse
;
2393 type
->tp_clear
= subtype_clear
;
2396 type
->tp_free
= PyObject_Del
;
2398 /* Initialize the rest */
2399 if (PyType_Ready(type
) < 0) {
2404 /* Put the proper slots in place */
2405 fixup_slot_dispatchers(type
);
2407 return (PyObject
*)type
;
2410 /* Internal API to look for a name through the MRO.
2411 This returns a borrowed reference, and doesn't set an exception! */
2413 _PyType_Lookup(PyTypeObject
*type
, PyObject
*name
)
2416 PyObject
*mro
, *res
, *base
, *dict
;
2419 if (MCACHE_CACHEABLE_NAME(name
) &&
2420 PyType_HasFeature(type
, Py_TPFLAGS_VALID_VERSION_TAG
)) {
2422 h
= MCACHE_HASH_METHOD(type
, name
);
2423 if (method_cache
[h
].version
== type
->tp_version_tag
&&
2424 method_cache
[h
].name
== name
)
2425 return method_cache
[h
].value
;
2428 /* Look in tp_dict of types in MRO */
2431 /* If mro is NULL, the type is either not yet initialized
2432 by PyType_Ready(), or already cleared by type_clear().
2433 Either way the safest thing to do is to return NULL. */
2438 assert(PyTuple_Check(mro
));
2439 n
= PyTuple_GET_SIZE(mro
);
2440 for (i
= 0; i
< n
; i
++) {
2441 base
= PyTuple_GET_ITEM(mro
, i
);
2442 if (PyClass_Check(base
))
2443 dict
= ((PyClassObject
*)base
)->cl_dict
;
2445 assert(PyType_Check(base
));
2446 dict
= ((PyTypeObject
*)base
)->tp_dict
;
2448 assert(dict
&& PyDict_Check(dict
));
2449 res
= PyDict_GetItem(dict
, name
);
2454 if (MCACHE_CACHEABLE_NAME(name
) && assign_version_tag(type
)) {
2455 h
= MCACHE_HASH_METHOD(type
, name
);
2456 method_cache
[h
].version
= type
->tp_version_tag
;
2457 method_cache
[h
].value
= res
; /* borrowed */
2459 Py_DECREF(method_cache
[h
].name
);
2460 method_cache
[h
].name
= name
;
2465 /* This is similar to PyObject_GenericGetAttr(),
2466 but uses _PyType_Lookup() instead of just looking in type->tp_dict. */
2468 type_getattro(PyTypeObject
*type
, PyObject
*name
)
2470 PyTypeObject
*metatype
= Py_TYPE(type
);
2471 PyObject
*meta_attribute
, *attribute
;
2472 descrgetfunc meta_get
;
2474 /* Initialize this type (we'll assume the metatype is initialized) */
2475 if (type
->tp_dict
== NULL
) {
2476 if (PyType_Ready(type
) < 0)
2480 /* No readable descriptor found yet */
2483 /* Look for the attribute in the metatype */
2484 meta_attribute
= _PyType_Lookup(metatype
, name
);
2486 if (meta_attribute
!= NULL
) {
2487 meta_get
= Py_TYPE(meta_attribute
)->tp_descr_get
;
2489 if (meta_get
!= NULL
&& PyDescr_IsData(meta_attribute
)) {
2490 /* Data descriptors implement tp_descr_set to intercept
2491 * writes. Assume the attribute is not overridden in
2492 * type's tp_dict (and bases): call the descriptor now.
2494 return meta_get(meta_attribute
, (PyObject
*)type
,
2495 (PyObject
*)metatype
);
2497 Py_INCREF(meta_attribute
);
2500 /* No data descriptor found on metatype. Look in tp_dict of this
2501 * type and its bases */
2502 attribute
= _PyType_Lookup(type
, name
);
2503 if (attribute
!= NULL
) {
2504 /* Implement descriptor functionality, if any */
2505 descrgetfunc local_get
= Py_TYPE(attribute
)->tp_descr_get
;
2507 Py_XDECREF(meta_attribute
);
2509 if (local_get
!= NULL
) {
2510 /* NULL 2nd argument indicates the descriptor was
2511 * found on the target object itself (or a base) */
2512 return local_get(attribute
, (PyObject
*)NULL
,
2516 Py_INCREF(attribute
);
2520 /* No attribute found in local __dict__ (or bases): use the
2521 * descriptor from the metatype, if any */
2522 if (meta_get
!= NULL
) {
2524 res
= meta_get(meta_attribute
, (PyObject
*)type
,
2525 (PyObject
*)metatype
);
2526 Py_DECREF(meta_attribute
);
2530 /* If an ordinary attribute was found on the metatype, return it now */
2531 if (meta_attribute
!= NULL
) {
2532 return meta_attribute
;
2536 PyErr_Format(PyExc_AttributeError
,
2537 "type object '%.50s' has no attribute '%.400s'",
2538 type
->tp_name
, PyString_AS_STRING(name
));
2543 type_setattro(PyTypeObject
*type
, PyObject
*name
, PyObject
*value
)
2545 if (!(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)) {
2548 "can't set attributes of built-in/extension type '%s'",
2552 if (PyObject_GenericSetAttr((PyObject
*)type
, name
, value
) < 0)
2554 return update_slot(type
, name
);
2558 type_dealloc(PyTypeObject
*type
)
2560 PyHeapTypeObject
*et
;
2562 /* Assert this is a heap-allocated type object */
2563 assert(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
);
2564 _PyObject_GC_UNTRACK(type
);
2565 PyObject_ClearWeakRefs((PyObject
*)type
);
2566 et
= (PyHeapTypeObject
*)type
;
2567 Py_XDECREF(type
->tp_base
);
2568 Py_XDECREF(type
->tp_dict
);
2569 Py_XDECREF(type
->tp_bases
);
2570 Py_XDECREF(type
->tp_mro
);
2571 Py_XDECREF(type
->tp_cache
);
2572 Py_XDECREF(type
->tp_subclasses
);
2573 /* A type's tp_doc is heap allocated, unlike the tp_doc slots
2574 * of most other objects. It's okay to cast it to char *.
2576 PyObject_Free((char *)type
->tp_doc
);
2577 Py_XDECREF(et
->ht_name
);
2578 Py_XDECREF(et
->ht_slots
);
2579 Py_TYPE(type
)->tp_free((PyObject
*)type
);
2583 type_subclasses(PyTypeObject
*type
, PyObject
*args_ignored
)
2585 PyObject
*list
, *raw
, *ref
;
2588 list
= PyList_New(0);
2591 raw
= type
->tp_subclasses
;
2594 assert(PyList_Check(raw
));
2595 n
= PyList_GET_SIZE(raw
);
2596 for (i
= 0; i
< n
; i
++) {
2597 ref
= PyList_GET_ITEM(raw
, i
);
2598 assert(PyWeakref_CheckRef(ref
));
2599 ref
= PyWeakref_GET_OBJECT(ref
);
2600 if (ref
!= Py_None
) {
2601 if (PyList_Append(list
, ref
) < 0) {
2610 static PyMethodDef type_methods
[] = {
2611 {"mro", (PyCFunction
)mro_external
, METH_NOARGS
,
2612 PyDoc_STR("mro() -> list\nreturn a type's method resolution order")},
2613 {"__subclasses__", (PyCFunction
)type_subclasses
, METH_NOARGS
,
2614 PyDoc_STR("__subclasses__() -> list of immediate subclasses")},
2618 PyDoc_STRVAR(type_doc
,
2619 "type(object) -> the object's type\n"
2620 "type(name, bases, dict) -> a new type");
2623 type_traverse(PyTypeObject
*type
, visitproc visit
, void *arg
)
2625 /* Because of type_is_gc(), the collector only calls this
2627 assert(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
);
2629 Py_VISIT(type
->tp_dict
);
2630 Py_VISIT(type
->tp_cache
);
2631 Py_VISIT(type
->tp_mro
);
2632 Py_VISIT(type
->tp_bases
);
2633 Py_VISIT(type
->tp_base
);
2635 /* There's no need to visit type->tp_subclasses or
2636 ((PyHeapTypeObject *)type)->ht_slots, because they can't be involved
2637 in cycles; tp_subclasses is a list of weak references,
2638 and slots is a tuple of strings. */
2644 type_clear(PyTypeObject
*type
)
2646 /* Because of type_is_gc(), the collector only calls this
2648 assert(type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
);
2650 /* The only field we need to clear is tp_mro, which is part of a
2651 hard cycle (its first element is the class itself) that won't
2652 be broken otherwise (it's a tuple and tuples don't have a
2653 tp_clear handler). None of the other fields need to be
2654 cleared, and here's why:
2657 It is a dict, so the collector will call its tp_clear.
2660 Not used; if it were, it would be a dict.
2663 If these are involved in a cycle, there must be at least
2664 one other, mutable object in the cycle, e.g. a base
2665 class's dict; the cycle will be broken that way.
2668 A list of weak references can't be part of a cycle; and
2669 lists have their own tp_clear.
2671 slots (in PyHeapTypeObject):
2672 A tuple of strings can't be part of a cycle.
2675 Py_CLEAR(type
->tp_mro
);
2681 type_is_gc(PyTypeObject
*type
)
2683 return type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
;
2686 PyTypeObject PyType_Type
= {
2687 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
2688 "type", /* tp_name */
2689 sizeof(PyHeapTypeObject
), /* tp_basicsize */
2690 sizeof(PyMemberDef
), /* tp_itemsize */
2691 (destructor
)type_dealloc
, /* tp_dealloc */
2695 type_compare
, /* tp_compare */
2696 (reprfunc
)type_repr
, /* tp_repr */
2697 0, /* tp_as_number */
2698 0, /* tp_as_sequence */
2699 0, /* tp_as_mapping */
2700 (hashfunc
)_Py_HashPointer
, /* tp_hash */
2701 (ternaryfunc
)type_call
, /* tp_call */
2703 (getattrofunc
)type_getattro
, /* tp_getattro */
2704 (setattrofunc
)type_setattro
, /* tp_setattro */
2705 0, /* tp_as_buffer */
2706 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
|
2707 Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_TYPE_SUBCLASS
, /* tp_flags */
2708 type_doc
, /* tp_doc */
2709 (traverseproc
)type_traverse
, /* tp_traverse */
2710 (inquiry
)type_clear
, /* tp_clear */
2711 type_richcompare
, /* tp_richcompare */
2712 offsetof(PyTypeObject
, tp_weaklist
), /* tp_weaklistoffset */
2714 0, /* tp_iternext */
2715 type_methods
, /* tp_methods */
2716 type_members
, /* tp_members */
2717 type_getsets
, /* tp_getset */
2720 0, /* tp_descr_get */
2721 0, /* tp_descr_set */
2722 offsetof(PyTypeObject
, tp_dict
), /* tp_dictoffset */
2723 type_init
, /* tp_init */
2725 type_new
, /* tp_new */
2726 PyObject_GC_Del
, /* tp_free */
2727 (inquiry
)type_is_gc
, /* tp_is_gc */
2731 /* The base type of all types (eventually)... except itself. */
2733 /* You may wonder why object.__new__() only complains about arguments
2734 when object.__init__() is not overridden, and vice versa.
2736 Consider the use cases:
2738 1. When neither is overridden, we want to hear complaints about
2739 excess (i.e., any) arguments, since their presence could
2740 indicate there's a bug.
2742 2. When defining an Immutable type, we are likely to override only
2743 __new__(), since __init__() is called too late to initialize an
2744 Immutable object. Since __new__() defines the signature for the
2745 type, it would be a pain to have to override __init__() just to
2746 stop it from complaining about excess arguments.
2748 3. When defining a Mutable type, we are likely to override only
2749 __init__(). So here the converse reasoning applies: we don't
2750 want to have to override __new__() just to stop it from
2753 4. When __init__() is overridden, and the subclass __init__() calls
2754 object.__init__(), the latter should complain about excess
2755 arguments; ditto for __new__().
2757 Use cases 2 and 3 make it unattractive to unconditionally check for
2758 excess arguments. The best solution that addresses all four use
2759 cases is as follows: __init__() complains about excess arguments
2760 unless __new__() is overridden and __init__() is not overridden
2761 (IOW, if __init__() is overridden or __new__() is not overridden);
2762 symmetrically, __new__() complains about excess arguments unless
2763 __init__() is overridden and __new__() is not overridden
2764 (IOW, if __new__() is overridden or __init__() is not overridden).
2766 However, for backwards compatibility, this breaks too much code.
2767 Therefore, in 2.6, we'll *warn* about excess arguments when both
2768 methods are overridden; for all other cases we'll use the above
2775 object_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
);
2778 excess_args(PyObject
*args
, PyObject
*kwds
)
2780 return PyTuple_GET_SIZE(args
) ||
2781 (kwds
&& PyDict_Check(kwds
) && PyDict_Size(kwds
));
2785 object_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
2788 if (excess_args(args
, kwds
)) {
2789 PyTypeObject
*type
= Py_TYPE(self
);
2790 if (type
->tp_init
!= object_init
&&
2791 type
->tp_new
!= object_new
)
2793 err
= PyErr_WarnEx(PyExc_DeprecationWarning
,
2794 "object.__init__() takes no parameters",
2797 else if (type
->tp_init
!= object_init
||
2798 type
->tp_new
== object_new
)
2800 PyErr_SetString(PyExc_TypeError
,
2801 "object.__init__() takes no parameters");
2809 object_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
2812 if (excess_args(args
, kwds
)) {
2813 if (type
->tp_new
!= object_new
&&
2814 type
->tp_init
!= object_init
)
2816 err
= PyErr_WarnEx(PyExc_DeprecationWarning
,
2817 "object.__new__() takes no parameters",
2820 else if (type
->tp_new
!= object_new
||
2821 type
->tp_init
== object_init
)
2823 PyErr_SetString(PyExc_TypeError
,
2824 "object.__new__() takes no parameters");
2831 if (type
->tp_flags
& Py_TPFLAGS_IS_ABSTRACT
) {
2832 static PyObject
*comma
= NULL
;
2833 PyObject
*abstract_methods
= NULL
;
2836 PyObject
*sorted_methods
= NULL
;
2837 PyObject
*joined
= NULL
;
2838 const char *joined_str
;
2840 /* Compute ", ".join(sorted(type.__abstractmethods__))
2842 abstract_methods
= type_abstractmethods(type
, NULL
);
2843 if (abstract_methods
== NULL
)
2845 builtins
= PyEval_GetBuiltins();
2846 if (builtins
== NULL
)
2848 sorted
= PyDict_GetItemString(builtins
, "sorted");
2851 sorted_methods
= PyObject_CallFunctionObjArgs(sorted
,
2854 if (sorted_methods
== NULL
)
2856 if (comma
== NULL
) {
2857 comma
= PyString_InternFromString(", ");
2861 joined
= PyObject_CallMethod(comma
, "join",
2862 "O", sorted_methods
);
2865 joined_str
= PyString_AsString(joined
);
2866 if (joined_str
== NULL
)
2869 PyErr_Format(PyExc_TypeError
,
2870 "Can't instantiate abstract class %s "
2871 "with abstract methods %s",
2876 Py_XDECREF(sorted_methods
);
2877 Py_XDECREF(abstract_methods
);
2880 return type
->tp_alloc(type
, 0);
2884 object_dealloc(PyObject
*self
)
2886 Py_TYPE(self
)->tp_free(self
);
2890 object_repr(PyObject
*self
)
2893 PyObject
*mod
, *name
, *rtn
;
2895 type
= Py_TYPE(self
);
2896 mod
= type_module(type
, NULL
);
2899 else if (!PyString_Check(mod
)) {
2903 name
= type_name(type
, NULL
);
2906 if (mod
!= NULL
&& strcmp(PyString_AS_STRING(mod
), "__builtin__"))
2907 rtn
= PyString_FromFormat("<%s.%s object at %p>",
2908 PyString_AS_STRING(mod
),
2909 PyString_AS_STRING(name
),
2912 rtn
= PyString_FromFormat("<%s object at %p>",
2913 type
->tp_name
, self
);
2920 object_str(PyObject
*self
)
2924 f
= Py_TYPE(self
)->tp_repr
;
2931 object_get_class(PyObject
*self
, void *closure
)
2933 Py_INCREF(Py_TYPE(self
));
2934 return (PyObject
*)(Py_TYPE(self
));
2938 equiv_structs(PyTypeObject
*a
, PyTypeObject
*b
)
2943 a
->tp_basicsize
== b
->tp_basicsize
&&
2944 a
->tp_itemsize
== b
->tp_itemsize
&&
2945 a
->tp_dictoffset
== b
->tp_dictoffset
&&
2946 a
->tp_weaklistoffset
== b
->tp_weaklistoffset
&&
2947 ((a
->tp_flags
& Py_TPFLAGS_HAVE_GC
) ==
2948 (b
->tp_flags
& Py_TPFLAGS_HAVE_GC
)));
2952 same_slots_added(PyTypeObject
*a
, PyTypeObject
*b
)
2954 PyTypeObject
*base
= a
->tp_base
;
2956 PyObject
*slots_a
, *slots_b
;
2958 if (base
!= b
->tp_base
)
2960 if (equiv_structs(a
, base
) && equiv_structs(b
, base
))
2962 size
= base
->tp_basicsize
;
2963 if (a
->tp_dictoffset
== size
&& b
->tp_dictoffset
== size
)
2964 size
+= sizeof(PyObject
*);
2965 if (a
->tp_weaklistoffset
== size
&& b
->tp_weaklistoffset
== size
)
2966 size
+= sizeof(PyObject
*);
2968 /* Check slots compliance */
2969 slots_a
= ((PyHeapTypeObject
*)a
)->ht_slots
;
2970 slots_b
= ((PyHeapTypeObject
*)b
)->ht_slots
;
2971 if (slots_a
&& slots_b
) {
2972 if (PyObject_Compare(slots_a
, slots_b
) != 0)
2974 size
+= sizeof(PyObject
*) * PyTuple_GET_SIZE(slots_a
);
2976 return size
== a
->tp_basicsize
&& size
== b
->tp_basicsize
;
2980 compatible_for_assignment(PyTypeObject
* oldto
, PyTypeObject
* newto
, char* attr
)
2982 PyTypeObject
*newbase
, *oldbase
;
2984 if (newto
->tp_dealloc
!= oldto
->tp_dealloc
||
2985 newto
->tp_free
!= oldto
->tp_free
)
2987 PyErr_Format(PyExc_TypeError
,
2989 "'%s' deallocator differs from '%s'",
2997 while (equiv_structs(newbase
, newbase
->tp_base
))
2998 newbase
= newbase
->tp_base
;
2999 while (equiv_structs(oldbase
, oldbase
->tp_base
))
3000 oldbase
= oldbase
->tp_base
;
3001 if (newbase
!= oldbase
&&
3002 (newbase
->tp_base
!= oldbase
->tp_base
||
3003 !same_slots_added(newbase
, oldbase
))) {
3004 PyErr_Format(PyExc_TypeError
,
3006 "'%s' object layout differs from '%s'",
3017 object_set_class(PyObject
*self
, PyObject
*value
, void *closure
)
3019 PyTypeObject
*oldto
= Py_TYPE(self
);
3020 PyTypeObject
*newto
;
3022 if (value
== NULL
) {
3023 PyErr_SetString(PyExc_TypeError
,
3024 "can't delete __class__ attribute");
3027 if (!PyType_Check(value
)) {
3028 PyErr_Format(PyExc_TypeError
,
3029 "__class__ must be set to new-style class, not '%s' object",
3030 Py_TYPE(value
)->tp_name
);
3033 newto
= (PyTypeObject
*)value
;
3034 if (!(newto
->tp_flags
& Py_TPFLAGS_HEAPTYPE
) ||
3035 !(oldto
->tp_flags
& Py_TPFLAGS_HEAPTYPE
))
3037 PyErr_Format(PyExc_TypeError
,
3038 "__class__ assignment: only for heap types");
3041 if (compatible_for_assignment(newto
, oldto
, "__class__")) {
3043 Py_TYPE(self
) = newto
;
3052 static PyGetSetDef object_getsets
[] = {
3053 {"__class__", object_get_class
, object_set_class
,
3054 PyDoc_STR("the object's class")},
3059 /* Stuff to implement __reduce_ex__ for pickle protocols >= 2.
3060 We fall back to helpers in copy_reg for:
3061 - pickle protocols < 2
3062 - calculating the list of slot names (done only once per class)
3063 - the __newobj__ function (which is used as a token but never called)
3067 import_copyreg(void)
3069 static PyObject
*copyreg_str
;
3072 copyreg_str
= PyString_InternFromString("copy_reg");
3073 if (copyreg_str
== NULL
)
3077 return PyImport_Import(copyreg_str
);
3081 slotnames(PyObject
*cls
)
3085 PyObject
*slotnames
;
3087 if (!PyType_Check(cls
)) {
3092 clsdict
= ((PyTypeObject
*)cls
)->tp_dict
;
3093 slotnames
= PyDict_GetItemString(clsdict
, "__slotnames__");
3094 if (slotnames
!= NULL
&& PyList_Check(slotnames
)) {
3095 Py_INCREF(slotnames
);
3099 copyreg
= import_copyreg();
3100 if (copyreg
== NULL
)
3103 slotnames
= PyObject_CallMethod(copyreg
, "_slotnames", "O", cls
);
3105 if (slotnames
!= NULL
&&
3106 slotnames
!= Py_None
&&
3107 !PyList_Check(slotnames
))
3109 PyErr_SetString(PyExc_TypeError
,
3110 "copy_reg._slotnames didn't return a list or None");
3111 Py_DECREF(slotnames
);
3119 reduce_2(PyObject
*obj
)
3121 PyObject
*cls
, *getnewargs
;
3122 PyObject
*args
= NULL
, *args2
= NULL
;
3123 PyObject
*getstate
= NULL
, *state
= NULL
, *names
= NULL
;
3124 PyObject
*slots
= NULL
, *listitems
= NULL
, *dictitems
= NULL
;
3125 PyObject
*copyreg
= NULL
, *newobj
= NULL
, *res
= NULL
;
3128 cls
= PyObject_GetAttrString(obj
, "__class__");
3132 getnewargs
= PyObject_GetAttrString(obj
, "__getnewargs__");
3133 if (getnewargs
!= NULL
) {
3134 args
= PyObject_CallObject(getnewargs
, NULL
);
3135 Py_DECREF(getnewargs
);
3136 if (args
!= NULL
&& !PyTuple_Check(args
)) {
3137 PyErr_Format(PyExc_TypeError
,
3138 "__getnewargs__ should return a tuple, "
3139 "not '%.200s'", Py_TYPE(args
)->tp_name
);
3145 args
= PyTuple_New(0);
3150 getstate
= PyObject_GetAttrString(obj
, "__getstate__");
3151 if (getstate
!= NULL
) {
3152 state
= PyObject_CallObject(getstate
, NULL
);
3153 Py_DECREF(getstate
);
3159 state
= PyObject_GetAttrString(obj
, "__dict__");
3160 if (state
== NULL
) {
3165 names
= slotnames(cls
);
3168 if (names
!= Py_None
) {
3169 assert(PyList_Check(names
));
3170 slots
= PyDict_New();
3174 /* Can't pre-compute the list size; the list
3175 is stored on the class so accessible to other
3176 threads, which may be run by DECREF */
3177 for (i
= 0; i
< PyList_GET_SIZE(names
); i
++) {
3178 PyObject
*name
, *value
;
3179 name
= PyList_GET_ITEM(names
, i
);
3180 value
= PyObject_GetAttr(obj
, name
);
3184 int err
= PyDict_SetItem(slots
, name
,
3193 state
= Py_BuildValue("(NO)", state
, slots
);
3200 if (!PyList_Check(obj
)) {
3201 listitems
= Py_None
;
3202 Py_INCREF(listitems
);
3205 listitems
= PyObject_GetIter(obj
);
3206 if (listitems
== NULL
)
3210 if (!PyDict_Check(obj
)) {
3211 dictitems
= Py_None
;
3212 Py_INCREF(dictitems
);
3215 dictitems
= PyObject_CallMethod(obj
, "iteritems", "");
3216 if (dictitems
== NULL
)
3220 copyreg
= import_copyreg();
3221 if (copyreg
== NULL
)
3223 newobj
= PyObject_GetAttrString(copyreg
, "__newobj__");
3227 n
= PyTuple_GET_SIZE(args
);
3228 args2
= PyTuple_New(n
+1);
3231 PyTuple_SET_ITEM(args2
, 0, cls
);
3233 for (i
= 0; i
< n
; i
++) {
3234 PyObject
*v
= PyTuple_GET_ITEM(args
, i
);
3236 PyTuple_SET_ITEM(args2
, i
+1, v
);
3239 res
= PyTuple_Pack(5, newobj
, args2
, state
, listitems
, dictitems
);
3248 Py_XDECREF(listitems
);
3249 Py_XDECREF(dictitems
);
3250 Py_XDECREF(copyreg
);
3256 * There were two problems when object.__reduce__ and object.__reduce_ex__
3257 * were implemented in the same function:
3258 * - trying to pickle an object with a custom __reduce__ method that
3259 * fell back to object.__reduce__ in certain circumstances led to
3260 * infinite recursion at Python level and eventual RuntimeError.
3261 * - Pickling objects that lied about their type by overwriting the
3262 * __class__ descriptor could lead to infinite recursion at C level
3263 * and eventual segfault.
3265 * Because of backwards compatibility, the two methods still have to
3266 * behave in the same way, even if this is not required by the pickle
3267 * protocol. This common functionality was moved to the _common_reduce
3271 _common_reduce(PyObject
*self
, int proto
)
3273 PyObject
*copyreg
, *res
;
3276 return reduce_2(self
);
3278 copyreg
= import_copyreg();
3282 res
= PyEval_CallMethod(copyreg
, "_reduce_ex", "(Oi)", self
, proto
);
3289 object_reduce(PyObject
*self
, PyObject
*args
)
3293 if (!PyArg_ParseTuple(args
, "|i:__reduce__", &proto
))
3296 return _common_reduce(self
, proto
);
3300 object_reduce_ex(PyObject
*self
, PyObject
*args
)
3302 PyObject
*reduce
, *res
;
3305 if (!PyArg_ParseTuple(args
, "|i:__reduce_ex__", &proto
))
3308 reduce
= PyObject_GetAttrString(self
, "__reduce__");
3312 PyObject
*cls
, *clsreduce
, *objreduce
;
3314 cls
= PyObject_GetAttrString(self
, "__class__");
3319 clsreduce
= PyObject_GetAttrString(cls
, "__reduce__");
3321 if (clsreduce
== NULL
) {
3325 objreduce
= PyDict_GetItemString(PyBaseObject_Type
.tp_dict
,
3327 override
= (clsreduce
!= objreduce
);
3328 Py_DECREF(clsreduce
);
3330 res
= PyObject_CallObject(reduce
, NULL
);
3338 return _common_reduce(self
, proto
);
3342 object_subclasshook(PyObject
*cls
, PyObject
*args
)
3344 Py_INCREF(Py_NotImplemented
);
3345 return Py_NotImplemented
;
3348 PyDoc_STRVAR(object_subclasshook_doc
,
3349 "Abstract classes can override this to customize issubclass().\n"
3351 "This is invoked early on by abc.ABCMeta.__subclasscheck__().\n"
3352 "It should return True, False or NotImplemented. If it returns\n"
3353 "NotImplemented, the normal algorithm is used. Otherwise, it\n"
3354 "overrides the normal algorithm (and the outcome is cached).\n");
3357 from PEP 3101, this code implements:
3360 def __format__(self, format_spec):
3361 if isinstance(format_spec, str):
3362 return format(str(self), format_spec)
3363 elif isinstance(format_spec, unicode):
3364 return format(unicode(self), format_spec)
3367 object_format(PyObject
*self
, PyObject
*args
)
3369 PyObject
*format_spec
;
3370 PyObject
*self_as_str
= NULL
;
3371 PyObject
*result
= NULL
;
3372 PyObject
*format_meth
= NULL
;
3374 if (!PyArg_ParseTuple(args
, "O:__format__", &format_spec
))
3376 if (PyUnicode_Check(format_spec
)) {
3377 self_as_str
= PyObject_Unicode(self
);
3378 } else if (PyString_Check(format_spec
)) {
3379 self_as_str
= PyObject_Str(self
);
3381 PyErr_SetString(PyExc_TypeError
, "argument to __format__ must be unicode or str");
3385 if (self_as_str
!= NULL
) {
3386 /* find the format function */
3387 format_meth
= PyObject_GetAttrString(self_as_str
, "__format__");
3388 if (format_meth
!= NULL
) {
3390 result
= PyObject_CallFunctionObjArgs(format_meth
, format_spec
, NULL
);
3394 Py_XDECREF(self_as_str
);
3395 Py_XDECREF(format_meth
);
3401 object_sizeof(PyObject
*self
, PyObject
*args
)
3403 Py_ssize_t res
, isize
;
3406 isize
= self
->ob_type
->tp_itemsize
;
3408 res
= self
->ob_type
->ob_size
* isize
;
3409 res
+= self
->ob_type
->tp_basicsize
;
3411 return PyInt_FromSsize_t(res
);
3414 static PyMethodDef object_methods
[] = {
3415 {"__reduce_ex__", object_reduce_ex
, METH_VARARGS
,
3416 PyDoc_STR("helper for pickle")},
3417 {"__reduce__", object_reduce
, METH_VARARGS
,
3418 PyDoc_STR("helper for pickle")},
3419 {"__subclasshook__", object_subclasshook
, METH_CLASS
| METH_VARARGS
,
3420 object_subclasshook_doc
},
3421 {"__format__", object_format
, METH_VARARGS
,
3422 PyDoc_STR("default object formatter")},
3423 {"__sizeof__", object_sizeof
, METH_NOARGS
,
3424 PyDoc_STR("__sizeof__() -> size of object in memory, in bytes")},
3429 PyTypeObject PyBaseObject_Type
= {
3430 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
3431 "object", /* tp_name */
3432 sizeof(PyObject
), /* tp_basicsize */
3433 0, /* tp_itemsize */
3434 object_dealloc
, /* tp_dealloc */
3439 object_repr
, /* tp_repr */
3440 0, /* tp_as_number */
3441 0, /* tp_as_sequence */
3442 0, /* tp_as_mapping */
3443 (hashfunc
)_Py_HashPointer
, /* tp_hash */
3445 object_str
, /* tp_str */
3446 PyObject_GenericGetAttr
, /* tp_getattro */
3447 PyObject_GenericSetAttr
, /* tp_setattro */
3448 0, /* tp_as_buffer */
3449 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
3450 PyDoc_STR("The most base type"), /* tp_doc */
3451 0, /* tp_traverse */
3453 0, /* tp_richcompare */
3454 0, /* tp_weaklistoffset */
3456 0, /* tp_iternext */
3457 object_methods
, /* tp_methods */
3459 object_getsets
, /* tp_getset */
3462 0, /* tp_descr_get */
3463 0, /* tp_descr_set */
3464 0, /* tp_dictoffset */
3465 object_init
, /* tp_init */
3466 PyType_GenericAlloc
, /* tp_alloc */
3467 object_new
, /* tp_new */
3468 PyObject_Del
, /* tp_free */
3472 /* Initialize the __dict__ in a type object */
3475 add_methods(PyTypeObject
*type
, PyMethodDef
*meth
)
3477 PyObject
*dict
= type
->tp_dict
;
3479 for (; meth
->ml_name
!= NULL
; meth
++) {
3481 if (PyDict_GetItemString(dict
, meth
->ml_name
) &&
3482 !(meth
->ml_flags
& METH_COEXIST
))
3484 if (meth
->ml_flags
& METH_CLASS
) {
3485 if (meth
->ml_flags
& METH_STATIC
) {
3486 PyErr_SetString(PyExc_ValueError
,
3487 "method cannot be both class and static");
3490 descr
= PyDescr_NewClassMethod(type
, meth
);
3492 else if (meth
->ml_flags
& METH_STATIC
) {
3493 PyObject
*cfunc
= PyCFunction_New(meth
, NULL
);
3496 descr
= PyStaticMethod_New(cfunc
);
3500 descr
= PyDescr_NewMethod(type
, meth
);
3504 if (PyDict_SetItemString(dict
, meth
->ml_name
, descr
) < 0)
3512 add_members(PyTypeObject
*type
, PyMemberDef
*memb
)
3514 PyObject
*dict
= type
->tp_dict
;
3516 for (; memb
->name
!= NULL
; memb
++) {
3518 if (PyDict_GetItemString(dict
, memb
->name
))
3520 descr
= PyDescr_NewMember(type
, memb
);
3523 if (PyDict_SetItemString(dict
, memb
->name
, descr
) < 0)
3531 add_getset(PyTypeObject
*type
, PyGetSetDef
*gsp
)
3533 PyObject
*dict
= type
->tp_dict
;
3535 for (; gsp
->name
!= NULL
; gsp
++) {
3537 if (PyDict_GetItemString(dict
, gsp
->name
))
3539 descr
= PyDescr_NewGetSet(type
, gsp
);
3543 if (PyDict_SetItemString(dict
, gsp
->name
, descr
) < 0)
3551 inherit_special(PyTypeObject
*type
, PyTypeObject
*base
)
3553 Py_ssize_t oldsize
, newsize
;
3555 /* Special flag magic */
3556 if (!type
->tp_as_buffer
&& base
->tp_as_buffer
) {
3557 type
->tp_flags
&= ~Py_TPFLAGS_HAVE_GETCHARBUFFER
;
3559 base
->tp_flags
& Py_TPFLAGS_HAVE_GETCHARBUFFER
;
3561 if (!type
->tp_as_sequence
&& base
->tp_as_sequence
) {
3562 type
->tp_flags
&= ~Py_TPFLAGS_HAVE_SEQUENCE_IN
;
3563 type
->tp_flags
|= base
->tp_flags
& Py_TPFLAGS_HAVE_SEQUENCE_IN
;
3565 if ((type
->tp_flags
& Py_TPFLAGS_HAVE_INPLACEOPS
) !=
3566 (base
->tp_flags
& Py_TPFLAGS_HAVE_INPLACEOPS
)) {
3567 if ((!type
->tp_as_number
&& base
->tp_as_number
) ||
3568 (!type
->tp_as_sequence
&& base
->tp_as_sequence
)) {
3569 type
->tp_flags
&= ~Py_TPFLAGS_HAVE_INPLACEOPS
;
3570 if (!type
->tp_as_number
&& !type
->tp_as_sequence
) {
3571 type
->tp_flags
|= base
->tp_flags
&
3572 Py_TPFLAGS_HAVE_INPLACEOPS
;
3577 if (!type
->tp_as_number
&& base
->tp_as_number
) {
3578 type
->tp_flags
&= ~Py_TPFLAGS_CHECKTYPES
;
3579 type
->tp_flags
|= base
->tp_flags
& Py_TPFLAGS_CHECKTYPES
;
3582 /* Copying basicsize is connected to the GC flags */
3583 oldsize
= base
->tp_basicsize
;
3584 newsize
= type
->tp_basicsize
? type
->tp_basicsize
: oldsize
;
3585 if (!(type
->tp_flags
& Py_TPFLAGS_HAVE_GC
) &&
3586 (base
->tp_flags
& Py_TPFLAGS_HAVE_GC
) &&
3587 (type
->tp_flags
& Py_TPFLAGS_HAVE_RICHCOMPARE
/*GC slots exist*/) &&
3588 (!type
->tp_traverse
&& !type
->tp_clear
)) {
3589 type
->tp_flags
|= Py_TPFLAGS_HAVE_GC
;
3590 if (type
->tp_traverse
== NULL
)
3591 type
->tp_traverse
= base
->tp_traverse
;
3592 if (type
->tp_clear
== NULL
)
3593 type
->tp_clear
= base
->tp_clear
;
3595 if (type
->tp_flags
& base
->tp_flags
& Py_TPFLAGS_HAVE_CLASS
) {
3596 /* The condition below could use some explanation.
3597 It appears that tp_new is not inherited for static types
3598 whose base class is 'object'; this seems to be a precaution
3599 so that old extension types don't suddenly become
3600 callable (object.__new__ wouldn't insure the invariants
3601 that the extension type's own factory function ensures).
3602 Heap types, of course, are under our control, so they do
3603 inherit tp_new; static extension types that specify some
3604 other built-in type as the default are considered
3605 new-style-aware so they also inherit object.__new__. */
3606 if (base
!= &PyBaseObject_Type
||
3607 (type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)) {
3608 if (type
->tp_new
== NULL
)
3609 type
->tp_new
= base
->tp_new
;
3612 type
->tp_basicsize
= newsize
;
3614 /* Copy other non-function slots */
3617 #define COPYVAL(SLOT) \
3618 if (type->SLOT == 0) type->SLOT = base->SLOT
3620 COPYVAL(tp_itemsize
);
3621 if (type
->tp_flags
& base
->tp_flags
& Py_TPFLAGS_HAVE_WEAKREFS
) {
3622 COPYVAL(tp_weaklistoffset
);
3624 if (type
->tp_flags
& base
->tp_flags
& Py_TPFLAGS_HAVE_CLASS
) {
3625 COPYVAL(tp_dictoffset
);
3628 /* Setup fast subclass flags */
3629 if (PyType_IsSubtype(base
, (PyTypeObject
*)PyExc_BaseException
))
3630 type
->tp_flags
|= Py_TPFLAGS_BASE_EXC_SUBCLASS
;
3631 else if (PyType_IsSubtype(base
, &PyType_Type
))
3632 type
->tp_flags
|= Py_TPFLAGS_TYPE_SUBCLASS
;
3633 else if (PyType_IsSubtype(base
, &PyInt_Type
))
3634 type
->tp_flags
|= Py_TPFLAGS_INT_SUBCLASS
;
3635 else if (PyType_IsSubtype(base
, &PyLong_Type
))
3636 type
->tp_flags
|= Py_TPFLAGS_LONG_SUBCLASS
;
3637 else if (PyType_IsSubtype(base
, &PyString_Type
))
3638 type
->tp_flags
|= Py_TPFLAGS_STRING_SUBCLASS
;
3639 #ifdef Py_USING_UNICODE
3640 else if (PyType_IsSubtype(base
, &PyUnicode_Type
))
3641 type
->tp_flags
|= Py_TPFLAGS_UNICODE_SUBCLASS
;
3643 else if (PyType_IsSubtype(base
, &PyTuple_Type
))
3644 type
->tp_flags
|= Py_TPFLAGS_TUPLE_SUBCLASS
;
3645 else if (PyType_IsSubtype(base
, &PyList_Type
))
3646 type
->tp_flags
|= Py_TPFLAGS_LIST_SUBCLASS
;
3647 else if (PyType_IsSubtype(base
, &PyDict_Type
))
3648 type
->tp_flags
|= Py_TPFLAGS_DICT_SUBCLASS
;
3651 static char *hash_name_op
[] = {
3659 overrides_hash(PyTypeObject
*type
)
3662 PyObject
*dict
= type
->tp_dict
;
3664 assert(dict
!= NULL
);
3665 for (p
= hash_name_op
; *p
; p
++) {
3666 if (PyDict_GetItemString(dict
, *p
) != NULL
)
3673 inherit_slots(PyTypeObject
*type
, PyTypeObject
*base
)
3675 PyTypeObject
*basebase
;
3684 #define SLOTDEFINED(SLOT) \
3685 (base->SLOT != 0 && \
3686 (basebase == NULL || base->SLOT != basebase->SLOT))
3688 #define COPYSLOT(SLOT) \
3689 if (!type->SLOT && SLOTDEFINED(SLOT)) type->SLOT = base->SLOT
3691 #define COPYNUM(SLOT) COPYSLOT(tp_as_number->SLOT)
3692 #define COPYSEQ(SLOT) COPYSLOT(tp_as_sequence->SLOT)
3693 #define COPYMAP(SLOT) COPYSLOT(tp_as_mapping->SLOT)
3694 #define COPYBUF(SLOT) COPYSLOT(tp_as_buffer->SLOT)
3696 /* This won't inherit indirect slots (from tp_as_number etc.)
3697 if type doesn't provide the space. */
3699 if (type
->tp_as_number
!= NULL
&& base
->tp_as_number
!= NULL
) {
3700 basebase
= base
->tp_base
;
3701 if (basebase
->tp_as_number
== NULL
)
3704 COPYNUM(nb_subtract
);
3705 COPYNUM(nb_multiply
);
3707 COPYNUM(nb_remainder
);
3710 COPYNUM(nb_negative
);
3711 COPYNUM(nb_positive
);
3712 COPYNUM(nb_absolute
);
3713 COPYNUM(nb_nonzero
);
3726 COPYNUM(nb_inplace_add
);
3727 COPYNUM(nb_inplace_subtract
);
3728 COPYNUM(nb_inplace_multiply
);
3729 COPYNUM(nb_inplace_divide
);
3730 COPYNUM(nb_inplace_remainder
);
3731 COPYNUM(nb_inplace_power
);
3732 COPYNUM(nb_inplace_lshift
);
3733 COPYNUM(nb_inplace_rshift
);
3734 COPYNUM(nb_inplace_and
);
3735 COPYNUM(nb_inplace_xor
);
3736 COPYNUM(nb_inplace_or
);
3737 if (base
->tp_flags
& Py_TPFLAGS_CHECKTYPES
) {
3738 COPYNUM(nb_true_divide
);
3739 COPYNUM(nb_floor_divide
);
3740 COPYNUM(nb_inplace_true_divide
);
3741 COPYNUM(nb_inplace_floor_divide
);
3743 if (base
->tp_flags
& Py_TPFLAGS_HAVE_INDEX
) {
3748 if (type
->tp_as_sequence
!= NULL
&& base
->tp_as_sequence
!= NULL
) {
3749 basebase
= base
->tp_base
;
3750 if (basebase
->tp_as_sequence
== NULL
)
3757 COPYSEQ(sq_ass_item
);
3758 COPYSEQ(sq_ass_slice
);
3759 COPYSEQ(sq_contains
);
3760 COPYSEQ(sq_inplace_concat
);
3761 COPYSEQ(sq_inplace_repeat
);
3764 if (type
->tp_as_mapping
!= NULL
&& base
->tp_as_mapping
!= NULL
) {
3765 basebase
= base
->tp_base
;
3766 if (basebase
->tp_as_mapping
== NULL
)
3769 COPYMAP(mp_subscript
);
3770 COPYMAP(mp_ass_subscript
);
3773 if (type
->tp_as_buffer
!= NULL
&& base
->tp_as_buffer
!= NULL
) {
3774 basebase
= base
->tp_base
;
3775 if (basebase
->tp_as_buffer
== NULL
)
3777 COPYBUF(bf_getreadbuffer
);
3778 COPYBUF(bf_getwritebuffer
);
3779 COPYBUF(bf_getsegcount
);
3780 COPYBUF(bf_getcharbuffer
);
3781 COPYBUF(bf_getbuffer
);
3782 COPYBUF(bf_releasebuffer
);
3785 basebase
= base
->tp_base
;
3787 COPYSLOT(tp_dealloc
);
3789 if (type
->tp_getattr
== NULL
&& type
->tp_getattro
== NULL
) {
3790 type
->tp_getattr
= base
->tp_getattr
;
3791 type
->tp_getattro
= base
->tp_getattro
;
3793 if (type
->tp_setattr
== NULL
&& type
->tp_setattro
== NULL
) {
3794 type
->tp_setattr
= base
->tp_setattr
;
3795 type
->tp_setattro
= base
->tp_setattro
;
3797 /* tp_compare see tp_richcompare */
3799 /* tp_hash see tp_richcompare */
3802 if (type
->tp_flags
& base
->tp_flags
& Py_TPFLAGS_HAVE_RICHCOMPARE
) {
3803 if (type
->tp_compare
== NULL
&&
3804 type
->tp_richcompare
== NULL
&&
3805 type
->tp_hash
== NULL
&&
3806 !overrides_hash(type
))
3808 type
->tp_compare
= base
->tp_compare
;
3809 type
->tp_richcompare
= base
->tp_richcompare
;
3810 type
->tp_hash
= base
->tp_hash
;
3814 COPYSLOT(tp_compare
);
3816 if (type
->tp_flags
& base
->tp_flags
& Py_TPFLAGS_HAVE_ITER
) {
3818 COPYSLOT(tp_iternext
);
3820 if (type
->tp_flags
& base
->tp_flags
& Py_TPFLAGS_HAVE_CLASS
) {
3821 COPYSLOT(tp_descr_get
);
3822 COPYSLOT(tp_descr_set
);
3823 COPYSLOT(tp_dictoffset
);
3827 if ((type
->tp_flags
& Py_TPFLAGS_HAVE_GC
) ==
3828 (base
->tp_flags
& Py_TPFLAGS_HAVE_GC
)) {
3829 /* They agree about gc. */
3832 else if ((type
->tp_flags
& Py_TPFLAGS_HAVE_GC
) &&
3833 type
->tp_free
== NULL
&&
3834 base
->tp_free
== _PyObject_Del
) {
3835 /* A bit of magic to plug in the correct default
3836 * tp_free function when a derived class adds gc,
3837 * didn't define tp_free, and the base uses the
3838 * default non-gc tp_free.
3840 type
->tp_free
= PyObject_GC_Del
;
3842 /* else they didn't agree about gc, and there isn't something
3843 * obvious to be done -- the type is on its own.
3848 static int add_operators(PyTypeObject
*);
3851 PyType_Ready(PyTypeObject
*type
)
3853 PyObject
*dict
, *bases
;
3857 if (type
->tp_flags
& Py_TPFLAGS_READY
) {
3858 assert(type
->tp_dict
!= NULL
);
3861 assert((type
->tp_flags
& Py_TPFLAGS_READYING
) == 0);
3863 type
->tp_flags
|= Py_TPFLAGS_READYING
;
3865 #ifdef Py_TRACE_REFS
3866 /* PyType_Ready is the closest thing we have to a choke point
3867 * for type objects, so is the best place I can think of to try
3868 * to get type objects into the doubly-linked list of all objects.
3869 * Still, not all type objects go thru PyType_Ready.
3871 _Py_AddToAllObjects((PyObject
*)type
, 0);
3874 /* Initialize tp_base (defaults to BaseObject unless that's us) */
3875 base
= type
->tp_base
;
3876 if (base
== NULL
&& type
!= &PyBaseObject_Type
) {
3877 base
= type
->tp_base
= &PyBaseObject_Type
;
3881 /* Now the only way base can still be NULL is if type is
3882 * &PyBaseObject_Type.
3885 /* Initialize the base class */
3886 if (base
&& base
->tp_dict
== NULL
) {
3887 if (PyType_Ready(base
) < 0)
3891 /* Initialize ob_type if NULL. This means extensions that want to be
3892 compilable separately on Windows can call PyType_Ready() instead of
3893 initializing the ob_type field of their type objects. */
3894 /* The test for base != NULL is really unnecessary, since base is only
3895 NULL when type is &PyBaseObject_Type, and we know its ob_type is
3896 not NULL (it's initialized to &PyType_Type). But coverity doesn't
3898 if (Py_TYPE(type
) == NULL
&& base
!= NULL
)
3899 Py_TYPE(type
) = Py_TYPE(base
);
3901 /* Initialize tp_bases */
3902 bases
= type
->tp_bases
;
3903 if (bases
== NULL
) {
3905 bases
= PyTuple_New(0);
3907 bases
= PyTuple_Pack(1, base
);
3910 type
->tp_bases
= bases
;
3913 /* Initialize tp_dict */
3914 dict
= type
->tp_dict
;
3916 dict
= PyDict_New();
3919 type
->tp_dict
= dict
;
3922 /* Add type-specific descriptors to tp_dict */
3923 if (add_operators(type
) < 0)
3925 if (type
->tp_methods
!= NULL
) {
3926 if (add_methods(type
, type
->tp_methods
) < 0)
3929 if (type
->tp_members
!= NULL
) {
3930 if (add_members(type
, type
->tp_members
) < 0)
3933 if (type
->tp_getset
!= NULL
) {
3934 if (add_getset(type
, type
->tp_getset
) < 0)
3938 /* Calculate method resolution order */
3939 if (mro_internal(type
) < 0) {
3943 /* Inherit special flags from dominant base */
3944 if (type
->tp_base
!= NULL
)
3945 inherit_special(type
, type
->tp_base
);
3947 /* Initialize tp_dict properly */
3948 bases
= type
->tp_mro
;
3949 assert(bases
!= NULL
);
3950 assert(PyTuple_Check(bases
));
3951 n
= PyTuple_GET_SIZE(bases
);
3952 for (i
= 1; i
< n
; i
++) {
3953 PyObject
*b
= PyTuple_GET_ITEM(bases
, i
);
3954 if (PyType_Check(b
))
3955 inherit_slots(type
, (PyTypeObject
*)b
);
3958 /* Sanity check for tp_free. */
3959 if (PyType_IS_GC(type
) && (type
->tp_flags
& Py_TPFLAGS_BASETYPE
) &&
3960 (type
->tp_free
== NULL
|| type
->tp_free
== PyObject_Del
)) {
3961 /* This base class needs to call tp_free, but doesn't have
3962 * one, or its tp_free is for non-gc'ed objects.
3964 PyErr_Format(PyExc_TypeError
, "type '%.100s' participates in "
3965 "gc and is a base type but has inappropriate "
3971 /* if the type dictionary doesn't contain a __doc__, set it from
3974 if (PyDict_GetItemString(type
->tp_dict
, "__doc__") == NULL
) {
3975 if (type
->tp_doc
!= NULL
) {
3976 PyObject
*doc
= PyString_FromString(type
->tp_doc
);
3979 PyDict_SetItemString(type
->tp_dict
, "__doc__", doc
);
3982 PyDict_SetItemString(type
->tp_dict
,
3983 "__doc__", Py_None
);
3987 /* Hack for tp_hash and __hash__.
3988 If after all that, tp_hash is still NULL, and __hash__ is not in
3989 tp_dict, set tp_dict['__hash__'] equal to None.
3990 This signals that __hash__ is not inherited.
3992 if (type
->tp_hash
== NULL
&&
3993 PyDict_GetItemString(type
->tp_dict
, "__hash__") == NULL
&&
3994 PyDict_SetItemString(type
->tp_dict
, "__hash__", Py_None
) < 0)
3999 /* Some more special stuff */
4000 base
= type
->tp_base
;
4002 if (type
->tp_as_number
== NULL
)
4003 type
->tp_as_number
= base
->tp_as_number
;
4004 if (type
->tp_as_sequence
== NULL
)
4005 type
->tp_as_sequence
= base
->tp_as_sequence
;
4006 if (type
->tp_as_mapping
== NULL
)
4007 type
->tp_as_mapping
= base
->tp_as_mapping
;
4008 if (type
->tp_as_buffer
== NULL
)
4009 type
->tp_as_buffer
= base
->tp_as_buffer
;
4012 /* Link into each base class's list of subclasses */
4013 bases
= type
->tp_bases
;
4014 n
= PyTuple_GET_SIZE(bases
);
4015 for (i
= 0; i
< n
; i
++) {
4016 PyObject
*b
= PyTuple_GET_ITEM(bases
, i
);
4017 if (PyType_Check(b
) &&
4018 add_subclass((PyTypeObject
*)b
, type
) < 0)
4022 /* All done -- set the ready flag */
4023 assert(type
->tp_dict
!= NULL
);
4025 (type
->tp_flags
& ~Py_TPFLAGS_READYING
) | Py_TPFLAGS_READY
;
4029 type
->tp_flags
&= ~Py_TPFLAGS_READYING
;
4034 add_subclass(PyTypeObject
*base
, PyTypeObject
*type
)
4038 PyObject
*list
, *ref
, *newobj
;
4040 list
= base
->tp_subclasses
;
4042 base
->tp_subclasses
= list
= PyList_New(0);
4046 assert(PyList_Check(list
));
4047 newobj
= PyWeakref_NewRef((PyObject
*)type
, NULL
);
4048 i
= PyList_GET_SIZE(list
);
4050 ref
= PyList_GET_ITEM(list
, i
);
4051 assert(PyWeakref_CheckRef(ref
));
4052 if (PyWeakref_GET_OBJECT(ref
) == Py_None
)
4053 return PyList_SetItem(list
, i
, newobj
);
4055 result
= PyList_Append(list
, newobj
);
4061 remove_subclass(PyTypeObject
*base
, PyTypeObject
*type
)
4064 PyObject
*list
, *ref
;
4066 list
= base
->tp_subclasses
;
4070 assert(PyList_Check(list
));
4071 i
= PyList_GET_SIZE(list
);
4073 ref
= PyList_GET_ITEM(list
, i
);
4074 assert(PyWeakref_CheckRef(ref
));
4075 if (PyWeakref_GET_OBJECT(ref
) == (PyObject
*)type
) {
4076 /* this can't fail, right? */
4077 PySequence_DelItem(list
, i
);
4084 check_num_args(PyObject
*ob
, int n
)
4086 if (!PyTuple_CheckExact(ob
)) {
4087 PyErr_SetString(PyExc_SystemError
,
4088 "PyArg_UnpackTuple() argument list is not a tuple");
4091 if (n
== PyTuple_GET_SIZE(ob
))
4095 "expected %d arguments, got %zd", n
, PyTuple_GET_SIZE(ob
));
4099 /* Generic wrappers for overloadable 'operators' such as __getitem__ */
4101 /* There's a wrapper *function* for each distinct function typedef used
4102 for type object slots (e.g. binaryfunc, ternaryfunc, etc.). There's a
4103 wrapper *table* for each distinct operation (e.g. __len__, __add__).
4104 Most tables have only one entry; the tables for binary operators have two
4105 entries, one regular and one with reversed arguments. */
4108 wrap_lenfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4110 lenfunc func
= (lenfunc
)wrapped
;
4113 if (!check_num_args(args
, 0))
4115 res
= (*func
)(self
);
4116 if (res
== -1 && PyErr_Occurred())
4118 return PyInt_FromLong((long)res
);
4122 wrap_inquirypred(PyObject
*self
, PyObject
*args
, void *wrapped
)
4124 inquiry func
= (inquiry
)wrapped
;
4127 if (!check_num_args(args
, 0))
4129 res
= (*func
)(self
);
4130 if (res
== -1 && PyErr_Occurred())
4132 return PyBool_FromLong((long)res
);
4136 wrap_binaryfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4138 binaryfunc func
= (binaryfunc
)wrapped
;
4141 if (!check_num_args(args
, 1))
4143 other
= PyTuple_GET_ITEM(args
, 0);
4144 return (*func
)(self
, other
);
4148 wrap_binaryfunc_l(PyObject
*self
, PyObject
*args
, void *wrapped
)
4150 binaryfunc func
= (binaryfunc
)wrapped
;
4153 if (!check_num_args(args
, 1))
4155 other
= PyTuple_GET_ITEM(args
, 0);
4156 if (!(self
->ob_type
->tp_flags
& Py_TPFLAGS_CHECKTYPES
) &&
4157 !PyType_IsSubtype(other
->ob_type
, self
->ob_type
)) {
4158 Py_INCREF(Py_NotImplemented
);
4159 return Py_NotImplemented
;
4161 return (*func
)(self
, other
);
4165 wrap_binaryfunc_r(PyObject
*self
, PyObject
*args
, void *wrapped
)
4167 binaryfunc func
= (binaryfunc
)wrapped
;
4170 if (!check_num_args(args
, 1))
4172 other
= PyTuple_GET_ITEM(args
, 0);
4173 if (!(self
->ob_type
->tp_flags
& Py_TPFLAGS_CHECKTYPES
) &&
4174 !PyType_IsSubtype(other
->ob_type
, self
->ob_type
)) {
4175 Py_INCREF(Py_NotImplemented
);
4176 return Py_NotImplemented
;
4178 return (*func
)(other
, self
);
4182 wrap_coercefunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4184 coercion func
= (coercion
)wrapped
;
4185 PyObject
*other
, *res
;
4188 if (!check_num_args(args
, 1))
4190 other
= PyTuple_GET_ITEM(args
, 0);
4191 ok
= func(&self
, &other
);
4195 Py_INCREF(Py_NotImplemented
);
4196 return Py_NotImplemented
;
4198 res
= PyTuple_New(2);
4204 PyTuple_SET_ITEM(res
, 0, self
);
4205 PyTuple_SET_ITEM(res
, 1, other
);
4210 wrap_ternaryfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4212 ternaryfunc func
= (ternaryfunc
)wrapped
;
4214 PyObject
*third
= Py_None
;
4216 /* Note: This wrapper only works for __pow__() */
4218 if (!PyArg_UnpackTuple(args
, "", 1, 2, &other
, &third
))
4220 return (*func
)(self
, other
, third
);
4224 wrap_ternaryfunc_r(PyObject
*self
, PyObject
*args
, void *wrapped
)
4226 ternaryfunc func
= (ternaryfunc
)wrapped
;
4228 PyObject
*third
= Py_None
;
4230 /* Note: This wrapper only works for __pow__() */
4232 if (!PyArg_UnpackTuple(args
, "", 1, 2, &other
, &third
))
4234 return (*func
)(other
, self
, third
);
4238 wrap_unaryfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4240 unaryfunc func
= (unaryfunc
)wrapped
;
4242 if (!check_num_args(args
, 0))
4244 return (*func
)(self
);
4248 wrap_indexargfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4250 ssizeargfunc func
= (ssizeargfunc
)wrapped
;
4254 if (!PyArg_UnpackTuple(args
, "", 1, 1, &o
))
4256 i
= PyNumber_AsSsize_t(o
, PyExc_OverflowError
);
4257 if (i
== -1 && PyErr_Occurred())
4259 return (*func
)(self
, i
);
4263 getindex(PyObject
*self
, PyObject
*arg
)
4267 i
= PyNumber_AsSsize_t(arg
, PyExc_OverflowError
);
4268 if (i
== -1 && PyErr_Occurred())
4271 PySequenceMethods
*sq
= Py_TYPE(self
)->tp_as_sequence
;
4272 if (sq
&& sq
->sq_length
) {
4273 Py_ssize_t n
= (*sq
->sq_length
)(self
);
4283 wrap_sq_item(PyObject
*self
, PyObject
*args
, void *wrapped
)
4285 ssizeargfunc func
= (ssizeargfunc
)wrapped
;
4289 if (PyTuple_GET_SIZE(args
) == 1) {
4290 arg
= PyTuple_GET_ITEM(args
, 0);
4291 i
= getindex(self
, arg
);
4292 if (i
== -1 && PyErr_Occurred())
4294 return (*func
)(self
, i
);
4296 check_num_args(args
, 1);
4297 assert(PyErr_Occurred());
4302 wrap_ssizessizeargfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4304 ssizessizeargfunc func
= (ssizessizeargfunc
)wrapped
;
4307 if (!PyArg_ParseTuple(args
, "nn", &i
, &j
))
4309 return (*func
)(self
, i
, j
);
4313 wrap_sq_setitem(PyObject
*self
, PyObject
*args
, void *wrapped
)
4315 ssizeobjargproc func
= (ssizeobjargproc
)wrapped
;
4318 PyObject
*arg
, *value
;
4320 if (!PyArg_UnpackTuple(args
, "", 2, 2, &arg
, &value
))
4322 i
= getindex(self
, arg
);
4323 if (i
== -1 && PyErr_Occurred())
4325 res
= (*func
)(self
, i
, value
);
4326 if (res
== -1 && PyErr_Occurred())
4333 wrap_sq_delitem(PyObject
*self
, PyObject
*args
, void *wrapped
)
4335 ssizeobjargproc func
= (ssizeobjargproc
)wrapped
;
4340 if (!check_num_args(args
, 1))
4342 arg
= PyTuple_GET_ITEM(args
, 0);
4343 i
= getindex(self
, arg
);
4344 if (i
== -1 && PyErr_Occurred())
4346 res
= (*func
)(self
, i
, NULL
);
4347 if (res
== -1 && PyErr_Occurred())
4354 wrap_ssizessizeobjargproc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4356 ssizessizeobjargproc func
= (ssizessizeobjargproc
)wrapped
;
4361 if (!PyArg_ParseTuple(args
, "nnO", &i
, &j
, &value
))
4363 res
= (*func
)(self
, i
, j
, value
);
4364 if (res
== -1 && PyErr_Occurred())
4371 wrap_delslice(PyObject
*self
, PyObject
*args
, void *wrapped
)
4373 ssizessizeobjargproc func
= (ssizessizeobjargproc
)wrapped
;
4377 if (!PyArg_ParseTuple(args
, "nn", &i
, &j
))
4379 res
= (*func
)(self
, i
, j
, NULL
);
4380 if (res
== -1 && PyErr_Occurred())
4386 /* XXX objobjproc is a misnomer; should be objargpred */
4388 wrap_objobjproc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4390 objobjproc func
= (objobjproc
)wrapped
;
4394 if (!check_num_args(args
, 1))
4396 value
= PyTuple_GET_ITEM(args
, 0);
4397 res
= (*func
)(self
, value
);
4398 if (res
== -1 && PyErr_Occurred())
4401 return PyBool_FromLong(res
);
4405 wrap_objobjargproc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4407 objobjargproc func
= (objobjargproc
)wrapped
;
4409 PyObject
*key
, *value
;
4411 if (!PyArg_UnpackTuple(args
, "", 2, 2, &key
, &value
))
4413 res
= (*func
)(self
, key
, value
);
4414 if (res
== -1 && PyErr_Occurred())
4421 wrap_delitem(PyObject
*self
, PyObject
*args
, void *wrapped
)
4423 objobjargproc func
= (objobjargproc
)wrapped
;
4427 if (!check_num_args(args
, 1))
4429 key
= PyTuple_GET_ITEM(args
, 0);
4430 res
= (*func
)(self
, key
, NULL
);
4431 if (res
== -1 && PyErr_Occurred())
4438 wrap_cmpfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4440 cmpfunc func
= (cmpfunc
)wrapped
;
4444 if (!check_num_args(args
, 1))
4446 other
= PyTuple_GET_ITEM(args
, 0);
4447 if (Py_TYPE(other
)->tp_compare
!= func
&&
4448 !PyType_IsSubtype(Py_TYPE(other
), Py_TYPE(self
))) {
4451 "%s.__cmp__(x,y) requires y to be a '%s', not a '%s'",
4452 Py_TYPE(self
)->tp_name
,
4453 Py_TYPE(self
)->tp_name
,
4454 Py_TYPE(other
)->tp_name
);
4457 res
= (*func
)(self
, other
);
4458 if (PyErr_Occurred())
4460 return PyInt_FromLong((long)res
);
4463 /* Helper to check for object.__setattr__ or __delattr__ applied to a type.
4464 This is called the Carlo Verre hack after its discoverer. */
4466 hackcheck(PyObject
*self
, setattrofunc func
, char *what
)
4468 PyTypeObject
*type
= Py_TYPE(self
);
4469 while (type
&& type
->tp_flags
& Py_TPFLAGS_HEAPTYPE
)
4470 type
= type
->tp_base
;
4471 /* If type is NULL now, this is a really weird type.
4472 In the spirit of backwards compatibility (?), just shut up. */
4473 if (type
&& type
->tp_setattro
!= func
) {
4474 PyErr_Format(PyExc_TypeError
,
4475 "can't apply this %s to %s object",
4484 wrap_setattr(PyObject
*self
, PyObject
*args
, void *wrapped
)
4486 setattrofunc func
= (setattrofunc
)wrapped
;
4488 PyObject
*name
, *value
;
4490 if (!PyArg_UnpackTuple(args
, "", 2, 2, &name
, &value
))
4492 if (!hackcheck(self
, func
, "__setattr__"))
4494 res
= (*func
)(self
, name
, value
);
4502 wrap_delattr(PyObject
*self
, PyObject
*args
, void *wrapped
)
4504 setattrofunc func
= (setattrofunc
)wrapped
;
4508 if (!check_num_args(args
, 1))
4510 name
= PyTuple_GET_ITEM(args
, 0);
4511 if (!hackcheck(self
, func
, "__delattr__"))
4513 res
= (*func
)(self
, name
, NULL
);
4521 wrap_hashfunc(PyObject
*self
, PyObject
*args
, void *wrapped
)
4523 hashfunc func
= (hashfunc
)wrapped
;
4526 if (!check_num_args(args
, 0))
4528 res
= (*func
)(self
);
4529 if (res
== -1 && PyErr_Occurred())
4531 return PyInt_FromLong(res
);
4535 wrap_call(PyObject
*self
, PyObject
*args
, void *wrapped
, PyObject
*kwds
)
4537 ternaryfunc func
= (ternaryfunc
)wrapped
;
4539 return (*func
)(self
, args
, kwds
);
4543 wrap_richcmpfunc(PyObject
*self
, PyObject
*args
, void *wrapped
, int op
)
4545 richcmpfunc func
= (richcmpfunc
)wrapped
;
4548 if (!check_num_args(args
, 1))
4550 other
= PyTuple_GET_ITEM(args
, 0);
4551 return (*func
)(self
, other
, op
);
4554 #undef RICHCMP_WRAPPER
4555 #define RICHCMP_WRAPPER(NAME, OP) \
4557 richcmp_##NAME(PyObject *self, PyObject *args, void *wrapped) \
4559 return wrap_richcmpfunc(self, args, wrapped, OP); \
4562 RICHCMP_WRAPPER(lt
, Py_LT
)
4563 RICHCMP_WRAPPER(le
, Py_LE
)
4564 RICHCMP_WRAPPER(eq
, Py_EQ
)
4565 RICHCMP_WRAPPER(ne
, Py_NE
)
4566 RICHCMP_WRAPPER(gt
, Py_GT
)
4567 RICHCMP_WRAPPER(ge
, Py_GE
)
4570 wrap_next(PyObject
*self
, PyObject
*args
, void *wrapped
)
4572 unaryfunc func
= (unaryfunc
)wrapped
;
4575 if (!check_num_args(args
, 0))
4577 res
= (*func
)(self
);
4578 if (res
== NULL
&& !PyErr_Occurred())
4579 PyErr_SetNone(PyExc_StopIteration
);
4584 wrap_descr_get(PyObject
*self
, PyObject
*args
, void *wrapped
)
4586 descrgetfunc func
= (descrgetfunc
)wrapped
;
4588 PyObject
*type
= NULL
;
4590 if (!PyArg_UnpackTuple(args
, "", 1, 2, &obj
, &type
))
4594 if (type
== Py_None
)
4596 if (type
== NULL
&&obj
== NULL
) {
4597 PyErr_SetString(PyExc_TypeError
,
4598 "__get__(None, None) is invalid");
4601 return (*func
)(self
, obj
, type
);
4605 wrap_descr_set(PyObject
*self
, PyObject
*args
, void *wrapped
)
4607 descrsetfunc func
= (descrsetfunc
)wrapped
;
4608 PyObject
*obj
, *value
;
4611 if (!PyArg_UnpackTuple(args
, "", 2, 2, &obj
, &value
))
4613 ret
= (*func
)(self
, obj
, value
);
4621 wrap_descr_delete(PyObject
*self
, PyObject
*args
, void *wrapped
)
4623 descrsetfunc func
= (descrsetfunc
)wrapped
;
4627 if (!check_num_args(args
, 1))
4629 obj
= PyTuple_GET_ITEM(args
, 0);
4630 ret
= (*func
)(self
, obj
, NULL
);
4638 wrap_init(PyObject
*self
, PyObject
*args
, void *wrapped
, PyObject
*kwds
)
4640 initproc func
= (initproc
)wrapped
;
4642 if (func(self
, args
, kwds
) < 0)
4649 tp_new_wrapper(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
4651 PyTypeObject
*type
, *subtype
, *staticbase
;
4652 PyObject
*arg0
, *res
;
4654 if (self
== NULL
|| !PyType_Check(self
))
4655 Py_FatalError("__new__() called with non-type 'self'");
4656 type
= (PyTypeObject
*)self
;
4657 if (!PyTuple_Check(args
) || PyTuple_GET_SIZE(args
) < 1) {
4658 PyErr_Format(PyExc_TypeError
,
4659 "%s.__new__(): not enough arguments",
4663 arg0
= PyTuple_GET_ITEM(args
, 0);
4664 if (!PyType_Check(arg0
)) {
4665 PyErr_Format(PyExc_TypeError
,
4666 "%s.__new__(X): X is not a type object (%s)",
4668 Py_TYPE(arg0
)->tp_name
);
4671 subtype
= (PyTypeObject
*)arg0
;
4672 if (!PyType_IsSubtype(subtype
, type
)) {
4673 PyErr_Format(PyExc_TypeError
,
4674 "%s.__new__(%s): %s is not a subtype of %s",
4682 /* Check that the use doesn't do something silly and unsafe like
4683 object.__new__(dict). To do this, we check that the
4684 most derived base that's not a heap type is this type. */
4685 staticbase
= subtype
;
4686 while (staticbase
&& (staticbase
->tp_flags
& Py_TPFLAGS_HEAPTYPE
))
4687 staticbase
= staticbase
->tp_base
;
4688 /* If staticbase is NULL now, it is a really weird type.
4689 In the spirit of backwards compatibility (?), just shut up. */
4690 if (staticbase
&& staticbase
->tp_new
!= type
->tp_new
) {
4691 PyErr_Format(PyExc_TypeError
,
4692 "%s.__new__(%s) is not safe, use %s.__new__()",
4695 staticbase
== NULL
? "?" : staticbase
->tp_name
);
4699 args
= PyTuple_GetSlice(args
, 1, PyTuple_GET_SIZE(args
));
4702 res
= type
->tp_new(subtype
, args
, kwds
);
4707 static struct PyMethodDef tp_new_methoddef
[] = {
4708 {"__new__", (PyCFunction
)tp_new_wrapper
, METH_VARARGS
|METH_KEYWORDS
,
4709 PyDoc_STR("T.__new__(S, ...) -> "
4710 "a new object with type S, a subtype of T")},
4715 add_tp_new_wrapper(PyTypeObject
*type
)
4719 if (PyDict_GetItemString(type
->tp_dict
, "__new__") != NULL
)
4721 func
= PyCFunction_New(tp_new_methoddef
, (PyObject
*)type
);
4724 if (PyDict_SetItemString(type
->tp_dict
, "__new__", func
)) {
4732 /* Slot wrappers that call the corresponding __foo__ slot. See comments
4733 below at override_slots() for more explanation. */
4735 #define SLOT0(FUNCNAME, OPSTR) \
4737 FUNCNAME(PyObject *self) \
4739 static PyObject *cache_str; \
4740 return call_method(self, OPSTR, &cache_str, "()"); \
4743 #define SLOT1(FUNCNAME, OPSTR, ARG1TYPE, ARGCODES) \
4745 FUNCNAME(PyObject *self, ARG1TYPE arg1) \
4747 static PyObject *cache_str; \
4748 return call_method(self, OPSTR, &cache_str, "(" ARGCODES ")", arg1); \
4751 /* Boolean helper for SLOT1BINFULL().
4752 right.__class__ is a nontrivial subclass of left.__class__. */
4754 method_is_overloaded(PyObject
*left
, PyObject
*right
, char *name
)
4759 b
= PyObject_GetAttrString((PyObject
*)(Py_TYPE(right
)), name
);
4762 /* If right doesn't have it, it's not overloaded */
4766 a
= PyObject_GetAttrString((PyObject
*)(Py_TYPE(left
)), name
);
4770 /* If right has it but left doesn't, it's overloaded */
4774 ok
= PyObject_RichCompareBool(a
, b
, Py_NE
);
4786 #define SLOT1BINFULL(FUNCNAME, TESTFUNC, SLOTNAME, OPSTR, ROPSTR) \
4788 FUNCNAME(PyObject *self, PyObject *other) \
4790 static PyObject *cache_str, *rcache_str; \
4791 int do_other = Py_TYPE(self) != Py_TYPE(other) && \
4792 Py_TYPE(other)->tp_as_number != NULL && \
4793 Py_TYPE(other)->tp_as_number->SLOTNAME == TESTFUNC; \
4794 if (Py_TYPE(self)->tp_as_number != NULL && \
4795 Py_TYPE(self)->tp_as_number->SLOTNAME == TESTFUNC) { \
4798 PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self)) && \
4799 method_is_overloaded(self, other, ROPSTR)) { \
4801 other, ROPSTR, &rcache_str, "(O)", self); \
4802 if (r != Py_NotImplemented) \
4808 self, OPSTR, &cache_str, "(O)", other); \
4809 if (r != Py_NotImplemented || \
4810 Py_TYPE(other) == Py_TYPE(self)) \
4815 return call_maybe( \
4816 other, ROPSTR, &rcache_str, "(O)", self); \
4818 Py_INCREF(Py_NotImplemented); \
4819 return Py_NotImplemented; \
4822 #define SLOT1BIN(FUNCNAME, SLOTNAME, OPSTR, ROPSTR) \
4823 SLOT1BINFULL(FUNCNAME, FUNCNAME, SLOTNAME, OPSTR, ROPSTR)
4825 #define SLOT2(FUNCNAME, OPSTR, ARG1TYPE, ARG2TYPE, ARGCODES) \
4827 FUNCNAME(PyObject *self, ARG1TYPE arg1, ARG2TYPE arg2) \
4829 static PyObject *cache_str; \
4830 return call_method(self, OPSTR, &cache_str, \
4831 "(" ARGCODES ")", arg1, arg2); \
4835 slot_sq_length(PyObject
*self
)
4837 static PyObject
*len_str
;
4838 PyObject
*res
= call_method(self
, "__len__", &len_str
, "()");
4843 len
= PyInt_AsSsize_t(res
);
4846 if (!PyErr_Occurred())
4847 PyErr_SetString(PyExc_ValueError
,
4848 "__len__() should return >= 0");
4854 /* Super-optimized version of slot_sq_item.
4855 Other slots could do the same... */
4857 slot_sq_item(PyObject
*self
, Py_ssize_t i
)
4859 static PyObject
*getitem_str
;
4860 PyObject
*func
, *args
= NULL
, *ival
= NULL
, *retval
= NULL
;
4863 if (getitem_str
== NULL
) {
4864 getitem_str
= PyString_InternFromString("__getitem__");
4865 if (getitem_str
== NULL
)
4868 func
= _PyType_Lookup(Py_TYPE(self
), getitem_str
);
4870 if ((f
= Py_TYPE(func
)->tp_descr_get
) == NULL
)
4873 func
= f(func
, self
, (PyObject
*)(Py_TYPE(self
)));
4878 ival
= PyInt_FromSsize_t(i
);
4880 args
= PyTuple_New(1);
4882 PyTuple_SET_ITEM(args
, 0, ival
);
4883 retval
= PyObject_Call(func
, args
, NULL
);
4891 PyErr_SetObject(PyExc_AttributeError
, getitem_str
);
4899 SLOT2(slot_sq_slice
, "__getslice__", Py_ssize_t
, Py_ssize_t
, "nn")
4902 slot_sq_ass_item(PyObject
*self
, Py_ssize_t index
, PyObject
*value
)
4905 static PyObject
*delitem_str
, *setitem_str
;
4908 res
= call_method(self
, "__delitem__", &delitem_str
,
4911 res
= call_method(self
, "__setitem__", &setitem_str
,
4912 "(nO)", index
, value
);
4920 slot_sq_ass_slice(PyObject
*self
, Py_ssize_t i
, Py_ssize_t j
, PyObject
*value
)
4923 static PyObject
*delslice_str
, *setslice_str
;
4926 res
= call_method(self
, "__delslice__", &delslice_str
,
4929 res
= call_method(self
, "__setslice__", &setslice_str
,
4930 "(nnO)", i
, j
, value
);
4938 slot_sq_contains(PyObject
*self
, PyObject
*value
)
4940 PyObject
*func
, *res
, *args
;
4943 static PyObject
*contains_str
;
4945 func
= lookup_maybe(self
, "__contains__", &contains_str
);
4947 args
= PyTuple_Pack(1, value
);
4951 res
= PyObject_Call(func
, args
, NULL
);
4956 result
= PyObject_IsTrue(res
);
4960 else if (! PyErr_Occurred()) {
4961 /* Possible results: -1 and 1 */
4962 result
= (int)_PySequence_IterSearch(self
, value
,
4963 PY_ITERSEARCH_CONTAINS
);
4968 #define slot_mp_length slot_sq_length
4970 SLOT1(slot_mp_subscript
, "__getitem__", PyObject
*, "O")
4973 slot_mp_ass_subscript(PyObject
*self
, PyObject
*key
, PyObject
*value
)
4976 static PyObject
*delitem_str
, *setitem_str
;
4979 res
= call_method(self
, "__delitem__", &delitem_str
,
4982 res
= call_method(self
, "__setitem__", &setitem_str
,
4983 "(OO)", key
, value
);
4990 SLOT1BIN(slot_nb_add
, nb_add
, "__add__", "__radd__")
4991 SLOT1BIN(slot_nb_subtract
, nb_subtract
, "__sub__", "__rsub__")
4992 SLOT1BIN(slot_nb_multiply
, nb_multiply
, "__mul__", "__rmul__")
4993 SLOT1BIN(slot_nb_divide
, nb_divide
, "__div__", "__rdiv__")
4994 SLOT1BIN(slot_nb_remainder
, nb_remainder
, "__mod__", "__rmod__")
4995 SLOT1BIN(slot_nb_divmod
, nb_divmod
, "__divmod__", "__rdivmod__")
4997 static PyObject
*slot_nb_power(PyObject
*, PyObject
*, PyObject
*);
4999 SLOT1BINFULL(slot_nb_power_binary
, slot_nb_power
,
5000 nb_power
, "__pow__", "__rpow__")
5003 slot_nb_power(PyObject
*self
, PyObject
*other
, PyObject
*modulus
)
5005 static PyObject
*pow_str
;
5007 if (modulus
== Py_None
)
5008 return slot_nb_power_binary(self
, other
);
5009 /* Three-arg power doesn't use __rpow__. But ternary_op
5010 can call this when the second argument's type uses
5011 slot_nb_power, so check before calling self.__pow__. */
5012 if (Py_TYPE(self
)->tp_as_number
!= NULL
&&
5013 Py_TYPE(self
)->tp_as_number
->nb_power
== slot_nb_power
) {
5014 return call_method(self
, "__pow__", &pow_str
,
5015 "(OO)", other
, modulus
);
5017 Py_INCREF(Py_NotImplemented
);
5018 return Py_NotImplemented
;
5021 SLOT0(slot_nb_negative
, "__neg__")
5022 SLOT0(slot_nb_positive
, "__pos__")
5023 SLOT0(slot_nb_absolute
, "__abs__")
5026 slot_nb_nonzero(PyObject
*self
)
5028 PyObject
*func
, *args
;
5029 static PyObject
*nonzero_str
, *len_str
;
5032 func
= lookup_maybe(self
, "__nonzero__", &nonzero_str
);
5034 if (PyErr_Occurred())
5036 func
= lookup_maybe(self
, "__len__", &len_str
);
5038 return PyErr_Occurred() ? -1 : 1;
5040 args
= PyTuple_New(0);
5042 PyObject
*temp
= PyObject_Call(func
, args
, NULL
);
5045 if (PyInt_CheckExact(temp
) || PyBool_Check(temp
))
5046 result
= PyObject_IsTrue(temp
);
5048 PyErr_Format(PyExc_TypeError
,
5049 "__nonzero__ should return "
5050 "bool or int, returned %s",
5051 temp
->ob_type
->tp_name
);
5063 slot_nb_index(PyObject
*self
)
5065 static PyObject
*index_str
;
5066 return call_method(self
, "__index__", &index_str
, "()");
5070 SLOT0(slot_nb_invert
, "__invert__")
5071 SLOT1BIN(slot_nb_lshift
, nb_lshift
, "__lshift__", "__rlshift__")
5072 SLOT1BIN(slot_nb_rshift
, nb_rshift
, "__rshift__", "__rrshift__")
5073 SLOT1BIN(slot_nb_and
, nb_and
, "__and__", "__rand__")
5074 SLOT1BIN(slot_nb_xor
, nb_xor
, "__xor__", "__rxor__")
5075 SLOT1BIN(slot_nb_or
, nb_or
, "__or__", "__ror__")
5078 slot_nb_coerce(PyObject
**a
, PyObject
**b
)
5080 static PyObject
*coerce_str
;
5081 PyObject
*self
= *a
, *other
= *b
;
5083 if (self
->ob_type
->tp_as_number
!= NULL
&&
5084 self
->ob_type
->tp_as_number
->nb_coerce
== slot_nb_coerce
) {
5087 self
, "__coerce__", &coerce_str
, "(O)", other
);
5090 if (r
== Py_NotImplemented
) {
5094 if (!PyTuple_Check(r
) || PyTuple_GET_SIZE(r
) != 2) {
5095 PyErr_SetString(PyExc_TypeError
,
5096 "__coerce__ didn't return a 2-tuple");
5100 *a
= PyTuple_GET_ITEM(r
, 0);
5102 *b
= PyTuple_GET_ITEM(r
, 1);
5108 if (other
->ob_type
->tp_as_number
!= NULL
&&
5109 other
->ob_type
->tp_as_number
->nb_coerce
== slot_nb_coerce
) {
5112 other
, "__coerce__", &coerce_str
, "(O)", self
);
5115 if (r
== Py_NotImplemented
) {
5119 if (!PyTuple_Check(r
) || PyTuple_GET_SIZE(r
) != 2) {
5120 PyErr_SetString(PyExc_TypeError
,
5121 "__coerce__ didn't return a 2-tuple");
5125 *a
= PyTuple_GET_ITEM(r
, 1);
5127 *b
= PyTuple_GET_ITEM(r
, 0);
5135 SLOT0(slot_nb_int
, "__int__")
5136 SLOT0(slot_nb_long
, "__long__")
5137 SLOT0(slot_nb_float
, "__float__")
5138 SLOT0(slot_nb_oct
, "__oct__")
5139 SLOT0(slot_nb_hex
, "__hex__")
5140 SLOT1(slot_nb_inplace_add
, "__iadd__", PyObject
*, "O")
5141 SLOT1(slot_nb_inplace_subtract
, "__isub__", PyObject
*, "O")
5142 SLOT1(slot_nb_inplace_multiply
, "__imul__", PyObject
*, "O")
5143 SLOT1(slot_nb_inplace_divide
, "__idiv__", PyObject
*, "O")
5144 SLOT1(slot_nb_inplace_remainder
, "__imod__", PyObject
*, "O")
5145 /* Can't use SLOT1 here, because nb_inplace_power is ternary */
5147 slot_nb_inplace_power(PyObject
*self
, PyObject
* arg1
, PyObject
*arg2
)
5149 static PyObject
*cache_str
;
5150 return call_method(self
, "__ipow__", &cache_str
, "(" "O" ")", arg1
);
5152 SLOT1(slot_nb_inplace_lshift
, "__ilshift__", PyObject
*, "O")
5153 SLOT1(slot_nb_inplace_rshift
, "__irshift__", PyObject
*, "O")
5154 SLOT1(slot_nb_inplace_and
, "__iand__", PyObject
*, "O")
5155 SLOT1(slot_nb_inplace_xor
, "__ixor__", PyObject
*, "O")
5156 SLOT1(slot_nb_inplace_or
, "__ior__", PyObject
*, "O")
5157 SLOT1BIN(slot_nb_floor_divide
, nb_floor_divide
,
5158 "__floordiv__", "__rfloordiv__")
5159 SLOT1BIN(slot_nb_true_divide
, nb_true_divide
, "__truediv__", "__rtruediv__")
5160 SLOT1(slot_nb_inplace_floor_divide
, "__ifloordiv__", PyObject
*, "O")
5161 SLOT1(slot_nb_inplace_true_divide
, "__itruediv__", PyObject
*, "O")
5164 half_compare(PyObject
*self
, PyObject
*other
)
5166 PyObject
*func
, *args
, *res
;
5167 static PyObject
*cmp_str
;
5170 func
= lookup_method(self
, "__cmp__", &cmp_str
);
5175 args
= PyTuple_Pack(1, other
);
5179 res
= PyObject_Call(func
, args
, NULL
);
5183 if (res
!= Py_NotImplemented
) {
5186 c
= PyInt_AsLong(res
);
5188 if (c
== -1 && PyErr_Occurred())
5190 return (c
< 0) ? -1 : (c
> 0) ? 1 : 0;
5197 /* This slot is published for the benefit of try_3way_compare in object.c */
5199 _PyObject_SlotCompare(PyObject
*self
, PyObject
*other
)
5203 if (Py_TYPE(self
)->tp_compare
== _PyObject_SlotCompare
) {
5204 c
= half_compare(self
, other
);
5208 if (Py_TYPE(other
)->tp_compare
== _PyObject_SlotCompare
) {
5209 c
= half_compare(other
, self
);
5215 return (void *)self
< (void *)other
? -1 :
5216 (void *)self
> (void *)other
? 1 : 0;
5220 slot_tp_repr(PyObject
*self
)
5222 PyObject
*func
, *res
;
5223 static PyObject
*repr_str
;
5225 func
= lookup_method(self
, "__repr__", &repr_str
);
5227 res
= PyEval_CallObject(func
, NULL
);
5232 return PyString_FromFormat("<%s object at %p>",
5233 Py_TYPE(self
)->tp_name
, self
);
5237 slot_tp_str(PyObject
*self
)
5239 PyObject
*func
, *res
;
5240 static PyObject
*str_str
;
5242 func
= lookup_method(self
, "__str__", &str_str
);
5244 res
= PyEval_CallObject(func
, NULL
);
5250 return slot_tp_repr(self
);
5255 slot_tp_hash(PyObject
*self
)
5258 static PyObject
*hash_str
, *eq_str
, *cmp_str
;
5261 func
= lookup_method(self
, "__hash__", &hash_str
);
5263 if (func
!= NULL
&& func
!= Py_None
) {
5264 PyObject
*res
= PyEval_CallObject(func
, NULL
);
5268 if (PyLong_Check(res
))
5269 h
= PyLong_Type
.tp_hash(res
);
5271 h
= PyInt_AsLong(res
);
5275 Py_XDECREF(func
); /* may be None */
5277 func
= lookup_method(self
, "__eq__", &eq_str
);
5280 func
= lookup_method(self
, "__cmp__", &cmp_str
);
5283 PyErr_Format(PyExc_TypeError
, "unhashable type: '%.200s'",
5284 self
->ob_type
->tp_name
);
5289 h
= _Py_HashPointer((void *)self
);
5291 if (h
== -1 && !PyErr_Occurred())
5297 slot_tp_call(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
5299 static PyObject
*call_str
;
5300 PyObject
*meth
= lookup_method(self
, "__call__", &call_str
);
5306 res
= PyObject_Call(meth
, args
, kwds
);
5312 /* There are two slot dispatch functions for tp_getattro.
5314 - slot_tp_getattro() is used when __getattribute__ is overridden
5315 but no __getattr__ hook is present;
5317 - slot_tp_getattr_hook() is used when a __getattr__ hook is present.
5319 The code in update_one_slot() always installs slot_tp_getattr_hook(); this
5320 detects the absence of __getattr__ and then installs the simpler slot if
5324 slot_tp_getattro(PyObject
*self
, PyObject
*name
)
5326 static PyObject
*getattribute_str
= NULL
;
5327 return call_method(self
, "__getattribute__", &getattribute_str
,
5332 slot_tp_getattr_hook(PyObject
*self
, PyObject
*name
)
5334 PyTypeObject
*tp
= Py_TYPE(self
);
5335 PyObject
*getattr
, *getattribute
, *res
;
5336 static PyObject
*getattribute_str
= NULL
;
5337 static PyObject
*getattr_str
= NULL
;
5339 if (getattr_str
== NULL
) {
5340 getattr_str
= PyString_InternFromString("__getattr__");
5341 if (getattr_str
== NULL
)
5344 if (getattribute_str
== NULL
) {
5346 PyString_InternFromString("__getattribute__");
5347 if (getattribute_str
== NULL
)
5350 getattr
= _PyType_Lookup(tp
, getattr_str
);
5351 if (getattr
== NULL
) {
5352 /* No __getattr__ hook: use a simpler dispatcher */
5353 tp
->tp_getattro
= slot_tp_getattro
;
5354 return slot_tp_getattro(self
, name
);
5356 getattribute
= _PyType_Lookup(tp
, getattribute_str
);
5357 if (getattribute
== NULL
||
5358 (Py_TYPE(getattribute
) == &PyWrapperDescr_Type
&&
5359 ((PyWrapperDescrObject
*)getattribute
)->d_wrapped
==
5360 (void *)PyObject_GenericGetAttr
))
5361 res
= PyObject_GenericGetAttr(self
, name
);
5363 res
= PyObject_CallFunctionObjArgs(getattribute
, self
, name
, NULL
);
5364 if (res
== NULL
&& PyErr_ExceptionMatches(PyExc_AttributeError
)) {
5366 res
= PyObject_CallFunctionObjArgs(getattr
, self
, name
, NULL
);
5372 slot_tp_setattro(PyObject
*self
, PyObject
*name
, PyObject
*value
)
5375 static PyObject
*delattr_str
, *setattr_str
;
5378 res
= call_method(self
, "__delattr__", &delattr_str
,
5381 res
= call_method(self
, "__setattr__", &setattr_str
,
5382 "(OO)", name
, value
);
5389 static char *name_op
[] = {
5399 half_richcompare(PyObject
*self
, PyObject
*other
, int op
)
5401 PyObject
*func
, *args
, *res
;
5402 static PyObject
*op_str
[6];
5404 func
= lookup_method(self
, name_op
[op
], &op_str
[op
]);
5407 Py_INCREF(Py_NotImplemented
);
5408 return Py_NotImplemented
;
5410 args
= PyTuple_Pack(1, other
);
5414 res
= PyObject_Call(func
, args
, NULL
);
5422 slot_tp_richcompare(PyObject
*self
, PyObject
*other
, int op
)
5426 if (Py_TYPE(self
)->tp_richcompare
== slot_tp_richcompare
) {
5427 res
= half_richcompare(self
, other
, op
);
5428 if (res
!= Py_NotImplemented
)
5432 if (Py_TYPE(other
)->tp_richcompare
== slot_tp_richcompare
) {
5433 res
= half_richcompare(other
, self
, _Py_SwappedOp
[op
]);
5434 if (res
!= Py_NotImplemented
) {
5439 Py_INCREF(Py_NotImplemented
);
5440 return Py_NotImplemented
;
5444 slot_tp_iter(PyObject
*self
)
5446 PyObject
*func
, *res
;
5447 static PyObject
*iter_str
, *getitem_str
;
5449 func
= lookup_method(self
, "__iter__", &iter_str
);
5452 args
= res
= PyTuple_New(0);
5454 res
= PyObject_Call(func
, args
, NULL
);
5461 func
= lookup_method(self
, "__getitem__", &getitem_str
);
5463 PyErr_Format(PyExc_TypeError
,
5464 "'%.200s' object is not iterable",
5465 Py_TYPE(self
)->tp_name
);
5469 return PySeqIter_New(self
);
5473 slot_tp_iternext(PyObject
*self
)
5475 static PyObject
*next_str
;
5476 return call_method(self
, "next", &next_str
, "()");
5480 slot_tp_descr_get(PyObject
*self
, PyObject
*obj
, PyObject
*type
)
5482 PyTypeObject
*tp
= Py_TYPE(self
);
5484 static PyObject
*get_str
= NULL
;
5486 if (get_str
== NULL
) {
5487 get_str
= PyString_InternFromString("__get__");
5488 if (get_str
== NULL
)
5491 get
= _PyType_Lookup(tp
, get_str
);
5493 /* Avoid further slowdowns */
5494 if (tp
->tp_descr_get
== slot_tp_descr_get
)
5495 tp
->tp_descr_get
= NULL
;
5503 return PyObject_CallFunctionObjArgs(get
, self
, obj
, type
, NULL
);
5507 slot_tp_descr_set(PyObject
*self
, PyObject
*target
, PyObject
*value
)
5510 static PyObject
*del_str
, *set_str
;
5513 res
= call_method(self
, "__delete__", &del_str
,
5516 res
= call_method(self
, "__set__", &set_str
,
5517 "(OO)", target
, value
);
5525 slot_tp_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
5527 static PyObject
*init_str
;
5528 PyObject
*meth
= lookup_method(self
, "__init__", &init_str
);
5533 res
= PyObject_Call(meth
, args
, kwds
);
5537 if (res
!= Py_None
) {
5538 PyErr_Format(PyExc_TypeError
,
5539 "__init__() should return None, not '%.200s'",
5540 Py_TYPE(res
)->tp_name
);
5549 slot_tp_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
5551 static PyObject
*new_str
;
5553 PyObject
*newargs
, *x
;
5556 if (new_str
== NULL
) {
5557 new_str
= PyString_InternFromString("__new__");
5558 if (new_str
== NULL
)
5561 func
= PyObject_GetAttr((PyObject
*)type
, new_str
);
5564 assert(PyTuple_Check(args
));
5565 n
= PyTuple_GET_SIZE(args
);
5566 newargs
= PyTuple_New(n
+1);
5567 if (newargs
== NULL
)
5570 PyTuple_SET_ITEM(newargs
, 0, (PyObject
*)type
);
5571 for (i
= 0; i
< n
; i
++) {
5572 x
= PyTuple_GET_ITEM(args
, i
);
5574 PyTuple_SET_ITEM(newargs
, i
+1, x
);
5576 x
= PyObject_Call(func
, newargs
, kwds
);
5583 slot_tp_del(PyObject
*self
)
5585 static PyObject
*del_str
= NULL
;
5586 PyObject
*del
, *res
;
5587 PyObject
*error_type
, *error_value
, *error_traceback
;
5589 /* Temporarily resurrect the object. */
5590 assert(self
->ob_refcnt
== 0);
5591 self
->ob_refcnt
= 1;
5593 /* Save the current exception, if any. */
5594 PyErr_Fetch(&error_type
, &error_value
, &error_traceback
);
5596 /* Execute __del__ method, if any. */
5597 del
= lookup_maybe(self
, "__del__", &del_str
);
5599 res
= PyEval_CallObject(del
, NULL
);
5601 PyErr_WriteUnraisable(del
);
5607 /* Restore the saved exception. */
5608 PyErr_Restore(error_type
, error_value
, error_traceback
);
5610 /* Undo the temporary resurrection; can't use DECREF here, it would
5611 * cause a recursive call.
5613 assert(self
->ob_refcnt
> 0);
5614 if (--self
->ob_refcnt
== 0)
5615 return; /* this is the normal path out */
5617 /* __del__ resurrected it! Make it look like the original Py_DECREF
5621 Py_ssize_t refcnt
= self
->ob_refcnt
;
5622 _Py_NewReference(self
);
5623 self
->ob_refcnt
= refcnt
;
5625 assert(!PyType_IS_GC(Py_TYPE(self
)) ||
5626 _Py_AS_GC(self
)->gc
.gc_refs
!= _PyGC_REFS_UNTRACKED
);
5627 /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
5628 * we need to undo that. */
5630 /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
5631 * chain, so no more to do there.
5632 * If COUNT_ALLOCS, the original decref bumped tp_frees, and
5633 * _Py_NewReference bumped tp_allocs: both of those need to be
5637 --Py_TYPE(self
)->tp_frees
;
5638 --Py_TYPE(self
)->tp_allocs
;
5643 /* Table mapping __foo__ names to tp_foo offsets and slot_tp_foo wrapper
5644 functions. The offsets here are relative to the 'PyHeapTypeObject'
5645 structure, which incorporates the additional structures used for numbers,
5646 sequences and mappings.
5647 Note that multiple names may map to the same slot (e.g. __eq__,
5648 __ne__ etc. all map to tp_richcompare) and one name may map to multiple
5649 slots (e.g. __str__ affects tp_str as well as tp_repr). The table is
5650 terminated with an all-zero entry. (This table is further initialized and
5651 sorted in init_slotdefs() below.) */
5653 typedef struct wrapperbase slotdef
;
5666 #define TPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
5667 {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
5669 #define FLSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC, FLAGS) \
5670 {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
5671 PyDoc_STR(DOC), FLAGS}
5672 #define ETSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
5673 {NAME, offsetof(PyHeapTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
5675 #define SQSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
5676 ETSLOT(NAME, as_sequence.SLOT, FUNCTION, WRAPPER, DOC)
5677 #define MPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
5678 ETSLOT(NAME, as_mapping.SLOT, FUNCTION, WRAPPER, DOC)
5679 #define NBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
5680 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, DOC)
5681 #define UNSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
5682 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \
5683 "x." NAME "() <==> " DOC)
5684 #define IBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
5685 ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \
5686 "x." NAME "(y) <==> x" DOC "y")
5687 #define BINSLOT(NAME, SLOT, FUNCTION, DOC) \
5688 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \
5689 "x." NAME "(y) <==> x" DOC "y")
5690 #define RBINSLOT(NAME, SLOT, FUNCTION, DOC) \
5691 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \
5692 "x." NAME "(y) <==> y" DOC "x")
5693 #define BINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \
5694 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \
5695 "x." NAME "(y) <==> " DOC)
5696 #define RBINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \
5697 ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \
5698 "x." NAME "(y) <==> " DOC)
5700 static slotdef slotdefs
[] = {
5701 SQSLOT("__len__", sq_length
, slot_sq_length
, wrap_lenfunc
,
5702 "x.__len__() <==> len(x)"),
5703 /* Heap types defining __add__/__mul__ have sq_concat/sq_repeat == NULL.
5704 The logic in abstract.c always falls back to nb_add/nb_multiply in
5705 this case. Defining both the nb_* and the sq_* slots to call the
5706 user-defined methods has unexpected side-effects, as shown by
5707 test_descr.notimplemented() */
5708 SQSLOT("__add__", sq_concat
, NULL
, wrap_binaryfunc
,
5709 "x.__add__(y) <==> x+y"),
5710 SQSLOT("__mul__", sq_repeat
, NULL
, wrap_indexargfunc
,
5711 "x.__mul__(n) <==> x*n"),
5712 SQSLOT("__rmul__", sq_repeat
, NULL
, wrap_indexargfunc
,
5713 "x.__rmul__(n) <==> n*x"),
5714 SQSLOT("__getitem__", sq_item
, slot_sq_item
, wrap_sq_item
,
5715 "x.__getitem__(y) <==> x[y]"),
5716 SQSLOT("__getslice__", sq_slice
, slot_sq_slice
, wrap_ssizessizeargfunc
,
5717 "x.__getslice__(i, j) <==> x[i:j]\n\
5719 Use of negative indices is not supported."),
5720 SQSLOT("__setitem__", sq_ass_item
, slot_sq_ass_item
, wrap_sq_setitem
,
5721 "x.__setitem__(i, y) <==> x[i]=y"),
5722 SQSLOT("__delitem__", sq_ass_item
, slot_sq_ass_item
, wrap_sq_delitem
,
5723 "x.__delitem__(y) <==> del x[y]"),
5724 SQSLOT("__setslice__", sq_ass_slice
, slot_sq_ass_slice
,
5725 wrap_ssizessizeobjargproc
,
5726 "x.__setslice__(i, j, y) <==> x[i:j]=y\n\
5728 Use of negative indices is not supported."),
5729 SQSLOT("__delslice__", sq_ass_slice
, slot_sq_ass_slice
, wrap_delslice
,
5730 "x.__delslice__(i, j) <==> del x[i:j]\n\
5732 Use of negative indices is not supported."),
5733 SQSLOT("__contains__", sq_contains
, slot_sq_contains
, wrap_objobjproc
,
5734 "x.__contains__(y) <==> y in x"),
5735 SQSLOT("__iadd__", sq_inplace_concat
, NULL
,
5736 wrap_binaryfunc
, "x.__iadd__(y) <==> x+=y"),
5737 SQSLOT("__imul__", sq_inplace_repeat
, NULL
,
5738 wrap_indexargfunc
, "x.__imul__(y) <==> x*=y"),
5740 MPSLOT("__len__", mp_length
, slot_mp_length
, wrap_lenfunc
,
5741 "x.__len__() <==> len(x)"),
5742 MPSLOT("__getitem__", mp_subscript
, slot_mp_subscript
,
5744 "x.__getitem__(y) <==> x[y]"),
5745 MPSLOT("__setitem__", mp_ass_subscript
, slot_mp_ass_subscript
,
5747 "x.__setitem__(i, y) <==> x[i]=y"),
5748 MPSLOT("__delitem__", mp_ass_subscript
, slot_mp_ass_subscript
,
5750 "x.__delitem__(y) <==> del x[y]"),
5752 BINSLOT("__add__", nb_add
, slot_nb_add
,
5754 RBINSLOT("__radd__", nb_add
, slot_nb_add
,
5756 BINSLOT("__sub__", nb_subtract
, slot_nb_subtract
,
5758 RBINSLOT("__rsub__", nb_subtract
, slot_nb_subtract
,
5760 BINSLOT("__mul__", nb_multiply
, slot_nb_multiply
,
5762 RBINSLOT("__rmul__", nb_multiply
, slot_nb_multiply
,
5764 BINSLOT("__div__", nb_divide
, slot_nb_divide
,
5766 RBINSLOT("__rdiv__", nb_divide
, slot_nb_divide
,
5768 BINSLOT("__mod__", nb_remainder
, slot_nb_remainder
,
5770 RBINSLOT("__rmod__", nb_remainder
, slot_nb_remainder
,
5772 BINSLOTNOTINFIX("__divmod__", nb_divmod
, slot_nb_divmod
,
5774 RBINSLOTNOTINFIX("__rdivmod__", nb_divmod
, slot_nb_divmod
,
5776 NBSLOT("__pow__", nb_power
, slot_nb_power
, wrap_ternaryfunc
,
5777 "x.__pow__(y[, z]) <==> pow(x, y[, z])"),
5778 NBSLOT("__rpow__", nb_power
, slot_nb_power
, wrap_ternaryfunc_r
,
5779 "y.__rpow__(x[, z]) <==> pow(x, y[, z])"),
5780 UNSLOT("__neg__", nb_negative
, slot_nb_negative
, wrap_unaryfunc
, "-x"),
5781 UNSLOT("__pos__", nb_positive
, slot_nb_positive
, wrap_unaryfunc
, "+x"),
5782 UNSLOT("__abs__", nb_absolute
, slot_nb_absolute
, wrap_unaryfunc
,
5784 UNSLOT("__nonzero__", nb_nonzero
, slot_nb_nonzero
, wrap_inquirypred
,
5786 UNSLOT("__invert__", nb_invert
, slot_nb_invert
, wrap_unaryfunc
, "~x"),
5787 BINSLOT("__lshift__", nb_lshift
, slot_nb_lshift
, "<<"),
5788 RBINSLOT("__rlshift__", nb_lshift
, slot_nb_lshift
, "<<"),
5789 BINSLOT("__rshift__", nb_rshift
, slot_nb_rshift
, ">>"),
5790 RBINSLOT("__rrshift__", nb_rshift
, slot_nb_rshift
, ">>"),
5791 BINSLOT("__and__", nb_and
, slot_nb_and
, "&"),
5792 RBINSLOT("__rand__", nb_and
, slot_nb_and
, "&"),
5793 BINSLOT("__xor__", nb_xor
, slot_nb_xor
, "^"),
5794 RBINSLOT("__rxor__", nb_xor
, slot_nb_xor
, "^"),
5795 BINSLOT("__or__", nb_or
, slot_nb_or
, "|"),
5796 RBINSLOT("__ror__", nb_or
, slot_nb_or
, "|"),
5797 NBSLOT("__coerce__", nb_coerce
, slot_nb_coerce
, wrap_coercefunc
,
5798 "x.__coerce__(y) <==> coerce(x, y)"),
5799 UNSLOT("__int__", nb_int
, slot_nb_int
, wrap_unaryfunc
,
5801 UNSLOT("__long__", nb_long
, slot_nb_long
, wrap_unaryfunc
,
5803 UNSLOT("__float__", nb_float
, slot_nb_float
, wrap_unaryfunc
,
5805 UNSLOT("__oct__", nb_oct
, slot_nb_oct
, wrap_unaryfunc
,
5807 UNSLOT("__hex__", nb_hex
, slot_nb_hex
, wrap_unaryfunc
,
5809 NBSLOT("__index__", nb_index
, slot_nb_index
, wrap_unaryfunc
,
5810 "x[y:z] <==> x[y.__index__():z.__index__()]"),
5811 IBSLOT("__iadd__", nb_inplace_add
, slot_nb_inplace_add
,
5812 wrap_binaryfunc
, "+"),
5813 IBSLOT("__isub__", nb_inplace_subtract
, slot_nb_inplace_subtract
,
5814 wrap_binaryfunc
, "-"),
5815 IBSLOT("__imul__", nb_inplace_multiply
, slot_nb_inplace_multiply
,
5816 wrap_binaryfunc
, "*"),
5817 IBSLOT("__idiv__", nb_inplace_divide
, slot_nb_inplace_divide
,
5818 wrap_binaryfunc
, "/"),
5819 IBSLOT("__imod__", nb_inplace_remainder
, slot_nb_inplace_remainder
,
5820 wrap_binaryfunc
, "%"),
5821 IBSLOT("__ipow__", nb_inplace_power
, slot_nb_inplace_power
,
5822 wrap_binaryfunc
, "**"),
5823 IBSLOT("__ilshift__", nb_inplace_lshift
, slot_nb_inplace_lshift
,
5824 wrap_binaryfunc
, "<<"),
5825 IBSLOT("__irshift__", nb_inplace_rshift
, slot_nb_inplace_rshift
,
5826 wrap_binaryfunc
, ">>"),
5827 IBSLOT("__iand__", nb_inplace_and
, slot_nb_inplace_and
,
5828 wrap_binaryfunc
, "&"),
5829 IBSLOT("__ixor__", nb_inplace_xor
, slot_nb_inplace_xor
,
5830 wrap_binaryfunc
, "^"),
5831 IBSLOT("__ior__", nb_inplace_or
, slot_nb_inplace_or
,
5832 wrap_binaryfunc
, "|"),
5833 BINSLOT("__floordiv__", nb_floor_divide
, slot_nb_floor_divide
, "//"),
5834 RBINSLOT("__rfloordiv__", nb_floor_divide
, slot_nb_floor_divide
, "//"),
5835 BINSLOT("__truediv__", nb_true_divide
, slot_nb_true_divide
, "/"),
5836 RBINSLOT("__rtruediv__", nb_true_divide
, slot_nb_true_divide
, "/"),
5837 IBSLOT("__ifloordiv__", nb_inplace_floor_divide
,
5838 slot_nb_inplace_floor_divide
, wrap_binaryfunc
, "//"),
5839 IBSLOT("__itruediv__", nb_inplace_true_divide
,
5840 slot_nb_inplace_true_divide
, wrap_binaryfunc
, "/"),
5842 TPSLOT("__str__", tp_str
, slot_tp_str
, wrap_unaryfunc
,
5843 "x.__str__() <==> str(x)"),
5844 TPSLOT("__str__", tp_print
, NULL
, NULL
, ""),
5845 TPSLOT("__repr__", tp_repr
, slot_tp_repr
, wrap_unaryfunc
,
5846 "x.__repr__() <==> repr(x)"),
5847 TPSLOT("__repr__", tp_print
, NULL
, NULL
, ""),
5848 TPSLOT("__cmp__", tp_compare
, _PyObject_SlotCompare
, wrap_cmpfunc
,
5849 "x.__cmp__(y) <==> cmp(x,y)"),
5850 TPSLOT("__hash__", tp_hash
, slot_tp_hash
, wrap_hashfunc
,
5851 "x.__hash__() <==> hash(x)"),
5852 FLSLOT("__call__", tp_call
, slot_tp_call
, (wrapperfunc
)wrap_call
,
5853 "x.__call__(...) <==> x(...)", PyWrapperFlag_KEYWORDS
),
5854 TPSLOT("__getattribute__", tp_getattro
, slot_tp_getattr_hook
,
5855 wrap_binaryfunc
, "x.__getattribute__('name') <==> x.name"),
5856 TPSLOT("__getattribute__", tp_getattr
, NULL
, NULL
, ""),
5857 TPSLOT("__getattr__", tp_getattro
, slot_tp_getattr_hook
, NULL
, ""),
5858 TPSLOT("__getattr__", tp_getattr
, NULL
, NULL
, ""),
5859 TPSLOT("__setattr__", tp_setattro
, slot_tp_setattro
, wrap_setattr
,
5860 "x.__setattr__('name', value) <==> x.name = value"),
5861 TPSLOT("__setattr__", tp_setattr
, NULL
, NULL
, ""),
5862 TPSLOT("__delattr__", tp_setattro
, slot_tp_setattro
, wrap_delattr
,
5863 "x.__delattr__('name') <==> del x.name"),
5864 TPSLOT("__delattr__", tp_setattr
, NULL
, NULL
, ""),
5865 TPSLOT("__lt__", tp_richcompare
, slot_tp_richcompare
, richcmp_lt
,
5866 "x.__lt__(y) <==> x<y"),
5867 TPSLOT("__le__", tp_richcompare
, slot_tp_richcompare
, richcmp_le
,
5868 "x.__le__(y) <==> x<=y"),
5869 TPSLOT("__eq__", tp_richcompare
, slot_tp_richcompare
, richcmp_eq
,
5870 "x.__eq__(y) <==> x==y"),
5871 TPSLOT("__ne__", tp_richcompare
, slot_tp_richcompare
, richcmp_ne
,
5872 "x.__ne__(y) <==> x!=y"),
5873 TPSLOT("__gt__", tp_richcompare
, slot_tp_richcompare
, richcmp_gt
,
5874 "x.__gt__(y) <==> x>y"),
5875 TPSLOT("__ge__", tp_richcompare
, slot_tp_richcompare
, richcmp_ge
,
5876 "x.__ge__(y) <==> x>=y"),
5877 TPSLOT("__iter__", tp_iter
, slot_tp_iter
, wrap_unaryfunc
,
5878 "x.__iter__() <==> iter(x)"),
5879 TPSLOT("next", tp_iternext
, slot_tp_iternext
, wrap_next
,
5880 "x.next() -> the next value, or raise StopIteration"),
5881 TPSLOT("__get__", tp_descr_get
, slot_tp_descr_get
, wrap_descr_get
,
5882 "descr.__get__(obj[, type]) -> value"),
5883 TPSLOT("__set__", tp_descr_set
, slot_tp_descr_set
, wrap_descr_set
,
5884 "descr.__set__(obj, value)"),
5885 TPSLOT("__delete__", tp_descr_set
, slot_tp_descr_set
,
5886 wrap_descr_delete
, "descr.__delete__(obj)"),
5887 FLSLOT("__init__", tp_init
, slot_tp_init
, (wrapperfunc
)wrap_init
,
5888 "x.__init__(...) initializes x; "
5889 "see x.__class__.__doc__ for signature",
5890 PyWrapperFlag_KEYWORDS
),
5891 TPSLOT("__new__", tp_new
, slot_tp_new
, NULL
, ""),
5892 TPSLOT("__del__", tp_del
, slot_tp_del
, NULL
, ""),
5896 /* Given a type pointer and an offset gotten from a slotdef entry, return a
5897 pointer to the actual slot. This is not quite the same as simply adding
5898 the offset to the type pointer, since it takes care to indirect through the
5899 proper indirection pointer (as_buffer, etc.); it returns NULL if the
5900 indirection pointer is NULL. */
5902 slotptr(PyTypeObject
*type
, int ioffset
)
5905 long offset
= ioffset
;
5907 /* Note: this depends on the order of the members of PyHeapTypeObject! */
5908 assert(offset
>= 0);
5909 assert((size_t)offset
< offsetof(PyHeapTypeObject
, as_buffer
));
5910 if ((size_t)offset
>= offsetof(PyHeapTypeObject
, as_sequence
)) {
5911 ptr
= (char *)type
->tp_as_sequence
;
5912 offset
-= offsetof(PyHeapTypeObject
, as_sequence
);
5914 else if ((size_t)offset
>= offsetof(PyHeapTypeObject
, as_mapping
)) {
5915 ptr
= (char *)type
->tp_as_mapping
;
5916 offset
-= offsetof(PyHeapTypeObject
, as_mapping
);
5918 else if ((size_t)offset
>= offsetof(PyHeapTypeObject
, as_number
)) {
5919 ptr
= (char *)type
->tp_as_number
;
5920 offset
-= offsetof(PyHeapTypeObject
, as_number
);
5927 return (void **)ptr
;
5930 /* Length of array of slotdef pointers used to store slots with the
5931 same __name__. There should be at most MAX_EQUIV-1 slotdef entries with
5932 the same __name__, for any __name__. Since that's a static property, it is
5933 appropriate to declare fixed-size arrays for this. */
5934 #define MAX_EQUIV 10
5936 /* Return a slot pointer for a given name, but ONLY if the attribute has
5937 exactly one slot function. The name must be an interned string. */
5939 resolve_slotdups(PyTypeObject
*type
, PyObject
*name
)
5941 /* XXX Maybe this could be optimized more -- but is it worth it? */
5943 /* pname and ptrs act as a little cache */
5944 static PyObject
*pname
;
5945 static slotdef
*ptrs
[MAX_EQUIV
];
5949 if (pname
!= name
) {
5950 /* Collect all slotdefs that match name into ptrs. */
5953 for (p
= slotdefs
; p
->name_strobj
; p
++) {
5954 if (p
->name_strobj
== name
)
5960 /* Look in all matching slots of the type; if exactly one of these has
5961 a filled-in slot, return its value. Otherwise return NULL. */
5963 for (pp
= ptrs
; *pp
; pp
++) {
5964 ptr
= slotptr(type
, (*pp
)->offset
);
5965 if (ptr
== NULL
|| *ptr
== NULL
)
5974 /* Common code for update_slots_callback() and fixup_slot_dispatchers(). This
5975 does some incredibly complex thinking and then sticks something into the
5976 slot. (It sees if the adjacent slotdefs for the same slot have conflicting
5977 interests, and then stores a generic wrapper or a specific function into
5978 the slot.) Return a pointer to the next slotdef with a different offset,
5979 because that's convenient for fixup_slot_dispatchers(). */
5981 update_one_slot(PyTypeObject
*type
, slotdef
*p
)
5984 PyWrapperDescrObject
*d
;
5985 void *generic
= NULL
, *specific
= NULL
;
5986 int use_generic
= 0;
5987 int offset
= p
->offset
;
5988 void **ptr
= slotptr(type
, offset
);
5993 } while (p
->offset
== offset
);
5997 descr
= _PyType_Lookup(type
, p
->name_strobj
);
6000 if (Py_TYPE(descr
) == &PyWrapperDescr_Type
) {
6001 void **tptr
= resolve_slotdups(type
, p
->name_strobj
);
6002 if (tptr
== NULL
|| tptr
== ptr
)
6003 generic
= p
->function
;
6004 d
= (PyWrapperDescrObject
*)descr
;
6005 if (d
->d_base
->wrapper
== p
->wrapper
&&
6006 PyType_IsSubtype(type
, d
->d_type
))
6008 if (specific
== NULL
||
6009 specific
== d
->d_wrapped
)
6010 specific
= d
->d_wrapped
;
6015 else if (Py_TYPE(descr
) == &PyCFunction_Type
&&
6016 PyCFunction_GET_FUNCTION(descr
) ==
6017 (PyCFunction
)tp_new_wrapper
&&
6018 strcmp(p
->name
, "__new__") == 0)
6020 /* The __new__ wrapper is not a wrapper descriptor,
6021 so must be special-cased differently.
6022 If we don't do this, creating an instance will
6023 always use slot_tp_new which will look up
6024 __new__ in the MRO which will call tp_new_wrapper
6025 which will look through the base classes looking
6026 for a static base and call its tp_new (usually
6027 PyType_GenericNew), after performing various
6028 sanity checks and constructing a new argument
6029 list. Cut all that nonsense short -- this speeds
6030 up instance creation tremendously. */
6031 specific
= (void *)type
->tp_new
;
6032 /* XXX I'm not 100% sure that there isn't a hole
6033 in this reasoning that requires additional
6034 sanity checks. I'll buy the first person to
6035 point out a bug in this reasoning a beer. */
6039 generic
= p
->function
;
6041 } while ((++p
)->offset
== offset
);
6042 if (specific
&& !use_generic
)
6049 /* In the type, update the slots whose slotdefs are gathered in the pp array.
6050 This is a callback for update_subclasses(). */
6052 update_slots_callback(PyTypeObject
*type
, void *data
)
6054 slotdef
**pp
= (slotdef
**)data
;
6057 update_one_slot(type
, *pp
);
6061 /* Comparison function for qsort() to compare slotdefs by their offset, and
6062 for equal offset by their address (to force a stable sort). */
6064 slotdef_cmp(const void *aa
, const void *bb
)
6066 const slotdef
*a
= (const slotdef
*)aa
, *b
= (const slotdef
*)bb
;
6067 int c
= a
->offset
- b
->offset
;
6071 /* Cannot use a-b, as this gives off_t,
6072 which may lose precision when converted to int. */
6073 return (a
> b
) ? 1 : (a
< b
) ? -1 : 0;
6076 /* Initialize the slotdefs table by adding interned string objects for the
6077 names and sorting the entries. */
6082 static int initialized
= 0;
6086 for (p
= slotdefs
; p
->name
; p
++) {
6087 p
->name_strobj
= PyString_InternFromString(p
->name
);
6088 if (!p
->name_strobj
)
6089 Py_FatalError("Out of memory interning slotdef names");
6091 qsort((void *)slotdefs
, (size_t)(p
-slotdefs
), sizeof(slotdef
),
6096 /* Update the slots after assignment to a class (type) attribute. */
6098 update_slot(PyTypeObject
*type
, PyObject
*name
)
6100 slotdef
*ptrs
[MAX_EQUIV
];
6105 /* Clear the VALID_VERSION flag of 'type' and all its
6106 subclasses. This could possibly be unified with the
6107 update_subclasses() recursion below, but carefully:
6108 they each have their own conditions on which to stop
6109 recursing into subclasses. */
6110 PyType_Modified(type
);
6114 for (p
= slotdefs
; p
->name
; p
++) {
6115 /* XXX assume name is interned! */
6116 if (p
->name_strobj
== name
)
6120 for (pp
= ptrs
; *pp
; pp
++) {
6123 while (p
> slotdefs
&& (p
-1)->offset
== offset
)
6127 if (ptrs
[0] == NULL
)
6128 return 0; /* Not an attribute that affects any slots */
6129 return update_subclasses(type
, name
,
6130 update_slots_callback
, (void *)ptrs
);
6133 /* Store the proper functions in the slot dispatches at class (type)
6134 definition time, based upon which operations the class overrides in its
6137 fixup_slot_dispatchers(PyTypeObject
*type
)
6142 for (p
= slotdefs
; p
->name
; )
6143 p
= update_one_slot(type
, p
);
6147 update_all_slots(PyTypeObject
* type
)
6152 for (p
= slotdefs
; p
->name
; p
++) {
6153 /* update_slot returns int but can't actually fail */
6154 update_slot(type
, p
->name_strobj
);
6158 /* recurse_down_subclasses() and update_subclasses() are mutually
6159 recursive functions to call a callback for all subclasses,
6160 but refraining from recursing into subclasses that define 'name'. */
6163 update_subclasses(PyTypeObject
*type
, PyObject
*name
,
6164 update_callback callback
, void *data
)
6166 if (callback(type
, data
) < 0)
6168 return recurse_down_subclasses(type
, name
, callback
, data
);
6172 recurse_down_subclasses(PyTypeObject
*type
, PyObject
*name
,
6173 update_callback callback
, void *data
)
6175 PyTypeObject
*subclass
;
6176 PyObject
*ref
, *subclasses
, *dict
;
6179 subclasses
= type
->tp_subclasses
;
6180 if (subclasses
== NULL
)
6182 assert(PyList_Check(subclasses
));
6183 n
= PyList_GET_SIZE(subclasses
);
6184 for (i
= 0; i
< n
; i
++) {
6185 ref
= PyList_GET_ITEM(subclasses
, i
);
6186 assert(PyWeakref_CheckRef(ref
));
6187 subclass
= (PyTypeObject
*)PyWeakref_GET_OBJECT(ref
);
6188 assert(subclass
!= NULL
);
6189 if ((PyObject
*)subclass
== Py_None
)
6191 assert(PyType_Check(subclass
));
6192 /* Avoid recursing down into unaffected classes */
6193 dict
= subclass
->tp_dict
;
6194 if (dict
!= NULL
&& PyDict_Check(dict
) &&
6195 PyDict_GetItem(dict
, name
) != NULL
)
6197 if (update_subclasses(subclass
, name
, callback
, data
) < 0)
6203 /* This function is called by PyType_Ready() to populate the type's
6204 dictionary with method descriptors for function slots. For each
6205 function slot (like tp_repr) that's defined in the type, one or more
6206 corresponding descriptors are added in the type's tp_dict dictionary
6207 under the appropriate name (like __repr__). Some function slots
6208 cause more than one descriptor to be added (for example, the nb_add
6209 slot adds both __add__ and __radd__ descriptors) and some function
6210 slots compete for the same descriptor (for example both sq_item and
6211 mp_subscript generate a __getitem__ descriptor).
6213 In the latter case, the first slotdef entry encoutered wins. Since
6214 slotdef entries are sorted by the offset of the slot in the
6215 PyHeapTypeObject, this gives us some control over disambiguating
6216 between competing slots: the members of PyHeapTypeObject are listed
6217 from most general to least general, so the most general slot is
6218 preferred. In particular, because as_mapping comes before as_sequence,
6219 for a type that defines both mp_subscript and sq_item, mp_subscript
6222 This only adds new descriptors and doesn't overwrite entries in
6223 tp_dict that were previously defined. The descriptors contain a
6224 reference to the C function they must call, so that it's safe if they
6225 are copied into a subtype's __dict__ and the subtype has a different
6226 C function in its slot -- calling the method defined by the
6227 descriptor will call the C function that was used to create it,
6228 rather than the C function present in the slot when it is called.
6229 (This is important because a subtype may have a C function in the
6230 slot that calls the method from the dictionary, and we want to avoid
6231 infinite recursion here.) */
6234 add_operators(PyTypeObject
*type
)
6236 PyObject
*dict
= type
->tp_dict
;
6242 for (p
= slotdefs
; p
->name
; p
++) {
6243 if (p
->wrapper
== NULL
)
6245 ptr
= slotptr(type
, p
->offset
);
6248 if (PyDict_GetItem(dict
, p
->name_strobj
))
6250 descr
= PyDescr_NewWrapper(type
, p
, *ptr
);
6253 if (PyDict_SetItem(dict
, p
->name_strobj
, descr
) < 0)
6257 if (type
->tp_new
!= NULL
) {
6258 if (add_tp_new_wrapper(type
) < 0)
6265 /* Cooperative 'super' */
6271 PyTypeObject
*obj_type
;
6274 static PyMemberDef super_members
[] = {
6275 {"__thisclass__", T_OBJECT
, offsetof(superobject
, type
), READONLY
,
6276 "the class invoking super()"},
6277 {"__self__", T_OBJECT
, offsetof(superobject
, obj
), READONLY
,
6278 "the instance invoking super(); may be None"},
6279 {"__self_class__", T_OBJECT
, offsetof(superobject
, obj_type
), READONLY
,
6280 "the type of the instance invoking super(); may be None"},
6285 super_dealloc(PyObject
*self
)
6287 superobject
*su
= (superobject
*)self
;
6289 _PyObject_GC_UNTRACK(self
);
6290 Py_XDECREF(su
->obj
);
6291 Py_XDECREF(su
->type
);
6292 Py_XDECREF(su
->obj_type
);
6293 Py_TYPE(self
)->tp_free(self
);
6297 super_repr(PyObject
*self
)
6299 superobject
*su
= (superobject
*)self
;
6302 return PyString_FromFormat(
6303 "<super: <class '%s'>, <%s object>>",
6304 su
->type
? su
->type
->tp_name
: "NULL",
6305 su
->obj_type
->tp_name
);
6307 return PyString_FromFormat(
6308 "<super: <class '%s'>, NULL>",
6309 su
->type
? su
->type
->tp_name
: "NULL");
6313 super_getattro(PyObject
*self
, PyObject
*name
)
6315 superobject
*su
= (superobject
*)self
;
6316 int skip
= su
->obj_type
== NULL
;
6319 /* We want __class__ to return the class of the super object
6320 (i.e. super, or a subclass), not the class of su->obj. */
6321 skip
= (PyString_Check(name
) &&
6322 PyString_GET_SIZE(name
) == 9 &&
6323 strcmp(PyString_AS_STRING(name
), "__class__") == 0);
6327 PyObject
*mro
, *res
, *tmp
, *dict
;
6328 PyTypeObject
*starttype
;
6332 starttype
= su
->obj_type
;
6333 mro
= starttype
->tp_mro
;
6338 assert(PyTuple_Check(mro
));
6339 n
= PyTuple_GET_SIZE(mro
);
6341 for (i
= 0; i
< n
; i
++) {
6342 if ((PyObject
*)(su
->type
) == PyTuple_GET_ITEM(mro
, i
))
6347 for (; i
< n
; i
++) {
6348 tmp
= PyTuple_GET_ITEM(mro
, i
);
6349 if (PyType_Check(tmp
))
6350 dict
= ((PyTypeObject
*)tmp
)->tp_dict
;
6351 else if (PyClass_Check(tmp
))
6352 dict
= ((PyClassObject
*)tmp
)->cl_dict
;
6355 res
= PyDict_GetItem(dict
, name
);
6358 f
= Py_TYPE(res
)->tp_descr_get
;
6361 /* Only pass 'obj' param if
6362 this is instance-mode super
6365 (su
->obj
== (PyObject
*)
6369 (PyObject
*)starttype
);
6377 return PyObject_GenericGetAttr(self
, name
);
6380 static PyTypeObject
*
6381 supercheck(PyTypeObject
*type
, PyObject
*obj
)
6383 /* Check that a super() call makes sense. Return a type object.
6385 obj can be a new-style class, or an instance of one:
6387 - If it is a class, it must be a subclass of 'type'. This case is
6388 used for class methods; the return value is obj.
6390 - If it is an instance, it must be an instance of 'type'. This is
6391 the normal case; the return value is obj.__class__.
6393 But... when obj is an instance, we want to allow for the case where
6394 Py_TYPE(obj) is not a subclass of type, but obj.__class__ is!
6395 This will allow using super() with a proxy for obj.
6398 /* Check for first bullet above (special case) */
6399 if (PyType_Check(obj
) && PyType_IsSubtype((PyTypeObject
*)obj
, type
)) {
6401 return (PyTypeObject
*)obj
;
6405 if (PyType_IsSubtype(Py_TYPE(obj
), type
)) {
6406 Py_INCREF(Py_TYPE(obj
));
6407 return Py_TYPE(obj
);
6410 /* Try the slow way */
6411 static PyObject
*class_str
= NULL
;
6412 PyObject
*class_attr
;
6414 if (class_str
== NULL
) {
6415 class_str
= PyString_FromString("__class__");
6416 if (class_str
== NULL
)
6420 class_attr
= PyObject_GetAttr(obj
, class_str
);
6422 if (class_attr
!= NULL
&&
6423 PyType_Check(class_attr
) &&
6424 (PyTypeObject
*)class_attr
!= Py_TYPE(obj
))
6426 int ok
= PyType_IsSubtype(
6427 (PyTypeObject
*)class_attr
, type
);
6429 return (PyTypeObject
*)class_attr
;
6432 if (class_attr
== NULL
)
6435 Py_DECREF(class_attr
);
6438 PyErr_SetString(PyExc_TypeError
,
6439 "super(type, obj): "
6440 "obj must be an instance or subtype of type");
6445 super_descr_get(PyObject
*self
, PyObject
*obj
, PyObject
*type
)
6447 superobject
*su
= (superobject
*)self
;
6448 superobject
*newobj
;
6450 if (obj
== NULL
|| obj
== Py_None
|| su
->obj
!= NULL
) {
6451 /* Not binding to an object, or already bound */
6455 if (Py_TYPE(su
) != &PySuper_Type
)
6456 /* If su is an instance of a (strict) subclass of super,
6458 return PyObject_CallFunctionObjArgs((PyObject
*)Py_TYPE(su
),
6459 su
->type
, obj
, NULL
);
6461 /* Inline the common case */
6462 PyTypeObject
*obj_type
= supercheck(su
->type
, obj
);
6463 if (obj_type
== NULL
)
6465 newobj
= (superobject
*)PySuper_Type
.tp_new(&PySuper_Type
,
6469 Py_INCREF(su
->type
);
6471 newobj
->type
= su
->type
;
6473 newobj
->obj_type
= obj_type
;
6474 return (PyObject
*)newobj
;
6479 super_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
6481 superobject
*su
= (superobject
*)self
;
6483 PyObject
*obj
= NULL
;
6484 PyTypeObject
*obj_type
= NULL
;
6486 if (!_PyArg_NoKeywords("super", kwds
))
6488 if (!PyArg_ParseTuple(args
, "O!|O:super", &PyType_Type
, &type
, &obj
))
6493 obj_type
= supercheck(type
, obj
);
6494 if (obj_type
== NULL
)
6501 su
->obj_type
= obj_type
;
6505 PyDoc_STRVAR(super_doc
,
6506 "super(type) -> unbound super object\n"
6507 "super(type, obj) -> bound super object; requires isinstance(obj, type)\n"
6508 "super(type, type2) -> bound super object; requires issubclass(type2, type)\n"
6509 "Typical use to call a cooperative superclass method:\n"
6511 " def meth(self, arg):\n"
6512 " super(C, self).meth(arg)");
6515 super_traverse(PyObject
*self
, visitproc visit
, void *arg
)
6517 superobject
*su
= (superobject
*)self
;
6521 Py_VISIT(su
->obj_type
);
6526 PyTypeObject PySuper_Type
= {
6527 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
6528 "super", /* tp_name */
6529 sizeof(superobject
), /* tp_basicsize */
6530 0, /* tp_itemsize */
6532 super_dealloc
, /* tp_dealloc */
6537 super_repr
, /* tp_repr */
6538 0, /* tp_as_number */
6539 0, /* tp_as_sequence */
6540 0, /* tp_as_mapping */
6544 super_getattro
, /* tp_getattro */
6545 0, /* tp_setattro */
6546 0, /* tp_as_buffer */
6547 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
|
6548 Py_TPFLAGS_BASETYPE
, /* tp_flags */
6549 super_doc
, /* tp_doc */
6550 super_traverse
, /* tp_traverse */
6552 0, /* tp_richcompare */
6553 0, /* tp_weaklistoffset */
6555 0, /* tp_iternext */
6557 super_members
, /* tp_members */
6561 super_descr_get
, /* tp_descr_get */
6562 0, /* tp_descr_set */
6563 0, /* tp_dictoffset */
6564 super_init
, /* tp_init */
6565 PyType_GenericAlloc
, /* tp_alloc */
6566 PyType_GenericNew
, /* tp_new */
6567 PyObject_GC_Del
, /* tp_free */