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
)
473 PyObject
*res
= NULL
;
474 PyObject
*func
= NULL
;
475 PyObject
*str
= NULL
;
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 */
494 func
= PyObject_GetAttr(v
, unicodestr
);
496 unicode_method_found
= 1;
497 res
= PyObject_CallFunctionObjArgs(func
, NULL
);
505 /* Not a classic class instance, try __unicode__. */
506 func
= _PyObject_LookupSpecial(v
, "__unicode__", &unicodestr
);
508 unicode_method_found
= 1;
509 res
= PyObject_CallFunctionObjArgs(func
, NULL
);
512 else if (PyErr_Occurred())
516 /* Didn't find __unicode__ */
517 if (!unicode_method_found
) {
518 if (PyUnicode_Check(v
)) {
519 /* For a Unicode subtype that's didn't overwrite __unicode__,
520 return a true Unicode object with the same data. */
521 return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v
),
522 PyUnicode_GET_SIZE(v
));
524 if (PyString_CheckExact(v
)) {
529 if (Py_TYPE(v
)->tp_str
!= NULL
)
530 res
= (*Py_TYPE(v
)->tp_str
)(v
);
532 res
= PyObject_Repr(v
);
538 if (!PyUnicode_Check(res
)) {
539 str
= PyUnicode_FromEncodedObject(res
, NULL
, "strict");
548 /* Helper to warn about deprecated tp_compare return values. Return:
553 (This function cannot return 2.)
556 adjust_tp_compare(int c
)
558 if (PyErr_Occurred()) {
559 if (c
!= -1 && c
!= -2) {
560 PyObject
*t
, *v
, *tb
;
561 PyErr_Fetch(&t
, &v
, &tb
);
562 if (PyErr_Warn(PyExc_RuntimeWarning
,
563 "tp_compare didn't return -1 or -2 "
564 "for exception") < 0) {
570 PyErr_Restore(t
, v
, tb
);
574 else if (c
< -1 || c
> 1) {
575 if (PyErr_Warn(PyExc_RuntimeWarning
,
576 "tp_compare didn't return -1, 0 or 1") < 0)
579 return c
< -1 ? -1 : 1;
582 assert(c
>= -1 && c
<= 1);
588 /* Macro to get the tp_richcompare field of a type if defined */
589 #define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) \
590 ? (t)->tp_richcompare : NULL)
592 /* Map rich comparison operators to their swapped version, e.g. LT --> GT */
593 int _Py_SwappedOp
[] = {Py_GT
, Py_GE
, Py_EQ
, Py_NE
, Py_LT
, Py_LE
};
595 /* Try a genuine rich comparison, returning an object. Return:
597 NotImplemented if this particular rich comparison is not implemented or
599 some object not equal to NotImplemented if it is implemented
600 (this latter object may not be a Boolean).
603 try_rich_compare(PyObject
*v
, PyObject
*w
, int op
)
608 if (v
->ob_type
!= w
->ob_type
&&
609 PyType_IsSubtype(w
->ob_type
, v
->ob_type
) &&
610 (f
= RICHCOMPARE(w
->ob_type
)) != NULL
) {
611 res
= (*f
)(w
, v
, _Py_SwappedOp
[op
]);
612 if (res
!= Py_NotImplemented
)
616 if ((f
= RICHCOMPARE(v
->ob_type
)) != NULL
) {
617 res
= (*f
)(v
, w
, op
);
618 if (res
!= Py_NotImplemented
)
622 if ((f
= RICHCOMPARE(w
->ob_type
)) != NULL
) {
623 return (*f
)(w
, v
, _Py_SwappedOp
[op
]);
625 res
= Py_NotImplemented
;
630 /* Try a genuine rich comparison, returning an int. Return:
631 -1 for exception (including the case where try_rich_compare() returns an
632 object that's not a Boolean);
633 0 if the outcome is false;
634 1 if the outcome is true;
635 2 if this particular rich comparison is not implemented or undefined.
638 try_rich_compare_bool(PyObject
*v
, PyObject
*w
, int op
)
643 if (RICHCOMPARE(v
->ob_type
) == NULL
&& RICHCOMPARE(w
->ob_type
) == NULL
)
644 return 2; /* Shortcut, avoid INCREF+DECREF */
645 res
= try_rich_compare(v
, w
, op
);
648 if (res
== Py_NotImplemented
) {
652 ok
= PyObject_IsTrue(res
);
657 /* Try rich comparisons to determine a 3-way comparison. Return:
662 2 if this particular rich comparison is not implemented or undefined.
665 try_rich_to_3way_compare(PyObject
*v
, PyObject
*w
)
667 static struct { int op
; int outcome
; } tries
[3] = {
668 /* Try this operator, and if it is true, use this outcome: */
675 if (RICHCOMPARE(v
->ob_type
) == NULL
&& RICHCOMPARE(w
->ob_type
) == NULL
)
676 return 2; /* Shortcut */
678 for (i
= 0; i
< 3; i
++) {
679 switch (try_rich_compare_bool(v
, w
, tries
[i
].op
)) {
683 return tries
[i
].outcome
;
690 /* Try a 3-way comparison, returning an int. Return:
695 2 if this particular 3-way comparison is not implemented or undefined.
698 try_3way_compare(PyObject
*v
, PyObject
*w
)
703 /* Comparisons involving instances are given to instance_compare,
704 which has the same return conventions as this function. */
706 f
= v
->ob_type
->tp_compare
;
707 if (PyInstance_Check(v
))
709 if (PyInstance_Check(w
))
710 return (*w
->ob_type
->tp_compare
)(v
, w
);
712 /* If both have the same (non-NULL) tp_compare, use it. */
713 if (f
!= NULL
&& f
== w
->ob_type
->tp_compare
) {
715 return adjust_tp_compare(c
);
718 /* If either tp_compare is _PyObject_SlotCompare, that's safe. */
719 if (f
== _PyObject_SlotCompare
||
720 w
->ob_type
->tp_compare
== _PyObject_SlotCompare
)
721 return _PyObject_SlotCompare(v
, w
);
723 /* If we're here, v and w,
724 a) are not instances;
725 b) have different types or a type without tp_compare; and
726 c) don't have a user-defined tp_compare.
727 tp_compare implementations in C assume that both arguments
728 have their type, so we give up if the coercion fails or if
729 it yields types which are still incompatible (which can
730 happen with a user-defined nb_coerce).
732 c
= PyNumber_CoerceEx(&v
, &w
);
737 f
= v
->ob_type
->tp_compare
;
738 if (f
!= NULL
&& f
== w
->ob_type
->tp_compare
) {
742 return adjust_tp_compare(c
);
745 /* No comparison defined */
751 /* Final fallback 3-way comparison, returning an int. Return:
752 -2 if an error occurred;
758 default_3way_compare(PyObject
*v
, PyObject
*w
)
761 const char *vname
, *wname
;
763 if (v
->ob_type
== w
->ob_type
) {
764 /* When comparing these pointers, they must be cast to
765 * integer types (i.e. Py_uintptr_t, our spelling of C9X's
766 * uintptr_t). ANSI specifies that pointer compares other
767 * than == and != to non-related structures are undefined.
769 Py_uintptr_t vv
= (Py_uintptr_t
)v
;
770 Py_uintptr_t ww
= (Py_uintptr_t
)w
;
771 return (vv
< ww
) ? -1 : (vv
> ww
) ? 1 : 0;
774 /* None is smaller than anything */
780 /* different type: compare type names; numbers are smaller */
781 if (PyNumber_Check(v
))
784 vname
= v
->ob_type
->tp_name
;
785 if (PyNumber_Check(w
))
788 wname
= w
->ob_type
->tp_name
;
789 c
= strcmp(vname
, wname
);
794 /* Same type name, or (more likely) incomparable numeric types */
795 return ((Py_uintptr_t
)(v
->ob_type
) < (
796 Py_uintptr_t
)(w
->ob_type
)) ? -1 : 1;
799 /* Do a 3-way comparison, by hook or by crook. Return:
800 -2 for an exception (but see below);
804 BUT: if the object implements a tp_compare function, it returns
805 whatever this function returns (whether with an exception or not).
808 do_cmp(PyObject
*v
, PyObject
*w
)
813 if (v
->ob_type
== w
->ob_type
814 && (f
= v
->ob_type
->tp_compare
) != NULL
) {
816 if (PyInstance_Check(v
)) {
817 /* Instance tp_compare has a different signature.
818 But if it returns undefined we fall through. */
821 /* Else fall through to try_rich_to_3way_compare() */
824 return adjust_tp_compare(c
);
826 /* We only get here if one of the following is true:
827 a) v and w have different types
828 b) v and w have the same type, which doesn't have tp_compare
829 c) v and w are instances, and either __cmp__ is not defined or
830 __cmp__ returns NotImplemented
832 c
= try_rich_to_3way_compare(v
, w
);
835 c
= try_3way_compare(v
, w
);
838 return default_3way_compare(v
, w
);
841 /* Compare v to w. Return
842 -1 if v < w or exception (PyErr_Occurred() true in latter case).
845 XXX The docs (C API manual) say the return value is undefined in case
849 PyObject_Compare(PyObject
*v
, PyObject
*w
)
853 if (v
== NULL
|| w
== NULL
) {
854 PyErr_BadInternalCall();
859 if (Py_EnterRecursiveCall(" in cmp"))
861 result
= do_cmp(v
, w
);
862 Py_LeaveRecursiveCall();
863 return result
< 0 ? -1 : result
;
866 /* Return (new reference to) Py_True or Py_False. */
868 convert_3way_to_object(int op
, int c
)
872 case Py_LT
: c
= c
< 0; break;
873 case Py_LE
: c
= c
<= 0; break;
874 case Py_EQ
: c
= c
== 0; break;
875 case Py_NE
: c
= c
!= 0; break;
876 case Py_GT
: c
= c
> 0; break;
877 case Py_GE
: c
= c
>= 0; break;
879 result
= c
? Py_True
: Py_False
;
884 /* We want a rich comparison but don't have one. Try a 3-way cmp instead.
888 Py_False if not (v op w)
891 try_3way_to_rich_compare(PyObject
*v
, PyObject
*w
, int op
)
895 c
= try_3way_compare(v
, w
);
898 /* Py3K warning if types are not equal and comparison isn't == or != */
899 if (Py_Py3kWarningFlag
&&
900 v
->ob_type
!= w
->ob_type
&& op
!= Py_EQ
&& op
!= Py_NE
&&
901 PyErr_WarnEx(PyExc_DeprecationWarning
,
902 "comparing unequal types not supported "
907 c
= default_3way_compare(v
, w
);
911 return convert_3way_to_object(op
, c
);
914 /* Do rich comparison on v and w. Return
916 Else a new reference to an object other than Py_NotImplemented, usually(?):
918 Py_False if not (v op w)
921 do_richcmp(PyObject
*v
, PyObject
*w
, int op
)
925 res
= try_rich_compare(v
, w
, op
);
926 if (res
!= Py_NotImplemented
)
930 return try_3way_to_rich_compare(v
, w
, op
);
935 some object not equal to NotImplemented if it is implemented
936 (this latter object may not be a Boolean).
939 PyObject_RichCompare(PyObject
*v
, PyObject
*w
, int op
)
943 assert(Py_LT
<= op
&& op
<= Py_GE
);
944 if (Py_EnterRecursiveCall(" in cmp"))
947 /* If the types are equal, and not old-style instances, try to
948 get out cheap (don't bother with coercions etc.). */
949 if (v
->ob_type
== w
->ob_type
&& !PyInstance_Check(v
)) {
951 richcmpfunc frich
= RICHCOMPARE(v
->ob_type
);
952 /* If the type has richcmp, try it first. try_rich_compare
953 tries it two-sided, which is not needed since we've a
956 res
= (*frich
)(v
, w
, op
);
957 if (res
!= Py_NotImplemented
)
961 /* No richcmp, or this particular richmp not implemented.
963 fcmp
= v
->ob_type
->tp_compare
;
965 int c
= (*fcmp
)(v
, w
);
966 c
= adjust_tp_compare(c
);
971 res
= convert_3way_to_object(op
, c
);
976 /* Fast path not taken, or couldn't deliver a useful result. */
977 res
= do_richcmp(v
, w
, op
);
979 Py_LeaveRecursiveCall();
983 /* Return -1 if error; 1 if v op w; 0 if not (v op w). */
985 PyObject_RichCompareBool(PyObject
*v
, PyObject
*w
, int op
)
990 /* Quick result when objects are the same.
991 Guarantees that identity implies equality. */
995 else if (op
== Py_NE
)
999 res
= PyObject_RichCompare(v
, w
, op
);
1002 if (PyBool_Check(res
))
1003 ok
= (res
== Py_True
);
1005 ok
= PyObject_IsTrue(res
);
1010 /* Set of hash utility functions to help maintaining the invariant that
1011 if a==b then hash(a)==hash(b)
1013 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
1017 _Py_HashDouble(double v
)
1019 double intpart
, fractpart
;
1022 long x
; /* the final hash value */
1023 /* This is designed so that Python numbers of different types
1024 * that compare equal hash to the same value; otherwise comparisons
1025 * of mapping keys will turn out weird.
1028 if (!Py_IS_FINITE(v
)) {
1029 if (Py_IS_INFINITY(v
))
1030 return v
< 0 ? -271828 : 314159;
1034 fractpart
= modf(v
, &intpart
);
1035 if (fractpart
== 0.0) {
1036 /* This must return the same hash as an equal int or long. */
1037 if (intpart
> LONG_MAX
/2 || -intpart
> LONG_MAX
/2) {
1038 /* Convert to long and use its hash. */
1039 PyObject
*plong
; /* converted to Python long */
1040 plong
= PyLong_FromDouble(v
);
1043 x
= PyObject_Hash(plong
);
1047 /* Fits in a C long == a Python int, so is its own hash. */
1053 /* The fractional part is non-zero, so we don't have to worry about
1054 * making this match the hash of some other type.
1055 * Use frexp to get at the bits in the double.
1056 * Since the VAX D double format has 56 mantissa bits, which is the
1057 * most of any double format in use, each of these parts may have as
1058 * many as (but no more than) 56 significant bits.
1059 * So, assuming sizeof(long) >= 4, each part can be broken into two
1060 * longs; frexp and multiplication are used to do that.
1061 * Also, since the Cray double format has 15 exponent bits, which is
1062 * the most of any double format in use, shifting the exponent field
1063 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4).
1065 v
= frexp(v
, &expo
);
1066 v
*= 2147483648.0; /* 2**31 */
1067 hipart
= (long)v
; /* take the top 32 bits */
1068 v
= (v
- (double)hipart
) * 2147483648.0; /* get the next 32 bits */
1069 x
= hipart
+ (long)v
+ (expo
<< 15);
1076 _Py_HashPointer(void *p
)
1079 size_t y
= (size_t)p
;
1080 /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
1081 excessive hash collisions for dicts and sets */
1082 y
= (y
>> 4) | (y
<< (8 * SIZEOF_VOID_P
- 4));
1090 PyObject_HashNotImplemented(PyObject
*self
)
1092 PyErr_Format(PyExc_TypeError
, "unhashable type: '%.200s'",
1093 self
->ob_type
->tp_name
);
1098 PyObject_Hash(PyObject
*v
)
1100 PyTypeObject
*tp
= v
->ob_type
;
1101 if (tp
->tp_hash
!= NULL
)
1102 return (*tp
->tp_hash
)(v
);
1103 /* To keep to the general practice that inheriting
1104 * solely from object in C code should work without
1105 * an explicit call to PyType_Ready, we implicitly call
1106 * PyType_Ready here and then check the tp_hash slot again
1108 if (tp
->tp_dict
== NULL
) {
1109 if (PyType_Ready(tp
) < 0)
1111 if (tp
->tp_hash
!= NULL
)
1112 return (*tp
->tp_hash
)(v
);
1114 if (tp
->tp_compare
== NULL
&& RICHCOMPARE(tp
) == NULL
) {
1115 return _Py_HashPointer(v
); /* Use address as hash value */
1117 /* If there's a cmp but no hash defined, the object can't be hashed */
1118 return PyObject_HashNotImplemented(v
);
1122 PyObject_GetAttrString(PyObject
*v
, const char *name
)
1126 if (Py_TYPE(v
)->tp_getattr
!= NULL
)
1127 return (*Py_TYPE(v
)->tp_getattr
)(v
, (char*)name
);
1128 w
= PyString_InternFromString(name
);
1131 res
= PyObject_GetAttr(v
, w
);
1137 PyObject_HasAttrString(PyObject
*v
, const char *name
)
1139 PyObject
*res
= PyObject_GetAttrString(v
, name
);
1149 PyObject_SetAttrString(PyObject
*v
, const char *name
, PyObject
*w
)
1154 if (Py_TYPE(v
)->tp_setattr
!= NULL
)
1155 return (*Py_TYPE(v
)->tp_setattr
)(v
, (char*)name
, w
);
1156 s
= PyString_InternFromString(name
);
1159 res
= PyObject_SetAttr(v
, s
, w
);
1165 PyObject_GetAttr(PyObject
*v
, PyObject
*name
)
1167 PyTypeObject
*tp
= Py_TYPE(v
);
1169 if (!PyString_Check(name
)) {
1170 #ifdef Py_USING_UNICODE
1171 /* The Unicode to string conversion is done here because the
1172 existing tp_getattro slots expect a string object as name
1173 and we wouldn't want to break those. */
1174 if (PyUnicode_Check(name
)) {
1175 name
= _PyUnicode_AsDefaultEncodedString(name
, NULL
);
1182 PyErr_Format(PyExc_TypeError
,
1183 "attribute name must be string, not '%.200s'",
1184 Py_TYPE(name
)->tp_name
);
1188 if (tp
->tp_getattro
!= NULL
)
1189 return (*tp
->tp_getattro
)(v
, name
);
1190 if (tp
->tp_getattr
!= NULL
)
1191 return (*tp
->tp_getattr
)(v
, PyString_AS_STRING(name
));
1192 PyErr_Format(PyExc_AttributeError
,
1193 "'%.50s' object has no attribute '%.400s'",
1194 tp
->tp_name
, PyString_AS_STRING(name
));
1199 PyObject_HasAttr(PyObject
*v
, PyObject
*name
)
1201 PyObject
*res
= PyObject_GetAttr(v
, name
);
1211 PyObject_SetAttr(PyObject
*v
, PyObject
*name
, PyObject
*value
)
1213 PyTypeObject
*tp
= Py_TYPE(v
);
1216 if (!PyString_Check(name
)){
1217 #ifdef Py_USING_UNICODE
1218 /* The Unicode to string conversion is done here because the
1219 existing tp_setattro slots expect a string object as name
1220 and we wouldn't want to break those. */
1221 if (PyUnicode_Check(name
)) {
1222 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1229 PyErr_Format(PyExc_TypeError
,
1230 "attribute name must be string, not '%.200s'",
1231 Py_TYPE(name
)->tp_name
);
1238 PyString_InternInPlace(&name
);
1239 if (tp
->tp_setattro
!= NULL
) {
1240 err
= (*tp
->tp_setattro
)(v
, name
, value
);
1244 if (tp
->tp_setattr
!= NULL
) {
1245 err
= (*tp
->tp_setattr
)(v
, PyString_AS_STRING(name
), value
);
1250 if (tp
->tp_getattr
== NULL
&& tp
->tp_getattro
== NULL
)
1251 PyErr_Format(PyExc_TypeError
,
1252 "'%.100s' object has no attributes "
1255 value
==NULL
? "del" : "assign to",
1256 PyString_AS_STRING(name
));
1258 PyErr_Format(PyExc_TypeError
,
1259 "'%.100s' object has only read-only attributes "
1262 value
==NULL
? "del" : "assign to",
1263 PyString_AS_STRING(name
));
1267 /* Helper to get a pointer to an object's __dict__ slot, if any */
1270 _PyObject_GetDictPtr(PyObject
*obj
)
1272 Py_ssize_t dictoffset
;
1273 PyTypeObject
*tp
= Py_TYPE(obj
);
1275 if (!(tp
->tp_flags
& Py_TPFLAGS_HAVE_CLASS
))
1277 dictoffset
= tp
->tp_dictoffset
;
1278 if (dictoffset
== 0)
1280 if (dictoffset
< 0) {
1284 tsize
= ((PyVarObject
*)obj
)->ob_size
;
1287 size
= _PyObject_VAR_SIZE(tp
, tsize
);
1289 dictoffset
+= (long)size
;
1290 assert(dictoffset
> 0);
1291 assert(dictoffset
% SIZEOF_VOID_P
== 0);
1293 return (PyObject
**) ((char *)obj
+ dictoffset
);
1297 PyObject_SelfIter(PyObject
*obj
)
1303 /* Helper used when the __next__ method is removed from a type:
1304 tp_iternext is never NULL and can be safely called without checking
1309 _PyObject_NextNotImplemented(PyObject
*self
)
1311 PyErr_Format(PyExc_TypeError
,
1312 "'%.200s' object is not iterable",
1313 Py_TYPE(self
)->tp_name
);
1317 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
1320 _PyObject_GenericGetAttrWithDict(PyObject
*obj
, PyObject
*name
, PyObject
*dict
)
1322 PyTypeObject
*tp
= Py_TYPE(obj
);
1323 PyObject
*descr
= NULL
;
1324 PyObject
*res
= NULL
;
1326 Py_ssize_t dictoffset
;
1329 if (!PyString_Check(name
)){
1330 #ifdef Py_USING_UNICODE
1331 /* The Unicode to string conversion is done here because the
1332 existing tp_setattro slots expect a string object as name
1333 and we wouldn't want to break those. */
1334 if (PyUnicode_Check(name
)) {
1335 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1342 PyErr_Format(PyExc_TypeError
,
1343 "attribute name must be string, not '%.200s'",
1344 Py_TYPE(name
)->tp_name
);
1351 if (tp
->tp_dict
== NULL
) {
1352 if (PyType_Ready(tp
) < 0)
1356 #if 0 /* XXX this is not quite _PyType_Lookup anymore */
1357 /* Inline _PyType_Lookup */
1360 PyObject
*mro
, *base
, *dict
;
1362 /* Look in tp_dict of types in MRO */
1364 assert(mro
!= NULL
);
1365 assert(PyTuple_Check(mro
));
1366 n
= PyTuple_GET_SIZE(mro
);
1367 for (i
= 0; i
< n
; i
++) {
1368 base
= PyTuple_GET_ITEM(mro
, i
);
1369 if (PyClass_Check(base
))
1370 dict
= ((PyClassObject
*)base
)->cl_dict
;
1372 assert(PyType_Check(base
));
1373 dict
= ((PyTypeObject
*)base
)->tp_dict
;
1375 assert(dict
&& PyDict_Check(dict
));
1376 descr
= PyDict_GetItem(dict
, name
);
1382 descr
= _PyType_Lookup(tp
, name
);
1388 if (descr
!= NULL
&&
1389 PyType_HasFeature(descr
->ob_type
, Py_TPFLAGS_HAVE_CLASS
)) {
1390 f
= descr
->ob_type
->tp_descr_get
;
1391 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1392 res
= f(descr
, obj
, (PyObject
*)obj
->ob_type
);
1399 /* Inline _PyObject_GetDictPtr */
1400 dictoffset
= tp
->tp_dictoffset
;
1401 if (dictoffset
!= 0) {
1402 if (dictoffset
< 0) {
1406 tsize
= ((PyVarObject
*)obj
)->ob_size
;
1409 size
= _PyObject_VAR_SIZE(tp
, tsize
);
1411 dictoffset
+= (long)size
;
1412 assert(dictoffset
> 0);
1413 assert(dictoffset
% SIZEOF_VOID_P
== 0);
1415 dictptr
= (PyObject
**) ((char *)obj
+ dictoffset
);
1421 res
= PyDict_GetItem(dict
, name
);
1432 res
= f(descr
, obj
, (PyObject
*)Py_TYPE(obj
));
1437 if (descr
!= NULL
) {
1439 /* descr was already increfed above */
1443 PyErr_Format(PyExc_AttributeError
,
1444 "'%.50s' object has no attribute '%.400s'",
1445 tp
->tp_name
, PyString_AS_STRING(name
));
1452 PyObject_GenericGetAttr(PyObject
*obj
, PyObject
*name
)
1454 return _PyObject_GenericGetAttrWithDict(obj
, name
, NULL
);
1458 _PyObject_GenericSetAttrWithDict(PyObject
*obj
, PyObject
*name
,
1459 PyObject
*value
, PyObject
*dict
)
1461 PyTypeObject
*tp
= Py_TYPE(obj
);
1467 if (!PyString_Check(name
)){
1468 #ifdef Py_USING_UNICODE
1469 /* The Unicode to string conversion is done here because the
1470 existing tp_setattro slots expect a string object as name
1471 and we wouldn't want to break those. */
1472 if (PyUnicode_Check(name
)) {
1473 name
= PyUnicode_AsEncodedString(name
, NULL
, NULL
);
1480 PyErr_Format(PyExc_TypeError
,
1481 "attribute name must be string, not '%.200s'",
1482 Py_TYPE(name
)->tp_name
);
1489 if (tp
->tp_dict
== NULL
) {
1490 if (PyType_Ready(tp
) < 0)
1494 descr
= _PyType_Lookup(tp
, name
);
1496 if (descr
!= NULL
&&
1497 PyType_HasFeature(descr
->ob_type
, Py_TPFLAGS_HAVE_CLASS
)) {
1498 f
= descr
->ob_type
->tp_descr_set
;
1499 if (f
!= NULL
&& PyDescr_IsData(descr
)) {
1500 res
= f(descr
, obj
, value
);
1506 dictptr
= _PyObject_GetDictPtr(obj
);
1507 if (dictptr
!= NULL
) {
1509 if (dict
== NULL
&& value
!= NULL
) {
1510 dict
= PyDict_New();
1520 res
= PyDict_DelItem(dict
, name
);
1522 res
= PyDict_SetItem(dict
, name
, value
);
1523 if (res
< 0 && PyErr_ExceptionMatches(PyExc_KeyError
))
1524 PyErr_SetObject(PyExc_AttributeError
, name
);
1530 res
= f(descr
, obj
, value
);
1534 if (descr
== NULL
) {
1535 PyErr_Format(PyExc_AttributeError
,
1536 "'%.100s' object has no attribute '%.200s'",
1537 tp
->tp_name
, PyString_AS_STRING(name
));
1541 PyErr_Format(PyExc_AttributeError
,
1542 "'%.50s' object attribute '%.400s' is read-only",
1543 tp
->tp_name
, PyString_AS_STRING(name
));
1550 PyObject_GenericSetAttr(PyObject
*obj
, PyObject
*name
, PyObject
*value
)
1552 return _PyObject_GenericSetAttrWithDict(obj
, name
, value
, NULL
);
1556 /* Test a value used as condition, e.g., in a for or if statement.
1557 Return -1 if an error occurred */
1560 PyObject_IsTrue(PyObject
*v
)
1569 else if (v
->ob_type
->tp_as_number
!= NULL
&&
1570 v
->ob_type
->tp_as_number
->nb_nonzero
!= NULL
)
1571 res
= (*v
->ob_type
->tp_as_number
->nb_nonzero
)(v
);
1572 else if (v
->ob_type
->tp_as_mapping
!= NULL
&&
1573 v
->ob_type
->tp_as_mapping
->mp_length
!= NULL
)
1574 res
= (*v
->ob_type
->tp_as_mapping
->mp_length
)(v
);
1575 else if (v
->ob_type
->tp_as_sequence
!= NULL
&&
1576 v
->ob_type
->tp_as_sequence
->sq_length
!= NULL
)
1577 res
= (*v
->ob_type
->tp_as_sequence
->sq_length
)(v
);
1580 /* if it is negative, it should be either -1 or -2 */
1581 return (res
> 0) ? 1 : Py_SAFE_DOWNCAST(res
, Py_ssize_t
, int);
1584 /* equivalent of 'not v'
1585 Return -1 if an error occurred */
1588 PyObject_Not(PyObject
*v
)
1591 res
= PyObject_IsTrue(v
);
1597 /* Coerce two numeric types to the "larger" one.
1598 Increment the reference count on each argument.
1600 -1 if an error occurred;
1601 0 if the coercion succeeded (and then the reference counts are increased);
1602 1 if no coercion is possible (and no error is raised).
1605 PyNumber_CoerceEx(PyObject
**pv
, PyObject
**pw
)
1607 register PyObject
*v
= *pv
;
1608 register PyObject
*w
= *pw
;
1611 /* Shortcut only for old-style types */
1612 if (v
->ob_type
== w
->ob_type
&&
1613 !PyType_HasFeature(v
->ob_type
, Py_TPFLAGS_CHECKTYPES
))
1619 if (v
->ob_type
->tp_as_number
&& v
->ob_type
->tp_as_number
->nb_coerce
) {
1620 res
= (*v
->ob_type
->tp_as_number
->nb_coerce
)(pv
, pw
);
1624 if (w
->ob_type
->tp_as_number
&& w
->ob_type
->tp_as_number
->nb_coerce
) {
1625 res
= (*w
->ob_type
->tp_as_number
->nb_coerce
)(pw
, pv
);
1632 /* Coerce two numeric types to the "larger" one.
1633 Increment the reference count on each argument.
1634 Return -1 and raise an exception if no coercion is possible
1635 (and then no reference count is incremented).
1638 PyNumber_Coerce(PyObject
**pv
, PyObject
**pw
)
1640 int err
= PyNumber_CoerceEx(pv
, pw
);
1643 PyErr_SetString(PyExc_TypeError
, "number coercion failed");
1648 /* Test whether an object can be called */
1651 PyCallable_Check(PyObject
*x
)
1655 if (PyInstance_Check(x
)) {
1656 PyObject
*call
= PyObject_GetAttrString(x
, "__call__");
1661 /* Could test recursively but don't, for fear of endless
1662 recursion if some joker sets self.__call__ = self */
1667 return x
->ob_type
->tp_call
!= NULL
;
1671 /* ------------------------- PyObject_Dir() helpers ------------------------- */
1673 /* Helper for PyObject_Dir.
1674 Merge the __dict__ of aclass into dict, and recursively also all
1675 the __dict__s of aclass's base classes. The order of merging isn't
1676 defined, as it's expected that only the final set of dict keys is
1678 Return 0 on success, -1 on error.
1682 merge_class_dict(PyObject
* dict
, PyObject
* aclass
)
1684 PyObject
*classdict
;
1687 assert(PyDict_Check(dict
));
1690 /* Merge in the type's dict (if any). */
1691 classdict
= PyObject_GetAttrString(aclass
, "__dict__");
1692 if (classdict
== NULL
)
1695 int status
= PyDict_Update(dict
, classdict
);
1696 Py_DECREF(classdict
);
1701 /* Recursively merge in the base types' (if any) dicts. */
1702 bases
= PyObject_GetAttrString(aclass
, "__bases__");
1706 /* We have no guarantee that bases is a real tuple */
1708 n
= PySequence_Size(bases
); /* This better be right */
1712 for (i
= 0; i
< n
; i
++) {
1714 PyObject
*base
= PySequence_GetItem(bases
, i
);
1719 status
= merge_class_dict(dict
, base
);
1732 /* Helper for PyObject_Dir.
1733 If obj has an attr named attrname that's a list, merge its string
1734 elements into keys of dict.
1735 Return 0 on success, -1 on error. Errors due to not finding the attr,
1736 or the attr not being a list, are suppressed.
1740 merge_list_attr(PyObject
* dict
, PyObject
* obj
, const char *attrname
)
1745 assert(PyDict_Check(dict
));
1749 list
= PyObject_GetAttrString(obj
, attrname
);
1753 else if (PyList_Check(list
)) {
1755 for (i
= 0; i
< PyList_GET_SIZE(list
); ++i
) {
1756 PyObject
*item
= PyList_GET_ITEM(list
, i
);
1757 if (PyString_Check(item
)) {
1758 result
= PyDict_SetItem(dict
, item
, Py_None
);
1763 if (Py_Py3kWarningFlag
&&
1764 (strcmp(attrname
, "__members__") == 0 ||
1765 strcmp(attrname
, "__methods__") == 0)) {
1766 if (PyErr_WarnEx(PyExc_DeprecationWarning
,
1767 "__members__ and __methods__ not "
1768 "supported in 3.x", 1) < 0) {
1779 /* Helper for PyObject_Dir without arguments: returns the local scope. */
1784 PyObject
*locals
= PyEval_GetLocals();
1786 if (locals
== NULL
) {
1787 PyErr_SetString(PyExc_SystemError
, "frame does not exist");
1791 names
= PyMapping_Keys(locals
);
1794 if (!PyList_Check(names
)) {
1795 PyErr_Format(PyExc_TypeError
,
1796 "dir(): expected keys() of locals to be a list, "
1797 "not '%.200s'", Py_TYPE(names
)->tp_name
);
1801 /* the locals don't need to be DECREF'd */
1805 /* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__.
1806 We deliberately don't suck up its __class__, as methods belonging to the
1807 metaclass would probably be more confusing than helpful.
1810 _specialized_dir_type(PyObject
*obj
)
1812 PyObject
*result
= NULL
;
1813 PyObject
*dict
= PyDict_New();
1815 if (dict
!= NULL
&& merge_class_dict(dict
, obj
) == 0)
1816 result
= PyDict_Keys(dict
);
1822 /* Helper for PyObject_Dir of module objects: returns the module's __dict__. */
1824 _specialized_dir_module(PyObject
*obj
)
1826 PyObject
*result
= NULL
;
1827 PyObject
*dict
= PyObject_GetAttrString(obj
, "__dict__");
1830 if (PyDict_Check(dict
))
1831 result
= PyDict_Keys(dict
);
1833 char *name
= PyModule_GetName(obj
);
1835 PyErr_Format(PyExc_TypeError
,
1836 "%.200s.__dict__ is not a dictionary",
1845 /* Helper for PyObject_Dir of generic objects: returns __dict__, __class__,
1846 and recursively up the __class__.__bases__ chain.
1849 _generic_dir(PyObject
*obj
)
1851 PyObject
*result
= NULL
;
1852 PyObject
*dict
= NULL
;
1853 PyObject
*itsclass
= NULL
;
1855 /* Get __dict__ (which may or may not be a real dict...) */
1856 dict
= PyObject_GetAttrString(obj
, "__dict__");
1859 dict
= PyDict_New();
1861 else if (!PyDict_Check(dict
)) {
1863 dict
= PyDict_New();
1866 /* Copy __dict__ to avoid mutating it. */
1867 PyObject
*temp
= PyDict_Copy(dict
);
1875 /* Merge in __members__ and __methods__ (if any).
1876 * This is removed in Python 3000. */
1877 if (merge_list_attr(dict
, obj
, "__members__") < 0)
1879 if (merge_list_attr(dict
, obj
, "__methods__") < 0)
1882 /* Merge in attrs reachable from its class. */
1883 itsclass
= PyObject_GetAttrString(obj
, "__class__");
1884 if (itsclass
== NULL
)
1885 /* XXX(tomer): Perhaps fall back to obj->ob_type if no
1886 __class__ exists? */
1889 if (merge_class_dict(dict
, itsclass
) != 0)
1893 result
= PyDict_Keys(dict
);
1896 Py_XDECREF(itsclass
);
1901 /* Helper for PyObject_Dir: object introspection.
1902 This calls one of the above specialized versions if no __dir__ method
1905 _dir_object(PyObject
*obj
)
1907 PyObject
*result
= NULL
;
1908 static PyObject
*dir_str
= NULL
;
1912 if (PyInstance_Check(obj
)) {
1913 dirfunc
= PyObject_GetAttrString(obj
, "__dir__");
1914 if (dirfunc
== NULL
) {
1915 if (PyErr_ExceptionMatches(PyExc_AttributeError
))
1922 dirfunc
= _PyObject_LookupSpecial(obj
, "__dir__", &dir_str
);
1923 if (PyErr_Occurred())
1926 if (dirfunc
== NULL
) {
1927 /* use default implementation */
1928 if (PyModule_Check(obj
))
1929 result
= _specialized_dir_module(obj
);
1930 else if (PyType_Check(obj
) || PyClass_Check(obj
))
1931 result
= _specialized_dir_type(obj
);
1933 result
= _generic_dir(obj
);
1937 result
= PyObject_CallFunctionObjArgs(dirfunc
, NULL
);
1942 /* result must be a list */
1943 /* XXX(gbrandl): could also check if all items are strings */
1944 if (!PyList_Check(result
)) {
1945 PyErr_Format(PyExc_TypeError
,
1946 "__dir__() must return a list, not %.200s",
1947 Py_TYPE(result
)->tp_name
);
1956 /* Implementation of dir() -- if obj is NULL, returns the names in the current
1957 (local) scope. Otherwise, performs introspection of the object: returns a
1958 sorted list of attribute names (supposedly) accessible from the object
1961 PyObject_Dir(PyObject
*obj
)
1966 /* no object -- introspect the locals */
1967 result
= _dir_locals();
1969 /* object -- introspect the object */
1970 result
= _dir_object(obj
);
1972 assert(result
== NULL
|| PyList_Check(result
));
1974 if (result
!= NULL
&& PyList_Sort(result
) != 0) {
1975 /* sorting the list failed */
1984 NoObject is usable as a non-NULL undefined value, used by the macro None.
1985 There is (and should be!) no way to create other objects of this type,
1986 so there is exactly one (which is indestructible, by the way).
1987 (XXX This type and the type of NotImplemented below should be unified.)
1992 none_repr(PyObject
*op
)
1994 return PyString_FromString("None");
1999 none_dealloc(PyObject
* ignore
)
2001 /* This should never get called, but we also don't want to SEGV if
2002 * we accidentally decref None out of existence.
2004 Py_FatalError("deallocating None");
2008 static PyTypeObject PyNone_Type
= {
2009 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
2013 none_dealloc
, /*tp_dealloc*/ /*never called*/
2018 none_repr
, /*tp_repr*/
2020 0, /*tp_as_sequence*/
2021 0, /*tp_as_mapping*/
2022 (hashfunc
)_Py_HashPointer
, /*tp_hash */
2025 PyObject _Py_NoneStruct
= {
2026 _PyObject_EXTRA_INIT
2030 /* NotImplemented is an object that can be used to signal that an
2031 operation is not implemented for the given type combination. */
2034 NotImplemented_repr(PyObject
*op
)
2036 return PyString_FromString("NotImplemented");
2039 static PyTypeObject PyNotImplemented_Type
= {
2040 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
2041 "NotImplementedType",
2044 none_dealloc
, /*tp_dealloc*/ /*never called*/
2049 NotImplemented_repr
, /*tp_repr*/
2051 0, /*tp_as_sequence*/
2052 0, /*tp_as_mapping*/
2056 PyObject _Py_NotImplementedStruct
= {
2057 _PyObject_EXTRA_INIT
2058 1, &PyNotImplemented_Type
2062 _Py_ReadyTypes(void)
2064 if (PyType_Ready(&PyType_Type
) < 0)
2065 Py_FatalError("Can't initialize type type");
2067 if (PyType_Ready(&_PyWeakref_RefType
) < 0)
2068 Py_FatalError("Can't initialize weakref type");
2070 if (PyType_Ready(&_PyWeakref_CallableProxyType
) < 0)
2071 Py_FatalError("Can't initialize callable weakref proxy type");
2073 if (PyType_Ready(&_PyWeakref_ProxyType
) < 0)
2074 Py_FatalError("Can't initialize weakref proxy type");
2076 if (PyType_Ready(&PyBool_Type
) < 0)
2077 Py_FatalError("Can't initialize bool type");
2079 if (PyType_Ready(&PyString_Type
) < 0)
2080 Py_FatalError("Can't initialize str type");
2082 if (PyType_Ready(&PyByteArray_Type
) < 0)
2083 Py_FatalError("Can't initialize bytearray type");
2085 if (PyType_Ready(&PyList_Type
) < 0)
2086 Py_FatalError("Can't initialize list type");
2088 if (PyType_Ready(&PyNone_Type
) < 0)
2089 Py_FatalError("Can't initialize None type");
2091 if (PyType_Ready(&PyNotImplemented_Type
) < 0)
2092 Py_FatalError("Can't initialize NotImplemented type");
2094 if (PyType_Ready(&PyTraceBack_Type
) < 0)
2095 Py_FatalError("Can't initialize traceback type");
2097 if (PyType_Ready(&PySuper_Type
) < 0)
2098 Py_FatalError("Can't initialize super type");
2100 if (PyType_Ready(&PyBaseObject_Type
) < 0)
2101 Py_FatalError("Can't initialize object type");
2103 if (PyType_Ready(&PyRange_Type
) < 0)
2104 Py_FatalError("Can't initialize xrange type");
2106 if (PyType_Ready(&PyDict_Type
) < 0)
2107 Py_FatalError("Can't initialize dict type");
2109 if (PyType_Ready(&PySet_Type
) < 0)
2110 Py_FatalError("Can't initialize set type");
2112 if (PyType_Ready(&PyUnicode_Type
) < 0)
2113 Py_FatalError("Can't initialize unicode type");
2115 if (PyType_Ready(&PySlice_Type
) < 0)
2116 Py_FatalError("Can't initialize slice type");
2118 if (PyType_Ready(&PyStaticMethod_Type
) < 0)
2119 Py_FatalError("Can't initialize static method type");
2121 #ifndef WITHOUT_COMPLEX
2122 if (PyType_Ready(&PyComplex_Type
) < 0)
2123 Py_FatalError("Can't initialize complex type");
2126 if (PyType_Ready(&PyFloat_Type
) < 0)
2127 Py_FatalError("Can't initialize float type");
2129 if (PyType_Ready(&PyBuffer_Type
) < 0)
2130 Py_FatalError("Can't initialize buffer type");
2132 if (PyType_Ready(&PyLong_Type
) < 0)
2133 Py_FatalError("Can't initialize long type");
2135 if (PyType_Ready(&PyInt_Type
) < 0)
2136 Py_FatalError("Can't initialize int type");
2138 if (PyType_Ready(&PyFrozenSet_Type
) < 0)
2139 Py_FatalError("Can't initialize frozenset type");
2141 if (PyType_Ready(&PyProperty_Type
) < 0)
2142 Py_FatalError("Can't initialize property type");
2144 if (PyType_Ready(&PyMemoryView_Type
) < 0)
2145 Py_FatalError("Can't initialize memoryview type");
2147 if (PyType_Ready(&PyTuple_Type
) < 0)
2148 Py_FatalError("Can't initialize tuple type");
2150 if (PyType_Ready(&PyEnum_Type
) < 0)
2151 Py_FatalError("Can't initialize enumerate type");
2153 if (PyType_Ready(&PyReversed_Type
) < 0)
2154 Py_FatalError("Can't initialize reversed type");
2156 if (PyType_Ready(&PyCode_Type
) < 0)
2157 Py_FatalError("Can't initialize code type");
2159 if (PyType_Ready(&PyFrame_Type
) < 0)
2160 Py_FatalError("Can't initialize frame type");
2162 if (PyType_Ready(&PyCFunction_Type
) < 0)
2163 Py_FatalError("Can't initialize builtin function type");
2165 if (PyType_Ready(&PyMethod_Type
) < 0)
2166 Py_FatalError("Can't initialize method type");
2168 if (PyType_Ready(&PyFunction_Type
) < 0)
2169 Py_FatalError("Can't initialize function type");
2171 if (PyType_Ready(&PyClass_Type
) < 0)
2172 Py_FatalError("Can't initialize class type");
2174 if (PyType_Ready(&PyDictProxy_Type
) < 0)
2175 Py_FatalError("Can't initialize dict proxy type");
2177 if (PyType_Ready(&PyGen_Type
) < 0)
2178 Py_FatalError("Can't initialize generator type");
2180 if (PyType_Ready(&PyGetSetDescr_Type
) < 0)
2181 Py_FatalError("Can't initialize get-set descriptor type");
2183 if (PyType_Ready(&PyWrapperDescr_Type
) < 0)
2184 Py_FatalError("Can't initialize wrapper type");
2186 if (PyType_Ready(&PyInstance_Type
) < 0)
2187 Py_FatalError("Can't initialize instance type");
2189 if (PyType_Ready(&PyEllipsis_Type
) < 0)
2190 Py_FatalError("Can't initialize ellipsis type");
2192 if (PyType_Ready(&PyMemberDescr_Type
) < 0)
2193 Py_FatalError("Can't initialize member descriptor type");
2195 if (PyType_Ready(&PyFile_Type
) < 0)
2196 Py_FatalError("Can't initialize file type");
2200 #ifdef Py_TRACE_REFS
2203 _Py_NewReference(PyObject
*op
)
2207 _Py_AddToAllObjects(op
, 1);
2208 _Py_INC_TPALLOCS(op
);
2212 _Py_ForgetReference(register PyObject
*op
)
2214 #ifdef SLOW_UNREF_CHECK
2215 register PyObject
*p
;
2217 if (op
->ob_refcnt
< 0)
2218 Py_FatalError("UNREF negative refcnt");
2219 if (op
== &refchain
||
2220 op
->_ob_prev
->_ob_next
!= op
|| op
->_ob_next
->_ob_prev
!= op
)
2221 Py_FatalError("UNREF invalid object");
2222 #ifdef SLOW_UNREF_CHECK
2223 for (p
= refchain
._ob_next
; p
!= &refchain
; p
= p
->_ob_next
) {
2227 if (p
== &refchain
) /* Not found */
2228 Py_FatalError("UNREF unknown object");
2230 op
->_ob_next
->_ob_prev
= op
->_ob_prev
;
2231 op
->_ob_prev
->_ob_next
= op
->_ob_next
;
2232 op
->_ob_next
= op
->_ob_prev
= NULL
;
2233 _Py_INC_TPFREES(op
);
2237 _Py_Dealloc(PyObject
*op
)
2239 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
2240 _Py_ForgetReference(op
);
2244 /* Print all live objects. Because PyObject_Print is called, the
2245 * interpreter must be in a healthy state.
2248 _Py_PrintReferences(FILE *fp
)
2251 fprintf(fp
, "Remaining objects:\n");
2252 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
) {
2253 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] ", op
, op
->ob_refcnt
);
2254 if (PyObject_Print(op
, fp
, 0) != 0)
2260 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
2261 * doesn't make any calls to the Python C API, so is always safe to call.
2264 _Py_PrintReferenceAddresses(FILE *fp
)
2267 fprintf(fp
, "Remaining object addresses:\n");
2268 for (op
= refchain
._ob_next
; op
!= &refchain
; op
= op
->_ob_next
)
2269 fprintf(fp
, "%p [%" PY_FORMAT_SIZE_T
"d] %s\n", op
,
2270 op
->ob_refcnt
, Py_TYPE(op
)->tp_name
);
2274 _Py_GetObjects(PyObject
*self
, PyObject
*args
)
2280 if (!PyArg_ParseTuple(args
, "i|O", &n
, &t
))
2282 op
= refchain
._ob_next
;
2283 res
= PyList_New(0);
2286 for (i
= 0; (n
== 0 || i
< n
) && op
!= &refchain
; i
++) {
2287 while (op
== self
|| op
== args
|| op
== res
|| op
== t
||
2288 (t
!= NULL
&& Py_TYPE(op
) != (PyTypeObject
*) t
)) {
2290 if (op
== &refchain
)
2293 if (PyList_Append(res
, op
) < 0) {
2305 /* Hack to force loading of capsule.o */
2306 PyTypeObject
*_Py_capsule_hack
= &PyCapsule_Type
;
2309 /* Hack to force loading of cobject.o */
2310 PyTypeObject
*_Py_cobject_hack
= &PyCObject_Type
;
2313 /* Hack to force loading of abstract.o */
2314 Py_ssize_t (*_Py_abstract_hack
)(PyObject
*) = PyObject_Size
;
2317 /* Python's malloc wrappers (see pymem.h) */
2320 PyMem_Malloc(size_t nbytes
)
2322 return PyMem_MALLOC(nbytes
);
2326 PyMem_Realloc(void *p
, size_t nbytes
)
2328 return PyMem_REALLOC(p
, nbytes
);
2338 /* These methods are used to control infinite recursion in repr, str, print,
2339 etc. Container objects that may recursively contain themselves,
2340 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
2341 Py_ReprLeave() to avoid infinite recursion.
2343 Py_ReprEnter() returns 0 the first time it is called for a particular
2344 object and 1 every time thereafter. It returns -1 if an exception
2345 occurred. Py_ReprLeave() has no return value.
2347 See dictobject.c and listobject.c for examples of use.
2350 #define KEY "Py_Repr"
2353 Py_ReprEnter(PyObject
*obj
)
2359 dict
= PyThreadState_GetDict();
2362 list
= PyDict_GetItemString(dict
, KEY
);
2364 list
= PyList_New(0);
2367 if (PyDict_SetItemString(dict
, KEY
, list
) < 0)
2371 i
= PyList_GET_SIZE(list
);
2373 if (PyList_GET_ITEM(list
, i
) == obj
)
2376 PyList_Append(list
, obj
);
2381 Py_ReprLeave(PyObject
*obj
)
2387 dict
= PyThreadState_GetDict();
2390 list
= PyDict_GetItemString(dict
, KEY
);
2391 if (list
== NULL
|| !PyList_Check(list
))
2393 i
= PyList_GET_SIZE(list
);
2394 /* Count backwards because we always expect obj to be list[-1] */
2396 if (PyList_GET_ITEM(list
, i
) == obj
) {
2397 PyList_SetSlice(list
, i
, i
+ 1, NULL
);
2403 /* Trashcan support. */
2405 /* Current call-stack depth of tp_dealloc calls. */
2406 int _PyTrash_delete_nesting
= 0;
2408 /* List of objects that still need to be cleaned up, singly linked via their
2409 * gc headers' gc_prev pointers.
2411 PyObject
*_PyTrash_delete_later
= NULL
;
2413 /* Add op to the _PyTrash_delete_later list. Called when the current
2414 * call-stack depth gets large. op must be a currently untracked gc'ed
2415 * object, with refcount 0. Py_DECREF must already have been called on it.
2418 _PyTrash_deposit_object(PyObject
*op
)
2420 assert(PyObject_IS_GC(op
));
2421 assert(_Py_AS_GC(op
)->gc
.gc_refs
== _PyGC_REFS_UNTRACKED
);
2422 assert(op
->ob_refcnt
== 0);
2423 _Py_AS_GC(op
)->gc
.gc_prev
= (PyGC_Head
*)_PyTrash_delete_later
;
2424 _PyTrash_delete_later
= op
;
2427 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
2428 * the call-stack unwinds again.
2431 _PyTrash_destroy_chain(void)
2433 while (_PyTrash_delete_later
) {
2434 PyObject
*op
= _PyTrash_delete_later
;
2435 destructor dealloc
= Py_TYPE(op
)->tp_dealloc
;
2437 _PyTrash_delete_later
=
2438 (PyObject
*) _Py_AS_GC(op
)->gc
.gc_prev
;
2440 /* Call the deallocator directly. This used to try to
2441 * fool Py_DECREF into calling it indirectly, but
2442 * Py_DECREF was already called on this object, and in
2443 * assorted non-release builds calling Py_DECREF again ends
2444 * up distorting allocation statistics.
2446 assert(op
->ob_refcnt
== 0);
2447 ++_PyTrash_delete_nesting
;
2449 --_PyTrash_delete_nesting
;