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 /* Helper for PyObject_Dir.
1570 Merge the __dict__ of aclass into dict, and recursively also all
1571 the __dict__s of aclass's base classes. The order of merging isn't
1572 defined, as it's expected that only the final set of dict keys is
1574 Return 0 on success, -1 on error.
1578 merge_class_dict(PyObject
* dict
, PyObject
* aclass
)
1580 PyObject
*classdict
;
1583 assert(PyDict_Check(dict
));
1586 /* Merge in the type's dict (if any). */
1587 classdict
= PyObject_GetAttrString(aclass
, "__dict__");
1588 if (classdict
== NULL
)
1591 int status
= PyDict_Update(dict
, classdict
);
1592 Py_DECREF(classdict
);
1597 /* Recursively merge in the base types' (if any) dicts. */
1598 bases
= PyObject_GetAttrString(aclass
, "__bases__");
1602 /* We have no guarantee that bases is a real tuple */
1604 n
= PySequence_Size(bases
); /* This better be right */
1608 for (i
= 0; i
< n
; i
++) {
1610 PyObject
*base
= PySequence_GetItem(bases
, i
);
1615 status
= merge_class_dict(dict
, base
);
1628 /* Helper for PyObject_Dir.
1629 If obj has an attr named attrname that's a list, merge its string
1630 elements into keys of dict.
1631 Return 0 on success, -1 on error. Errors due to not finding the attr,
1632 or the attr not being a list, are suppressed.
1636 merge_list_attr(PyObject
* dict
, PyObject
* obj
, const char *attrname
)
1641 assert(PyDict_Check(dict
));
1645 list
= PyObject_GetAttrString(obj
, attrname
);
1649 else if (PyList_Check(list
)) {
1651 for (i
= 0; i
< PyList_GET_SIZE(list
); ++i
) {
1652 PyObject
*item
= PyList_GET_ITEM(list
, i
);
1653 if (PyString_Check(item
)) {
1654 result
= PyDict_SetItem(dict
, item
, Py_None
);
1665 /* Like __builtin__.dir(arg). See bltinmodule.c's builtin_dir for the
1666 docstring, which should be kept in synch with this implementation. */
1669 PyObject_Dir(PyObject
*arg
)
1671 /* Set exactly one of these non-NULL before the end. */
1672 PyObject
*result
= NULL
; /* result list */
1673 PyObject
*masterdict
= NULL
; /* result is masterdict.keys() */
1675 /* If NULL arg, return the locals. */
1677 PyObject
*locals
= PyEval_GetLocals();
1680 result
= PyMapping_Keys(locals
);
1685 /* Elif this is some form of module, we only want its dict. */
1686 else if (PyModule_Check(arg
)) {
1687 masterdict
= PyObject_GetAttrString(arg
, "__dict__");
1688 if (masterdict
== NULL
)
1690 if (!PyDict_Check(masterdict
)) {
1691 PyErr_SetString(PyExc_TypeError
,
1692 "module.__dict__ is not a dictionary");
1697 /* Elif some form of type or class, grab its dict and its bases.
1698 We deliberately don't suck up its __class__, as methods belonging
1699 to the metaclass would probably be more confusing than helpful. */
1700 else if (PyType_Check(arg
) || PyClass_Check(arg
)) {
1701 masterdict
= PyDict_New();
1702 if (masterdict
== NULL
)
1704 if (merge_class_dict(masterdict
, arg
) < 0)
1708 /* Else look at its dict, and the attrs reachable from its class. */
1711 /* Create a dict to start with. CAUTION: Not everything
1712 responding to __dict__ returns a dict! */
1713 masterdict
= PyObject_GetAttrString(arg
, "__dict__");
1714 if (masterdict
== NULL
) {
1716 masterdict
= PyDict_New();
1718 else if (!PyDict_Check(masterdict
)) {
1719 Py_DECREF(masterdict
);
1720 masterdict
= PyDict_New();
1723 /* The object may have returned a reference to its
1724 dict, so copy it to avoid mutating it. */
1725 PyObject
*temp
= PyDict_Copy(masterdict
);
1726 Py_DECREF(masterdict
);
1729 if (masterdict
== NULL
)
1732 /* Merge in __members__ and __methods__ (if any).
1733 XXX Would like this to go away someday; for now, it's
1734 XXX needed to get at im_self etc of method objects. */
1735 if (merge_list_attr(masterdict
, arg
, "__members__") < 0)
1737 if (merge_list_attr(masterdict
, arg
, "__methods__") < 0)
1740 /* Merge in attrs reachable from its class.
1741 CAUTION: Not all objects have a __class__ attr. */
1742 itsclass
= PyObject_GetAttrString(arg
, "__class__");
1743 if (itsclass
== NULL
)
1746 int status
= merge_class_dict(masterdict
, itsclass
);
1747 Py_DECREF(itsclass
);
1753 assert((result
== NULL
) ^ (masterdict
== NULL
));
1754 if (masterdict
!= NULL
) {
1755 /* The result comes from its keys. */
1756 assert(result
== NULL
);
1757 result
= PyDict_Keys(masterdict
);
1763 if (!PyList_Check(result
)) {
1764 PyErr_Format(PyExc_TypeError
,
1765 "Expected keys() to be a list, not '%.200s'",
1766 result
->ob_type
->tp_name
);
1769 if (PyList_Sort(result
) != 0)
1779 Py_XDECREF(masterdict
);
1784 NoObject is usable as a non-NULL undefined value, used by the macro None.
1785 There is (and should be!) no way to create other objects of this type,
1786 so there is exactly one (which is indestructible, by the way).
1787 (XXX This type and the type of NotImplemented below should be unified.)
1792 none_repr(PyObject
*op
)
1794 return PyString_FromString("None");
1799 none_dealloc(PyObject
* ignore
)
1801 /* This should never get called, but we also don't want to SEGV if
1802 * we accidently decref None out of existance.
1804 Py_FatalError("deallocating None");
1808 static PyTypeObject PyNone_Type
= {
1809 PyObject_HEAD_INIT(&PyType_Type
)
1814 none_dealloc
, /*tp_dealloc*/ /*never called*/
1819 none_repr
, /*tp_repr*/
1821 0, /*tp_as_sequence*/
1822 0, /*tp_as_mapping*/
1826 PyObject _Py_NoneStruct
= {
1827 PyObject_HEAD_INIT(&PyNone_Type
)
1830 /* NotImplemented is an object that can be used to signal that an
1831 operation is not implemented for the given type combination. */
1834 NotImplemented_repr(PyObject
*op
)
1836 return PyString_FromString("NotImplemented");
1839 static PyTypeObject PyNotImplemented_Type
= {
1840 PyObject_HEAD_INIT(&PyType_Type
)
1842 "NotImplementedType",
1845 none_dealloc
, /*tp_dealloc*/ /*never called*/
1850 NotImplemented_repr
, /*tp_repr*/
1852 0, /*tp_as_sequence*/
1853 0, /*tp_as_mapping*/
1857 PyObject _Py_NotImplementedStruct
= {
1858 PyObject_HEAD_INIT(&PyNotImplemented_Type
)
1862 _Py_ReadyTypes(void)
1864 if (PyType_Ready(&PyType_Type
) < 0)
1865 Py_FatalError("Can't initialize 'type'");
1867 if (PyType_Ready(&_PyWeakref_RefType
) < 0)
1868 Py_FatalError("Can't initialize 'weakref'");
1870 if (PyType_Ready(&PyBool_Type
) < 0)
1871 Py_FatalError("Can't initialize 'bool'");
1873 if (PyType_Ready(&PyString_Type
) < 0)
1874 Py_FatalError("Can't initialize 'str'");
1876 if (PyType_Ready(&PyList_Type
) < 0)
1877 Py_FatalError("Can't initialize 'list'");
1879 if (PyType_Ready(&PyNone_Type
) < 0)
1880 Py_FatalError("Can't initialize type(None)");
1882 if (PyType_Ready(&PyNotImplemented_Type
) < 0)
1883 Py_FatalError("Can't initialize type(NotImplemented)");
1887 #ifdef Py_TRACE_REFS
1890 _Py_NewReference(PyObject
*op
)
1894 _Py_AddToAllObjects(op
, 1);
1895 _Py_INC_TPALLOCS(op
);
1899 _Py_ForgetReference(register PyObject
*op
)
1901 #ifdef SLOW_UNREF_CHECK
1902 register PyObject
*p
;
1904 if (op
->ob_refcnt
< 0)
1905 Py_FatalError("UNREF negative refcnt");
1906 if (op
== &refchain
||
1907 op
->_ob_prev
->_ob_next
!= op
|| op
->_ob_next
->_ob_prev
!= op
)
1908 Py_FatalError("UNREF invalid object");
1909 #ifdef SLOW_UNREF_CHECK
1910 for (p
= refchain
._ob_next
; p
!= &refchain
; p
= p
->_ob_next
) {
1914 if (p
== &refchain
) /* Not found */
1915 Py_FatalError("UNREF unknown object");
1917 op
->_ob_next
->_ob_prev
= op
->_ob_prev
;
1918 op
->_ob_prev
->_ob_next
= op
->_ob_next
;
1919 op
->_ob_next
= op
->_ob_prev
= NULL
;
1920 _Py_INC_TPFREES(op
);
1924 _Py_Dealloc(PyObject
*op
)
1926 destructor dealloc
= op
->ob_type
->tp_dealloc
;
1927 _Py_ForgetReference(op
);
1931 /* Print all live objects. Because PyObject_Print is called, the
1932 * interpreter must be in a healthy state.
1935 _Py_PrintReferences(FILE *fp
)
1938 fprintf(fp
, "Remaining objects:\n");
1939 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
) {
1940 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] ", op
, op
->ob_refcnt
);
1941 if (PyObject_Print(op
, fp
, 0) != 0)
1947 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
1948 * doesn't make any calls to the Python C API, so is always safe to call.
1951 _Py_PrintReferenceAddresses(FILE *fp
)
1954 fprintf(fp
, "Remaining object addresses:\n");
1955 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
)
1956 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] %s\n", op
,
1957 op
->ob_refcnt
, op
->ob_type
->tp_name
);
1961 _Py_GetObjects(PyObject
*self
, PyObject
*args
)
1967 if (!PyArg_ParseTuple(args
, "i|O", &n
, &t
))
1969 op
= refchain
._ob_next
;
1970 res
= PyList_New(0);
1973 for (i
= 0; (n
== 0 || i
< n
) && op
!= &refchain
; i
++) {
1974 while (op
== self
|| op
== args
|| op
== res
|| op
== t
||
1975 (t
!= NULL
&& op
->ob_type
!= (PyTypeObject
*) t
)) {
1977 if (op
== &refchain
)
1980 if (PyList_Append(res
, op
) < 0) {
1992 /* Hack to force loading of cobject.o */
1993 PyTypeObject
*_Py_cobject_hack
= &PyCObject_Type
;
1996 /* Hack to force loading of abstract.o */
1997 Py_ssize_t (*_Py_abstract_hack
)(PyObject
*) = PyObject_Size
;
2000 /* Python's malloc wrappers (see pymem.h) */
2003 PyMem_Malloc(size_t nbytes
)
2005 return PyMem_MALLOC(nbytes
);
2009 PyMem_Realloc(void *p
, size_t nbytes
)
2011 return PyMem_REALLOC(p
, nbytes
);
2021 /* These methods are used to control infinite recursion in repr, str, print,
2022 etc. Container objects that may recursively contain themselves,
2023 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
2024 Py_ReprLeave() to avoid infinite recursion.
2026 Py_ReprEnter() returns 0 the first time it is called for a particular
2027 object and 1 every time thereafter. It returns -1 if an exception
2028 occurred. Py_ReprLeave() has no return value.
2030 See dictobject.c and listobject.c for examples of use.
2033 #define KEY "Py_Repr"
2036 Py_ReprEnter(PyObject
*obj
)
2042 dict
= PyThreadState_GetDict();
2045 list
= PyDict_GetItemString(dict
, KEY
);
2047 list
= PyList_New(0);
2050 if (PyDict_SetItemString(dict
, KEY
, list
) < 0)
2054 i
= PyList_GET_SIZE(list
);
2056 if (PyList_GET_ITEM(list
, i
) == obj
)
2059 PyList_Append(list
, obj
);
2064 Py_ReprLeave(PyObject
*obj
)
2070 dict
= PyThreadState_GetDict();
2073 list
= PyDict_GetItemString(dict
, KEY
);
2074 if (list
== NULL
|| !PyList_Check(list
))
2076 i
= PyList_GET_SIZE(list
);
2077 /* Count backwards because we always expect obj to be list[-1] */
2079 if (PyList_GET_ITEM(list
, i
) == obj
) {
2080 PyList_SetSlice(list
, i
, i
+ 1, NULL
);
2086 /* Trashcan support. */
2088 /* Current call-stack depth of tp_dealloc calls. */
2089 int _PyTrash_delete_nesting
= 0;
2091 /* List of objects that still need to be cleaned up, singly linked via their
2092 * gc headers' gc_prev pointers.
2094 PyObject
*_PyTrash_delete_later
= NULL
;
2096 /* Add op to the _PyTrash_delete_later list. Called when the current
2097 * call-stack depth gets large. op must be a currently untracked gc'ed
2098 * object, with refcount 0. Py_DECREF must already have been called on it.
2101 _PyTrash_deposit_object(PyObject
*op
)
2103 assert(PyObject_IS_GC(op
));
2104 assert(_Py_AS_GC(op
)->gc
.gc_refs
== _PyGC_REFS_UNTRACKED
);
2105 assert(op
->ob_refcnt
== 0);
2106 _Py_AS_GC(op
)->gc
.gc_prev
= (PyGC_Head
*)_PyTrash_delete_later
;
2107 _PyTrash_delete_later
= op
;
2110 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
2111 * the call-stack unwinds again.
2114 _PyTrash_destroy_chain(void)
2116 while (_PyTrash_delete_later
) {
2117 PyObject
*op
= _PyTrash_delete_later
;
2118 destructor dealloc
= op
->ob_type
->tp_dealloc
;
2120 _PyTrash_delete_later
=
2121 (PyObject
*) _Py_AS_GC(op
)->gc
.gc_prev
;
2123 /* Call the deallocator directly. This used to try to
2124 * fool Py_DECREF into calling it indirectly, but
2125 * Py_DECREF was already called on this object, and in
2126 * assorted non-release builds calling Py_DECREF again ends
2127 * up distorting allocation statistics.
2129 assert(op
->ob_refcnt
== 0);
2130 ++_PyTrash_delete_nesting
;
2132 --_PyTrash_delete_nesting
;