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
);
262 PyObject_Print(PyObject
*op
, FILE *fp
, int flags
)
265 if (PyErr_CheckSignals())
267 #ifdef USE_STACKCHECK
268 if (PyOS_CheckStack()) {
269 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
273 clearerr(fp
); /* Clear any previous error condition */
275 Py_BEGIN_ALLOW_THREADS
276 fprintf(fp
, "<nil>");
280 if (op
->ob_refcnt
<= 0)
281 /* XXX(twouters) cast refcount to long until %zd is
282 universally available */
283 Py_BEGIN_ALLOW_THREADS
284 fprintf(fp
, "<refcnt %ld at %p>",
285 (long)op
->ob_refcnt
, op
);
289 if (flags
& Py_PRINT_RAW
)
290 s
= PyObject_Str(op
);
292 s
= PyObject_Repr(op
);
295 else if (PyBytes_Check(s
)) {
296 fwrite(PyBytes_AS_STRING(s
), 1,
297 PyBytes_GET_SIZE(s
), fp
);
299 else if (PyUnicode_Check(s
)) {
301 t
= PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(s
),
302 PyUnicode_GET_SIZE(s
),
307 fwrite(PyBytes_AS_STRING(t
), 1,
308 PyBytes_GET_SIZE(t
), fp
);
313 PyErr_Format(PyExc_TypeError
,
314 "str() or repr() returned '%.100s'",
315 s
->ob_type
->tp_name
);
323 PyErr_SetFromErrno(PyExc_IOError
);
331 /* For debugging convenience. Set a breakpoint here and call it from your DLL */
338 /* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
340 _PyObject_Dump(PyObject
* op
)
343 fprintf(stderr
, "NULL\n");
346 PyGILState_STATE gil
;
348 fprintf(stderr
, "object : ");
350 gil
= PyGILState_Ensure();
352 (void)PyObject_Print(op
, stderr
, 0);
354 PyGILState_Release(gil
);
356 /* XXX(twouters) cast refcount to long until %zd is
357 universally available */
362 Py_TYPE(op
)==NULL
? "NULL" : Py_TYPE(op
)->tp_name
,
369 PyObject_Repr(PyObject
*v
)
372 if (PyErr_CheckSignals())
374 #ifdef USE_STACKCHECK
375 if (PyOS_CheckStack()) {
376 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
381 return PyUnicode_FromString("<NULL>");
382 if (Py_TYPE(v
)->tp_repr
== NULL
)
383 return PyUnicode_FromFormat("<%s object at %p>",
384 v
->ob_type
->tp_name
, v
);
385 res
= (*v
->ob_type
->tp_repr
)(v
);
386 if (res
!= NULL
&& !PyUnicode_Check(res
)) {
387 PyErr_Format(PyExc_TypeError
,
388 "__repr__ returned non-string (type %.200s)",
389 res
->ob_type
->tp_name
);
397 PyObject_Str(PyObject
*v
)
400 if (PyErr_CheckSignals())
402 #ifdef USE_STACKCHECK
403 if (PyOS_CheckStack()) {
404 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
409 return PyUnicode_FromString("<NULL>");
410 if (PyUnicode_CheckExact(v
)) {
414 if (Py_TYPE(v
)->tp_str
== NULL
)
415 return PyObject_Repr(v
);
417 /* It is possible for a type to have a tp_str representation that loops
419 if (Py_EnterRecursiveCall(" while getting the str of an object"))
421 res
= (*Py_TYPE(v
)->tp_str
)(v
);
422 Py_LeaveRecursiveCall();
425 if (!PyUnicode_Check(res
)) {
426 PyErr_Format(PyExc_TypeError
,
427 "__str__ returned non-string (type %.200s)",
428 Py_TYPE(res
)->tp_name
);
436 PyObject_ASCII(PyObject
*v
)
438 PyObject
*repr
, *ascii
, *res
;
440 repr
= PyObject_Repr(v
);
444 /* repr is guaranteed to be a PyUnicode object by PyObject_Repr */
445 ascii
= PyUnicode_EncodeASCII(
446 PyUnicode_AS_UNICODE(repr
),
447 PyUnicode_GET_SIZE(repr
),
454 res
= PyUnicode_DecodeASCII(
455 PyBytes_AS_STRING(ascii
),
456 PyBytes_GET_SIZE(ascii
),
464 PyObject_Bytes(PyObject
*v
)
466 PyObject
*result
, *func
;
467 static PyObject
*bytesstring
= NULL
;
470 return PyBytes_FromString("<NULL>");
472 if (PyBytes_CheckExact(v
)) {
477 func
= _PyObject_LookupSpecial(v
, "__bytes__", &bytesstring
);
479 result
= PyObject_CallFunctionObjArgs(func
, NULL
);
483 if (!PyBytes_Check(result
)) {
484 PyErr_Format(PyExc_TypeError
,
485 "__bytes__ returned non-bytes (type %.200s)",
486 Py_TYPE(result
)->tp_name
);
492 else if (PyErr_Occurred())
494 return PyBytes_FromObject(v
);
497 /* For Python 3.0.1 and later, the old three-way comparison has been
498 completely removed in favour of rich comparisons. PyObject_Compare() and
499 PyObject_Cmp() are gone, and the builtin cmp function no longer exists.
500 The old tp_compare slot has been renamed to tp_reserved, and should no
501 longer be used. Use tp_richcompare instead.
503 See (*) below for practical amendments.
505 tp_richcompare gets called with a first argument of the appropriate type
506 and a second object of an arbitrary type. We never do any kind of
509 The tp_richcompare slot should return an object, as follows:
511 NULL if an exception occurred
512 NotImplemented if the requested comparison is not implemented
513 any other false value if the requested comparison is false
514 any other true value if the requested comparison is true
516 The PyObject_RichCompare[Bool]() wrappers raise TypeError when they get
519 (*) Practical amendments:
521 - If rich comparison returns NotImplemented, == and != are decided by
522 comparing the object pointer (i.e. falling back to the base object
527 /* Map rich comparison operators to their swapped version, e.g. LT <--> GT */
528 int _Py_SwappedOp
[] = {Py_GT
, Py_GE
, Py_EQ
, Py_NE
, Py_LT
, Py_LE
};
530 static char *opstrings
[] = {"<", "<=", "==", "!=", ">", ">="};
532 /* Perform a rich comparison, raising TypeError when the requested comparison
533 operator is not supported. */
535 do_richcompare(PyObject
*v
, PyObject
*w
, int op
)
540 if (v
->ob_type
!= w
->ob_type
&&
541 PyType_IsSubtype(w
->ob_type
, v
->ob_type
) &&
542 (f
= w
->ob_type
->tp_richcompare
) != NULL
) {
543 res
= (*f
)(w
, v
, _Py_SwappedOp
[op
]);
544 if (res
!= Py_NotImplemented
)
548 if ((f
= v
->ob_type
->tp_richcompare
) != NULL
) {
549 res
= (*f
)(v
, w
, op
);
550 if (res
!= Py_NotImplemented
)
554 if ((f
= w
->ob_type
->tp_richcompare
) != NULL
) {
555 res
= (*f
)(w
, v
, _Py_SwappedOp
[op
]);
556 if (res
!= Py_NotImplemented
)
560 /* If neither object implements it, provide a sensible default
561 for == and !=, but raise an exception for ordering. */
564 res
= (v
== w
) ? Py_True
: Py_False
;
567 res
= (v
!= w
) ? Py_True
: Py_False
;
570 /* XXX Special-case None so it doesn't show as NoneType() */
571 PyErr_Format(PyExc_TypeError
,
572 "unorderable types: %.100s() %s %.100s()",
575 w
->ob_type
->tp_name
);
582 /* Perform a rich comparison with object result. This wraps do_richcompare()
583 with a check for NULL arguments and a recursion check. */
586 PyObject_RichCompare(PyObject
*v
, PyObject
*w
, int op
)
590 assert(Py_LT
<= op
&& op
<= Py_GE
);
591 if (v
== NULL
|| w
== NULL
) {
592 if (!PyErr_Occurred())
593 PyErr_BadInternalCall();
596 if (Py_EnterRecursiveCall(" in comparison"))
598 res
= do_richcompare(v
, w
, op
);
599 Py_LeaveRecursiveCall();
603 /* Perform a rich comparison with integer result. This wraps
604 PyObject_RichCompare(), returning -1 for error, 0 for false, 1 for true. */
606 PyObject_RichCompareBool(PyObject
*v
, PyObject
*w
, int op
)
611 /* Quick result when objects are the same.
612 Guarantees that identity implies equality. */
616 else if (op
== Py_NE
)
620 res
= PyObject_RichCompare(v
, w
, op
);
623 if (PyBool_Check(res
))
624 ok
= (res
== Py_True
);
626 ok
= PyObject_IsTrue(res
);
631 /* Set of hash utility functions to help maintaining the invariant that
632 if a==b then hash(a)==hash(b)
634 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
638 _Py_HashDouble(double v
)
640 double intpart
, fractpart
;
643 long x
; /* the final hash value */
644 /* This is designed so that Python numbers of different types
645 * that compare equal hash to the same value; otherwise comparisons
646 * of mapping keys will turn out weird.
649 fractpart
= modf(v
, &intpart
);
650 if (fractpart
== 0.0) {
651 /* This must return the same hash as an equal int or long. */
652 if (intpart
> LONG_MAX
/2 || -intpart
> LONG_MAX
/2) {
653 /* Convert to long and use its hash. */
654 PyObject
*plong
; /* converted to Python long */
655 if (Py_IS_INFINITY(intpart
))
656 /* can't convert to long int -- arbitrary */
657 v
= v
< 0 ? -271828.0 : 314159.0;
658 plong
= PyLong_FromDouble(v
);
661 x
= PyObject_Hash(plong
);
665 /* Fits in a C long == a Python int, so is its own hash. */
671 /* The fractional part is non-zero, so we don't have to worry about
672 * making this match the hash of some other type.
673 * Use frexp to get at the bits in the double.
674 * Since the VAX D double format has 56 mantissa bits, which is the
675 * most of any double format in use, each of these parts may have as
676 * many as (but no more than) 56 significant bits.
677 * So, assuming sizeof(long) >= 4, each part can be broken into two
678 * longs; frexp and multiplication are used to do that.
679 * Also, since the Cray double format has 15 exponent bits, which is
680 * the most of any double format in use, shifting the exponent field
681 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4).
684 v
*= 2147483648.0; /* 2**31 */
685 hipart
= (long)v
; /* take the top 32 bits */
686 v
= (v
- (double)hipart
) * 2147483648.0; /* get the next 32 bits */
687 x
= hipart
+ (long)v
+ (expo
<< 15);
694 _Py_HashPointer(void *p
)
697 size_t y
= (size_t)p
;
698 /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
699 excessive hash collisions for dicts and sets */
700 y
= (y
>> 4) | (y
<< (8 * SIZEOF_VOID_P
- 4));
708 PyObject_HashNotImplemented(PyObject
*v
)
710 PyErr_Format(PyExc_TypeError
, "unhashable type: '%.200s'",
711 Py_TYPE(v
)->tp_name
);
716 PyObject_Hash(PyObject
*v
)
718 PyTypeObject
*tp
= Py_TYPE(v
);
719 if (tp
->tp_hash
!= NULL
)
720 return (*tp
->tp_hash
)(v
);
721 /* To keep to the general practice that inheriting
722 * solely from object in C code should work without
723 * an explicit call to PyType_Ready, we implicitly call
724 * PyType_Ready here and then check the tp_hash slot again
726 if (tp
->tp_dict
== NULL
) {
727 if (PyType_Ready(tp
) < 0)
729 if (tp
->tp_hash
!= NULL
)
730 return (*tp
->tp_hash
)(v
);
732 /* Otherwise, the object can't be hashed */
733 return PyObject_HashNotImplemented(v
);
737 PyObject_GetAttrString(PyObject
*v
, const char *name
)
741 if (Py_TYPE(v
)->tp_getattr
!= NULL
)
742 return (*Py_TYPE(v
)->tp_getattr
)(v
, (char*)name
);
743 w
= PyUnicode_InternFromString(name
);
746 res
= PyObject_GetAttr(v
, w
);
752 PyObject_HasAttrString(PyObject
*v
, const char *name
)
754 PyObject
*res
= PyObject_GetAttrString(v
, name
);
764 PyObject_SetAttrString(PyObject
*v
, const char *name
, PyObject
*w
)
769 if (Py_TYPE(v
)->tp_setattr
!= NULL
)
770 return (*Py_TYPE(v
)->tp_setattr
)(v
, (char*)name
, w
);
771 s
= PyUnicode_InternFromString(name
);
774 res
= PyObject_SetAttr(v
, s
, w
);
780 PyObject_GetAttr(PyObject
*v
, PyObject
*name
)
782 PyTypeObject
*tp
= Py_TYPE(v
);
784 if (!PyUnicode_Check(name
)) {
785 PyErr_Format(PyExc_TypeError
,
786 "attribute name must be string, not '%.200s'",
787 name
->ob_type
->tp_name
);
790 if (tp
->tp_getattro
!= NULL
)
791 return (*tp
->tp_getattro
)(v
, name
);
792 if (tp
->tp_getattr
!= NULL
) {
793 char *name_str
= _PyUnicode_AsString(name
);
794 if (name_str
== NULL
)
796 return (*tp
->tp_getattr
)(v
, name_str
);
798 PyErr_Format(PyExc_AttributeError
,
799 "'%.50s' object has no attribute '%U'",
805 PyObject_HasAttr(PyObject
*v
, PyObject
*name
)
807 PyObject
*res
= PyObject_GetAttr(v
, name
);
817 PyObject_SetAttr(PyObject
*v
, PyObject
*name
, PyObject
*value
)
819 PyTypeObject
*tp
= Py_TYPE(v
);
822 if (!PyUnicode_Check(name
)) {
823 PyErr_Format(PyExc_TypeError
,
824 "attribute name must be string, not '%.200s'",
825 name
->ob_type
->tp_name
);
830 PyUnicode_InternInPlace(&name
);
831 if (tp
->tp_setattro
!= NULL
) {
832 err
= (*tp
->tp_setattro
)(v
, name
, value
);
836 if (tp
->tp_setattr
!= NULL
) {
837 char *name_str
= _PyUnicode_AsString(name
);
838 if (name_str
== NULL
)
840 err
= (*tp
->tp_setattr
)(v
, name_str
, value
);
845 assert(name
->ob_refcnt
>= 1);
846 if (tp
->tp_getattr
== NULL
&& tp
->tp_getattro
== NULL
)
847 PyErr_Format(PyExc_TypeError
,
848 "'%.100s' object has no attributes "
851 value
==NULL
? "del" : "assign to",
854 PyErr_Format(PyExc_TypeError
,
855 "'%.100s' object has only read-only attributes "
858 value
==NULL
? "del" : "assign to",
863 /* Helper to get a pointer to an object's __dict__ slot, if any */
866 _PyObject_GetDictPtr(PyObject
*obj
)
868 Py_ssize_t dictoffset
;
869 PyTypeObject
*tp
= Py_TYPE(obj
);
871 dictoffset
= tp
->tp_dictoffset
;
874 if (dictoffset
< 0) {
878 tsize
= ((PyVarObject
*)obj
)->ob_size
;
881 size
= _PyObject_VAR_SIZE(tp
, tsize
);
883 dictoffset
+= (long)size
;
884 assert(dictoffset
> 0);
885 assert(dictoffset
% SIZEOF_VOID_P
== 0);
887 return (PyObject
**) ((char *)obj
+ dictoffset
);
891 PyObject_SelfIter(PyObject
*obj
)
897 /* Helper used when the __next__ method is removed from a type:
898 tp_iternext is never NULL and can be safely called without checking
903 _PyObject_NextNotImplemented(PyObject
*self
)
905 PyErr_Format(PyExc_TypeError
,
906 "'%.200s' object is not iterable",
907 Py_TYPE(self
)->tp_name
);
911 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
914 PyObject_GenericGetAttr(PyObject
*obj
, PyObject
*name
)
916 PyTypeObject
*tp
= Py_TYPE(obj
);
917 PyObject
*descr
= NULL
;
918 PyObject
*res
= NULL
;
920 Py_ssize_t dictoffset
;
923 if (!PyUnicode_Check(name
)){
924 PyErr_Format(PyExc_TypeError
,
925 "attribute name must be string, not '%.200s'",
926 name
->ob_type
->tp_name
);
932 if (tp
->tp_dict
== NULL
) {
933 if (PyType_Ready(tp
) < 0)
937 #if 0 /* XXX this is not quite _PyType_Lookup anymore */
938 /* Inline _PyType_Lookup */
941 PyObject
*mro
, *base
, *dict
;
943 /* Look in tp_dict of types in MRO */
946 assert(PyTuple_Check(mro
));
947 n
= PyTuple_GET_SIZE(mro
);
948 for (i
= 0; i
< n
; i
++) {
949 base
= PyTuple_GET_ITEM(mro
, i
);
950 assert(PyType_Check(base
));
951 dict
= ((PyTypeObject
*)base
)->tp_dict
;
952 assert(dict
&& PyDict_Check(dict
));
953 descr
= PyDict_GetItem(dict
, name
);
959 descr
= _PyType_Lookup(tp
, name
);
966 f
= descr
->ob_type
->tp_descr_get
;
967 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
968 res
= f(descr
, obj
, (PyObject
*)obj
->ob_type
);
974 /* Inline _PyObject_GetDictPtr */
975 dictoffset
= tp
->tp_dictoffset
;
976 if (dictoffset
!= 0) {
978 if (dictoffset
< 0) {
982 tsize
= ((PyVarObject
*)obj
)->ob_size
;
985 size
= _PyObject_VAR_SIZE(tp
, tsize
);
987 dictoffset
+= (long)size
;
988 assert(dictoffset
> 0);
989 assert(dictoffset
% SIZEOF_VOID_P
== 0);
991 dictptr
= (PyObject
**) ((char *)obj
+ dictoffset
);
995 res
= PyDict_GetItem(dict
, name
);
1007 res
= f(descr
, obj
, (PyObject
*)Py_TYPE(obj
));
1012 if (descr
!= NULL
) {
1014 /* descr was already increfed above */
1018 PyErr_Format(PyExc_AttributeError
,
1019 "'%.50s' object has no attribute '%U'",
1027 PyObject_GenericSetAttr(PyObject
*obj
, PyObject
*name
, PyObject
*value
)
1029 PyTypeObject
*tp
= Py_TYPE(obj
);
1035 if (!PyUnicode_Check(name
)){
1036 PyErr_Format(PyExc_TypeError
,
1037 "attribute name must be string, not '%.200s'",
1038 name
->ob_type
->tp_name
);
1044 if (tp
->tp_dict
== NULL
) {
1045 if (PyType_Ready(tp
) < 0)
1049 descr
= _PyType_Lookup(tp
, name
);
1051 if (descr
!= NULL
) {
1052 f
= descr
->ob_type
->tp_descr_set
;
1053 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1054 res
= f(descr
, obj
, value
);
1059 dictptr
= _PyObject_GetDictPtr(obj
);
1060 if (dictptr
!= NULL
) {
1061 PyObject
*dict
= *dictptr
;
1062 if (dict
== NULL
&& value
!= NULL
) {
1063 dict
= PyDict_New();
1071 res
= PyDict_DelItem(dict
, name
);
1073 res
= PyDict_SetItem(dict
, name
, value
);
1074 if (res
< 0 && PyErr_ExceptionMatches(PyExc_KeyError
))
1075 PyErr_SetObject(PyExc_AttributeError
, name
);
1082 res
= f(descr
, obj
, value
);
1086 if (descr
== NULL
) {
1087 PyErr_Format(PyExc_AttributeError
,
1088 "'%.100s' object has no attribute '%U'",
1093 PyErr_Format(PyExc_AttributeError
,
1094 "'%.50s' object attribute '%U' is read-only",
1101 /* Test a value used as condition, e.g., in a for or if statement.
1102 Return -1 if an error occurred */
1105 PyObject_IsTrue(PyObject
*v
)
1114 else if (v
->ob_type
->tp_as_number
!= NULL
&&
1115 v
->ob_type
->tp_as_number
->nb_bool
!= NULL
)
1116 res
= (*v
->ob_type
->tp_as_number
->nb_bool
)(v
);
1117 else if (v
->ob_type
->tp_as_mapping
!= NULL
&&
1118 v
->ob_type
->tp_as_mapping
->mp_length
!= NULL
)
1119 res
= (*v
->ob_type
->tp_as_mapping
->mp_length
)(v
);
1120 else if (v
->ob_type
->tp_as_sequence
!= NULL
&&
1121 v
->ob_type
->tp_as_sequence
->sq_length
!= NULL
)
1122 res
= (*v
->ob_type
->tp_as_sequence
->sq_length
)(v
);
1125 /* if it is negative, it should be either -1 or -2 */
1126 return (res
> 0) ? 1 : Py_SAFE_DOWNCAST(res
, Py_ssize_t
, int);
1129 /* equivalent of 'not v'
1130 Return -1 if an error occurred */
1133 PyObject_Not(PyObject
*v
)
1136 res
= PyObject_IsTrue(v
);
1142 /* Test whether an object can be called */
1145 PyCallable_Check(PyObject
*x
)
1149 return x
->ob_type
->tp_call
!= NULL
;
1152 /* ------------------------- PyObject_Dir() helpers ------------------------- */
1154 /* Helper for PyObject_Dir.
1155 Merge the __dict__ of aclass into dict, and recursively also all
1156 the __dict__s of aclass's base classes. The order of merging isn't
1157 defined, as it's expected that only the final set of dict keys is
1159 Return 0 on success, -1 on error.
1163 merge_class_dict(PyObject
* dict
, PyObject
* aclass
)
1165 PyObject
*classdict
;
1168 assert(PyDict_Check(dict
));
1171 /* Merge in the type's dict (if any). */
1172 classdict
= PyObject_GetAttrString(aclass
, "__dict__");
1173 if (classdict
== NULL
)
1176 int status
= PyDict_Update(dict
, classdict
);
1177 Py_DECREF(classdict
);
1182 /* Recursively merge in the base types' (if any) dicts. */
1183 bases
= PyObject_GetAttrString(aclass
, "__bases__");
1187 /* We have no guarantee that bases is a real tuple */
1189 n
= PySequence_Size(bases
); /* This better be right */
1193 for (i
= 0; i
< n
; i
++) {
1195 PyObject
*base
= PySequence_GetItem(bases
, i
);
1200 status
= merge_class_dict(dict
, base
);
1213 /* Helper for PyObject_Dir without arguments: returns the local scope. */
1218 PyObject
*locals
= PyEval_GetLocals();
1220 if (locals
== NULL
) {
1221 PyErr_SetString(PyExc_SystemError
, "frame does not exist");
1225 names
= PyMapping_Keys(locals
);
1228 if (!PyList_Check(names
)) {
1229 PyErr_Format(PyExc_TypeError
,
1230 "dir(): expected keys() of locals to be a list, "
1231 "not '%.200s'", Py_TYPE(names
)->tp_name
);
1235 /* the locals don't need to be DECREF'd */
1239 /* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__.
1240 We deliberately don't suck up its __class__, as methods belonging to the
1241 metaclass would probably be more confusing than helpful.
1244 _specialized_dir_type(PyObject
*obj
)
1246 PyObject
*result
= NULL
;
1247 PyObject
*dict
= PyDict_New();
1249 if (dict
!= NULL
&& merge_class_dict(dict
, obj
) == 0)
1250 result
= PyDict_Keys(dict
);
1256 /* Helper for PyObject_Dir of module objects: returns the module's __dict__. */
1258 _specialized_dir_module(PyObject
*obj
)
1260 PyObject
*result
= NULL
;
1261 PyObject
*dict
= PyObject_GetAttrString(obj
, "__dict__");
1264 if (PyDict_Check(dict
))
1265 result
= PyDict_Keys(dict
);
1267 const char *name
= PyModule_GetName(obj
);
1269 PyErr_Format(PyExc_TypeError
,
1270 "%.200s.__dict__ is not a dictionary",
1279 /* Helper for PyObject_Dir of generic objects: returns __dict__, __class__,
1280 and recursively up the __class__.__bases__ chain.
1283 _generic_dir(PyObject
*obj
)
1285 PyObject
*result
= NULL
;
1286 PyObject
*dict
= NULL
;
1287 PyObject
*itsclass
= NULL
;
1289 /* Get __dict__ (which may or may not be a real dict...) */
1290 dict
= PyObject_GetAttrString(obj
, "__dict__");
1293 dict
= PyDict_New();
1295 else if (!PyDict_Check(dict
)) {
1297 dict
= PyDict_New();
1300 /* Copy __dict__ to avoid mutating it. */
1301 PyObject
*temp
= PyDict_Copy(dict
);
1309 /* Merge in attrs reachable from its class. */
1310 itsclass
= PyObject_GetAttrString(obj
, "__class__");
1311 if (itsclass
== NULL
)
1312 /* XXX(tomer): Perhaps fall back to obj->ob_type if no
1313 __class__ exists? */
1316 if (merge_class_dict(dict
, itsclass
) != 0)
1320 result
= PyDict_Keys(dict
);
1323 Py_XDECREF(itsclass
);
1328 /* Helper for PyObject_Dir: object introspection.
1329 This calls one of the above specialized versions if no __dir__ method
1332 _dir_object(PyObject
*obj
)
1334 PyObject
* result
= NULL
;
1335 PyObject
* dirfunc
= PyObject_GetAttrString((PyObject
*)obj
->ob_type
,
1339 if (dirfunc
== NULL
) {
1340 /* use default implementation */
1342 if (PyModule_Check(obj
))
1343 result
= _specialized_dir_module(obj
);
1344 else if (PyType_Check(obj
))
1345 result
= _specialized_dir_type(obj
);
1347 result
= _generic_dir(obj
);
1351 result
= PyObject_CallFunctionObjArgs(dirfunc
, obj
, NULL
);
1356 /* result must be a list */
1357 /* XXX(gbrandl): could also check if all items are strings */
1358 if (!PyList_Check(result
)) {
1359 PyErr_Format(PyExc_TypeError
,
1360 "__dir__() must return a list, not %.200s",
1361 Py_TYPE(result
)->tp_name
);
1370 /* Implementation of dir() -- if obj is NULL, returns the names in the current
1371 (local) scope. Otherwise, performs introspection of the object: returns a
1372 sorted list of attribute names (supposedly) accessible from the object
1375 PyObject_Dir(PyObject
*obj
)
1380 /* no object -- introspect the locals */
1381 result
= _dir_locals();
1383 /* object -- introspect the object */
1384 result
= _dir_object(obj
);
1386 assert(result
== NULL
|| PyList_Check(result
));
1388 if (result
!= NULL
&& PyList_Sort(result
) != 0) {
1389 /* sorting the list failed */
1398 NoObject is usable as a non-NULL undefined value, used by the macro None.
1399 There is (and should be!) no way to create other objects of this type,
1400 so there is exactly one (which is indestructible, by the way).
1401 (XXX This type and the type of NotImplemented below should be unified.)
1406 none_repr(PyObject
*op
)
1408 return PyUnicode_FromString("None");
1413 none_dealloc(PyObject
* ignore
)
1415 /* This should never get called, but we also don't want to SEGV if
1416 * we accidentally decref None out of existence.
1418 Py_FatalError("deallocating None");
1422 static PyTypeObject PyNone_Type
= {
1423 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
1427 none_dealloc
, /*tp_dealloc*/ /*never called*/
1432 none_repr
, /*tp_repr*/
1434 0, /*tp_as_sequence*/
1435 0, /*tp_as_mapping*/
1439 PyObject _Py_NoneStruct
= {
1440 _PyObject_EXTRA_INIT
1444 /* NotImplemented is an object that can be used to signal that an
1445 operation is not implemented for the given type combination. */
1448 NotImplemented_repr(PyObject
*op
)
1450 return PyUnicode_FromString("NotImplemented");
1453 static PyTypeObject PyNotImplemented_Type
= {
1454 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
1455 "NotImplementedType",
1458 none_dealloc
, /*tp_dealloc*/ /*never called*/
1463 NotImplemented_repr
, /*tp_repr*/
1465 0, /*tp_as_sequence*/
1466 0, /*tp_as_mapping*/
1470 PyObject _Py_NotImplementedStruct
= {
1471 _PyObject_EXTRA_INIT
1472 1, &PyNotImplemented_Type
1476 _Py_ReadyTypes(void)
1478 if (PyType_Ready(&PyType_Type
) < 0)
1479 Py_FatalError("Can't initialize type type");
1481 if (PyType_Ready(&_PyWeakref_RefType
) < 0)
1482 Py_FatalError("Can't initialize weakref type");
1484 if (PyType_Ready(&_PyWeakref_CallableProxyType
) < 0)
1485 Py_FatalError("Can't initialize callable weakref proxy type");
1487 if (PyType_Ready(&_PyWeakref_ProxyType
) < 0)
1488 Py_FatalError("Can't initialize weakref proxy type");
1490 if (PyType_Ready(&PyBool_Type
) < 0)
1491 Py_FatalError("Can't initialize bool type");
1493 if (PyType_Ready(&PyByteArray_Type
) < 0)
1494 Py_FatalError("Can't initialize bytearray type");
1496 if (PyType_Ready(&PyBytes_Type
) < 0)
1497 Py_FatalError("Can't initialize 'str'");
1499 if (PyType_Ready(&PyList_Type
) < 0)
1500 Py_FatalError("Can't initialize list type");
1502 if (PyType_Ready(&PyNone_Type
) < 0)
1503 Py_FatalError("Can't initialize None type");
1505 if (PyType_Ready(Py_Ellipsis
->ob_type
) < 0)
1506 Py_FatalError("Can't initialize type(Ellipsis)");
1508 if (PyType_Ready(&PyNotImplemented_Type
) < 0)
1509 Py_FatalError("Can't initialize NotImplemented type");
1511 if (PyType_Ready(&PyTraceBack_Type
) < 0)
1512 Py_FatalError("Can't initialize traceback type");
1514 if (PyType_Ready(&PySuper_Type
) < 0)
1515 Py_FatalError("Can't initialize super type");
1517 if (PyType_Ready(&PyBaseObject_Type
) < 0)
1518 Py_FatalError("Can't initialize object type");
1520 if (PyType_Ready(&PyRange_Type
) < 0)
1521 Py_FatalError("Can't initialize range type");
1523 if (PyType_Ready(&PyDict_Type
) < 0)
1524 Py_FatalError("Can't initialize dict type");
1526 if (PyType_Ready(&PySet_Type
) < 0)
1527 Py_FatalError("Can't initialize set type");
1529 if (PyType_Ready(&PyUnicode_Type
) < 0)
1530 Py_FatalError("Can't initialize str type");
1532 if (PyType_Ready(&PySlice_Type
) < 0)
1533 Py_FatalError("Can't initialize slice type");
1535 if (PyType_Ready(&PyStaticMethod_Type
) < 0)
1536 Py_FatalError("Can't initialize static method type");
1538 #ifndef WITHOUT_COMPLEX
1539 if (PyType_Ready(&PyComplex_Type
) < 0)
1540 Py_FatalError("Can't initialize complex type");
1542 if (PyType_Ready(&PyFloat_Type
) < 0)
1543 Py_FatalError("Can't initialize float type");
1545 if (PyType_Ready(&PyLong_Type
) < 0)
1546 Py_FatalError("Can't initialize int type");
1548 if (PyType_Ready(&PyFrozenSet_Type
) < 0)
1549 Py_FatalError("Can't initialize frozenset type");
1551 if (PyType_Ready(&PyProperty_Type
) < 0)
1552 Py_FatalError("Can't initialize property type");
1554 if (PyType_Ready(&PyMemoryView_Type
) < 0)
1555 Py_FatalError("Can't initialize memoryview type");
1557 if (PyType_Ready(&PyTuple_Type
) < 0)
1558 Py_FatalError("Can't initialize tuple type");
1560 if (PyType_Ready(&PyEnum_Type
) < 0)
1561 Py_FatalError("Can't initialize enumerate type");
1563 if (PyType_Ready(&PyReversed_Type
) < 0)
1564 Py_FatalError("Can't initialize reversed type");
1566 if (PyType_Ready(&PyStdPrinter_Type
) < 0)
1567 Py_FatalError("Can't initialize StdPrinter");
1569 if (PyType_Ready(&PyCode_Type
) < 0)
1570 Py_FatalError("Can't initialize code type");
1572 if (PyType_Ready(&PyFrame_Type
) < 0)
1573 Py_FatalError("Can't initialize frame type");
1575 if (PyType_Ready(&PyCFunction_Type
) < 0)
1576 Py_FatalError("Can't initialize builtin function type");
1578 if (PyType_Ready(&PyMethod_Type
) < 0)
1579 Py_FatalError("Can't initialize method type");
1581 if (PyType_Ready(&PyFunction_Type
) < 0)
1582 Py_FatalError("Can't initialize function type");
1584 if (PyType_Ready(&PyDictProxy_Type
) < 0)
1585 Py_FatalError("Can't initialize dict proxy type");
1587 if (PyType_Ready(&PyGen_Type
) < 0)
1588 Py_FatalError("Can't initialize generator type");
1590 if (PyType_Ready(&PyGetSetDescr_Type
) < 0)
1591 Py_FatalError("Can't initialize get-set descriptor type");
1593 if (PyType_Ready(&PyWrapperDescr_Type
) < 0)
1594 Py_FatalError("Can't initialize wrapper type");
1596 if (PyType_Ready(&PyEllipsis_Type
) < 0)
1597 Py_FatalError("Can't initialize ellipsis type");
1599 if (PyType_Ready(&PyMemberDescr_Type
) < 0)
1600 Py_FatalError("Can't initialize member descriptor type");
1602 if (PyType_Ready(&PyFilter_Type
) < 0)
1603 Py_FatalError("Can't initialize filter type");
1605 if (PyType_Ready(&PyMap_Type
) < 0)
1606 Py_FatalError("Can't initialize map type");
1608 if (PyType_Ready(&PyZip_Type
) < 0)
1609 Py_FatalError("Can't initialize zip type");
1613 #ifdef Py_TRACE_REFS
1616 _Py_NewReference(PyObject
*op
)
1620 _Py_AddToAllObjects(op
, 1);
1621 _Py_INC_TPALLOCS(op
);
1625 _Py_ForgetReference(register PyObject
*op
)
1627 #ifdef SLOW_UNREF_CHECK
1628 register PyObject
*p
;
1630 if (op
->ob_refcnt
< 0)
1631 Py_FatalError("UNREF negative refcnt");
1632 if (op
== &refchain
||
1633 op
->_ob_prev
->_ob_next
!= op
|| op
->_ob_next
->_ob_prev
!= op
) {
1634 fprintf(stderr
, "* ob\n");
1636 fprintf(stderr
, "* op->_ob_prev->_ob_next\n");
1637 _PyObject_Dump(op
->_ob_prev
->_ob_next
);
1638 fprintf(stderr
, "* op->_ob_next->_ob_prev\n");
1639 _PyObject_Dump(op
->_ob_next
->_ob_prev
);
1640 Py_FatalError("UNREF invalid object");
1642 #ifdef SLOW_UNREF_CHECK
1643 for (p
= refchain
._ob_next
; p
!= &refchain
; p
= p
->_ob_next
) {
1647 if (p
== &refchain
) /* Not found */
1648 Py_FatalError("UNREF unknown object");
1650 op
->_ob_next
->_ob_prev
= op
->_ob_prev
;
1651 op
->_ob_prev
->_ob_next
= op
->_ob_next
;
1652 op
->_ob_next
= op
->_ob_prev
= NULL
;
1653 _Py_INC_TPFREES(op
);
1657 _Py_Dealloc(PyObject
*op
)
1659 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
1660 _Py_ForgetReference(op
);
1664 /* Print all live objects. Because PyObject_Print is called, the
1665 * interpreter must be in a healthy state.
1668 _Py_PrintReferences(FILE *fp
)
1671 fprintf(fp
, "Remaining objects:\n");
1672 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
) {
1673 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] ", op
, op
->ob_refcnt
);
1674 if (PyObject_Print(op
, fp
, 0) != 0)
1680 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
1681 * doesn't make any calls to the Python C API, so is always safe to call.
1684 _Py_PrintReferenceAddresses(FILE *fp
)
1687 fprintf(fp
, "Remaining object addresses:\n");
1688 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
)
1689 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] %s\n", op
,
1690 op
->ob_refcnt
, Py_TYPE(op
)->tp_name
);
1694 _Py_GetObjects(PyObject
*self
, PyObject
*args
)
1700 if (!PyArg_ParseTuple(args
, "i|O", &n
, &t
))
1702 op
= refchain
._ob_next
;
1703 res
= PyList_New(0);
1706 for (i
= 0; (n
== 0 || i
< n
) && op
!= &refchain
; i
++) {
1707 while (op
== self
|| op
== args
|| op
== res
|| op
== t
||
1708 (t
!= NULL
&& Py_TYPE(op
) != (PyTypeObject
*) t
)) {
1710 if (op
== &refchain
)
1713 if (PyList_Append(res
, op
) < 0) {
1724 /* Hack to force loading of cobject.o */
1725 PyTypeObject
*_Py_cobject_hack
= &PyCObject_Type
;
1728 /* Hack to force loading of pycapsule.o */
1729 PyTypeObject
*_PyCapsule_hack
= &PyCapsule_Type
;
1732 /* Hack to force loading of abstract.o */
1733 Py_ssize_t (*_Py_abstract_hack
)(PyObject
*) = PyObject_Size
;
1736 /* Python's malloc wrappers (see pymem.h) */
1739 PyMem_Malloc(size_t nbytes
)
1741 return PyMem_MALLOC(nbytes
);
1745 PyMem_Realloc(void *p
, size_t nbytes
)
1747 return PyMem_REALLOC(p
, nbytes
);
1757 /* These methods are used to control infinite recursion in repr, str, print,
1758 etc. Container objects that may recursively contain themselves,
1759 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
1760 Py_ReprLeave() to avoid infinite recursion.
1762 Py_ReprEnter() returns 0 the first time it is called for a particular
1763 object and 1 every time thereafter. It returns -1 if an exception
1764 occurred. Py_ReprLeave() has no return value.
1766 See dictobject.c and listobject.c for examples of use.
1769 #define KEY "Py_Repr"
1772 Py_ReprEnter(PyObject
*obj
)
1778 dict
= PyThreadState_GetDict();
1781 list
= PyDict_GetItemString(dict
, KEY
);
1783 list
= PyList_New(0);
1786 if (PyDict_SetItemString(dict
, KEY
, list
) < 0)
1790 i
= PyList_GET_SIZE(list
);
1792 if (PyList_GET_ITEM(list
, i
) == obj
)
1795 PyList_Append(list
, obj
);
1800 Py_ReprLeave(PyObject
*obj
)
1806 dict
= PyThreadState_GetDict();
1809 list
= PyDict_GetItemString(dict
, KEY
);
1810 if (list
== NULL
|| !PyList_Check(list
))
1812 i
= PyList_GET_SIZE(list
);
1813 /* Count backwards because we always expect obj to be list[-1] */
1815 if (PyList_GET_ITEM(list
, i
) == obj
) {
1816 PyList_SetSlice(list
, i
, i
+ 1, NULL
);
1822 /* Trashcan support. */
1824 /* Current call-stack depth of tp_dealloc calls. */
1825 int _PyTrash_delete_nesting
= 0;
1827 /* List of objects that still need to be cleaned up, singly linked via their
1828 * gc headers' gc_prev pointers.
1830 PyObject
*_PyTrash_delete_later
= NULL
;
1832 /* Add op to the _PyTrash_delete_later list. Called when the current
1833 * call-stack depth gets large. op must be a currently untracked gc'ed
1834 * object, with refcount 0. Py_DECREF must already have been called on it.
1837 _PyTrash_deposit_object(PyObject
*op
)
1839 assert(PyObject_IS_GC(op
));
1840 assert(_Py_AS_GC(op
)->gc
.gc_refs
== _PyGC_REFS_UNTRACKED
);
1841 assert(op
->ob_refcnt
== 0);
1842 _Py_AS_GC(op
)->gc
.gc_prev
= (PyGC_Head
*)_PyTrash_delete_later
;
1843 _PyTrash_delete_later
= op
;
1846 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
1847 * the call-stack unwinds again.
1850 _PyTrash_destroy_chain(void)
1852 while (_PyTrash_delete_later
) {
1853 PyObject
*op
= _PyTrash_delete_later
;
1854 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
1856 _PyTrash_delete_later
=
1857 (PyObject
*) _Py_AS_GC(op
)->gc
.gc_prev
;
1859 /* Call the deallocator directly. This used to try to
1860 * fool Py_DECREF into calling it indirectly, but
1861 * Py_DECREF was already called on this object, and in
1862 * assorted non-release builds calling Py_DECREF again ends
1863 * up distorting allocation statistics.
1865 assert(op
->ob_refcnt
== 0);
1866 ++_PyTrash_delete_nesting
;
1868 --_PyTrash_delete_nesting
;