2 /* Generic object operations; and implementation of None (NoObject) */
5 #include "frameobject.h"
12 Py_ssize_t _Py_RefTotal
;
18 Py_ssize_t total
= _Py_RefTotal
;
19 /* ignore the references to the dummy object of the dicts and sets
20 because they are not reliable and not useful (now that the
21 hash table code is well-tested) */
24 total
-= o
->ob_refcnt
;
27 total
-= o
->ob_refcnt
;
30 #endif /* Py_REF_DEBUG */
32 int Py_DivisionWarningFlag
;
33 int Py_Py3kWarningFlag
;
35 /* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
36 These are used by the individual routines for object creation.
37 Do not call them otherwise, they do not initialize the object! */
40 /* Head of circular doubly-linked list of all objects. These are linked
41 * together via the _ob_prev and _ob_next members of a PyObject, which
42 * exist only in a Py_TRACE_REFS build.
44 static PyObject refchain
= {&refchain
, &refchain
};
46 /* Insert op at the front of the list of all objects. If force is true,
47 * op is added even if _ob_prev and _ob_next are non-NULL already. If
48 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.
49 * force should be true if and only if op points to freshly allocated,
50 * uninitialized memory, or you've unlinked op from the list and are
51 * relinking it into the front.
52 * Note that objects are normally added to the list via _Py_NewReference,
53 * which is called by PyObject_Init. Not all objects are initialized that
54 * way, though; exceptions include statically allocated type objects, and
55 * statically allocated singletons (like Py_True and Py_None).
58 _Py_AddToAllObjects(PyObject
*op
, int force
)
62 /* If it's initialized memory, op must be in or out of
63 * the list unambiguously.
65 assert((op
->_ob_prev
== NULL
) == (op
->_ob_next
== NULL
));
68 if (force
|| op
->_ob_prev
== NULL
) {
69 op
->_ob_next
= refchain
._ob_next
;
70 op
->_ob_prev
= &refchain
;
71 refchain
._ob_next
->_ob_prev
= op
;
72 refchain
._ob_next
= op
;
75 #endif /* Py_TRACE_REFS */
78 static PyTypeObject
*type_list
;
79 /* All types are added to type_list, at least when
80 they get one object created. That makes them
81 immortal, which unfortunately contributes to
82 garbage itself. If unlist_types_without_objects
83 is set, they will be removed from the type_list
84 once the last object is deallocated. */
85 static int unlist_types_without_objects
;
86 extern Py_ssize_t tuple_zero_allocs
, fast_tuple_allocs
;
87 extern Py_ssize_t quick_int_allocs
, quick_neg_int_allocs
;
88 extern Py_ssize_t null_strings
, one_strings
;
94 for (tp
= type_list
; tp
; tp
= tp
->tp_next
)
95 fprintf(f
, "%s alloc'd: %" PY_FORMAT_SIZE_T
"d, "
96 "freed: %" PY_FORMAT_SIZE_T
"d, "
97 "max in use: %" PY_FORMAT_SIZE_T
"d\n",
98 tp
->tp_name
, tp
->tp_allocs
, tp
->tp_frees
,
100 fprintf(f
, "fast tuple allocs: %" PY_FORMAT_SIZE_T
"d, "
101 "empty: %" PY_FORMAT_SIZE_T
"d\n",
102 fast_tuple_allocs
, tuple_zero_allocs
);
103 fprintf(f
, "fast int allocs: pos: %" PY_FORMAT_SIZE_T
"d, "
104 "neg: %" PY_FORMAT_SIZE_T
"d\n",
105 quick_int_allocs
, quick_neg_int_allocs
);
106 fprintf(f
, "null strings: %" PY_FORMAT_SIZE_T
"d, "
107 "1-strings: %" PY_FORMAT_SIZE_T
"d\n",
108 null_strings
, one_strings
);
118 result
= PyList_New(0);
121 for (tp
= type_list
; tp
; tp
= tp
->tp_next
) {
122 v
= Py_BuildValue("(snnn)", tp
->tp_name
, tp
->tp_allocs
,
123 tp
->tp_frees
, tp
->tp_maxalloc
);
128 if (PyList_Append(result
, v
) < 0) {
139 inc_count(PyTypeObject
*tp
)
141 if (tp
->tp_next
== NULL
&& tp
->tp_prev
== NULL
) {
142 /* first time; insert in linked list */
143 if (tp
->tp_next
!= NULL
) /* sanity check */
144 Py_FatalError("XXX inc_count sanity check");
146 type_list
->tp_prev
= tp
;
147 tp
->tp_next
= type_list
;
148 /* Note that as of Python 2.2, heap-allocated type objects
149 * can go away, but this code requires that they stay alive
150 * until program exit. That's why we're careful with
151 * refcounts here. type_list gets a new reference to tp,
152 * while ownership of the reference type_list used to hold
153 * (if any) was transferred to tp->tp_next in the line above.
154 * tp is thus effectively immortal after this.
159 /* Also insert in the doubly-linked list of all objects,
160 * if not already there.
162 _Py_AddToAllObjects((PyObject
*)tp
, 0);
166 if (tp
->tp_allocs
- tp
->tp_frees
> tp
->tp_maxalloc
)
167 tp
->tp_maxalloc
= tp
->tp_allocs
- tp
->tp_frees
;
170 void dec_count(PyTypeObject
*tp
)
173 if (unlist_types_without_objects
&&
174 tp
->tp_allocs
== tp
->tp_frees
) {
175 /* unlink the type from type_list */
177 tp
->tp_prev
->tp_next
= tp
->tp_next
;
179 type_list
= tp
->tp_next
;
181 tp
->tp_next
->tp_prev
= tp
->tp_prev
;
182 tp
->tp_next
= tp
->tp_prev
= NULL
;
190 /* Log a fatal error; doesn't return. */
192 _Py_NegativeRefcount(const char *fname
, int lineno
, PyObject
*op
)
196 PyOS_snprintf(buf
, sizeof(buf
),
197 "%s:%i object at %p has negative ref count "
198 "%" PY_FORMAT_SIZE_T
"d",
199 fname
, lineno
, op
, op
->ob_refcnt
);
203 #endif /* Py_REF_DEBUG */
206 Py_IncRef(PyObject
*o
)
212 Py_DecRef(PyObject
*o
)
218 PyObject_Init(PyObject
*op
, PyTypeObject
*tp
)
221 return PyErr_NoMemory();
222 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
224 _Py_NewReference(op
);
229 PyObject_InitVar(PyVarObject
*op
, PyTypeObject
*tp
, Py_ssize_t size
)
232 return (PyVarObject
*) PyErr_NoMemory();
233 /* Any changes should be reflected in PyObject_INIT_VAR */
236 _Py_NewReference((PyObject
*)op
);
241 _PyObject_New(PyTypeObject
*tp
)
244 op
= (PyObject
*) PyObject_MALLOC(_PyObject_SIZE(tp
));
246 return PyErr_NoMemory();
247 return PyObject_INIT(op
, tp
);
251 _PyObject_NewVar(PyTypeObject
*tp
, Py_ssize_t nitems
)
254 const size_t size
= _PyObject_VAR_SIZE(tp
, nitems
);
255 op
= (PyVarObject
*) PyObject_MALLOC(size
);
257 return (PyVarObject
*)PyErr_NoMemory();
258 return PyObject_INIT_VAR(op
, tp
, nitems
);
261 /* for binary compatibility with 2.2 */
264 _PyObject_Del(PyObject
*op
)
269 /* Implementation of PyObject_Print with recursion checking */
271 internal_print(PyObject
*op
, FILE *fp
, int flags
, int nesting
)
275 PyErr_SetString(PyExc_RuntimeError
, "print recursion");
278 if (PyErr_CheckSignals())
280 #ifdef USE_STACKCHECK
281 if (PyOS_CheckStack()) {
282 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
286 clearerr(fp
); /* Clear any previous error condition */
288 Py_BEGIN_ALLOW_THREADS
289 fprintf(fp
, "<nil>");
293 if (op
->ob_refcnt
<= 0)
294 /* XXX(twouters) cast refcount to long until %zd is
295 universally available */
296 Py_BEGIN_ALLOW_THREADS
297 fprintf(fp
, "<refcnt %ld at %p>",
298 (long)op
->ob_refcnt
, op
);
300 else if (Py_TYPE(op
)->tp_print
== NULL
) {
302 if (flags
& Py_PRINT_RAW
)
303 s
= PyObject_Str(op
);
305 s
= PyObject_Repr(op
);
309 ret
= internal_print(s
, fp
, Py_PRINT_RAW
,
315 ret
= (*Py_TYPE(op
)->tp_print
)(op
, fp
, flags
);
319 PyErr_SetFromErrno(PyExc_IOError
);
328 PyObject_Print(PyObject
*op
, FILE *fp
, int flags
)
330 return internal_print(op
, fp
, flags
, 0);
334 /* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
335 void _PyObject_Dump(PyObject
* op
)
338 fprintf(stderr
, "NULL\n");
341 PyGILState_STATE gil
;
343 fprintf(stderr
, "object : ");
345 gil
= PyGILState_Ensure();
347 (void)PyObject_Print(op
, stderr
, 0);
349 PyGILState_Release(gil
);
351 /* XXX(twouters) cast refcount to long until %zd is
352 universally available */
357 Py_TYPE(op
)==NULL
? "NULL" : Py_TYPE(op
)->tp_name
,
364 PyObject_Repr(PyObject
*v
)
366 if (PyErr_CheckSignals())
368 #ifdef USE_STACKCHECK
369 if (PyOS_CheckStack()) {
370 PyErr_SetString(PyExc_MemoryError
, "stack overflow");
375 return PyString_FromString("<NULL>");
376 else if (Py_TYPE(v
)->tp_repr
== NULL
)
377 return PyString_FromFormat("<%s object at %p>",
378 Py_TYPE(v
)->tp_name
, v
);
381 res
= (*Py_TYPE(v
)->tp_repr
)(v
);
384 #ifdef Py_USING_UNICODE
385 if (PyUnicode_Check(res
)) {
387 str
= PyUnicode_AsEncodedString(res
, NULL
, NULL
);
395 if (!PyString_Check(res
)) {
396 PyErr_Format(PyExc_TypeError
,
397 "__repr__ returned non-string (type %.200s)",
398 Py_TYPE(res
)->tp_name
);
407 _PyObject_Str(PyObject
*v
)
412 return PyString_FromString("<NULL>");
413 if (PyString_CheckExact(v
)) {
417 #ifdef Py_USING_UNICODE
418 if (PyUnicode_CheckExact(v
)) {
423 if (Py_TYPE(v
)->tp_str
== NULL
)
424 return PyObject_Repr(v
);
426 /* It is possible for a type to have a tp_str representation that loops
428 if (Py_EnterRecursiveCall(" while getting the str of an object"))
430 res
= (*Py_TYPE(v
)->tp_str
)(v
);
431 Py_LeaveRecursiveCall();
434 type_ok
= PyString_Check(res
);
435 #ifdef Py_USING_UNICODE
436 type_ok
= type_ok
|| PyUnicode_Check(res
);
439 PyErr_Format(PyExc_TypeError
,
440 "__str__ returned non-string (type %.200s)",
441 Py_TYPE(res
)->tp_name
);
449 PyObject_Str(PyObject
*v
)
451 PyObject
*res
= _PyObject_Str(v
);
454 #ifdef Py_USING_UNICODE
455 if (PyUnicode_Check(res
)) {
457 str
= PyUnicode_AsEncodedString(res
, NULL
, NULL
);
465 assert(PyString_Check(res
));
469 #ifdef Py_USING_UNICODE
471 PyObject_Unicode(PyObject
*v
)
476 int unicode_method_found
= 0;
477 static PyObject
*unicodestr
= NULL
;
480 res
= PyString_FromString("<NULL>");
483 str
= PyUnicode_FromEncodedObject(res
, NULL
, "strict");
486 } else if (PyUnicode_CheckExact(v
)) {
491 if (PyInstance_Check(v
)) {
492 /* We're an instance of a classic class */
493 /* Try __unicode__ from the instance -- alas we have no type */
495 unicodestr
= PyString_InternFromString("__unicode__");
499 func
= PyObject_GetAttr(v
, unicodestr
);
501 unicode_method_found
= 1;
502 res
= PyObject_CallFunctionObjArgs(func
, NULL
);
510 /* Not a classic class instance, try __unicode__. */
511 func
= _PyObject_LookupSpecial(v
, "__unicode__", &unicodestr
);
513 unicode_method_found
= 1;
514 res
= PyObject_CallFunctionObjArgs(func
, NULL
);
517 else if (PyErr_Occurred())
521 /* Didn't find __unicode__ */
522 if (!unicode_method_found
) {
523 if (PyUnicode_Check(v
)) {
524 /* For a Unicode subtype that's didn't overwrite __unicode__,
525 return a true Unicode object with the same data. */
526 return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v
),
527 PyUnicode_GET_SIZE(v
));
529 if (PyString_CheckExact(v
)) {
534 if (Py_TYPE(v
)->tp_str
!= NULL
)
535 res
= (*Py_TYPE(v
)->tp_str
)(v
);
537 res
= PyObject_Repr(v
);
543 if (!PyUnicode_Check(res
)) {
544 str
= PyUnicode_FromEncodedObject(res
, NULL
, "strict");
553 /* Helper to warn about deprecated tp_compare return values. Return:
558 (This function cannot return 2.)
561 adjust_tp_compare(int c
)
563 if (PyErr_Occurred()) {
564 if (c
!= -1 && c
!= -2) {
565 PyObject
*t
, *v
, *tb
;
566 PyErr_Fetch(&t
, &v
, &tb
);
567 if (PyErr_Warn(PyExc_RuntimeWarning
,
568 "tp_compare didn't return -1 or -2 "
569 "for exception") < 0) {
575 PyErr_Restore(t
, v
, tb
);
579 else if (c
< -1 || c
> 1) {
580 if (PyErr_Warn(PyExc_RuntimeWarning
,
581 "tp_compare didn't return -1, 0 or 1") < 0)
584 return c
< -1 ? -1 : 1;
587 assert(c
>= -1 && c
<= 1);
593 /* Macro to get the tp_richcompare field of a type if defined */
594 #define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) \
595 ? (t)->tp_richcompare : NULL)
597 /* Map rich comparison operators to their swapped version, e.g. LT --> GT */
598 int _Py_SwappedOp
[] = {Py_GT
, Py_GE
, Py_EQ
, Py_NE
, Py_LT
, Py_LE
};
600 /* Try a genuine rich comparison, returning an object. Return:
602 NotImplemented if this particular rich comparison is not implemented or
604 some object not equal to NotImplemented if it is implemented
605 (this latter object may not be a Boolean).
608 try_rich_compare(PyObject
*v
, PyObject
*w
, int op
)
613 if (v
->ob_type
!= w
->ob_type
&&
614 PyType_IsSubtype(w
->ob_type
, v
->ob_type
) &&
615 (f
= RICHCOMPARE(w
->ob_type
)) != NULL
) {
616 res
= (*f
)(w
, v
, _Py_SwappedOp
[op
]);
617 if (res
!= Py_NotImplemented
)
621 if ((f
= RICHCOMPARE(v
->ob_type
)) != NULL
) {
622 res
= (*f
)(v
, w
, op
);
623 if (res
!= Py_NotImplemented
)
627 if ((f
= RICHCOMPARE(w
->ob_type
)) != NULL
) {
628 return (*f
)(w
, v
, _Py_SwappedOp
[op
]);
630 res
= Py_NotImplemented
;
635 /* Try a genuine rich comparison, returning an int. Return:
636 -1 for exception (including the case where try_rich_compare() returns an
637 object that's not a Boolean);
638 0 if the outcome is false;
639 1 if the outcome is true;
640 2 if this particular rich comparison is not implemented or undefined.
643 try_rich_compare_bool(PyObject
*v
, PyObject
*w
, int op
)
648 if (RICHCOMPARE(v
->ob_type
) == NULL
&& RICHCOMPARE(w
->ob_type
) == NULL
)
649 return 2; /* Shortcut, avoid INCREF+DECREF */
650 res
= try_rich_compare(v
, w
, op
);
653 if (res
== Py_NotImplemented
) {
657 ok
= PyObject_IsTrue(res
);
662 /* Try rich comparisons to determine a 3-way comparison. Return:
667 2 if this particular rich comparison is not implemented or undefined.
670 try_rich_to_3way_compare(PyObject
*v
, PyObject
*w
)
672 static struct { int op
; int outcome
; } tries
[3] = {
673 /* Try this operator, and if it is true, use this outcome: */
680 if (RICHCOMPARE(v
->ob_type
) == NULL
&& RICHCOMPARE(w
->ob_type
) == NULL
)
681 return 2; /* Shortcut */
683 for (i
= 0; i
< 3; i
++) {
684 switch (try_rich_compare_bool(v
, w
, tries
[i
].op
)) {
688 return tries
[i
].outcome
;
695 /* Try a 3-way comparison, returning an int. Return:
700 2 if this particular 3-way comparison is not implemented or undefined.
703 try_3way_compare(PyObject
*v
, PyObject
*w
)
708 /* Comparisons involving instances are given to instance_compare,
709 which has the same return conventions as this function. */
711 f
= v
->ob_type
->tp_compare
;
712 if (PyInstance_Check(v
))
714 if (PyInstance_Check(w
))
715 return (*w
->ob_type
->tp_compare
)(v
, w
);
717 /* If both have the same (non-NULL) tp_compare, use it. */
718 if (f
!= NULL
&& f
== w
->ob_type
->tp_compare
) {
720 return adjust_tp_compare(c
);
723 /* If either tp_compare is _PyObject_SlotCompare, that's safe. */
724 if (f
== _PyObject_SlotCompare
||
725 w
->ob_type
->tp_compare
== _PyObject_SlotCompare
)
726 return _PyObject_SlotCompare(v
, w
);
728 /* If we're here, v and w,
729 a) are not instances;
730 b) have different types or a type without tp_compare; and
731 c) don't have a user-defined tp_compare.
732 tp_compare implementations in C assume that both arguments
733 have their type, so we give up if the coercion fails or if
734 it yields types which are still incompatible (which can
735 happen with a user-defined nb_coerce).
737 c
= PyNumber_CoerceEx(&v
, &w
);
742 f
= v
->ob_type
->tp_compare
;
743 if (f
!= NULL
&& f
== w
->ob_type
->tp_compare
) {
747 return adjust_tp_compare(c
);
750 /* No comparison defined */
756 /* Final fallback 3-way comparison, returning an int. Return:
757 -2 if an error occurred;
763 default_3way_compare(PyObject
*v
, PyObject
*w
)
766 const char *vname
, *wname
;
768 if (v
->ob_type
== w
->ob_type
) {
769 /* When comparing these pointers, they must be cast to
770 * integer types (i.e. Py_uintptr_t, our spelling of C9X's
771 * uintptr_t). ANSI specifies that pointer compares other
772 * than == and != to non-related structures are undefined.
774 Py_uintptr_t vv
= (Py_uintptr_t
)v
;
775 Py_uintptr_t ww
= (Py_uintptr_t
)w
;
776 return (vv
< ww
) ? -1 : (vv
> ww
) ? 1 : 0;
779 /* None is smaller than anything */
785 /* different type: compare type names; numbers are smaller */
786 if (PyNumber_Check(v
))
789 vname
= v
->ob_type
->tp_name
;
790 if (PyNumber_Check(w
))
793 wname
= w
->ob_type
->tp_name
;
794 c
= strcmp(vname
, wname
);
799 /* Same type name, or (more likely) incomparable numeric types */
800 return ((Py_uintptr_t
)(v
->ob_type
) < (
801 Py_uintptr_t
)(w
->ob_type
)) ? -1 : 1;
804 /* Do a 3-way comparison, by hook or by crook. Return:
805 -2 for an exception (but see below);
809 BUT: if the object implements a tp_compare function, it returns
810 whatever this function returns (whether with an exception or not).
813 do_cmp(PyObject
*v
, PyObject
*w
)
818 if (v
->ob_type
== w
->ob_type
819 && (f
= v
->ob_type
->tp_compare
) != NULL
) {
821 if (PyInstance_Check(v
)) {
822 /* Instance tp_compare has a different signature.
823 But if it returns undefined we fall through. */
826 /* Else fall through to try_rich_to_3way_compare() */
829 return adjust_tp_compare(c
);
831 /* We only get here if one of the following is true:
832 a) v and w have different types
833 b) v and w have the same type, which doesn't have tp_compare
834 c) v and w are instances, and either __cmp__ is not defined or
835 __cmp__ returns NotImplemented
837 c
= try_rich_to_3way_compare(v
, w
);
840 c
= try_3way_compare(v
, w
);
843 return default_3way_compare(v
, w
);
846 /* Compare v to w. Return
847 -1 if v < w or exception (PyErr_Occurred() true in latter case).
850 XXX The docs (C API manual) say the return value is undefined in case
854 PyObject_Compare(PyObject
*v
, PyObject
*w
)
858 if (v
== NULL
|| w
== NULL
) {
859 PyErr_BadInternalCall();
864 if (Py_EnterRecursiveCall(" in cmp"))
866 result
= do_cmp(v
, w
);
867 Py_LeaveRecursiveCall();
868 return result
< 0 ? -1 : result
;
871 /* Return (new reference to) Py_True or Py_False. */
873 convert_3way_to_object(int op
, int c
)
877 case Py_LT
: c
= c
< 0; break;
878 case Py_LE
: c
= c
<= 0; break;
879 case Py_EQ
: c
= c
== 0; break;
880 case Py_NE
: c
= c
!= 0; break;
881 case Py_GT
: c
= c
> 0; break;
882 case Py_GE
: c
= c
>= 0; break;
884 result
= c
? Py_True
: Py_False
;
889 /* We want a rich comparison but don't have one. Try a 3-way cmp instead.
893 Py_False if not (v op w)
896 try_3way_to_rich_compare(PyObject
*v
, PyObject
*w
, int op
)
900 c
= try_3way_compare(v
, w
);
903 /* Py3K warning if types are not equal and comparison isn't == or != */
904 if (Py_Py3kWarningFlag
&&
905 v
->ob_type
!= w
->ob_type
&& op
!= Py_EQ
&& op
!= Py_NE
&&
906 PyErr_WarnEx(PyExc_DeprecationWarning
,
907 "comparing unequal types not supported "
912 c
= default_3way_compare(v
, w
);
916 return convert_3way_to_object(op
, c
);
919 /* Do rich comparison on v and w. Return
921 Else a new reference to an object other than Py_NotImplemented, usually(?):
923 Py_False if not (v op w)
926 do_richcmp(PyObject
*v
, PyObject
*w
, int op
)
930 res
= try_rich_compare(v
, w
, op
);
931 if (res
!= Py_NotImplemented
)
935 return try_3way_to_rich_compare(v
, w
, op
);
940 some object not equal to NotImplemented if it is implemented
941 (this latter object may not be a Boolean).
944 PyObject_RichCompare(PyObject
*v
, PyObject
*w
, int op
)
948 assert(Py_LT
<= op
&& op
<= Py_GE
);
949 if (Py_EnterRecursiveCall(" in cmp"))
952 /* If the types are equal, and not old-style instances, try to
953 get out cheap (don't bother with coercions etc.). */
954 if (v
->ob_type
== w
->ob_type
&& !PyInstance_Check(v
)) {
956 richcmpfunc frich
= RICHCOMPARE(v
->ob_type
);
957 /* If the type has richcmp, try it first. try_rich_compare
958 tries it two-sided, which is not needed since we've a
961 res
= (*frich
)(v
, w
, op
);
962 if (res
!= Py_NotImplemented
)
966 /* No richcmp, or this particular richmp not implemented.
968 fcmp
= v
->ob_type
->tp_compare
;
970 int c
= (*fcmp
)(v
, w
);
971 c
= adjust_tp_compare(c
);
976 res
= convert_3way_to_object(op
, c
);
981 /* Fast path not taken, or couldn't deliver a useful result. */
982 res
= do_richcmp(v
, w
, op
);
984 Py_LeaveRecursiveCall();
988 /* Return -1 if error; 1 if v op w; 0 if not (v op w). */
990 PyObject_RichCompareBool(PyObject
*v
, PyObject
*w
, int op
)
995 /* Quick result when objects are the same.
996 Guarantees that identity implies equality. */
1000 else if (op
== Py_NE
)
1004 res
= PyObject_RichCompare(v
, w
, op
);
1007 if (PyBool_Check(res
))
1008 ok
= (res
== Py_True
);
1010 ok
= PyObject_IsTrue(res
);
1015 /* Set of hash utility functions to help maintaining the invariant that
1016 if a==b then hash(a)==hash(b)
1018 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
1022 _Py_HashDouble(double v
)
1024 double intpart
, fractpart
;
1027 long x
; /* the final hash value */
1028 /* This is designed so that Python numbers of different types
1029 * that compare equal hash to the same value; otherwise comparisons
1030 * of mapping keys will turn out weird.
1033 if (!Py_IS_FINITE(v
)) {
1034 if (Py_IS_INFINITY(v
))
1035 return v
< 0 ? -271828 : 314159;
1039 fractpart
= modf(v
, &intpart
);
1040 if (fractpart
== 0.0) {
1041 /* This must return the same hash as an equal int or long. */
1042 if (intpart
> LONG_MAX
/2 || -intpart
> LONG_MAX
/2) {
1043 /* Convert to long and use its hash. */
1044 PyObject
*plong
; /* converted to Python long */
1045 plong
= PyLong_FromDouble(v
);
1048 x
= PyObject_Hash(plong
);
1052 /* Fits in a C long == a Python int, so is its own hash. */
1058 /* The fractional part is non-zero, so we don't have to worry about
1059 * making this match the hash of some other type.
1060 * Use frexp to get at the bits in the double.
1061 * Since the VAX D double format has 56 mantissa bits, which is the
1062 * most of any double format in use, each of these parts may have as
1063 * many as (but no more than) 56 significant bits.
1064 * So, assuming sizeof(long) >= 4, each part can be broken into two
1065 * longs; frexp and multiplication are used to do that.
1066 * Also, since the Cray double format has 15 exponent bits, which is
1067 * the most of any double format in use, shifting the exponent field
1068 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4).
1070 v
= frexp(v
, &expo
);
1071 v
*= 2147483648.0; /* 2**31 */
1072 hipart
= (long)v
; /* take the top 32 bits */
1073 v
= (v
- (double)hipart
) * 2147483648.0; /* get the next 32 bits */
1074 x
= hipart
+ (long)v
+ (expo
<< 15);
1081 _Py_HashPointer(void *p
)
1084 size_t y
= (size_t)p
;
1085 /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
1086 excessive hash collisions for dicts and sets */
1087 y
= (y
>> 4) | (y
<< (8 * SIZEOF_VOID_P
- 4));
1095 PyObject_HashNotImplemented(PyObject
*self
)
1097 PyErr_Format(PyExc_TypeError
, "unhashable type: '%.200s'",
1098 self
->ob_type
->tp_name
);
1102 _Py_HashSecret_t _Py_HashSecret
;
1105 PyObject_Hash(PyObject
*v
)
1107 PyTypeObject
*tp
= v
->ob_type
;
1108 if (tp
->tp_hash
!= NULL
)
1109 return (*tp
->tp_hash
)(v
);
1110 /* To keep to the general practice that inheriting
1111 * solely from object in C code should work without
1112 * an explicit call to PyType_Ready, we implicitly call
1113 * PyType_Ready here and then check the tp_hash slot again
1115 if (tp
->tp_dict
== NULL
) {
1116 if (PyType_Ready(tp
) < 0)
1118 if (tp
->tp_hash
!= NULL
)
1119 return (*tp
->tp_hash
)(v
);
1121 if (tp
->tp_compare
== NULL
&& RICHCOMPARE(tp
) == NULL
) {
1122 return _Py_HashPointer(v
); /* Use address as hash value */
1124 /* If there's a cmp but no hash defined, the object can't be hashed */
1125 return PyObject_HashNotImplemented(v
);
1129 PyObject_GetAttrString(PyObject
*v
, const char *name
)
1133 if (Py_TYPE(v
)->tp_getattr
!= NULL
)
1134 return (*Py_TYPE(v
)->tp_getattr
)(v
, (char*)name
);
1135 w
= PyString_InternFromString(name
);
1138 res
= PyObject_GetAttr(v
, w
);
1144 PyObject_HasAttrString(PyObject
*v
, const char *name
)
1146 PyObject
*res
= PyObject_GetAttrString(v
, name
);
1156 PyObject_SetAttrString(PyObject
*v
, const char *name
, PyObject
*w
)
1161 if (Py_TYPE(v
)->tp_setattr
!= NULL
)
1162 return (*Py_TYPE(v
)->tp_setattr
)(v
, (char*)name
, w
);
1163 s
= PyString_InternFromString(name
);
1166 res
= PyObject_SetAttr(v
, s
, w
);
1172 PyObject_GetAttr(PyObject
*v
, PyObject
*name
)
1174 PyTypeObject
*tp
= Py_TYPE(v
);
1176 if (!PyString_Check(name
)) {
1177 #ifdef Py_USING_UNICODE
1178 /* The Unicode to string conversion is done here because the
1179 existing tp_getattro slots expect a string object as name
1180 and we wouldn't want to break those. */
1181 if (PyUnicode_Check(name
)) {
1182 name
= _PyUnicode_AsDefaultEncodedString(name
, NULL
);
1189 PyErr_Format(PyExc_TypeError
,
1190 "attribute name must be string, not '%.200s'",
1191 Py_TYPE(name
)->tp_name
);
1195 if (tp
->tp_getattro
!= NULL
)
1196 return (*tp
->tp_getattro
)(v
, name
);
1197 if (tp
->tp_getattr
!= NULL
)
1198 return (*tp
->tp_getattr
)(v
, PyString_AS_STRING(name
));
1199 PyErr_Format(PyExc_AttributeError
,
1200 "'%.50s' object has no attribute '%.400s'",
1201 tp
->tp_name
, PyString_AS_STRING(name
));
1206 PyObject_HasAttr(PyObject
*v
, PyObject
*name
)
1208 PyObject
*res
= PyObject_GetAttr(v
, name
);
1218 PyObject_SetAttr(PyObject
*v
, PyObject
*name
, PyObject
*value
)
1220 PyTypeObject
*tp
= Py_TYPE(v
);
1223 if (!PyString_Check(name
)){
1224 #ifdef Py_USING_UNICODE
1225 /* The Unicode to string conversion is done here because the
1226 existing tp_setattro slots expect a string object as name
1227 and we wouldn't want to break those. */
1228 if (PyUnicode_Check(name
)) {
1229 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1236 PyErr_Format(PyExc_TypeError
,
1237 "attribute name must be string, not '%.200s'",
1238 Py_TYPE(name
)->tp_name
);
1245 PyString_InternInPlace(&name
);
1246 if (tp
->tp_setattro
!= NULL
) {
1247 err
= (*tp
->tp_setattro
)(v
, name
, value
);
1251 if (tp
->tp_setattr
!= NULL
) {
1252 err
= (*tp
->tp_setattr
)(v
, PyString_AS_STRING(name
), value
);
1257 if (tp
->tp_getattr
== NULL
&& tp
->tp_getattro
== NULL
)
1258 PyErr_Format(PyExc_TypeError
,
1259 "'%.100s' object has no attributes "
1262 value
==NULL
? "del" : "assign to",
1263 PyString_AS_STRING(name
));
1265 PyErr_Format(PyExc_TypeError
,
1266 "'%.100s' object has only read-only attributes "
1269 value
==NULL
? "del" : "assign to",
1270 PyString_AS_STRING(name
));
1274 /* Helper to get a pointer to an object's __dict__ slot, if any */
1277 _PyObject_GetDictPtr(PyObject
*obj
)
1279 Py_ssize_t dictoffset
;
1280 PyTypeObject
*tp
= Py_TYPE(obj
);
1282 if (!(tp
->tp_flags
& Py_TPFLAGS_HAVE_CLASS
))
1284 dictoffset
= tp
->tp_dictoffset
;
1285 if (dictoffset
== 0)
1287 if (dictoffset
< 0) {
1291 tsize
= ((PyVarObject
*)obj
)->ob_size
;
1294 size
= _PyObject_VAR_SIZE(tp
, tsize
);
1296 dictoffset
+= (long)size
;
1297 assert(dictoffset
> 0);
1298 assert(dictoffset
% SIZEOF_VOID_P
== 0);
1300 return (PyObject
**) ((char *)obj
+ dictoffset
);
1304 PyObject_SelfIter(PyObject
*obj
)
1310 /* Helper used when the __next__ method is removed from a type:
1311 tp_iternext is never NULL and can be safely called without checking
1316 _PyObject_NextNotImplemented(PyObject
*self
)
1318 PyErr_Format(PyExc_TypeError
,
1319 "'%.200s' object is not iterable",
1320 Py_TYPE(self
)->tp_name
);
1324 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
1327 _PyObject_GenericGetAttrWithDict(PyObject
*obj
, PyObject
*name
, PyObject
*dict
)
1329 PyTypeObject
*tp
= Py_TYPE(obj
);
1330 PyObject
*descr
= NULL
;
1331 PyObject
*res
= NULL
;
1333 Py_ssize_t dictoffset
;
1336 if (!PyString_Check(name
)){
1337 #ifdef Py_USING_UNICODE
1338 /* The Unicode to string conversion is done here because the
1339 existing tp_setattro slots expect a string object as name
1340 and we wouldn't want to break those. */
1341 if (PyUnicode_Check(name
)) {
1342 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1349 PyErr_Format(PyExc_TypeError
,
1350 "attribute name must be string, not '%.200s'",
1351 Py_TYPE(name
)->tp_name
);
1358 if (tp
->tp_dict
== NULL
) {
1359 if (PyType_Ready(tp
) < 0)
1363 #if 0 /* XXX this is not quite _PyType_Lookup anymore */
1364 /* Inline _PyType_Lookup */
1367 PyObject
*mro
, *base
, *dict
;
1369 /* Look in tp_dict of types in MRO */
1371 assert(mro
!= NULL
);
1372 assert(PyTuple_Check(mro
));
1373 n
= PyTuple_GET_SIZE(mro
);
1374 for (i
= 0; i
< n
; i
++) {
1375 base
= PyTuple_GET_ITEM(mro
, i
);
1376 if (PyClass_Check(base
))
1377 dict
= ((PyClassObject
*)base
)->cl_dict
;
1379 assert(PyType_Check(base
));
1380 dict
= ((PyTypeObject
*)base
)->tp_dict
;
1382 assert(dict
&& PyDict_Check(dict
));
1383 descr
= PyDict_GetItem(dict
, name
);
1389 descr
= _PyType_Lookup(tp
, name
);
1395 if (descr
!= NULL
&&
1396 PyType_HasFeature(descr
->ob_type
, Py_TPFLAGS_HAVE_CLASS
)) {
1397 f
= descr
->ob_type
->tp_descr_get
;
1398 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1399 res
= f(descr
, obj
, (PyObject
*)obj
->ob_type
);
1406 /* Inline _PyObject_GetDictPtr */
1407 dictoffset
= tp
->tp_dictoffset
;
1408 if (dictoffset
!= 0) {
1409 if (dictoffset
< 0) {
1413 tsize
= ((PyVarObject
*)obj
)->ob_size
;
1416 size
= _PyObject_VAR_SIZE(tp
, tsize
);
1418 dictoffset
+= (long)size
;
1419 assert(dictoffset
> 0);
1420 assert(dictoffset
% SIZEOF_VOID_P
== 0);
1422 dictptr
= (PyObject
**) ((char *)obj
+ dictoffset
);
1428 res
= PyDict_GetItem(dict
, name
);
1439 res
= f(descr
, obj
, (PyObject
*)Py_TYPE(obj
));
1444 if (descr
!= NULL
) {
1446 /* descr was already increfed above */
1450 PyErr_Format(PyExc_AttributeError
,
1451 "'%.50s' object has no attribute '%.400s'",
1452 tp
->tp_name
, PyString_AS_STRING(name
));
1459 PyObject_GenericGetAttr(PyObject
*obj
, PyObject
*name
)
1461 return _PyObject_GenericGetAttrWithDict(obj
, name
, NULL
);
1465 _PyObject_GenericSetAttrWithDict(PyObject
*obj
, PyObject
*name
,
1466 PyObject
*value
, PyObject
*dict
)
1468 PyTypeObject
*tp
= Py_TYPE(obj
);
1474 if (!PyString_Check(name
)){
1475 #ifdef Py_USING_UNICODE
1476 /* The Unicode to string conversion is done here because the
1477 existing tp_setattro slots expect a string object as name
1478 and we wouldn't want to break those. */
1479 if (PyUnicode_Check(name
)) {
1480 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1487 PyErr_Format(PyExc_TypeError
,
1488 "attribute name must be string, not '%.200s'",
1489 Py_TYPE(name
)->tp_name
);
1496 if (tp
->tp_dict
== NULL
) {
1497 if (PyType_Ready(tp
) < 0)
1501 descr
= _PyType_Lookup(tp
, name
);
1503 if (descr
!= NULL
&&
1504 PyType_HasFeature(descr
->ob_type
, Py_TPFLAGS_HAVE_CLASS
)) {
1505 f
= descr
->ob_type
->tp_descr_set
;
1506 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1507 res
= f(descr
, obj
, value
);
1513 dictptr
= _PyObject_GetDictPtr(obj
);
1514 if (dictptr
!= NULL
) {
1516 if (dict
== NULL
&& value
!= NULL
) {
1517 dict
= PyDict_New();
1527 res
= PyDict_DelItem(dict
, name
);
1529 res
= PyDict_SetItem(dict
, name
, value
);
1530 if (res
< 0 && PyErr_ExceptionMatches(PyExc_KeyError
))
1531 PyErr_SetObject(PyExc_AttributeError
, name
);
1537 res
= f(descr
, obj
, value
);
1541 if (descr
== NULL
) {
1542 PyErr_Format(PyExc_AttributeError
,
1543 "'%.100s' object has no attribute '%.200s'",
1544 tp
->tp_name
, PyString_AS_STRING(name
));
1548 PyErr_Format(PyExc_AttributeError
,
1549 "'%.50s' object attribute '%.400s' is read-only",
1550 tp
->tp_name
, PyString_AS_STRING(name
));
1557 PyObject_GenericSetAttr(PyObject
*obj
, PyObject
*name
, PyObject
*value
)
1559 return _PyObject_GenericSetAttrWithDict(obj
, name
, value
, NULL
);
1563 /* Test a value used as condition, e.g., in a for or if statement.
1564 Return -1 if an error occurred */
1567 PyObject_IsTrue(PyObject
*v
)
1576 else if (v
->ob_type
->tp_as_number
!= NULL
&&
1577 v
->ob_type
->tp_as_number
->nb_nonzero
!= NULL
)
1578 res
= (*v
->ob_type
->tp_as_number
->nb_nonzero
)(v
);
1579 else if (v
->ob_type
->tp_as_mapping
!= NULL
&&
1580 v
->ob_type
->tp_as_mapping
->mp_length
!= NULL
)
1581 res
= (*v
->ob_type
->tp_as_mapping
->mp_length
)(v
);
1582 else if (v
->ob_type
->tp_as_sequence
!= NULL
&&
1583 v
->ob_type
->tp_as_sequence
->sq_length
!= NULL
)
1584 res
= (*v
->ob_type
->tp_as_sequence
->sq_length
)(v
);
1587 /* if it is negative, it should be either -1 or -2 */
1588 return (res
> 0) ? 1 : Py_SAFE_DOWNCAST(res
, Py_ssize_t
, int);
1591 /* equivalent of 'not v'
1592 Return -1 if an error occurred */
1595 PyObject_Not(PyObject
*v
)
1598 res
= PyObject_IsTrue(v
);
1604 /* Coerce two numeric types to the "larger" one.
1605 Increment the reference count on each argument.
1607 -1 if an error occurred;
1608 0 if the coercion succeeded (and then the reference counts are increased);
1609 1 if no coercion is possible (and no error is raised).
1612 PyNumber_CoerceEx(PyObject
**pv
, PyObject
**pw
)
1614 register PyObject
*v
= *pv
;
1615 register PyObject
*w
= *pw
;
1618 /* Shortcut only for old-style types */
1619 if (v
->ob_type
== w
->ob_type
&&
1620 !PyType_HasFeature(v
->ob_type
, Py_TPFLAGS_CHECKTYPES
))
1626 if (v
->ob_type
->tp_as_number
&& v
->ob_type
->tp_as_number
->nb_coerce
) {
1627 res
= (*v
->ob_type
->tp_as_number
->nb_coerce
)(pv
, pw
);
1631 if (w
->ob_type
->tp_as_number
&& w
->ob_type
->tp_as_number
->nb_coerce
) {
1632 res
= (*w
->ob_type
->tp_as_number
->nb_coerce
)(pw
, pv
);
1639 /* Coerce two numeric types to the "larger" one.
1640 Increment the reference count on each argument.
1641 Return -1 and raise an exception if no coercion is possible
1642 (and then no reference count is incremented).
1645 PyNumber_Coerce(PyObject
**pv
, PyObject
**pw
)
1647 int err
= PyNumber_CoerceEx(pv
, pw
);
1650 PyErr_SetString(PyExc_TypeError
, "number coercion failed");
1655 /* Test whether an object can be called */
1658 PyCallable_Check(PyObject
*x
)
1662 if (PyInstance_Check(x
)) {
1663 PyObject
*call
= PyObject_GetAttrString(x
, "__call__");
1668 /* Could test recursively but don't, for fear of endless
1669 recursion if some joker sets self.__call__ = self */
1674 return x
->ob_type
->tp_call
!= NULL
;
1678 /* ------------------------- PyObject_Dir() helpers ------------------------- */
1680 /* Helper for PyObject_Dir.
1681 Merge the __dict__ of aclass into dict, and recursively also all
1682 the __dict__s of aclass's base classes. The order of merging isn't
1683 defined, as it's expected that only the final set of dict keys is
1685 Return 0 on success, -1 on error.
1689 merge_class_dict(PyObject
* dict
, PyObject
* aclass
)
1691 PyObject
*classdict
;
1694 assert(PyDict_Check(dict
));
1697 /* Merge in the type's dict (if any). */
1698 classdict
= PyObject_GetAttrString(aclass
, "__dict__");
1699 if (classdict
== NULL
)
1702 int status
= PyDict_Update(dict
, classdict
);
1703 Py_DECREF(classdict
);
1708 /* Recursively merge in the base types' (if any) dicts. */
1709 bases
= PyObject_GetAttrString(aclass
, "__bases__");
1713 /* We have no guarantee that bases is a real tuple */
1715 n
= PySequence_Size(bases
); /* This better be right */
1719 for (i
= 0; i
< n
; i
++) {
1721 PyObject
*base
= PySequence_GetItem(bases
, i
);
1726 status
= merge_class_dict(dict
, base
);
1739 /* Helper for PyObject_Dir.
1740 If obj has an attr named attrname that's a list, merge its string
1741 elements into keys of dict.
1742 Return 0 on success, -1 on error. Errors due to not finding the attr,
1743 or the attr not being a list, are suppressed.
1747 merge_list_attr(PyObject
* dict
, PyObject
* obj
, const char *attrname
)
1752 assert(PyDict_Check(dict
));
1756 list
= PyObject_GetAttrString(obj
, attrname
);
1760 else if (PyList_Check(list
)) {
1762 for (i
= 0; i
< PyList_GET_SIZE(list
); ++i
) {
1763 PyObject
*item
= PyList_GET_ITEM(list
, i
);
1764 if (PyString_Check(item
)) {
1765 result
= PyDict_SetItem(dict
, item
, Py_None
);
1770 if (Py_Py3kWarningFlag
&&
1771 (strcmp(attrname
, "__members__") == 0 ||
1772 strcmp(attrname
, "__methods__") == 0)) {
1773 if (PyErr_WarnEx(PyExc_DeprecationWarning
,
1774 "__members__ and __methods__ not "
1775 "supported in 3.x", 1) < 0) {
1786 /* Helper for PyObject_Dir without arguments: returns the local scope. */
1791 PyObject
*locals
= PyEval_GetLocals();
1793 if (locals
== NULL
) {
1794 PyErr_SetString(PyExc_SystemError
, "frame does not exist");
1798 names
= PyMapping_Keys(locals
);
1801 if (!PyList_Check(names
)) {
1802 PyErr_Format(PyExc_TypeError
,
1803 "dir(): expected keys() of locals to be a list, "
1804 "not '%.200s'", Py_TYPE(names
)->tp_name
);
1808 /* the locals don't need to be DECREF'd */
1812 /* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__.
1813 We deliberately don't suck up its __class__, as methods belonging to the
1814 metaclass would probably be more confusing than helpful.
1817 _specialized_dir_type(PyObject
*obj
)
1819 PyObject
*result
= NULL
;
1820 PyObject
*dict
= PyDict_New();
1822 if (dict
!= NULL
&& merge_class_dict(dict
, obj
) == 0)
1823 result
= PyDict_Keys(dict
);
1829 /* Helper for PyObject_Dir of module objects: returns the module's __dict__. */
1831 _specialized_dir_module(PyObject
*obj
)
1833 PyObject
*result
= NULL
;
1834 PyObject
*dict
= PyObject_GetAttrString(obj
, "__dict__");
1837 if (PyDict_Check(dict
))
1838 result
= PyDict_Keys(dict
);
1840 char *name
= PyModule_GetName(obj
);
1842 PyErr_Format(PyExc_TypeError
,
1843 "%.200s.__dict__ is not a dictionary",
1852 /* Helper for PyObject_Dir of generic objects: returns __dict__, __class__,
1853 and recursively up the __class__.__bases__ chain.
1856 _generic_dir(PyObject
*obj
)
1858 PyObject
*result
= NULL
;
1859 PyObject
*dict
= NULL
;
1860 PyObject
*itsclass
= NULL
;
1862 /* Get __dict__ (which may or may not be a real dict...) */
1863 dict
= PyObject_GetAttrString(obj
, "__dict__");
1866 dict
= PyDict_New();
1868 else if (!PyDict_Check(dict
)) {
1870 dict
= PyDict_New();
1873 /* Copy __dict__ to avoid mutating it. */
1874 PyObject
*temp
= PyDict_Copy(dict
);
1882 /* Merge in __members__ and __methods__ (if any).
1883 * This is removed in Python 3000. */
1884 if (merge_list_attr(dict
, obj
, "__members__") < 0)
1886 if (merge_list_attr(dict
, obj
, "__methods__") < 0)
1889 /* Merge in attrs reachable from its class. */
1890 itsclass
= PyObject_GetAttrString(obj
, "__class__");
1891 if (itsclass
== NULL
)
1892 /* XXX(tomer): Perhaps fall back to obj->ob_type if no
1893 __class__ exists? */
1896 if (merge_class_dict(dict
, itsclass
) != 0)
1900 result
= PyDict_Keys(dict
);
1903 Py_XDECREF(itsclass
);
1908 /* Helper for PyObject_Dir: object introspection.
1909 This calls one of the above specialized versions if no __dir__ method
1912 _dir_object(PyObject
*obj
)
1914 PyObject
*result
= NULL
;
1915 static PyObject
*dir_str
= NULL
;
1919 if (PyInstance_Check(obj
)) {
1920 dirfunc
= PyObject_GetAttrString(obj
, "__dir__");
1921 if (dirfunc
== NULL
) {
1922 if (PyErr_ExceptionMatches(PyExc_AttributeError
))
1929 dirfunc
= _PyObject_LookupSpecial(obj
, "__dir__", &dir_str
);
1930 if (PyErr_Occurred())
1933 if (dirfunc
== NULL
) {
1934 /* use default implementation */
1935 if (PyModule_Check(obj
))
1936 result
= _specialized_dir_module(obj
);
1937 else if (PyType_Check(obj
) || PyClass_Check(obj
))
1938 result
= _specialized_dir_type(obj
);
1940 result
= _generic_dir(obj
);
1944 result
= PyObject_CallFunctionObjArgs(dirfunc
, NULL
);
1949 /* result must be a list */
1950 /* XXX(gbrandl): could also check if all items are strings */
1951 if (!PyList_Check(result
)) {
1952 PyErr_Format(PyExc_TypeError
,
1953 "__dir__() must return a list, not %.200s",
1954 Py_TYPE(result
)->tp_name
);
1963 /* Implementation of dir() -- if obj is NULL, returns the names in the current
1964 (local) scope. Otherwise, performs introspection of the object: returns a
1965 sorted list of attribute names (supposedly) accessible from the object
1968 PyObject_Dir(PyObject
*obj
)
1973 /* no object -- introspect the locals */
1974 result
= _dir_locals();
1976 /* object -- introspect the object */
1977 result
= _dir_object(obj
);
1979 assert(result
== NULL
|| PyList_Check(result
));
1981 if (result
!= NULL
&& PyList_Sort(result
) != 0) {
1982 /* sorting the list failed */
1991 NoObject is usable as a non-NULL undefined value, used by the macro None.
1992 There is (and should be!) no way to create other objects of this type,
1993 so there is exactly one (which is indestructible, by the way).
1994 (XXX This type and the type of NotImplemented below should be unified.)
1999 none_repr(PyObject
*op
)
2001 return PyString_FromString("None");
2006 none_dealloc(PyObject
* ignore
)
2008 /* This should never get called, but we also don't want to SEGV if
2009 * we accidentally decref None out of existence.
2011 Py_FatalError("deallocating None");
2015 static PyTypeObject PyNone_Type
= {
2016 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
2020 none_dealloc
, /*tp_dealloc*/ /*never called*/
2025 none_repr
, /*tp_repr*/
2027 0, /*tp_as_sequence*/
2028 0, /*tp_as_mapping*/
2029 (hashfunc
)_Py_HashPointer
, /*tp_hash */
2032 PyObject _Py_NoneStruct
= {
2033 _PyObject_EXTRA_INIT
2037 /* NotImplemented is an object that can be used to signal that an
2038 operation is not implemented for the given type combination. */
2041 NotImplemented_repr(PyObject
*op
)
2043 return PyString_FromString("NotImplemented");
2046 static PyTypeObject PyNotImplemented_Type
= {
2047 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
2048 "NotImplementedType",
2051 none_dealloc
, /*tp_dealloc*/ /*never called*/
2056 NotImplemented_repr
, /*tp_repr*/
2058 0, /*tp_as_sequence*/
2059 0, /*tp_as_mapping*/
2063 PyObject _Py_NotImplementedStruct
= {
2064 _PyObject_EXTRA_INIT
2065 1, &PyNotImplemented_Type
2069 _Py_ReadyTypes(void)
2071 if (PyType_Ready(&PyType_Type
) < 0)
2072 Py_FatalError("Can't initialize type type");
2074 if (PyType_Ready(&_PyWeakref_RefType
) < 0)
2075 Py_FatalError("Can't initialize weakref type");
2077 if (PyType_Ready(&_PyWeakref_CallableProxyType
) < 0)
2078 Py_FatalError("Can't initialize callable weakref proxy type");
2080 if (PyType_Ready(&_PyWeakref_ProxyType
) < 0)
2081 Py_FatalError("Can't initialize weakref proxy type");
2083 if (PyType_Ready(&PyBool_Type
) < 0)
2084 Py_FatalError("Can't initialize bool type");
2086 if (PyType_Ready(&PyString_Type
) < 0)
2087 Py_FatalError("Can't initialize str type");
2089 if (PyType_Ready(&PyByteArray_Type
) < 0)
2090 Py_FatalError("Can't initialize bytearray type");
2092 if (PyType_Ready(&PyList_Type
) < 0)
2093 Py_FatalError("Can't initialize list type");
2095 if (PyType_Ready(&PyNone_Type
) < 0)
2096 Py_FatalError("Can't initialize None type");
2098 if (PyType_Ready(&PyNotImplemented_Type
) < 0)
2099 Py_FatalError("Can't initialize NotImplemented type");
2101 if (PyType_Ready(&PyTraceBack_Type
) < 0)
2102 Py_FatalError("Can't initialize traceback type");
2104 if (PyType_Ready(&PySuper_Type
) < 0)
2105 Py_FatalError("Can't initialize super type");
2107 if (PyType_Ready(&PyBaseObject_Type
) < 0)
2108 Py_FatalError("Can't initialize object type");
2110 if (PyType_Ready(&PyRange_Type
) < 0)
2111 Py_FatalError("Can't initialize xrange type");
2113 if (PyType_Ready(&PyDict_Type
) < 0)
2114 Py_FatalError("Can't initialize dict type");
2116 if (PyType_Ready(&PySet_Type
) < 0)
2117 Py_FatalError("Can't initialize set type");
2119 #ifdef Py_USING_UNICODE
2120 if (PyType_Ready(&PyUnicode_Type
) < 0)
2121 Py_FatalError("Can't initialize unicode type");
2124 if (PyType_Ready(&PySlice_Type
) < 0)
2125 Py_FatalError("Can't initialize slice type");
2127 if (PyType_Ready(&PyStaticMethod_Type
) < 0)
2128 Py_FatalError("Can't initialize static method type");
2130 #ifndef WITHOUT_COMPLEX
2131 if (PyType_Ready(&PyComplex_Type
) < 0)
2132 Py_FatalError("Can't initialize complex type");
2135 if (PyType_Ready(&PyFloat_Type
) < 0)
2136 Py_FatalError("Can't initialize float type");
2138 if (PyType_Ready(&PyBuffer_Type
) < 0)
2139 Py_FatalError("Can't initialize buffer type");
2141 if (PyType_Ready(&PyLong_Type
) < 0)
2142 Py_FatalError("Can't initialize long type");
2144 if (PyType_Ready(&PyInt_Type
) < 0)
2145 Py_FatalError("Can't initialize int type");
2147 if (PyType_Ready(&PyFrozenSet_Type
) < 0)
2148 Py_FatalError("Can't initialize frozenset type");
2150 if (PyType_Ready(&PyProperty_Type
) < 0)
2151 Py_FatalError("Can't initialize property type");
2153 if (PyType_Ready(&PyMemoryView_Type
) < 0)
2154 Py_FatalError("Can't initialize memoryview type");
2156 if (PyType_Ready(&PyTuple_Type
) < 0)
2157 Py_FatalError("Can't initialize tuple type");
2159 if (PyType_Ready(&PyEnum_Type
) < 0)
2160 Py_FatalError("Can't initialize enumerate type");
2162 if (PyType_Ready(&PyReversed_Type
) < 0)
2163 Py_FatalError("Can't initialize reversed type");
2165 if (PyType_Ready(&PyCode_Type
) < 0)
2166 Py_FatalError("Can't initialize code type");
2168 if (PyType_Ready(&PyFrame_Type
) < 0)
2169 Py_FatalError("Can't initialize frame type");
2171 if (PyType_Ready(&PyCFunction_Type
) < 0)
2172 Py_FatalError("Can't initialize builtin function type");
2174 if (PyType_Ready(&PyMethod_Type
) < 0)
2175 Py_FatalError("Can't initialize method type");
2177 if (PyType_Ready(&PyFunction_Type
) < 0)
2178 Py_FatalError("Can't initialize function type");
2180 if (PyType_Ready(&PyClass_Type
) < 0)
2181 Py_FatalError("Can't initialize class type");
2183 if (PyType_Ready(&PyDictProxy_Type
) < 0)
2184 Py_FatalError("Can't initialize dict proxy type");
2186 if (PyType_Ready(&PyGen_Type
) < 0)
2187 Py_FatalError("Can't initialize generator type");
2189 if (PyType_Ready(&PyGetSetDescr_Type
) < 0)
2190 Py_FatalError("Can't initialize get-set descriptor type");
2192 if (PyType_Ready(&PyWrapperDescr_Type
) < 0)
2193 Py_FatalError("Can't initialize wrapper type");
2195 if (PyType_Ready(&PyInstance_Type
) < 0)
2196 Py_FatalError("Can't initialize instance type");
2198 if (PyType_Ready(&PyEllipsis_Type
) < 0)
2199 Py_FatalError("Can't initialize ellipsis type");
2201 if (PyType_Ready(&PyMemberDescr_Type
) < 0)
2202 Py_FatalError("Can't initialize member descriptor type");
2204 if (PyType_Ready(&PyFile_Type
) < 0)
2205 Py_FatalError("Can't initialize file type");
2207 if (PyType_Ready(&PyCapsule_Type
) < 0)
2208 Py_FatalError("Can't initialize capsule type");
2210 if (PyType_Ready(&PyCell_Type
) < 0)
2211 Py_FatalError("Can't initialize cell type");
2213 if (PyType_Ready(&PyCallIter_Type
) < 0)
2214 Py_FatalError("Can't initialize call iter type");
2216 if (PyType_Ready(&PySeqIter_Type
) < 0)
2217 Py_FatalError("Can't initialize sequence iterator type");
2221 #ifdef Py_TRACE_REFS
2224 _Py_NewReference(PyObject
*op
)
2228 _Py_AddToAllObjects(op
, 1);
2229 _Py_INC_TPALLOCS(op
);
2233 _Py_ForgetReference(register PyObject
*op
)
2235 #ifdef SLOW_UNREF_CHECK
2236 register PyObject
*p
;
2238 if (op
->ob_refcnt
< 0)
2239 Py_FatalError("UNREF negative refcnt");
2240 if (op
== &refchain
||
2241 op
->_ob_prev
->_ob_next
!= op
|| op
->_ob_next
->_ob_prev
!= op
)
2242 Py_FatalError("UNREF invalid object");
2243 #ifdef SLOW_UNREF_CHECK
2244 for (p
= refchain
._ob_next
; p
!= &refchain
; p
= p
->_ob_next
) {
2248 if (p
== &refchain
) /* Not found */
2249 Py_FatalError("UNREF unknown object");
2251 op
->_ob_next
->_ob_prev
= op
->_ob_prev
;
2252 op
->_ob_prev
->_ob_next
= op
->_ob_next
;
2253 op
->_ob_next
= op
->_ob_prev
= NULL
;
2254 _Py_INC_TPFREES(op
);
2258 _Py_Dealloc(PyObject
*op
)
2260 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
2261 _Py_ForgetReference(op
);
2265 /* Print all live objects. Because PyObject_Print is called, the
2266 * interpreter must be in a healthy state.
2269 _Py_PrintReferences(FILE *fp
)
2272 fprintf(fp
, "Remaining objects:\n");
2273 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
) {
2274 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] ", op
, op
->ob_refcnt
);
2275 if (PyObject_Print(op
, fp
, 0) != 0)
2281 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
2282 * doesn't make any calls to the Python C API, so is always safe to call.
2285 _Py_PrintReferenceAddresses(FILE *fp
)
2288 fprintf(fp
, "Remaining object addresses:\n");
2289 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
)
2290 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] %s\n", op
,
2291 op
->ob_refcnt
, Py_TYPE(op
)->tp_name
);
2295 _Py_GetObjects(PyObject
*self
, PyObject
*args
)
2301 if (!PyArg_ParseTuple(args
, "i|O", &n
, &t
))
2303 op
= refchain
._ob_next
;
2304 res
= PyList_New(0);
2307 for (i
= 0; (n
== 0 || i
< n
) && op
!= &refchain
; i
++) {
2308 while (op
== self
|| op
== args
|| op
== res
|| op
== t
||
2309 (t
!= NULL
&& Py_TYPE(op
) != (PyTypeObject
*) t
)) {
2311 if (op
== &refchain
)
2314 if (PyList_Append(res
, op
) < 0) {
2326 /* Hack to force loading of capsule.o */
2327 PyTypeObject
*_Py_capsule_hack
= &PyCapsule_Type
;
2330 /* Hack to force loading of cobject.o */
2331 PyTypeObject
*_Py_cobject_hack
= &PyCObject_Type
;
2334 /* Hack to force loading of abstract.o */
2335 Py_ssize_t (*_Py_abstract_hack
)(PyObject
*) = PyObject_Size
;
2338 /* Python's malloc wrappers (see pymem.h) */
2341 PyMem_Malloc(size_t nbytes
)
2343 return PyMem_MALLOC(nbytes
);
2347 PyMem_Realloc(void *p
, size_t nbytes
)
2349 return PyMem_REALLOC(p
, nbytes
);
2359 /* These methods are used to control infinite recursion in repr, str, print,
2360 etc. Container objects that may recursively contain themselves,
2361 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
2362 Py_ReprLeave() to avoid infinite recursion.
2364 Py_ReprEnter() returns 0 the first time it is called for a particular
2365 object and 1 every time thereafter. It returns -1 if an exception
2366 occurred. Py_ReprLeave() has no return value.
2368 See dictobject.c and listobject.c for examples of use.
2371 #define KEY "Py_Repr"
2374 Py_ReprEnter(PyObject
*obj
)
2380 dict
= PyThreadState_GetDict();
2383 list
= PyDict_GetItemString(dict
, KEY
);
2385 list
= PyList_New(0);
2388 if (PyDict_SetItemString(dict
, KEY
, list
) < 0)
2392 i
= PyList_GET_SIZE(list
);
2394 if (PyList_GET_ITEM(list
, i
) == obj
)
2397 PyList_Append(list
, obj
);
2402 Py_ReprLeave(PyObject
*obj
)
2408 dict
= PyThreadState_GetDict();
2411 list
= PyDict_GetItemString(dict
, KEY
);
2412 if (list
== NULL
|| !PyList_Check(list
))
2414 i
= PyList_GET_SIZE(list
);
2415 /* Count backwards because we always expect obj to be list[-1] */
2417 if (PyList_GET_ITEM(list
, i
) == obj
) {
2418 PyList_SetSlice(list
, i
, i
+ 1, NULL
);
2424 /* Trashcan support. */
2426 /* Current call-stack depth of tp_dealloc calls. */
2427 int _PyTrash_delete_nesting
= 0;
2429 /* List of objects that still need to be cleaned up, singly linked via their
2430 * gc headers' gc_prev pointers.
2432 PyObject
*_PyTrash_delete_later
= NULL
;
2434 /* Add op to the _PyTrash_delete_later list. Called when the current
2435 * call-stack depth gets large. op must be a currently untracked gc'ed
2436 * object, with refcount 0. Py_DECREF must already have been called on it.
2439 _PyTrash_deposit_object(PyObject
*op
)
2441 assert(PyObject_IS_GC(op
));
2442 assert(_Py_AS_GC(op
)->gc
.gc_refs
== _PyGC_REFS_UNTRACKED
);
2443 assert(op
->ob_refcnt
== 0);
2444 _Py_AS_GC(op
)->gc
.gc_prev
= (PyGC_Head
*)_PyTrash_delete_later
;
2445 _PyTrash_delete_later
= op
;
2448 /* The equivalent API, using per-thread state recursion info */
2450 _PyTrash_thread_deposit_object(PyObject
*op
)
2452 PyThreadState
*tstate
= PyThreadState_GET();
2453 assert(PyObject_IS_GC(op
));
2454 assert(_Py_AS_GC(op
)->gc
.gc_refs
== _PyGC_REFS_UNTRACKED
);
2455 assert(op
->ob_refcnt
== 0);
2456 _Py_AS_GC(op
)->gc
.gc_prev
= (PyGC_Head
*) tstate
->trash_delete_later
;
2457 tstate
->trash_delete_later
= op
;
2460 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
2461 * the call-stack unwinds again.
2464 _PyTrash_destroy_chain(void)
2466 while (_PyTrash_delete_later
) {
2467 PyObject
*op
= _PyTrash_delete_later
;
2468 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
2470 _PyTrash_delete_later
=
2471 (PyObject
*) _Py_AS_GC(op
)->gc
.gc_prev
;
2473 /* Call the deallocator directly. This used to try to
2474 * fool Py_DECREF into calling it indirectly, but
2475 * Py_DECREF was already called on this object, and in
2476 * assorted non-release builds calling Py_DECREF again ends
2477 * up distorting allocation statistics.
2479 assert(op
->ob_refcnt
== 0);
2480 ++_PyTrash_delete_nesting
;
2482 --_PyTrash_delete_nesting
;
2486 /* The equivalent API, using per-thread state recursion info */
2488 _PyTrash_thread_destroy_chain(void)
2490 PyThreadState
*tstate
= PyThreadState_GET();
2491 while (tstate
->trash_delete_later
) {
2492 PyObject
*op
= tstate
->trash_delete_later
;
2493 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
2495 tstate
->trash_delete_later
=
2496 (PyObject
*) _Py_AS_GC(op
)->gc
.gc_prev
;
2498 /* Call the deallocator directly. This used to try to
2499 * fool Py_DECREF into calling it indirectly, but
2500 * Py_DECREF was already called on this object, and in
2501 * assorted non-release builds calling Py_DECREF again ends
2502 * up distorting allocation statistics.
2504 assert(op
->ob_refcnt
== 0);
2505 ++tstate
->trash_delete_nesting
;
2507 --tstate
->trash_delete_nesting
;