2 /* Generic object operations; and implementation of None (NoObject) */
5 #include "sliceobject.h" /* For PyEllipsis_Type */
6 #include "frameobject.h"
13 Py_ssize_t _Py_RefTotal
;
19 Py_ssize_t total
= _Py_RefTotal
;
20 /* ignore the references to the dummy object of the dicts and sets
21 because they are not reliable and not useful (now that the
22 hash table code is well-tested) */
25 total
-= o
->ob_refcnt
;
28 total
-= o
->ob_refcnt
;
31 #endif /* Py_REF_DEBUG */
33 int Py_DivisionWarningFlag
;
35 /* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
36 These are used by the individual routines for object creation.
37 Do not call them otherwise, they do not initialize the object! */
40 /* Head of circular doubly-linked list of all objects. These are linked
41 * together via the _ob_prev and _ob_next members of a PyObject, which
42 * exist only in a Py_TRACE_REFS build.
44 static PyObject refchain
= {&refchain
, &refchain
};
46 /* Insert op at the front of the list of all objects. If force is true,
47 * op is added even if _ob_prev and _ob_next are non-NULL already. If
48 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.
49 * force should be true if and only if op points to freshly allocated,
50 * uninitialized memory, or you've unlinked op from the list and are
51 * relinking it into the front.
52 * Note that objects are normally added to the list via _Py_NewReference,
53 * which is called by PyObject_Init. Not all objects are initialized that
54 * way, though; exceptions include statically allocated type objects, and
55 * statically allocated singletons (like Py_True and Py_None).
58 _Py_AddToAllObjects(PyObject
*op
, int force
)
62 /* If it's initialized memory, op must be in or out of
63 * the list unambiguously.
65 assert((op
->_ob_prev
== NULL
) == (op
->_ob_next
== NULL
));
68 if (force
|| op
->_ob_prev
== NULL
) {
69 op
->_ob_next
= refchain
._ob_next
;
70 op
->_ob_prev
= &refchain
;
71 refchain
._ob_next
->_ob_prev
= op
;
72 refchain
._ob_next
= op
;
75 #endif /* Py_TRACE_REFS */
78 static PyTypeObject
*type_list
;
79 /* All types are added to type_list, at least when
80 they get one object created. That makes them
81 immortal, which unfortunately contributes to
82 garbage itself. If unlist_types_without_objects
83 is set, they will be removed from the type_list
84 once the last object is deallocated. */
85 static int unlist_types_without_objects
;
86 extern Py_ssize_t tuple_zero_allocs
, fast_tuple_allocs
;
87 extern Py_ssize_t quick_int_allocs
, quick_neg_int_allocs
;
88 extern Py_ssize_t null_strings
, one_strings
;
94 for (tp
= type_list
; tp
; tp
= tp
->tp_next
)
95 fprintf(f
, "%s alloc'd: %" PY_FORMAT_SIZE_T
"d, "
96 "freed: %" PY_FORMAT_SIZE_T
"d, "
97 "max in use: %" PY_FORMAT_SIZE_T
"d\n",
98 tp
->tp_name
, tp
->tp_allocs
, tp
->tp_frees
,
100 fprintf(f
, "fast tuple allocs: %" PY_FORMAT_SIZE_T
"d, "
101 "empty: %" PY_FORMAT_SIZE_T
"d\n",
102 fast_tuple_allocs
, tuple_zero_allocs
);
103 fprintf(f
, "fast int allocs: pos: %" PY_FORMAT_SIZE_T
"d, "
104 "neg: %" PY_FORMAT_SIZE_T
"d\n",
105 quick_int_allocs
, quick_neg_int_allocs
);
106 fprintf(f
, "null strings: %" PY_FORMAT_SIZE_T
"d, "
107 "1-strings: %" PY_FORMAT_SIZE_T
"d\n",
108 null_strings
, one_strings
);
118 result
= PyList_New(0);
121 for (tp
= type_list
; tp
; tp
= tp
->tp_next
) {
122 v
= Py_BuildValue("(snnn)", tp
->tp_name
, tp
->tp_allocs
,
123 tp
->tp_frees
, tp
->tp_maxalloc
);
128 if (PyList_Append(result
, v
) < 0) {
139 inc_count(PyTypeObject
*tp
)
141 if (tp
->tp_next
== NULL
&& tp
->tp_prev
== NULL
) {
142 /* first time; insert in linked list */
143 if (tp
->tp_next
!= NULL
) /* sanity check */
144 Py_FatalError("XXX inc_count sanity check");
146 type_list
->tp_prev
= tp
;
147 tp
->tp_next
= type_list
;
148 /* Note that as of Python 2.2, heap-allocated type objects
149 * can go away, but this code requires that they stay alive
150 * until program exit. That's why we're careful with
151 * refcounts here. type_list gets a new reference to tp,
152 * while ownership of the reference type_list used to hold
153 * (if any) was transferred to tp->tp_next in the line above.
154 * tp is thus effectively immortal after this.
159 /* Also insert in the doubly-linked list of all objects,
160 * if not already there.
162 _Py_AddToAllObjects((PyObject
*)tp
, 0);
166 if (tp
->tp_allocs
- tp
->tp_frees
> tp
->tp_maxalloc
)
167 tp
->tp_maxalloc
= tp
->tp_allocs
- tp
->tp_frees
;
170 void dec_count(PyTypeObject
*tp
)
173 if (unlist_types_without_objects
&&
174 tp
->tp_allocs
== tp
->tp_frees
) {
175 /* unlink the type from type_list */
177 tp
->tp_prev
->tp_next
= tp
->tp_next
;
179 type_list
= tp
->tp_next
;
181 tp
->tp_next
->tp_prev
= tp
->tp_prev
;
182 tp
->tp_next
= tp
->tp_prev
= NULL
;
190 /* Log a fatal error; doesn't return. */
192 _Py_NegativeRefcount(const char *fname
, int lineno
, PyObject
*op
)
196 PyOS_snprintf(buf
, sizeof(buf
),
197 "%s:%i object at %p has negative ref count "
198 "%" PY_FORMAT_SIZE_T
"d",
199 fname
, lineno
, op
, op
->ob_refcnt
);
203 #endif /* Py_REF_DEBUG */
206 Py_IncRef(PyObject
*o
)
212 Py_DecRef(PyObject
*o
)
218 PyObject_Init(PyObject
*op
, PyTypeObject
*tp
)
221 return PyErr_NoMemory();
222 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
224 _Py_NewReference(op
);
229 PyObject_InitVar(PyVarObject
*op
, PyTypeObject
*tp
, Py_ssize_t size
)
232 return (PyVarObject
*) PyErr_NoMemory();
233 /* Any changes should be reflected in PyObject_INIT_VAR */
236 _Py_NewReference((PyObject
*)op
);
241 _PyObject_New(PyTypeObject
*tp
)
244 op
= (PyObject
*) PyObject_MALLOC(_PyObject_SIZE(tp
));
246 return PyErr_NoMemory();
247 return PyObject_INIT(op
, tp
);
251 _PyObject_NewVar(PyTypeObject
*tp
, Py_ssize_t nitems
)
254 const size_t size
= _PyObject_VAR_SIZE(tp
, nitems
);
255 op
= (PyVarObject
*) PyObject_MALLOC(size
);
257 return (PyVarObject
*)PyErr_NoMemory();
258 return PyObject_INIT_VAR(op
, tp
, nitems
);
261 /* Implementation of PyObject_Print with recursion checking */
263 internal_print(PyObject
*op
, FILE *fp
, int flags
, int nesting
)
267 PyErr_SetString(PyExc_RuntimeError
, "print recursion");
270 if (PyErr_CheckSignals())
272 #ifdef USE_STACKCHECK
273 if (PyOS_CheckStack()) {
274 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
278 clearerr(fp
); /* Clear any previous error condition */
280 Py_BEGIN_ALLOW_THREADS
281 fprintf(fp
, "<nil>");
285 if (op
->ob_refcnt
<= 0)
286 /* XXX(twouters) cast refcount to long until %zd is
287 universally available */
288 Py_BEGIN_ALLOW_THREADS
289 fprintf(fp
, "<refcnt %ld at %p>",
290 (long)op
->ob_refcnt
, op
);
294 if (flags
& Py_PRINT_RAW
)
295 s
= PyObject_Str(op
);
297 s
= PyObject_Repr(op
);
300 else if (PyBytes_Check(s
)) {
301 fwrite(PyBytes_AS_STRING(s
), 1,
302 PyBytes_GET_SIZE(s
), fp
);
304 else if (PyUnicode_Check(s
)) {
306 t
= _PyUnicode_AsDefaultEncodedString(s
, NULL
);
310 fwrite(PyBytes_AS_STRING(t
), 1,
311 PyBytes_GET_SIZE(t
), fp
);
315 PyErr_Format(PyExc_TypeError
,
316 "str() or repr() returned '%.100s'",
317 s
->ob_type
->tp_name
);
325 PyErr_SetFromErrno(PyExc_IOError
);
334 PyObject_Print(PyObject
*op
, FILE *fp
, int flags
)
336 return internal_print(op
, fp
, flags
, 0);
339 /* For debugging convenience. Set a breakpoint here and call it from your DLL */
346 /* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
348 _PyObject_Dump(PyObject
* op
)
351 fprintf(stderr
, "NULL\n");
354 PyGILState_STATE gil
;
356 fprintf(stderr
, "object : ");
358 gil
= PyGILState_Ensure();
360 (void)PyObject_Print(op
, stderr
, 0);
362 PyGILState_Release(gil
);
364 /* XXX(twouters) cast refcount to long until %zd is
365 universally available */
370 Py_TYPE(op
)==NULL
? "NULL" : Py_TYPE(op
)->tp_name
,
377 PyObject_Repr(PyObject
*v
)
380 if (PyErr_CheckSignals())
382 #ifdef USE_STACKCHECK
383 if (PyOS_CheckStack()) {
384 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
389 return PyUnicode_FromString("<NULL>");
390 if (Py_TYPE(v
)->tp_repr
== NULL
)
391 return PyUnicode_FromFormat("<%s object at %p>",
392 v
->ob_type
->tp_name
, v
);
393 res
= (*v
->ob_type
->tp_repr
)(v
);
394 if (res
!= NULL
&& !PyUnicode_Check(res
)) {
395 PyErr_Format(PyExc_TypeError
,
396 "__repr__ returned non-string (type %.200s)",
397 res
->ob_type
->tp_name
);
405 PyObject_Str(PyObject
*v
)
408 if (PyErr_CheckSignals())
410 #ifdef USE_STACKCHECK
411 if (PyOS_CheckStack()) {
412 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
417 return PyUnicode_FromString("<NULL>");
418 if (PyUnicode_CheckExact(v
)) {
422 if (Py_TYPE(v
)->tp_str
== NULL
)
423 return PyObject_Repr(v
);
425 /* It is possible for a type to have a tp_str representation that loops
427 if (Py_EnterRecursiveCall(" while getting the str of an object"))
429 res
= (*Py_TYPE(v
)->tp_str
)(v
);
430 Py_LeaveRecursiveCall();
433 if (!PyUnicode_Check(res
)) {
434 PyErr_Format(PyExc_TypeError
,
435 "__str__ returned non-string (type %.200s)",
436 Py_TYPE(res
)->tp_name
);
444 PyObject_ASCII(PyObject
*v
)
446 PyObject
*repr
, *ascii
, *res
;
448 repr
= PyObject_Repr(v
);
452 /* repr is guaranteed to be a PyUnicode object by PyObject_Repr */
453 ascii
= PyUnicode_EncodeASCII(
454 PyUnicode_AS_UNICODE(repr
),
455 PyUnicode_GET_SIZE(repr
),
462 res
= PyUnicode_DecodeASCII(
463 PyBytes_AS_STRING(ascii
),
464 PyBytes_GET_SIZE(ascii
),
472 PyObject_Bytes(PyObject
*v
)
474 PyObject
*result
, *func
;
475 static PyObject
*bytesstring
= NULL
;
477 if (bytesstring
== NULL
) {
478 bytesstring
= PyUnicode_InternFromString("__bytes__");
479 if (bytesstring
== NULL
)
484 return PyBytes_FromString("<NULL>");
486 if (PyBytes_CheckExact(v
)) {
491 /* Doesn't create a reference */
492 func
= _PyType_Lookup(Py_TYPE(v
), bytesstring
);
494 result
= PyObject_CallFunctionObjArgs(func
, v
, NULL
);
497 if (!PyBytes_Check(result
)) {
498 PyErr_Format(PyExc_TypeError
,
499 "__bytes__ returned non-bytes (type %.200s)",
500 Py_TYPE(result
)->tp_name
);
507 return PyBytes_FromObject(v
);
510 /* For Python 3.0.1 and later, the old three-way comparison has been
511 completely removed in favour of rich comparisons. PyObject_Compare() and
512 PyObject_Cmp() are gone, and the builtin cmp function no longer exists.
513 The old tp_compare slot has been renamed to tp_reserved, and should no
514 longer be used. Use tp_richcompare instead.
516 See (*) below for practical amendments.
518 tp_richcompare gets called with a first argument of the appropriate type
519 and a second object of an arbitrary type. We never do any kind of
522 The tp_richcompare slot should return an object, as follows:
524 NULL if an exception occurred
525 NotImplemented if the requested comparison is not implemented
526 any other false value if the requested comparison is false
527 any other true value if the requested comparison is true
529 The PyObject_RichCompare[Bool]() wrappers raise TypeError when they get
532 (*) Practical amendments:
534 - If rich comparison returns NotImplemented, == and != are decided by
535 comparing the object pointer (i.e. falling back to the base object
540 /* Map rich comparison operators to their swapped version, e.g. LT <--> GT */
541 int _Py_SwappedOp
[] = {Py_GT
, Py_GE
, Py_EQ
, Py_NE
, Py_LT
, Py_LE
};
543 static char *opstrings
[] = {"<", "<=", "==", "!=", ">", ">="};
545 /* Perform a rich comparison, raising TypeError when the requested comparison
546 operator is not supported. */
548 do_richcompare(PyObject
*v
, PyObject
*w
, int op
)
553 if (v
->ob_type
!= w
->ob_type
&&
554 PyType_IsSubtype(w
->ob_type
, v
->ob_type
) &&
555 (f
= w
->ob_type
->tp_richcompare
) != NULL
) {
556 res
= (*f
)(w
, v
, _Py_SwappedOp
[op
]);
557 if (res
!= Py_NotImplemented
)
561 if ((f
= v
->ob_type
->tp_richcompare
) != NULL
) {
562 res
= (*f
)(v
, w
, op
);
563 if (res
!= Py_NotImplemented
)
567 if ((f
= w
->ob_type
->tp_richcompare
) != NULL
) {
568 res
= (*f
)(w
, v
, _Py_SwappedOp
[op
]);
569 if (res
!= Py_NotImplemented
)
573 /* If neither object implements it, provide a sensible default
574 for == and !=, but raise an exception for ordering. */
577 res
= (v
== w
) ? Py_True
: Py_False
;
580 res
= (v
!= w
) ? Py_True
: Py_False
;
583 /* XXX Special-case None so it doesn't show as NoneType() */
584 PyErr_Format(PyExc_TypeError
,
585 "unorderable types: %.100s() %s %.100s()",
588 w
->ob_type
->tp_name
);
595 /* Perform a rich comparison with object result. This wraps do_richcompare()
596 with a check for NULL arguments and a recursion check. */
599 PyObject_RichCompare(PyObject
*v
, PyObject
*w
, int op
)
603 assert(Py_LT
<= op
&& op
<= Py_GE
);
604 if (v
== NULL
|| w
== NULL
) {
605 if (!PyErr_Occurred())
606 PyErr_BadInternalCall();
609 if (Py_EnterRecursiveCall(" in cmp"))
611 res
= do_richcompare(v
, w
, op
);
612 Py_LeaveRecursiveCall();
616 /* Perform a rich comparison with integer result. This wraps
617 PyObject_RichCompare(), returning -1 for error, 0 for false, 1 for true. */
619 PyObject_RichCompareBool(PyObject
*v
, PyObject
*w
, int op
)
624 /* Quick result when objects are the same.
625 Guarantees that identity implies equality. */
629 else if (op
== Py_NE
)
633 res
= PyObject_RichCompare(v
, w
, op
);
636 if (PyBool_Check(res
))
637 ok
= (res
== Py_True
);
639 ok
= PyObject_IsTrue(res
);
644 /* Set of hash utility functions to help maintaining the invariant that
645 if a==b then hash(a)==hash(b)
647 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
651 _Py_HashDouble(double v
)
653 double intpart
, fractpart
;
656 long x
; /* the final hash value */
657 /* This is designed so that Python numbers of different types
658 * that compare equal hash to the same value; otherwise comparisons
659 * of mapping keys will turn out weird.
662 fractpart
= modf(v
, &intpart
);
663 if (fractpart
== 0.0) {
664 /* This must return the same hash as an equal int or long. */
665 if (intpart
> LONG_MAX
/2 || -intpart
> LONG_MAX
/2) {
666 /* Convert to long and use its hash. */
667 PyObject
*plong
; /* converted to Python long */
668 if (Py_IS_INFINITY(intpart
))
669 /* can't convert to long int -- arbitrary */
670 v
= v
< 0 ? -271828.0 : 314159.0;
671 plong
= PyLong_FromDouble(v
);
674 x
= PyObject_Hash(plong
);
678 /* Fits in a C long == a Python int, so is its own hash. */
684 /* The fractional part is non-zero, so we don't have to worry about
685 * making this match the hash of some other type.
686 * Use frexp to get at the bits in the double.
687 * Since the VAX D double format has 56 mantissa bits, which is the
688 * most of any double format in use, each of these parts may have as
689 * many as (but no more than) 56 significant bits.
690 * So, assuming sizeof(long) >= 4, each part can be broken into two
691 * longs; frexp and multiplication are used to do that.
692 * Also, since the Cray double format has 15 exponent bits, which is
693 * the most of any double format in use, shifting the exponent field
694 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4).
697 v
*= 2147483648.0; /* 2**31 */
698 hipart
= (long)v
; /* take the top 32 bits */
699 v
= (v
- (double)hipart
) * 2147483648.0; /* get the next 32 bits */
700 x
= hipart
+ (long)v
+ (expo
<< 15);
707 _Py_HashPointer(void *p
)
710 size_t y
= (size_t)p
;
711 /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
712 excessive hash collisions for dicts and sets */
713 y
= (y
>> 4) | (y
<< (8 * SIZEOF_VOID_P
- 4));
721 PyObject_HashNotImplemented(PyObject
*v
)
723 PyErr_Format(PyExc_TypeError
, "unhashable type: '%.200s'",
724 Py_TYPE(v
)->tp_name
);
729 PyObject_Hash(PyObject
*v
)
731 PyTypeObject
*tp
= Py_TYPE(v
);
732 if (tp
->tp_hash
!= NULL
)
733 return (*tp
->tp_hash
)(v
);
734 /* To keep to the general practice that inheriting
735 * solely from object in C code should work without
736 * an explicit call to PyType_Ready, we implicitly call
737 * PyType_Ready here and then check the tp_hash slot again
739 if (tp
->tp_dict
== NULL
) {
740 if (PyType_Ready(tp
) < 0)
742 if (tp
->tp_hash
!= NULL
)
743 return (*tp
->tp_hash
)(v
);
745 /* Otherwise, the object can't be hashed */
746 return PyObject_HashNotImplemented(v
);
750 PyObject_GetAttrString(PyObject
*v
, const char *name
)
754 if (Py_TYPE(v
)->tp_getattr
!= NULL
)
755 return (*Py_TYPE(v
)->tp_getattr
)(v
, (char*)name
);
756 w
= PyUnicode_InternFromString(name
);
759 res
= PyObject_GetAttr(v
, w
);
765 PyObject_HasAttrString(PyObject
*v
, const char *name
)
767 PyObject
*res
= PyObject_GetAttrString(v
, name
);
777 PyObject_SetAttrString(PyObject
*v
, const char *name
, PyObject
*w
)
782 if (Py_TYPE(v
)->tp_setattr
!= NULL
)
783 return (*Py_TYPE(v
)->tp_setattr
)(v
, (char*)name
, w
);
784 s
= PyUnicode_InternFromString(name
);
787 res
= PyObject_SetAttr(v
, s
, w
);
793 PyObject_GetAttr(PyObject
*v
, PyObject
*name
)
795 PyTypeObject
*tp
= Py_TYPE(v
);
797 if (!PyUnicode_Check(name
)) {
798 PyErr_Format(PyExc_TypeError
,
799 "attribute name must be string, not '%.200s'",
800 name
->ob_type
->tp_name
);
803 if (tp
->tp_getattro
!= NULL
)
804 return (*tp
->tp_getattro
)(v
, name
);
805 if (tp
->tp_getattr
!= NULL
)
806 return (*tp
->tp_getattr
)(v
, _PyUnicode_AsString(name
));
807 PyErr_Format(PyExc_AttributeError
,
808 "'%.50s' object has no attribute '%U'",
814 PyObject_HasAttr(PyObject
*v
, PyObject
*name
)
816 PyObject
*res
= PyObject_GetAttr(v
, name
);
826 PyObject_SetAttr(PyObject
*v
, PyObject
*name
, PyObject
*value
)
828 PyTypeObject
*tp
= Py_TYPE(v
);
831 if (!PyUnicode_Check(name
)) {
832 PyErr_Format(PyExc_TypeError
,
833 "attribute name must be string, not '%.200s'",
834 name
->ob_type
->tp_name
);
839 PyUnicode_InternInPlace(&name
);
840 if (tp
->tp_setattro
!= NULL
) {
841 err
= (*tp
->tp_setattro
)(v
, name
, value
);
845 if (tp
->tp_setattr
!= NULL
) {
846 err
= (*tp
->tp_setattr
)(v
, _PyUnicode_AsString(name
), value
);
851 assert(name
->ob_refcnt
>= 1);
852 if (tp
->tp_getattr
== NULL
&& tp
->tp_getattro
== NULL
)
853 PyErr_Format(PyExc_TypeError
,
854 "'%.100s' object has no attributes "
857 value
==NULL
? "del" : "assign to",
860 PyErr_Format(PyExc_TypeError
,
861 "'%.100s' object has only read-only attributes "
864 value
==NULL
? "del" : "assign to",
869 /* Helper to get a pointer to an object's __dict__ slot, if any */
872 _PyObject_GetDictPtr(PyObject
*obj
)
874 Py_ssize_t dictoffset
;
875 PyTypeObject
*tp
= Py_TYPE(obj
);
877 dictoffset
= tp
->tp_dictoffset
;
880 if (dictoffset
< 0) {
884 tsize
= ((PyVarObject
*)obj
)->ob_size
;
887 size
= _PyObject_VAR_SIZE(tp
, tsize
);
889 dictoffset
+= (long)size
;
890 assert(dictoffset
> 0);
891 assert(dictoffset
% SIZEOF_VOID_P
== 0);
893 return (PyObject
**) ((char *)obj
+ dictoffset
);
897 PyObject_SelfIter(PyObject
*obj
)
903 /* Helper used when the __next__ method is removed from a type:
904 tp_iternext is never NULL and can be safely called without checking
909 _PyObject_NextNotImplemented(PyObject
*self
)
911 PyErr_Format(PyExc_TypeError
,
912 "'%.200s' object is not iterable",
913 Py_TYPE(self
)->tp_name
);
917 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
920 PyObject_GenericGetAttr(PyObject
*obj
, PyObject
*name
)
922 PyTypeObject
*tp
= Py_TYPE(obj
);
923 PyObject
*descr
= NULL
;
924 PyObject
*res
= NULL
;
926 Py_ssize_t dictoffset
;
929 if (!PyUnicode_Check(name
)){
930 PyErr_Format(PyExc_TypeError
,
931 "attribute name must be string, not '%.200s'",
932 name
->ob_type
->tp_name
);
938 if (tp
->tp_dict
== NULL
) {
939 if (PyType_Ready(tp
) < 0)
943 #if 0 /* XXX this is not quite _PyType_Lookup anymore */
944 /* Inline _PyType_Lookup */
947 PyObject
*mro
, *base
, *dict
;
949 /* Look in tp_dict of types in MRO */
952 assert(PyTuple_Check(mro
));
953 n
= PyTuple_GET_SIZE(mro
);
954 for (i
= 0; i
< n
; i
++) {
955 base
= PyTuple_GET_ITEM(mro
, i
);
956 assert(PyType_Check(base
));
957 dict
= ((PyTypeObject
*)base
)->tp_dict
;
958 assert(dict
&& PyDict_Check(dict
));
959 descr
= PyDict_GetItem(dict
, name
);
965 descr
= _PyType_Lookup(tp
, name
);
972 f
= descr
->ob_type
->tp_descr_get
;
973 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
974 res
= f(descr
, obj
, (PyObject
*)obj
->ob_type
);
980 /* Inline _PyObject_GetDictPtr */
981 dictoffset
= tp
->tp_dictoffset
;
982 if (dictoffset
!= 0) {
984 if (dictoffset
< 0) {
988 tsize
= ((PyVarObject
*)obj
)->ob_size
;
991 size
= _PyObject_VAR_SIZE(tp
, tsize
);
993 dictoffset
+= (long)size
;
994 assert(dictoffset
> 0);
995 assert(dictoffset
% SIZEOF_VOID_P
== 0);
997 dictptr
= (PyObject
**) ((char *)obj
+ dictoffset
);
1001 res
= PyDict_GetItem(dict
, name
);
1013 res
= f(descr
, obj
, (PyObject
*)Py_TYPE(obj
));
1018 if (descr
!= NULL
) {
1020 /* descr was already increfed above */
1024 PyErr_Format(PyExc_AttributeError
,
1025 "'%.50s' object has no attribute '%.400s'",
1026 tp
->tp_name
, _PyUnicode_AsString(name
));
1033 PyObject_GenericSetAttr(PyObject
*obj
, PyObject
*name
, PyObject
*value
)
1035 PyTypeObject
*tp
= Py_TYPE(obj
);
1041 if (!PyUnicode_Check(name
)){
1042 PyErr_Format(PyExc_TypeError
,
1043 "attribute name must be string, not '%.200s'",
1044 name
->ob_type
->tp_name
);
1050 if (tp
->tp_dict
== NULL
) {
1051 if (PyType_Ready(tp
) < 0)
1055 descr
= _PyType_Lookup(tp
, name
);
1057 if (descr
!= NULL
) {
1058 f
= descr
->ob_type
->tp_descr_set
;
1059 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1060 res
= f(descr
, obj
, value
);
1065 dictptr
= _PyObject_GetDictPtr(obj
);
1066 if (dictptr
!= NULL
) {
1067 PyObject
*dict
= *dictptr
;
1068 if (dict
== NULL
&& value
!= NULL
) {
1069 dict
= PyDict_New();
1077 res
= PyDict_DelItem(dict
, name
);
1079 res
= PyDict_SetItem(dict
, name
, value
);
1080 if (res
< 0 && PyErr_ExceptionMatches(PyExc_KeyError
))
1081 PyErr_SetObject(PyExc_AttributeError
, name
);
1088 res
= f(descr
, obj
, value
);
1092 if (descr
== NULL
) {
1093 PyErr_Format(PyExc_AttributeError
,
1094 "'%.100s' object has no attribute '%U'",
1099 PyErr_Format(PyExc_AttributeError
,
1100 "'%.50s' object attribute '%U' is read-only",
1107 /* Test a value used as condition, e.g., in a for or if statement.
1108 Return -1 if an error occurred */
1111 PyObject_IsTrue(PyObject
*v
)
1120 else if (v
->ob_type
->tp_as_number
!= NULL
&&
1121 v
->ob_type
->tp_as_number
->nb_bool
!= NULL
)
1122 res
= (*v
->ob_type
->tp_as_number
->nb_bool
)(v
);
1123 else if (v
->ob_type
->tp_as_mapping
!= NULL
&&
1124 v
->ob_type
->tp_as_mapping
->mp_length
!= NULL
)
1125 res
= (*v
->ob_type
->tp_as_mapping
->mp_length
)(v
);
1126 else if (v
->ob_type
->tp_as_sequence
!= NULL
&&
1127 v
->ob_type
->tp_as_sequence
->sq_length
!= NULL
)
1128 res
= (*v
->ob_type
->tp_as_sequence
->sq_length
)(v
);
1131 /* if it is negative, it should be either -1 or -2 */
1132 return (res
> 0) ? 1 : Py_SAFE_DOWNCAST(res
, Py_ssize_t
, int);
1135 /* equivalent of 'not v'
1136 Return -1 if an error occurred */
1139 PyObject_Not(PyObject
*v
)
1142 res
= PyObject_IsTrue(v
);
1148 /* Test whether an object can be called */
1151 PyCallable_Check(PyObject
*x
)
1155 return x
->ob_type
->tp_call
!= NULL
;
1158 /* ------------------------- PyObject_Dir() helpers ------------------------- */
1160 /* Helper for PyObject_Dir.
1161 Merge the __dict__ of aclass into dict, and recursively also all
1162 the __dict__s of aclass's base classes. The order of merging isn't
1163 defined, as it's expected that only the final set of dict keys is
1165 Return 0 on success, -1 on error.
1169 merge_class_dict(PyObject
* dict
, PyObject
* aclass
)
1171 PyObject
*classdict
;
1174 assert(PyDict_Check(dict
));
1177 /* Merge in the type's dict (if any). */
1178 classdict
= PyObject_GetAttrString(aclass
, "__dict__");
1179 if (classdict
== NULL
)
1182 int status
= PyDict_Update(dict
, classdict
);
1183 Py_DECREF(classdict
);
1188 /* Recursively merge in the base types' (if any) dicts. */
1189 bases
= PyObject_GetAttrString(aclass
, "__bases__");
1193 /* We have no guarantee that bases is a real tuple */
1195 n
= PySequence_Size(bases
); /* This better be right */
1199 for (i
= 0; i
< n
; i
++) {
1201 PyObject
*base
= PySequence_GetItem(bases
, i
);
1206 status
= merge_class_dict(dict
, base
);
1219 /* Helper for PyObject_Dir without arguments: returns the local scope. */
1224 PyObject
*locals
= PyEval_GetLocals();
1226 if (locals
== NULL
) {
1227 PyErr_SetString(PyExc_SystemError
, "frame does not exist");
1231 names
= PyMapping_Keys(locals
);
1234 if (!PyList_Check(names
)) {
1235 PyErr_Format(PyExc_TypeError
,
1236 "dir(): expected keys() of locals to be a list, "
1237 "not '%.200s'", Py_TYPE(names
)->tp_name
);
1241 /* the locals don't need to be DECREF'd */
1245 /* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__.
1246 We deliberately don't suck up its __class__, as methods belonging to the
1247 metaclass would probably be more confusing than helpful.
1250 _specialized_dir_type(PyObject
*obj
)
1252 PyObject
*result
= NULL
;
1253 PyObject
*dict
= PyDict_New();
1255 if (dict
!= NULL
&& merge_class_dict(dict
, obj
) == 0)
1256 result
= PyDict_Keys(dict
);
1262 /* Helper for PyObject_Dir of module objects: returns the module's __dict__. */
1264 _specialized_dir_module(PyObject
*obj
)
1266 PyObject
*result
= NULL
;
1267 PyObject
*dict
= PyObject_GetAttrString(obj
, "__dict__");
1270 if (PyDict_Check(dict
))
1271 result
= PyDict_Keys(dict
);
1273 PyErr_Format(PyExc_TypeError
,
1274 "%.200s.__dict__ is not a dictionary",
1275 PyModule_GetName(obj
));
1283 /* Helper for PyObject_Dir of generic objects: returns __dict__, __class__,
1284 and recursively up the __class__.__bases__ chain.
1287 _generic_dir(PyObject
*obj
)
1289 PyObject
*result
= NULL
;
1290 PyObject
*dict
= NULL
;
1291 PyObject
*itsclass
= NULL
;
1293 /* Get __dict__ (which may or may not be a real dict...) */
1294 dict
= PyObject_GetAttrString(obj
, "__dict__");
1297 dict
= PyDict_New();
1299 else if (!PyDict_Check(dict
)) {
1301 dict
= PyDict_New();
1304 /* Copy __dict__ to avoid mutating it. */
1305 PyObject
*temp
= PyDict_Copy(dict
);
1313 /* Merge in attrs reachable from its class. */
1314 itsclass
= PyObject_GetAttrString(obj
, "__class__");
1315 if (itsclass
== NULL
)
1316 /* XXX(tomer): Perhaps fall back to obj->ob_type if no
1317 __class__ exists? */
1320 if (merge_class_dict(dict
, itsclass
) != 0)
1324 result
= PyDict_Keys(dict
);
1327 Py_XDECREF(itsclass
);
1332 /* Helper for PyObject_Dir: object introspection.
1333 This calls one of the above specialized versions if no __dir__ method
1336 _dir_object(PyObject
*obj
)
1338 PyObject
* result
= NULL
;
1339 PyObject
* dirfunc
= PyObject_GetAttrString((PyObject
*)obj
->ob_type
,
1343 if (dirfunc
== NULL
) {
1344 /* use default implementation */
1346 if (PyModule_Check(obj
))
1347 result
= _specialized_dir_module(obj
);
1348 else if (PyType_Check(obj
))
1349 result
= _specialized_dir_type(obj
);
1351 result
= _generic_dir(obj
);
1355 result
= PyObject_CallFunctionObjArgs(dirfunc
, obj
, NULL
);
1360 /* result must be a list */
1361 /* XXX(gbrandl): could also check if all items are strings */
1362 if (!PyList_Check(result
)) {
1363 PyErr_Format(PyExc_TypeError
,
1364 "__dir__() must return a list, not %.200s",
1365 Py_TYPE(result
)->tp_name
);
1374 /* Implementation of dir() -- if obj is NULL, returns the names in the current
1375 (local) scope. Otherwise, performs introspection of the object: returns a
1376 sorted list of attribute names (supposedly) accessible from the object
1379 PyObject_Dir(PyObject
*obj
)
1384 /* no object -- introspect the locals */
1385 result
= _dir_locals();
1387 /* object -- introspect the object */
1388 result
= _dir_object(obj
);
1390 assert(result
== NULL
|| PyList_Check(result
));
1392 if (result
!= NULL
&& PyList_Sort(result
) != 0) {
1393 /* sorting the list failed */
1402 NoObject is usable as a non-NULL undefined value, used by the macro None.
1403 There is (and should be!) no way to create other objects of this type,
1404 so there is exactly one (which is indestructible, by the way).
1405 (XXX This type and the type of NotImplemented below should be unified.)
1410 none_repr(PyObject
*op
)
1412 return PyUnicode_FromString("None");
1417 none_dealloc(PyObject
* ignore
)
1419 /* This should never get called, but we also don't want to SEGV if
1420 * we accidentally decref None out of existence.
1422 Py_FatalError("deallocating None");
1426 static PyTypeObject PyNone_Type
= {
1427 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
1431 none_dealloc
, /*tp_dealloc*/ /*never called*/
1436 none_repr
, /*tp_repr*/
1438 0, /*tp_as_sequence*/
1439 0, /*tp_as_mapping*/
1443 PyObject _Py_NoneStruct
= {
1444 _PyObject_EXTRA_INIT
1448 /* NotImplemented is an object that can be used to signal that an
1449 operation is not implemented for the given type combination. */
1452 NotImplemented_repr(PyObject
*op
)
1454 return PyUnicode_FromString("NotImplemented");
1457 static PyTypeObject PyNotImplemented_Type
= {
1458 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
1459 "NotImplementedType",
1462 none_dealloc
, /*tp_dealloc*/ /*never called*/
1467 NotImplemented_repr
, /*tp_repr*/
1469 0, /*tp_as_sequence*/
1470 0, /*tp_as_mapping*/
1474 PyObject _Py_NotImplementedStruct
= {
1475 _PyObject_EXTRA_INIT
1476 1, &PyNotImplemented_Type
1480 _Py_ReadyTypes(void)
1482 if (PyType_Ready(&PyType_Type
) < 0)
1483 Py_FatalError("Can't initialize type type");
1485 if (PyType_Ready(&_PyWeakref_RefType
) < 0)
1486 Py_FatalError("Can't initialize weakref type");
1488 if (PyType_Ready(&_PyWeakref_CallableProxyType
) < 0)
1489 Py_FatalError("Can't initialize callable weakref proxy type");
1491 if (PyType_Ready(&_PyWeakref_ProxyType
) < 0)
1492 Py_FatalError("Can't initialize weakref proxy type");
1494 if (PyType_Ready(&PyBool_Type
) < 0)
1495 Py_FatalError("Can't initialize bool type");
1497 if (PyType_Ready(&PyByteArray_Type
) < 0)
1498 Py_FatalError("Can't initialize bytearray type");
1500 if (PyType_Ready(&PyBytes_Type
) < 0)
1501 Py_FatalError("Can't initialize 'str'");
1503 if (PyType_Ready(&PyList_Type
) < 0)
1504 Py_FatalError("Can't initialize list type");
1506 if (PyType_Ready(&PyNone_Type
) < 0)
1507 Py_FatalError("Can't initialize None type");
1509 if (PyType_Ready(Py_Ellipsis
->ob_type
) < 0)
1510 Py_FatalError("Can't initialize type(Ellipsis)");
1512 if (PyType_Ready(&PyNotImplemented_Type
) < 0)
1513 Py_FatalError("Can't initialize NotImplemented type");
1515 if (PyType_Ready(&PyTraceBack_Type
) < 0)
1516 Py_FatalError("Can't initialize traceback type");
1518 if (PyType_Ready(&PySuper_Type
) < 0)
1519 Py_FatalError("Can't initialize super type");
1521 if (PyType_Ready(&PyBaseObject_Type
) < 0)
1522 Py_FatalError("Can't initialize object type");
1524 if (PyType_Ready(&PyRange_Type
) < 0)
1525 Py_FatalError("Can't initialize range type");
1527 if (PyType_Ready(&PyDict_Type
) < 0)
1528 Py_FatalError("Can't initialize dict type");
1530 if (PyType_Ready(&PySet_Type
) < 0)
1531 Py_FatalError("Can't initialize set type");
1533 if (PyType_Ready(&PyUnicode_Type
) < 0)
1534 Py_FatalError("Can't initialize str type");
1536 if (PyType_Ready(&PySlice_Type
) < 0)
1537 Py_FatalError("Can't initialize slice type");
1539 if (PyType_Ready(&PyStaticMethod_Type
) < 0)
1540 Py_FatalError("Can't initialize static method type");
1542 #ifndef WITHOUT_COMPLEX
1543 if (PyType_Ready(&PyComplex_Type
) < 0)
1544 Py_FatalError("Can't initialize complex type");
1546 if (PyType_Ready(&PyFloat_Type
) < 0)
1547 Py_FatalError("Can't initialize float type");
1549 if (PyType_Ready(&PyLong_Type
) < 0)
1550 Py_FatalError("Can't initialize int type");
1552 if (PyType_Ready(&PyFrozenSet_Type
) < 0)
1553 Py_FatalError("Can't initialize frozenset type");
1555 if (PyType_Ready(&PyProperty_Type
) < 0)
1556 Py_FatalError("Can't initialize property type");
1558 if (PyType_Ready(&PyMemoryView_Type
) < 0)
1559 Py_FatalError("Can't initialize memoryview type");
1561 if (PyType_Ready(&PyTuple_Type
) < 0)
1562 Py_FatalError("Can't initialize tuple type");
1564 if (PyType_Ready(&PyEnum_Type
) < 0)
1565 Py_FatalError("Can't initialize enumerate type");
1567 if (PyType_Ready(&PyReversed_Type
) < 0)
1568 Py_FatalError("Can't initialize reversed type");
1570 if (PyType_Ready(&PyStdPrinter_Type
) < 0)
1571 Py_FatalError("Can't initialize StdPrinter");
1573 if (PyType_Ready(&PyCode_Type
) < 0)
1574 Py_FatalError("Can't initialize code type");
1576 if (PyType_Ready(&PyFrame_Type
) < 0)
1577 Py_FatalError("Can't initialize frame type");
1579 if (PyType_Ready(&PyCFunction_Type
) < 0)
1580 Py_FatalError("Can't initialize builtin function type");
1582 if (PyType_Ready(&PyMethod_Type
) < 0)
1583 Py_FatalError("Can't initialize method type");
1585 if (PyType_Ready(&PyFunction_Type
) < 0)
1586 Py_FatalError("Can't initialize function type");
1588 if (PyType_Ready(&PyDictProxy_Type
) < 0)
1589 Py_FatalError("Can't initialize dict proxy type");
1591 if (PyType_Ready(&PyGen_Type
) < 0)
1592 Py_FatalError("Can't initialize generator type");
1594 if (PyType_Ready(&PyGetSetDescr_Type
) < 0)
1595 Py_FatalError("Can't initialize get-set descriptor type");
1597 if (PyType_Ready(&PyWrapperDescr_Type
) < 0)
1598 Py_FatalError("Can't initialize wrapper type");
1600 if (PyType_Ready(&PyEllipsis_Type
) < 0)
1601 Py_FatalError("Can't initialize ellipsis type");
1603 if (PyType_Ready(&PyMemberDescr_Type
) < 0)
1604 Py_FatalError("Can't initialize member descriptor type");
1608 #ifdef Py_TRACE_REFS
1611 _Py_NewReference(PyObject
*op
)
1615 _Py_AddToAllObjects(op
, 1);
1616 _Py_INC_TPALLOCS(op
);
1620 _Py_ForgetReference(register PyObject
*op
)
1622 #ifdef SLOW_UNREF_CHECK
1623 register PyObject
*p
;
1625 if (op
->ob_refcnt
< 0)
1626 Py_FatalError("UNREF negative refcnt");
1627 if (op
== &refchain
||
1628 op
->_ob_prev
->_ob_next
!= op
|| op
->_ob_next
->_ob_prev
!= op
) {
1629 fprintf(stderr
, "* ob\n");
1631 fprintf(stderr
, "* op->_ob_prev->_ob_next\n");
1632 _PyObject_Dump(op
->_ob_prev
->_ob_next
);
1633 fprintf(stderr
, "* op->_ob_next->_ob_prev\n");
1634 _PyObject_Dump(op
->_ob_next
->_ob_prev
);
1635 Py_FatalError("UNREF invalid object");
1637 #ifdef SLOW_UNREF_CHECK
1638 for (p
= refchain
._ob_next
; p
!= &refchain
; p
= p
->_ob_next
) {
1642 if (p
== &refchain
) /* Not found */
1643 Py_FatalError("UNREF unknown object");
1645 op
->_ob_next
->_ob_prev
= op
->_ob_prev
;
1646 op
->_ob_prev
->_ob_next
= op
->_ob_next
;
1647 op
->_ob_next
= op
->_ob_prev
= NULL
;
1648 _Py_INC_TPFREES(op
);
1652 _Py_Dealloc(PyObject
*op
)
1654 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
1655 _Py_ForgetReference(op
);
1659 /* Print all live objects. Because PyObject_Print is called, the
1660 * interpreter must be in a healthy state.
1663 _Py_PrintReferences(FILE *fp
)
1666 fprintf(fp
, "Remaining objects:\n");
1667 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
) {
1668 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] ", op
, op
->ob_refcnt
);
1669 if (PyObject_Print(op
, fp
, 0) != 0)
1675 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
1676 * doesn't make any calls to the Python C API, so is always safe to call.
1679 _Py_PrintReferenceAddresses(FILE *fp
)
1682 fprintf(fp
, "Remaining object addresses:\n");
1683 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
)
1684 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] %s\n", op
,
1685 op
->ob_refcnt
, Py_TYPE(op
)->tp_name
);
1689 _Py_GetObjects(PyObject
*self
, PyObject
*args
)
1695 if (!PyArg_ParseTuple(args
, "i|O", &n
, &t
))
1697 op
= refchain
._ob_next
;
1698 res
= PyList_New(0);
1701 for (i
= 0; (n
== 0 || i
< n
) && op
!= &refchain
; i
++) {
1702 while (op
== self
|| op
== args
|| op
== res
|| op
== t
||
1703 (t
!= NULL
&& Py_TYPE(op
) != (PyTypeObject
*) t
)) {
1705 if (op
== &refchain
)
1708 if (PyList_Append(res
, op
) < 0) {
1719 /* Hack to force loading of cobject.o */
1720 PyTypeObject
*_Py_cobject_hack
= &PyCObject_Type
;
1723 /* Hack to force loading of pycapsule.o */
1724 PyTypeObject
*_PyCapsule_hack
= &PyCapsule_Type
;
1727 /* Hack to force loading of abstract.o */
1728 Py_ssize_t (*_Py_abstract_hack
)(PyObject
*) = PyObject_Size
;
1731 /* Python's malloc wrappers (see pymem.h) */
1734 PyMem_Malloc(size_t nbytes
)
1736 return PyMem_MALLOC(nbytes
);
1740 PyMem_Realloc(void *p
, size_t nbytes
)
1742 return PyMem_REALLOC(p
, nbytes
);
1752 /* These methods are used to control infinite recursion in repr, str, print,
1753 etc. Container objects that may recursively contain themselves,
1754 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
1755 Py_ReprLeave() to avoid infinite recursion.
1757 Py_ReprEnter() returns 0 the first time it is called for a particular
1758 object and 1 every time thereafter. It returns -1 if an exception
1759 occurred. Py_ReprLeave() has no return value.
1761 See dictobject.c and listobject.c for examples of use.
1764 #define KEY "Py_Repr"
1767 Py_ReprEnter(PyObject
*obj
)
1773 dict
= PyThreadState_GetDict();
1776 list
= PyDict_GetItemString(dict
, KEY
);
1778 list
= PyList_New(0);
1781 if (PyDict_SetItemString(dict
, KEY
, list
) < 0)
1785 i
= PyList_GET_SIZE(list
);
1787 if (PyList_GET_ITEM(list
, i
) == obj
)
1790 PyList_Append(list
, obj
);
1795 Py_ReprLeave(PyObject
*obj
)
1801 dict
= PyThreadState_GetDict();
1804 list
= PyDict_GetItemString(dict
, KEY
);
1805 if (list
== NULL
|| !PyList_Check(list
))
1807 i
= PyList_GET_SIZE(list
);
1808 /* Count backwards because we always expect obj to be list[-1] */
1810 if (PyList_GET_ITEM(list
, i
) == obj
) {
1811 PyList_SetSlice(list
, i
, i
+ 1, NULL
);
1817 /* Trashcan support. */
1819 /* Current call-stack depth of tp_dealloc calls. */
1820 int _PyTrash_delete_nesting
= 0;
1822 /* List of objects that still need to be cleaned up, singly linked via their
1823 * gc headers' gc_prev pointers.
1825 PyObject
*_PyTrash_delete_later
= NULL
;
1827 /* Add op to the _PyTrash_delete_later list. Called when the current
1828 * call-stack depth gets large. op must be a currently untracked gc'ed
1829 * object, with refcount 0. Py_DECREF must already have been called on it.
1832 _PyTrash_deposit_object(PyObject
*op
)
1834 assert(PyObject_IS_GC(op
));
1835 assert(_Py_AS_GC(op
)->gc
.gc_refs
== _PyGC_REFS_UNTRACKED
);
1836 assert(op
->ob_refcnt
== 0);
1837 _Py_AS_GC(op
)->gc
.gc_prev
= (PyGC_Head
*)_PyTrash_delete_later
;
1838 _PyTrash_delete_later
= op
;
1841 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
1842 * the call-stack unwinds again.
1845 _PyTrash_destroy_chain(void)
1847 while (_PyTrash_delete_later
) {
1848 PyObject
*op
= _PyTrash_delete_later
;
1849 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
1851 _PyTrash_delete_later
=
1852 (PyObject
*) _Py_AS_GC(op
)->gc
.gc_prev
;
1854 /* Call the deallocator directly. This used to try to
1855 * fool Py_DECREF into calling it indirectly, but
1856 * Py_DECREF was already called on this object, and in
1857 * assorted non-release builds calling Py_DECREF again ends
1858 * up distorting allocation statistics.
1860 assert(op
->ob_refcnt
== 0);
1861 ++_PyTrash_delete_nesting
;
1863 --_PyTrash_delete_nesting
;