2 /* Generic object operations; and implementation of None (NoObject) */
11 Py_ssize_t _Py_RefTotal
;
17 Py_ssize_t total
= _Py_RefTotal
;
18 /* ignore the references to the dummy object of the dicts and sets
19 because they are not reliable and not useful (now that the
20 hash table code is well-tested) */
23 total
-= o
->ob_refcnt
;
26 total
-= o
->ob_refcnt
;
29 #endif /* Py_REF_DEBUG */
31 int Py_DivisionWarningFlag
;
33 /* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
34 These are used by the individual routines for object creation.
35 Do not call them otherwise, they do not initialize the object! */
38 /* Head of circular doubly-linked list of all objects. These are linked
39 * together via the _ob_prev and _ob_next members of a PyObject, which
40 * exist only in a Py_TRACE_REFS build.
42 static PyObject refchain
= {&refchain
, &refchain
};
44 /* Insert op at the front of the list of all objects. If force is true,
45 * op is added even if _ob_prev and _ob_next are non-NULL already. If
46 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.
47 * force should be true if and only if op points to freshly allocated,
48 * uninitialized memory, or you've unlinked op from the list and are
49 * relinking it into the front.
50 * Note that objects are normally added to the list via _Py_NewReference,
51 * which is called by PyObject_Init. Not all objects are initialized that
52 * way, though; exceptions include statically allocated type objects, and
53 * statically allocated singletons (like Py_True and Py_None).
56 _Py_AddToAllObjects(PyObject
*op
, int force
)
60 /* If it's initialized memory, op must be in or out of
61 * the list unambiguously.
63 assert((op
->_ob_prev
== NULL
) == (op
->_ob_next
== NULL
));
66 if (force
|| op
->_ob_prev
== NULL
) {
67 op
->_ob_next
= refchain
._ob_next
;
68 op
->_ob_prev
= &refchain
;
69 refchain
._ob_next
->_ob_prev
= op
;
70 refchain
._ob_next
= op
;
73 #endif /* Py_TRACE_REFS */
76 static PyTypeObject
*type_list
;
77 /* All types are added to type_list, at least when
78 they get one object created. That makes them
79 immortal, which unfortunately contributes to
80 garbage itself. If unlist_types_without_objects
81 is set, they will be removed from the type_list
82 once the last object is deallocated. */
83 int unlist_types_without_objects
;
84 extern int tuple_zero_allocs
, fast_tuple_allocs
;
85 extern int quick_int_allocs
, quick_neg_int_allocs
;
86 extern int null_strings
, one_strings
;
92 for (tp
= type_list
; tp
; tp
= tp
->tp_next
)
93 fprintf(f
, "%s alloc'd: %d, freed: %d, max in use: %d\n",
94 tp
->tp_name
, tp
->tp_allocs
, tp
->tp_frees
,
96 fprintf(f
, "fast tuple allocs: %d, empty: %d\n",
97 fast_tuple_allocs
, tuple_zero_allocs
);
98 fprintf(f
, "fast int allocs: pos: %d, neg: %d\n",
99 quick_int_allocs
, quick_neg_int_allocs
);
100 fprintf(f
, "null strings: %d, 1-strings: %d\n",
101 null_strings
, one_strings
);
111 result
= PyList_New(0);
114 for (tp
= type_list
; tp
; tp
= tp
->tp_next
) {
115 v
= Py_BuildValue("(snnn)", tp
->tp_name
, tp
->tp_allocs
,
116 tp
->tp_frees
, tp
->tp_maxalloc
);
121 if (PyList_Append(result
, v
) < 0) {
132 inc_count(PyTypeObject
*tp
)
134 if (tp
->tp_next
== NULL
&& tp
->tp_prev
== NULL
) {
135 /* first time; insert in linked list */
136 if (tp
->tp_next
!= NULL
) /* sanity check */
137 Py_FatalError("XXX inc_count sanity check");
139 type_list
->tp_prev
= tp
;
140 tp
->tp_next
= type_list
;
141 /* Note that as of Python 2.2, heap-allocated type objects
142 * can go away, but this code requires that they stay alive
143 * until program exit. That's why we're careful with
144 * refcounts here. type_list gets a new reference to tp,
145 * while ownership of the reference type_list used to hold
146 * (if any) was transferred to tp->tp_next in the line above.
147 * tp is thus effectively immortal after this.
152 /* Also insert in the doubly-linked list of all objects,
153 * if not already there.
155 _Py_AddToAllObjects((PyObject
*)tp
, 0);
159 if (tp
->tp_allocs
- tp
->tp_frees
> tp
->tp_maxalloc
)
160 tp
->tp_maxalloc
= tp
->tp_allocs
- tp
->tp_frees
;
163 void dec_count(PyTypeObject
*tp
)
166 if (unlist_types_without_objects
&&
167 tp
->tp_allocs
== tp
->tp_frees
) {
168 /* unlink the type from type_list */
170 tp
->tp_prev
->tp_next
= tp
->tp_next
;
172 type_list
= tp
->tp_next
;
174 tp
->tp_next
->tp_prev
= tp
->tp_prev
;
175 tp
->tp_next
= tp
->tp_prev
= NULL
;
183 /* Log a fatal error; doesn't return. */
185 _Py_NegativeRefcount(const char *fname
, int lineno
, PyObject
*op
)
189 PyOS_snprintf(buf
, sizeof(buf
),
190 "%s:%i object at %p has negative ref count "
191 "%" PY_FORMAT_SIZE_T
"d",
192 fname
, lineno
, op
, op
->ob_refcnt
);
196 #endif /* Py_REF_DEBUG */
199 Py_IncRef(PyObject
*o
)
205 Py_DecRef(PyObject
*o
)
211 PyObject_Init(PyObject
*op
, PyTypeObject
*tp
)
214 return PyErr_NoMemory();
215 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
217 _Py_NewReference(op
);
222 PyObject_InitVar(PyVarObject
*op
, PyTypeObject
*tp
, Py_ssize_t size
)
225 return (PyVarObject
*) PyErr_NoMemory();
226 /* Any changes should be reflected in PyObject_INIT_VAR */
229 _Py_NewReference((PyObject
*)op
);
234 _PyObject_New(PyTypeObject
*tp
)
237 op
= (PyObject
*) PyObject_MALLOC(_PyObject_SIZE(tp
));
239 return PyErr_NoMemory();
240 return PyObject_INIT(op
, tp
);
244 _PyObject_NewVar(PyTypeObject
*tp
, Py_ssize_t nitems
)
247 const size_t size
= _PyObject_VAR_SIZE(tp
, nitems
);
248 op
= (PyVarObject
*) PyObject_MALLOC(size
);
250 return (PyVarObject
*)PyErr_NoMemory();
251 return PyObject_INIT_VAR(op
, tp
, nitems
);
254 /* for binary compatibility with 2.2 */
257 _PyObject_Del(PyObject
*op
)
262 /* Implementation of PyObject_Print with recursion checking */
264 internal_print(PyObject
*op
, FILE *fp
, int flags
, int nesting
)
268 PyErr_SetString(PyExc_RuntimeError
, "print recursion");
271 if (PyErr_CheckSignals())
273 #ifdef USE_STACKCHECK
274 if (PyOS_CheckStack()) {
275 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
279 clearerr(fp
); /* Clear any previous error condition */
281 fprintf(fp
, "<nil>");
284 if (op
->ob_refcnt
<= 0)
285 /* XXX(twouters) cast refcount to long until %zd is
286 universally available */
287 fprintf(fp
, "<refcnt %ld at %p>",
288 (long)op
->ob_refcnt
, op
);
289 else if (op
->ob_type
->tp_print
== NULL
) {
291 if (flags
& Py_PRINT_RAW
)
292 s
= PyObject_Str(op
);
294 s
= PyObject_Repr(op
);
298 ret
= internal_print(s
, fp
, Py_PRINT_RAW
,
304 ret
= (*op
->ob_type
->tp_print
)(op
, fp
, flags
);
308 PyErr_SetFromErrno(PyExc_IOError
);
317 PyObject_Print(PyObject
*op
, FILE *fp
, int flags
)
319 return internal_print(op
, fp
, flags
, 0);
323 /* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
324 void _PyObject_Dump(PyObject
* op
)
327 fprintf(stderr
, "NULL\n");
329 fprintf(stderr
, "object : ");
330 (void)PyObject_Print(op
, stderr
, 0);
331 /* XXX(twouters) cast refcount to long until %zd is
332 universally available */
337 op
->ob_type
==NULL
? "NULL" : op
->ob_type
->tp_name
,
344 PyObject_Repr(PyObject
*v
)
346 if (PyErr_CheckSignals())
348 #ifdef USE_STACKCHECK
349 if (PyOS_CheckStack()) {
350 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
355 return PyString_FromString("<NULL>");
356 else if (v
->ob_type
->tp_repr
== NULL
)
357 return PyString_FromFormat("<%s object at %p>",
358 v
->ob_type
->tp_name
, v
);
361 res
= (*v
->ob_type
->tp_repr
)(v
);
364 #ifdef Py_USING_UNICODE
365 if (PyUnicode_Check(res
)) {
367 str
= PyUnicode_AsEncodedString(res
, NULL
, NULL
);
375 if (!PyString_Check(res
)) {
376 PyErr_Format(PyExc_TypeError
,
377 "__repr__ returned non-string (type %.200s)",
378 res
->ob_type
->tp_name
);
387 _PyObject_Str(PyObject
*v
)
392 return PyString_FromString("<NULL>");
393 if (PyString_CheckExact(v
)) {
397 #ifdef Py_USING_UNICODE
398 if (PyUnicode_CheckExact(v
)) {
403 if (v
->ob_type
->tp_str
== NULL
)
404 return PyObject_Repr(v
);
406 res
= (*v
->ob_type
->tp_str
)(v
);
409 type_ok
= PyString_Check(res
);
410 #ifdef Py_USING_UNICODE
411 type_ok
= type_ok
|| PyUnicode_Check(res
);
414 PyErr_Format(PyExc_TypeError
,
415 "__str__ returned non-string (type %.200s)",
416 res
->ob_type
->tp_name
);
424 PyObject_Str(PyObject
*v
)
426 PyObject
*res
= _PyObject_Str(v
);
429 #ifdef Py_USING_UNICODE
430 if (PyUnicode_Check(res
)) {
432 str
= PyUnicode_AsEncodedString(res
, NULL
, NULL
);
440 assert(PyString_Check(res
));
444 #ifdef Py_USING_UNICODE
446 PyObject_Unicode(PyObject
*v
)
451 static PyObject
*unicodestr
;
454 res
= PyString_FromString("<NULL>");
457 str
= PyUnicode_FromEncodedObject(res
, NULL
, "strict");
460 } else if (PyUnicode_CheckExact(v
)) {
464 /* XXX As soon as we have a tp_unicode slot, we should
465 check this before trying the __unicode__
467 if (unicodestr
== NULL
) {
468 unicodestr
= PyString_InternFromString("__unicode__");
469 if (unicodestr
== NULL
)
472 func
= PyObject_GetAttr(v
, unicodestr
);
474 res
= PyEval_CallObject(func
, (PyObject
*)NULL
);
479 if (PyUnicode_Check(v
)) {
480 /* For a Unicode subtype that's didn't overwrite __unicode__,
481 return a true Unicode object with the same data. */
482 return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v
),
483 PyUnicode_GET_SIZE(v
));
485 if (PyString_CheckExact(v
)) {
490 if (v
->ob_type
->tp_str
!= NULL
)
491 res
= (*v
->ob_type
->tp_str
)(v
);
493 res
= PyObject_Repr(v
);
498 if (!PyUnicode_Check(res
)) {
499 str
= PyUnicode_FromEncodedObject(res
, NULL
, "strict");
508 /* Helper to warn about deprecated tp_compare return values. Return:
513 (This function cannot return 2.)
516 adjust_tp_compare(int c
)
518 if (PyErr_Occurred()) {
519 if (c
!= -1 && c
!= -2) {
520 PyObject
*t
, *v
, *tb
;
521 PyErr_Fetch(&t
, &v
, &tb
);
522 if (PyErr_Warn(PyExc_RuntimeWarning
,
523 "tp_compare didn't return -1 or -2 "
524 "for exception") < 0) {
530 PyErr_Restore(t
, v
, tb
);
534 else if (c
< -1 || c
> 1) {
535 if (PyErr_Warn(PyExc_RuntimeWarning
,
536 "tp_compare didn't return -1, 0 or 1") < 0)
539 return c
< -1 ? -1 : 1;
542 assert(c
>= -1 && c
<= 1);
548 /* Macro to get the tp_richcompare field of a type if defined */
549 #define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) \
550 ? (t)->tp_richcompare : NULL)
552 /* Map rich comparison operators to their swapped version, e.g. LT --> GT */
553 int _Py_SwappedOp
[] = {Py_GT
, Py_GE
, Py_EQ
, Py_NE
, Py_LT
, Py_LE
};
555 /* Try a genuine rich comparison, returning an object. Return:
557 NotImplemented if this particular rich comparison is not implemented or
559 some object not equal to NotImplemented if it is implemented
560 (this latter object may not be a Boolean).
563 try_rich_compare(PyObject
*v
, PyObject
*w
, int op
)
568 if (v
->ob_type
!= w
->ob_type
&&
569 PyType_IsSubtype(w
->ob_type
, v
->ob_type
) &&
570 (f
= RICHCOMPARE(w
->ob_type
)) != NULL
) {
571 res
= (*f
)(w
, v
, _Py_SwappedOp
[op
]);
572 if (res
!= Py_NotImplemented
)
576 if ((f
= RICHCOMPARE(v
->ob_type
)) != NULL
) {
577 res
= (*f
)(v
, w
, op
);
578 if (res
!= Py_NotImplemented
)
582 if ((f
= RICHCOMPARE(w
->ob_type
)) != NULL
) {
583 return (*f
)(w
, v
, _Py_SwappedOp
[op
]);
585 res
= Py_NotImplemented
;
590 /* Try a genuine rich comparison, returning an int. Return:
591 -1 for exception (including the case where try_rich_compare() returns an
592 object that's not a Boolean);
593 0 if the outcome is false;
594 1 if the outcome is true;
595 2 if this particular rich comparison is not implemented or undefined.
598 try_rich_compare_bool(PyObject
*v
, PyObject
*w
, int op
)
603 if (RICHCOMPARE(v
->ob_type
) == NULL
&& RICHCOMPARE(w
->ob_type
) == NULL
)
604 return 2; /* Shortcut, avoid INCREF+DECREF */
605 res
= try_rich_compare(v
, w
, op
);
608 if (res
== Py_NotImplemented
) {
612 ok
= PyObject_IsTrue(res
);
617 /* Try rich comparisons to determine a 3-way comparison. Return:
622 2 if this particular rich comparison is not implemented or undefined.
625 try_rich_to_3way_compare(PyObject
*v
, PyObject
*w
)
627 static struct { int op
; int outcome
; } tries
[3] = {
628 /* Try this operator, and if it is true, use this outcome: */
635 if (RICHCOMPARE(v
->ob_type
) == NULL
&& RICHCOMPARE(w
->ob_type
) == NULL
)
636 return 2; /* Shortcut */
638 for (i
= 0; i
< 3; i
++) {
639 switch (try_rich_compare_bool(v
, w
, tries
[i
].op
)) {
643 return tries
[i
].outcome
;
650 /* Try a 3-way comparison, returning an int. Return:
655 2 if this particular 3-way comparison is not implemented or undefined.
658 try_3way_compare(PyObject
*v
, PyObject
*w
)
663 /* Comparisons involving instances are given to instance_compare,
664 which has the same return conventions as this function. */
666 f
= v
->ob_type
->tp_compare
;
667 if (PyInstance_Check(v
))
669 if (PyInstance_Check(w
))
670 return (*w
->ob_type
->tp_compare
)(v
, w
);
672 /* If both have the same (non-NULL) tp_compare, use it. */
673 if (f
!= NULL
&& f
== w
->ob_type
->tp_compare
) {
675 return adjust_tp_compare(c
);
678 /* If either tp_compare is _PyObject_SlotCompare, that's safe. */
679 if (f
== _PyObject_SlotCompare
||
680 w
->ob_type
->tp_compare
== _PyObject_SlotCompare
)
681 return _PyObject_SlotCompare(v
, w
);
683 /* If we're here, v and w,
684 a) are not instances;
685 b) have different types or a type without tp_compare; and
686 c) don't have a user-defined tp_compare.
687 tp_compare implementations in C assume that both arguments
688 have their type, so we give up if the coercion fails or if
689 it yields types which are still incompatible (which can
690 happen with a user-defined nb_coerce).
692 c
= PyNumber_CoerceEx(&v
, &w
);
697 f
= v
->ob_type
->tp_compare
;
698 if (f
!= NULL
&& f
== w
->ob_type
->tp_compare
) {
702 return adjust_tp_compare(c
);
705 /* No comparison defined */
711 /* Final fallback 3-way comparison, returning an int. Return:
712 -2 if an error occurred;
718 default_3way_compare(PyObject
*v
, PyObject
*w
)
721 const char *vname
, *wname
;
723 if (v
->ob_type
== w
->ob_type
) {
724 /* When comparing these pointers, they must be cast to
725 * integer types (i.e. Py_uintptr_t, our spelling of C9X's
726 * uintptr_t). ANSI specifies that pointer compares other
727 * than == and != to non-related structures are undefined.
729 Py_uintptr_t vv
= (Py_uintptr_t
)v
;
730 Py_uintptr_t ww
= (Py_uintptr_t
)w
;
731 return (vv
< ww
) ? -1 : (vv
> ww
) ? 1 : 0;
734 /* None is smaller than anything */
740 /* different type: compare type names; numbers are smaller */
741 if (PyNumber_Check(v
))
744 vname
= v
->ob_type
->tp_name
;
745 if (PyNumber_Check(w
))
748 wname
= w
->ob_type
->tp_name
;
749 c
= strcmp(vname
, wname
);
754 /* Same type name, or (more likely) incomparable numeric types */
755 return ((Py_uintptr_t
)(v
->ob_type
) < (
756 Py_uintptr_t
)(w
->ob_type
)) ? -1 : 1;
759 /* Do a 3-way comparison, by hook or by crook. Return:
760 -2 for an exception (but see below);
764 BUT: if the object implements a tp_compare function, it returns
765 whatever this function returns (whether with an exception or not).
768 do_cmp(PyObject
*v
, PyObject
*w
)
773 if (v
->ob_type
== w
->ob_type
774 && (f
= v
->ob_type
->tp_compare
) != NULL
) {
776 if (PyInstance_Check(v
)) {
777 /* Instance tp_compare has a different signature.
778 But if it returns undefined we fall through. */
781 /* Else fall through to try_rich_to_3way_compare() */
784 return adjust_tp_compare(c
);
786 /* We only get here if one of the following is true:
787 a) v and w have different types
788 b) v and w have the same type, which doesn't have tp_compare
789 c) v and w are instances, and either __cmp__ is not defined or
790 __cmp__ returns NotImplemented
792 c
= try_rich_to_3way_compare(v
, w
);
795 c
= try_3way_compare(v
, w
);
798 return default_3way_compare(v
, w
);
801 /* Compare v to w. Return
802 -1 if v < w or exception (PyErr_Occurred() true in latter case).
805 XXX The docs (C API manual) say the return value is undefined in case
809 PyObject_Compare(PyObject
*v
, PyObject
*w
)
813 if (v
== NULL
|| w
== NULL
) {
814 PyErr_BadInternalCall();
819 if (Py_EnterRecursiveCall(" in cmp"))
821 result
= do_cmp(v
, w
);
822 Py_LeaveRecursiveCall();
823 return result
< 0 ? -1 : result
;
826 /* Return (new reference to) Py_True or Py_False. */
828 convert_3way_to_object(int op
, int c
)
832 case Py_LT
: c
= c
< 0; break;
833 case Py_LE
: c
= c
<= 0; break;
834 case Py_EQ
: c
= c
== 0; break;
835 case Py_NE
: c
= c
!= 0; break;
836 case Py_GT
: c
= c
> 0; break;
837 case Py_GE
: c
= c
>= 0; break;
839 result
= c
? Py_True
: Py_False
;
844 /* We want a rich comparison but don't have one. Try a 3-way cmp instead.
848 Py_False if not (v op w)
851 try_3way_to_rich_compare(PyObject
*v
, PyObject
*w
, int op
)
855 c
= try_3way_compare(v
, w
);
857 c
= default_3way_compare(v
, w
);
860 return convert_3way_to_object(op
, c
);
863 /* Do rich comparison on v and w. Return
865 Else a new reference to an object other than Py_NotImplemented, usually(?):
867 Py_False if not (v op w)
870 do_richcmp(PyObject
*v
, PyObject
*w
, int op
)
874 res
= try_rich_compare(v
, w
, op
);
875 if (res
!= Py_NotImplemented
)
879 return try_3way_to_rich_compare(v
, w
, op
);
884 some object not equal to NotImplemented if it is implemented
885 (this latter object may not be a Boolean).
888 PyObject_RichCompare(PyObject
*v
, PyObject
*w
, int op
)
892 assert(Py_LT
<= op
&& op
<= Py_GE
);
893 if (Py_EnterRecursiveCall(" in cmp"))
896 /* If the types are equal, and not old-style instances, try to
897 get out cheap (don't bother with coercions etc.). */
898 if (v
->ob_type
== w
->ob_type
&& !PyInstance_Check(v
)) {
900 richcmpfunc frich
= RICHCOMPARE(v
->ob_type
);
901 /* If the type has richcmp, try it first. try_rich_compare
902 tries it two-sided, which is not needed since we've a
905 res
= (*frich
)(v
, w
, op
);
906 if (res
!= Py_NotImplemented
)
910 /* No richcmp, or this particular richmp not implemented.
912 fcmp
= v
->ob_type
->tp_compare
;
914 int c
= (*fcmp
)(v
, w
);
915 c
= adjust_tp_compare(c
);
920 res
= convert_3way_to_object(op
, c
);
925 /* Fast path not taken, or couldn't deliver a useful result. */
926 res
= do_richcmp(v
, w
, op
);
928 Py_LeaveRecursiveCall();
932 /* Return -1 if error; 1 if v op w; 0 if not (v op w). */
934 PyObject_RichCompareBool(PyObject
*v
, PyObject
*w
, int op
)
939 /* Quick result when objects are the same.
940 Guarantees that identity implies equality. */
944 else if (op
== Py_NE
)
948 res
= PyObject_RichCompare(v
, w
, op
);
951 if (PyBool_Check(res
))
952 ok
= (res
== Py_True
);
954 ok
= PyObject_IsTrue(res
);
959 /* Set of hash utility functions to help maintaining the invariant that
960 if a==b then hash(a)==hash(b)
962 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
966 _Py_HashDouble(double v
)
968 double intpart
, fractpart
;
971 long x
; /* the final hash value */
972 /* This is designed so that Python numbers of different types
973 * that compare equal hash to the same value; otherwise comparisons
974 * of mapping keys will turn out weird.
977 fractpart
= modf(v
, &intpart
);
978 if (fractpart
== 0.0) {
979 /* This must return the same hash as an equal int or long. */
980 if (intpart
> LONG_MAX
|| -intpart
> LONG_MAX
) {
981 /* Convert to long and use its hash. */
982 PyObject
*plong
; /* converted to Python long */
983 if (Py_IS_INFINITY(intpart
))
984 /* can't convert to long int -- arbitrary */
985 v
= v
< 0 ? -271828.0 : 314159.0;
986 plong
= PyLong_FromDouble(v
);
989 x
= PyObject_Hash(plong
);
993 /* Fits in a C long == a Python int, so is its own hash. */
999 /* The fractional part is non-zero, so we don't have to worry about
1000 * making this match the hash of some other type.
1001 * Use frexp to get at the bits in the double.
1002 * Since the VAX D double format has 56 mantissa bits, which is the
1003 * most of any double format in use, each of these parts may have as
1004 * many as (but no more than) 56 significant bits.
1005 * So, assuming sizeof(long) >= 4, each part can be broken into two
1006 * longs; frexp and multiplication are used to do that.
1007 * Also, since the Cray double format has 15 exponent bits, which is
1008 * the most of any double format in use, shifting the exponent field
1009 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4).
1011 v
= frexp(v
, &expo
);
1012 v
*= 2147483648.0; /* 2**31 */
1013 hipart
= (long)v
; /* take the top 32 bits */
1014 v
= (v
- (double)hipart
) * 2147483648.0; /* get the next 32 bits */
1015 x
= hipart
+ (long)v
+ (expo
<< 15);
1022 _Py_HashPointer(void *p
)
1024 #if SIZEOF_LONG >= SIZEOF_VOID_P
1027 /* convert to a Python long and hash that */
1031 if ((longobj
= PyLong_FromVoidPtr(p
)) == NULL
) {
1035 x
= PyObject_Hash(longobj
);
1038 Py_XDECREF(longobj
);
1045 PyObject_Hash(PyObject
*v
)
1047 PyTypeObject
*tp
= v
->ob_type
;
1048 if (tp
->tp_hash
!= NULL
)
1049 return (*tp
->tp_hash
)(v
);
1050 if (tp
->tp_compare
== NULL
&& RICHCOMPARE(tp
) == NULL
) {
1051 return _Py_HashPointer(v
); /* Use address as hash value */
1053 /* If there's a cmp but no hash defined, the object can't be hashed */
1054 PyErr_Format(PyExc_TypeError
, "unhashable type: '%.200s'",
1055 v
->ob_type
->tp_name
);
1060 PyObject_GetAttrString(PyObject
*v
, const char *name
)
1064 if (v
->ob_type
->tp_getattr
!= NULL
)
1065 return (*v
->ob_type
->tp_getattr
)(v
, (char*)name
);
1066 w
= PyString_InternFromString(name
);
1069 res
= PyObject_GetAttr(v
, w
);
1075 PyObject_HasAttrString(PyObject
*v
, const char *name
)
1077 PyObject
*res
= PyObject_GetAttrString(v
, name
);
1087 PyObject_SetAttrString(PyObject
*v
, const char *name
, PyObject
*w
)
1092 if (v
->ob_type
->tp_setattr
!= NULL
)
1093 return (*v
->ob_type
->tp_setattr
)(v
, (char*)name
, w
);
1094 s
= PyString_InternFromString(name
);
1097 res
= PyObject_SetAttr(v
, s
, w
);
1103 PyObject_GetAttr(PyObject
*v
, PyObject
*name
)
1105 PyTypeObject
*tp
= v
->ob_type
;
1107 if (!PyString_Check(name
)) {
1108 #ifdef Py_USING_UNICODE
1109 /* The Unicode to string conversion is done here because the
1110 existing tp_getattro slots expect a string object as name
1111 and we wouldn't want to break those. */
1112 if (PyUnicode_Check(name
)) {
1113 name
= _PyUnicode_AsDefaultEncodedString(name
, NULL
);
1120 PyErr_Format(PyExc_TypeError
,
1121 "attribute name must be string, not '%.200s'",
1122 name
->ob_type
->tp_name
);
1126 if (tp
->tp_getattro
!= NULL
)
1127 return (*tp
->tp_getattro
)(v
, name
);
1128 if (tp
->tp_getattr
!= NULL
)
1129 return (*tp
->tp_getattr
)(v
, PyString_AS_STRING(name
));
1130 PyErr_Format(PyExc_AttributeError
,
1131 "'%.50s' object has no attribute '%.400s'",
1132 tp
->tp_name
, PyString_AS_STRING(name
));
1137 PyObject_HasAttr(PyObject
*v
, PyObject
*name
)
1139 PyObject
*res
= PyObject_GetAttr(v
, name
);
1149 PyObject_SetAttr(PyObject
*v
, PyObject
*name
, PyObject
*value
)
1151 PyTypeObject
*tp
= v
->ob_type
;
1154 if (!PyString_Check(name
)){
1155 #ifdef Py_USING_UNICODE
1156 /* The Unicode to string conversion is done here because the
1157 existing tp_setattro slots expect a string object as name
1158 and we wouldn't want to break those. */
1159 if (PyUnicode_Check(name
)) {
1160 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1167 PyErr_Format(PyExc_TypeError
,
1168 "attribute name must be string, not '%.200s'",
1169 name
->ob_type
->tp_name
);
1176 PyString_InternInPlace(&name
);
1177 if (tp
->tp_setattro
!= NULL
) {
1178 err
= (*tp
->tp_setattro
)(v
, name
, value
);
1182 if (tp
->tp_setattr
!= NULL
) {
1183 err
= (*tp
->tp_setattr
)(v
, PyString_AS_STRING(name
), value
);
1188 if (tp
->tp_getattr
== NULL
&& tp
->tp_getattro
== NULL
)
1189 PyErr_Format(PyExc_TypeError
,
1190 "'%.100s' object has no attributes "
1193 value
==NULL
? "del" : "assign to",
1194 PyString_AS_STRING(name
));
1196 PyErr_Format(PyExc_TypeError
,
1197 "'%.100s' object has only read-only attributes "
1200 value
==NULL
? "del" : "assign to",
1201 PyString_AS_STRING(name
));
1205 /* Helper to get a pointer to an object's __dict__ slot, if any */
1208 _PyObject_GetDictPtr(PyObject
*obj
)
1210 Py_ssize_t dictoffset
;
1211 PyTypeObject
*tp
= obj
->ob_type
;
1213 if (!(tp
->tp_flags
& Py_TPFLAGS_HAVE_CLASS
))
1215 dictoffset
= tp
->tp_dictoffset
;
1216 if (dictoffset
== 0)
1218 if (dictoffset
< 0) {
1222 tsize
= ((PyVarObject
*)obj
)->ob_size
;
1225 size
= _PyObject_VAR_SIZE(tp
, tsize
);
1227 dictoffset
+= (long)size
;
1228 assert(dictoffset
> 0);
1229 assert(dictoffset
% SIZEOF_VOID_P
== 0);
1231 return (PyObject
**) ((char *)obj
+ dictoffset
);
1235 PyObject_SelfIter(PyObject
*obj
)
1241 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
1244 PyObject_GenericGetAttr(PyObject
*obj
, PyObject
*name
)
1246 PyTypeObject
*tp
= obj
->ob_type
;
1247 PyObject
*descr
= NULL
;
1248 PyObject
*res
= NULL
;
1250 Py_ssize_t dictoffset
;
1253 if (!PyString_Check(name
)){
1254 #ifdef Py_USING_UNICODE
1255 /* The Unicode to string conversion is done here because the
1256 existing tp_setattro slots expect a string object as name
1257 and we wouldn't want to break those. */
1258 if (PyUnicode_Check(name
)) {
1259 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1266 PyErr_Format(PyExc_TypeError
,
1267 "attribute name must be string, not '%.200s'",
1268 name
->ob_type
->tp_name
);
1275 if (tp
->tp_dict
== NULL
) {
1276 if (PyType_Ready(tp
) < 0)
1280 /* Inline _PyType_Lookup */
1283 PyObject
*mro
, *base
, *dict
;
1285 /* Look in tp_dict of types in MRO */
1287 assert(mro
!= NULL
);
1288 assert(PyTuple_Check(mro
));
1289 n
= PyTuple_GET_SIZE(mro
);
1290 for (i
= 0; i
< n
; i
++) {
1291 base
= PyTuple_GET_ITEM(mro
, i
);
1292 if (PyClass_Check(base
))
1293 dict
= ((PyClassObject
*)base
)->cl_dict
;
1295 assert(PyType_Check(base
));
1296 dict
= ((PyTypeObject
*)base
)->tp_dict
;
1298 assert(dict
&& PyDict_Check(dict
));
1299 descr
= PyDict_GetItem(dict
, name
);
1308 if (descr
!= NULL
&&
1309 PyType_HasFeature(descr
->ob_type
, Py_TPFLAGS_HAVE_CLASS
)) {
1310 f
= descr
->ob_type
->tp_descr_get
;
1311 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1312 res
= f(descr
, obj
, (PyObject
*)obj
->ob_type
);
1318 /* Inline _PyObject_GetDictPtr */
1319 dictoffset
= tp
->tp_dictoffset
;
1320 if (dictoffset
!= 0) {
1322 if (dictoffset
< 0) {
1326 tsize
= ((PyVarObject
*)obj
)->ob_size
;
1329 size
= _PyObject_VAR_SIZE(tp
, tsize
);
1331 dictoffset
+= (long)size
;
1332 assert(dictoffset
> 0);
1333 assert(dictoffset
% SIZEOF_VOID_P
== 0);
1335 dictptr
= (PyObject
**) ((char *)obj
+ dictoffset
);
1338 res
= PyDict_GetItem(dict
, name
);
1348 res
= f(descr
, obj
, (PyObject
*)obj
->ob_type
);
1353 if (descr
!= NULL
) {
1355 /* descr was already increfed above */
1359 PyErr_Format(PyExc_AttributeError
,
1360 "'%.50s' object has no attribute '%.400s'",
1361 tp
->tp_name
, PyString_AS_STRING(name
));
1368 PyObject_GenericSetAttr(PyObject
*obj
, PyObject
*name
, PyObject
*value
)
1370 PyTypeObject
*tp
= obj
->ob_type
;
1376 if (!PyString_Check(name
)){
1377 #ifdef Py_USING_UNICODE
1378 /* The Unicode to string conversion is done here because the
1379 existing tp_setattro slots expect a string object as name
1380 and we wouldn't want to break those. */
1381 if (PyUnicode_Check(name
)) {
1382 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1389 PyErr_Format(PyExc_TypeError
,
1390 "attribute name must be string, not '%.200s'",
1391 name
->ob_type
->tp_name
);
1398 if (tp
->tp_dict
== NULL
) {
1399 if (PyType_Ready(tp
) < 0)
1403 descr
= _PyType_Lookup(tp
, name
);
1405 if (descr
!= NULL
&&
1406 PyType_HasFeature(descr
->ob_type
, Py_TPFLAGS_HAVE_CLASS
)) {
1407 f
= descr
->ob_type
->tp_descr_set
;
1408 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1409 res
= f(descr
, obj
, value
);
1414 dictptr
= _PyObject_GetDictPtr(obj
);
1415 if (dictptr
!= NULL
) {
1416 PyObject
*dict
= *dictptr
;
1417 if (dict
== NULL
&& value
!= NULL
) {
1418 dict
= PyDict_New();
1425 res
= PyDict_DelItem(dict
, name
);
1427 res
= PyDict_SetItem(dict
, name
, value
);
1428 if (res
< 0 && PyErr_ExceptionMatches(PyExc_KeyError
))
1429 PyErr_SetObject(PyExc_AttributeError
, name
);
1435 res
= f(descr
, obj
, value
);
1439 if (descr
== NULL
) {
1440 PyErr_Format(PyExc_AttributeError
,
1441 "'%.100s' object has no attribute '%.200s'",
1442 tp
->tp_name
, PyString_AS_STRING(name
));
1446 PyErr_Format(PyExc_AttributeError
,
1447 "'%.50s' object attribute '%.400s' is read-only",
1448 tp
->tp_name
, PyString_AS_STRING(name
));
1454 /* Test a value used as condition, e.g., in a for or if statement.
1455 Return -1 if an error occurred */
1458 PyObject_IsTrue(PyObject
*v
)
1467 else if (v
->ob_type
->tp_as_number
!= NULL
&&
1468 v
->ob_type
->tp_as_number
->nb_nonzero
!= NULL
)
1469 res
= (*v
->ob_type
->tp_as_number
->nb_nonzero
)(v
);
1470 else if (v
->ob_type
->tp_as_mapping
!= NULL
&&
1471 v
->ob_type
->tp_as_mapping
->mp_length
!= NULL
)
1472 res
= (*v
->ob_type
->tp_as_mapping
->mp_length
)(v
);
1473 else if (v
->ob_type
->tp_as_sequence
!= NULL
&&
1474 v
->ob_type
->tp_as_sequence
->sq_length
!= NULL
)
1475 res
= (*v
->ob_type
->tp_as_sequence
->sq_length
)(v
);
1478 /* if it is negative, it should be either -1 or -2 */
1479 return (res
> 0) ? 1 : Py_SAFE_DOWNCAST(res
, Py_ssize_t
, int);
1482 /* equivalent of 'not v'
1483 Return -1 if an error occurred */
1486 PyObject_Not(PyObject
*v
)
1489 res
= PyObject_IsTrue(v
);
1495 /* Coerce two numeric types to the "larger" one.
1496 Increment the reference count on each argument.
1498 -1 if an error occurred;
1499 0 if the coercion succeeded (and then the reference counts are increased);
1500 1 if no coercion is possible (and no error is raised).
1503 PyNumber_CoerceEx(PyObject
**pv
, PyObject
**pw
)
1505 register PyObject
*v
= *pv
;
1506 register PyObject
*w
= *pw
;
1509 /* Shortcut only for old-style types */
1510 if (v
->ob_type
== w
->ob_type
&&
1511 !PyType_HasFeature(v
->ob_type
, Py_TPFLAGS_CHECKTYPES
))
1517 if (v
->ob_type
->tp_as_number
&& v
->ob_type
->tp_as_number
->nb_coerce
) {
1518 res
= (*v
->ob_type
->tp_as_number
->nb_coerce
)(pv
, pw
);
1522 if (w
->ob_type
->tp_as_number
&& w
->ob_type
->tp_as_number
->nb_coerce
) {
1523 res
= (*w
->ob_type
->tp_as_number
->nb_coerce
)(pw
, pv
);
1530 /* Coerce two numeric types to the "larger" one.
1531 Increment the reference count on each argument.
1532 Return -1 and raise an exception if no coercion is possible
1533 (and then no reference count is incremented).
1536 PyNumber_Coerce(PyObject
**pv
, PyObject
**pw
)
1538 int err
= PyNumber_CoerceEx(pv
, pw
);
1541 PyErr_SetString(PyExc_TypeError
, "number coercion failed");
1546 /* Test whether an object can be called */
1549 PyCallable_Check(PyObject
*x
)
1553 if (PyInstance_Check(x
)) {
1554 PyObject
*call
= PyObject_GetAttrString(x
, "__call__");
1559 /* Could test recursively but don't, for fear of endless
1560 recursion if some joker sets self.__call__ = self */
1565 return x
->ob_type
->tp_call
!= NULL
;
1569 /* ------------------------- PyObject_Dir() helpers ------------------------- */
1571 /* Helper for PyObject_Dir.
1572 Merge the __dict__ of aclass into dict, and recursively also all
1573 the __dict__s of aclass's base classes. The order of merging isn't
1574 defined, as it's expected that only the final set of dict keys is
1576 Return 0 on success, -1 on error.
1580 merge_class_dict(PyObject
* dict
, PyObject
* aclass
)
1582 PyObject
*classdict
;
1585 assert(PyDict_Check(dict
));
1588 /* Merge in the type's dict (if any). */
1589 classdict
= PyObject_GetAttrString(aclass
, "__dict__");
1590 if (classdict
== NULL
)
1593 int status
= PyDict_Update(dict
, classdict
);
1594 Py_DECREF(classdict
);
1599 /* Recursively merge in the base types' (if any) dicts. */
1600 bases
= PyObject_GetAttrString(aclass
, "__bases__");
1604 /* We have no guarantee that bases is a real tuple */
1606 n
= PySequence_Size(bases
); /* This better be right */
1610 for (i
= 0; i
< n
; i
++) {
1612 PyObject
*base
= PySequence_GetItem(bases
, i
);
1617 status
= merge_class_dict(dict
, base
);
1630 /* Helper for PyObject_Dir.
1631 If obj has an attr named attrname that's a list, merge its string
1632 elements into keys of dict.
1633 Return 0 on success, -1 on error. Errors due to not finding the attr,
1634 or the attr not being a list, are suppressed.
1638 merge_list_attr(PyObject
* dict
, PyObject
* obj
, const char *attrname
)
1643 assert(PyDict_Check(dict
));
1647 list
= PyObject_GetAttrString(obj
, attrname
);
1651 else if (PyList_Check(list
)) {
1653 for (i
= 0; i
< PyList_GET_SIZE(list
); ++i
) {
1654 PyObject
*item
= PyList_GET_ITEM(list
, i
);
1655 if (PyString_Check(item
)) {
1656 result
= PyDict_SetItem(dict
, item
, Py_None
);
1667 /* Helper for PyObject_Dir without arguments: returns the local scope. */
1672 PyObject
*locals
= PyEval_GetLocals();
1674 if (locals
== NULL
) {
1675 PyErr_SetString(PyExc_SystemError
, "frame does not exist");
1679 names
= PyMapping_Keys(locals
);
1682 if (!PyList_Check(names
)) {
1683 PyErr_Format(PyExc_TypeError
,
1684 "dir(): expected keys() of locals to be a list, "
1685 "not '%.200s'", names
->ob_type
->tp_name
);
1689 /* the locals don't need to be DECREF'd */
1693 /* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__.
1694 We deliberately don't suck up its __class__, as methods belonging to the
1695 metaclass would probably be more confusing than helpful.
1698 _specialized_dir_type(PyObject
*obj
)
1700 PyObject
*result
= NULL
;
1701 PyObject
*dict
= PyDict_New();
1703 if (dict
!= NULL
&& merge_class_dict(dict
, obj
) == 0)
1704 result
= PyDict_Keys(dict
);
1710 /* Helper for PyObject_Dir of module objects: returns the module's __dict__. */
1712 _specialized_dir_module(PyObject
*obj
)
1714 PyObject
*result
= NULL
;
1715 PyObject
*dict
= PyObject_GetAttrString(obj
, "__dict__");
1718 if (PyDict_Check(dict
))
1719 result
= PyDict_Keys(dict
);
1721 PyErr_Format(PyExc_TypeError
,
1722 "%.200s.__dict__ is not a dictionary",
1723 PyModule_GetName(obj
));
1731 /* Helper for PyObject_Dir of generic objects: returns __dict__, __class__,
1732 and recursively up the __class__.__bases__ chain.
1735 _generic_dir(PyObject
*obj
)
1737 PyObject
*result
= NULL
;
1738 PyObject
*dict
= NULL
;
1739 PyObject
*itsclass
= NULL
;
1741 /* Get __dict__ (which may or may not be a real dict...) */
1742 dict
= PyObject_GetAttrString(obj
, "__dict__");
1745 dict
= PyDict_New();
1747 else if (!PyDict_Check(dict
)) {
1749 dict
= PyDict_New();
1752 /* Copy __dict__ to avoid mutating it. */
1753 PyObject
*temp
= PyDict_Copy(dict
);
1761 /* Merge in __members__ and __methods__ (if any).
1762 * This is removed in Python 3000. */
1763 if (merge_list_attr(dict
, obj
, "__members__") < 0)
1765 if (merge_list_attr(dict
, obj
, "__methods__") < 0)
1768 /* Merge in attrs reachable from its class. */
1769 itsclass
= PyObject_GetAttrString(obj
, "__class__");
1770 if (itsclass
== NULL
)
1771 /* XXX(tomer): Perhaps fall back to obj->ob_type if no
1772 __class__ exists? */
1775 if (merge_class_dict(dict
, itsclass
) != 0)
1779 result
= PyDict_Keys(dict
);
1782 Py_XDECREF(itsclass
);
1787 /* Helper for PyObject_Dir: object introspection.
1788 This calls one of the above specialized versions if no __dir__ method
1791 _dir_object(PyObject
*obj
)
1793 PyObject
*result
= NULL
;
1794 PyObject
*dirfunc
= PyObject_GetAttrString((PyObject
*)obj
->ob_type
,
1798 if (dirfunc
== NULL
) {
1799 /* use default implementation */
1801 if (PyModule_Check(obj
))
1802 result
= _specialized_dir_module(obj
);
1803 else if (PyType_Check(obj
) || PyClass_Check(obj
))
1804 result
= _specialized_dir_type(obj
);
1806 result
= _generic_dir(obj
);
1810 result
= PyObject_CallFunctionObjArgs(dirfunc
, obj
, NULL
);
1815 /* result must be a list */
1816 /* XXX(gbrandl): could also check if all items are strings */
1817 if (!PyList_Check(result
)) {
1818 PyErr_Format(PyExc_TypeError
,
1819 "__dir__() must return a list, not %.200s",
1820 result
->ob_type
->tp_name
);
1829 /* Implementation of dir() -- if obj is NULL, returns the names in the current
1830 (local) scope. Otherwise, performs introspection of the object: returns a
1831 sorted list of attribute names (supposedly) accessible from the object
1834 PyObject_Dir(PyObject
*obj
)
1839 /* no object -- introspect the locals */
1840 result
= _dir_locals();
1842 /* object -- introspect the object */
1843 result
= _dir_object(obj
);
1845 assert(result
== NULL
|| PyList_Check(result
));
1847 if (result
!= NULL
&& PyList_Sort(result
) != 0) {
1848 /* sorting the list failed */
1857 NoObject is usable as a non-NULL undefined value, used by the macro None.
1858 There is (and should be!) no way to create other objects of this type,
1859 so there is exactly one (which is indestructible, by the way).
1860 (XXX This type and the type of NotImplemented below should be unified.)
1865 none_repr(PyObject
*op
)
1867 return PyString_FromString("None");
1872 none_dealloc(PyObject
* ignore
)
1874 /* This should never get called, but we also don't want to SEGV if
1875 * we accidently decref None out of existance.
1877 Py_FatalError("deallocating None");
1881 static PyTypeObject PyNone_Type
= {
1882 PyObject_HEAD_INIT(&PyType_Type
)
1887 none_dealloc
, /*tp_dealloc*/ /*never called*/
1892 none_repr
, /*tp_repr*/
1894 0, /*tp_as_sequence*/
1895 0, /*tp_as_mapping*/
1899 PyObject _Py_NoneStruct
= {
1900 PyObject_HEAD_INIT(&PyNone_Type
)
1903 /* NotImplemented is an object that can be used to signal that an
1904 operation is not implemented for the given type combination. */
1907 NotImplemented_repr(PyObject
*op
)
1909 return PyString_FromString("NotImplemented");
1912 static PyTypeObject PyNotImplemented_Type
= {
1913 PyObject_HEAD_INIT(&PyType_Type
)
1915 "NotImplementedType",
1918 none_dealloc
, /*tp_dealloc*/ /*never called*/
1923 NotImplemented_repr
, /*tp_repr*/
1925 0, /*tp_as_sequence*/
1926 0, /*tp_as_mapping*/
1930 PyObject _Py_NotImplementedStruct
= {
1931 PyObject_HEAD_INIT(&PyNotImplemented_Type
)
1935 _Py_ReadyTypes(void)
1937 if (PyType_Ready(&PyType_Type
) < 0)
1938 Py_FatalError("Can't initialize 'type'");
1940 if (PyType_Ready(&_PyWeakref_RefType
) < 0)
1941 Py_FatalError("Can't initialize 'weakref'");
1943 if (PyType_Ready(&PyBool_Type
) < 0)
1944 Py_FatalError("Can't initialize 'bool'");
1946 if (PyType_Ready(&PyString_Type
) < 0)
1947 Py_FatalError("Can't initialize 'str'");
1949 if (PyType_Ready(&PyList_Type
) < 0)
1950 Py_FatalError("Can't initialize 'list'");
1952 if (PyType_Ready(&PyNone_Type
) < 0)
1953 Py_FatalError("Can't initialize type(None)");
1955 if (PyType_Ready(&PyNotImplemented_Type
) < 0)
1956 Py_FatalError("Can't initialize type(NotImplemented)");
1960 #ifdef Py_TRACE_REFS
1963 _Py_NewReference(PyObject
*op
)
1967 _Py_AddToAllObjects(op
, 1);
1968 _Py_INC_TPALLOCS(op
);
1972 _Py_ForgetReference(register PyObject
*op
)
1974 #ifdef SLOW_UNREF_CHECK
1975 register PyObject
*p
;
1977 if (op
->ob_refcnt
< 0)
1978 Py_FatalError("UNREF negative refcnt");
1979 if (op
== &refchain
||
1980 op
->_ob_prev
->_ob_next
!= op
|| op
->_ob_next
->_ob_prev
!= op
)
1981 Py_FatalError("UNREF invalid object");
1982 #ifdef SLOW_UNREF_CHECK
1983 for (p
= refchain
._ob_next
; p
!= &refchain
; p
= p
->_ob_next
) {
1987 if (p
== &refchain
) /* Not found */
1988 Py_FatalError("UNREF unknown object");
1990 op
->_ob_next
->_ob_prev
= op
->_ob_prev
;
1991 op
->_ob_prev
->_ob_next
= op
->_ob_next
;
1992 op
->_ob_next
= op
->_ob_prev
= NULL
;
1993 _Py_INC_TPFREES(op
);
1997 _Py_Dealloc(PyObject
*op
)
1999 destructor dealloc
= op
->ob_type
->tp_dealloc
;
2000 _Py_ForgetReference(op
);
2004 /* Print all live objects. Because PyObject_Print is called, the
2005 * interpreter must be in a healthy state.
2008 _Py_PrintReferences(FILE *fp
)
2011 fprintf(fp
, "Remaining objects:\n");
2012 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
) {
2013 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] ", op
, op
->ob_refcnt
);
2014 if (PyObject_Print(op
, fp
, 0) != 0)
2020 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
2021 * doesn't make any calls to the Python C API, so is always safe to call.
2024 _Py_PrintReferenceAddresses(FILE *fp
)
2027 fprintf(fp
, "Remaining object addresses:\n");
2028 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
)
2029 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] %s\n", op
,
2030 op
->ob_refcnt
, op
->ob_type
->tp_name
);
2034 _Py_GetObjects(PyObject
*self
, PyObject
*args
)
2040 if (!PyArg_ParseTuple(args
, "i|O", &n
, &t
))
2042 op
= refchain
._ob_next
;
2043 res
= PyList_New(0);
2046 for (i
= 0; (n
== 0 || i
< n
) && op
!= &refchain
; i
++) {
2047 while (op
== self
|| op
== args
|| op
== res
|| op
== t
||
2048 (t
!= NULL
&& op
->ob_type
!= (PyTypeObject
*) t
)) {
2050 if (op
== &refchain
)
2053 if (PyList_Append(res
, op
) < 0) {
2065 /* Hack to force loading of cobject.o */
2066 PyTypeObject
*_Py_cobject_hack
= &PyCObject_Type
;
2069 /* Hack to force loading of abstract.o */
2070 Py_ssize_t (*_Py_abstract_hack
)(PyObject
*) = PyObject_Size
;
2073 /* Python's malloc wrappers (see pymem.h) */
2076 PyMem_Malloc(size_t nbytes
)
2078 return PyMem_MALLOC(nbytes
);
2082 PyMem_Realloc(void *p
, size_t nbytes
)
2084 return PyMem_REALLOC(p
, nbytes
);
2094 /* These methods are used to control infinite recursion in repr, str, print,
2095 etc. Container objects that may recursively contain themselves,
2096 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
2097 Py_ReprLeave() to avoid infinite recursion.
2099 Py_ReprEnter() returns 0 the first time it is called for a particular
2100 object and 1 every time thereafter. It returns -1 if an exception
2101 occurred. Py_ReprLeave() has no return value.
2103 See dictobject.c and listobject.c for examples of use.
2106 #define KEY "Py_Repr"
2109 Py_ReprEnter(PyObject
*obj
)
2115 dict
= PyThreadState_GetDict();
2118 list
= PyDict_GetItemString(dict
, KEY
);
2120 list
= PyList_New(0);
2123 if (PyDict_SetItemString(dict
, KEY
, list
) < 0)
2127 i
= PyList_GET_SIZE(list
);
2129 if (PyList_GET_ITEM(list
, i
) == obj
)
2132 PyList_Append(list
, obj
);
2137 Py_ReprLeave(PyObject
*obj
)
2143 dict
= PyThreadState_GetDict();
2146 list
= PyDict_GetItemString(dict
, KEY
);
2147 if (list
== NULL
|| !PyList_Check(list
))
2149 i
= PyList_GET_SIZE(list
);
2150 /* Count backwards because we always expect obj to be list[-1] */
2152 if (PyList_GET_ITEM(list
, i
) == obj
) {
2153 PyList_SetSlice(list
, i
, i
+ 1, NULL
);
2159 /* Trashcan support. */
2161 /* Current call-stack depth of tp_dealloc calls. */
2162 int _PyTrash_delete_nesting
= 0;
2164 /* List of objects that still need to be cleaned up, singly linked via their
2165 * gc headers' gc_prev pointers.
2167 PyObject
*_PyTrash_delete_later
= NULL
;
2169 /* Add op to the _PyTrash_delete_later list. Called when the current
2170 * call-stack depth gets large. op must be a currently untracked gc'ed
2171 * object, with refcount 0. Py_DECREF must already have been called on it.
2174 _PyTrash_deposit_object(PyObject
*op
)
2176 assert(PyObject_IS_GC(op
));
2177 assert(_Py_AS_GC(op
)->gc
.gc_refs
== _PyGC_REFS_UNTRACKED
);
2178 assert(op
->ob_refcnt
== 0);
2179 _Py_AS_GC(op
)->gc
.gc_prev
= (PyGC_Head
*)_PyTrash_delete_later
;
2180 _PyTrash_delete_later
= op
;
2183 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
2184 * the call-stack unwinds again.
2187 _PyTrash_destroy_chain(void)
2189 while (_PyTrash_delete_later
) {
2190 PyObject
*op
= _PyTrash_delete_later
;
2191 destructor dealloc
= op
->ob_type
->tp_dealloc
;
2193 _PyTrash_delete_later
=
2194 (PyObject
*) _Py_AS_GC(op
)->gc
.gc_prev
;
2196 /* Call the deallocator directly. This used to try to
2197 * fool Py_DECREF into calling it indirectly, but
2198 * Py_DECREF was already called on this object, and in
2199 * assorted non-release builds calling Py_DECREF again ends
2200 * up distorting allocation statistics.
2202 assert(op
->ob_refcnt
== 0);
2203 ++_PyTrash_delete_nesting
;
2205 --_PyTrash_delete_nesting
;