Bug Summary

File:Objects/object.c
Location:line 1743, column 18
Description:Access to field '_ob_next' results in a dereference of a null pointer (loaded from variable 'op')

Annotated Source Code

1
2/* Generic object operations; and implementation of None (NoObject) */
3
4#include "Python.h"
5#include "frameobject.h"
6
7#ifdef __cplusplus
8extern "C" {
9#endif
10
11#ifdef Py_REF_DEBUG
12Py_ssize_t _Py_RefTotal;
13
14Py_ssize_t
15_Py_GetRefTotal(void)
16{
17 PyObject *o;
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) */
22 o = _PyDict_Dummy();
23 if (o != NULL((void *)0))
24 total -= o->ob_refcnt;
25 o = _PySet_Dummy();
26 if (o != NULL((void *)0))
27 total -= o->ob_refcnt;
28 return total;
29}
30#endif /* Py_REF_DEBUG */
31
32int Py_DivisionWarningFlag;
33
34/* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
35 These are used by the individual routines for object creation.
36 Do not call them otherwise, they do not initialize the object! */
37
38#ifdef Py_TRACE_REFS
39/* Head of circular doubly-linked list of all objects. These are linked
40 * together via the _ob_prev and _ob_next members of a PyObject, which
41 * exist only in a Py_TRACE_REFS build.
42 */
43static PyObject refchain = {&refchain, &refchain};
44
45/* Insert op at the front of the list of all objects. If force is true,
46 * op is added even if _ob_prev and _ob_next are non-NULL already. If
47 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.
48 * force should be true if and only if op points to freshly allocated,
49 * uninitialized memory, or you've unlinked op from the list and are
50 * relinking it into the front.
51 * Note that objects are normally added to the list via _Py_NewReference,
52 * which is called by PyObject_Init. Not all objects are initialized that
53 * way, though; exceptions include statically allocated type objects, and
54 * statically allocated singletons (like Py_True and Py_None).
55 */
56void
57_Py_AddToAllObjects(PyObject *op, int force)
58{
59#ifdef Py_DEBUG1
60 if (!force) {
61 /* If it's initialized memory, op must be in or out of
62 * the list unambiguously.
63 */
64 assert((op->_ob_prev == NULL) == (op->_ob_next == NULL))(__builtin_expect(!((op->_ob_prev == ((void *)0)) == (op->
_ob_next == ((void *)0))), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 64, "(op->_ob_prev == NULL) == (op->_ob_next == NULL)"
) : (void)0)
;
65 }
66#endif
67 if (force || op->_ob_prev == NULL((void *)0)) {
68 op->_ob_next = refchain._ob_next;
69 op->_ob_prev = &refchain;
70 refchain._ob_next->_ob_prev = op;
71 refchain._ob_next = op;
72 }
73}
74#endif /* Py_TRACE_REFS */
75
76#ifdef COUNT_ALLOCS
77static PyTypeObject *type_list;
78/* All types are added to type_list, at least when
79 they get one object created. That makes them
80 immortal, which unfortunately contributes to
81 garbage itself. If unlist_types_without_objects
82 is set, they will be removed from the type_list
83 once the last object is deallocated. */
84static int unlist_types_without_objects;
85extern Py_ssize_t tuple_zero_allocs, fast_tuple_allocs;
86extern Py_ssize_t quick_int_allocs, quick_neg_int_allocs;
87extern Py_ssize_t null_strings, one_strings;
88void
89dump_counts(FILE* f)
90{
91 PyTypeObject *tp;
92
93 for (tp = type_list; tp; tp = tp->tp_next)
94 fprintf(f, "%s alloc'd: %" PY_FORMAT_SIZE_T"l" "d, "
95 "freed: %" PY_FORMAT_SIZE_T"l" "d, "
96 "max in use: %" PY_FORMAT_SIZE_T"l" "d\n",
97 tp->tp_name, tp->tp_allocs, tp->tp_frees,
98 tp->tp_maxalloc);
99 fprintf(f, "fast tuple allocs: %" PY_FORMAT_SIZE_T"l" "d, "
100 "empty: %" PY_FORMAT_SIZE_T"l" "d\n",
101 fast_tuple_allocs, tuple_zero_allocs);
102 fprintf(f, "fast int allocs: pos: %" PY_FORMAT_SIZE_T"l" "d, "
103 "neg: %" PY_FORMAT_SIZE_T"l" "d\n",
104 quick_int_allocs, quick_neg_int_allocs);
105 fprintf(f, "null strings: %" PY_FORMAT_SIZE_T"l" "d, "
106 "1-strings: %" PY_FORMAT_SIZE_T"l" "d\n",
107 null_strings, one_strings);
108}
109
110PyObject *
111get_counts(void)
112{
113 PyTypeObject *tp;
114 PyObject *result;
115 PyObject *v;
116
117 result = PyList_New(0);
118 if (result == NULL((void *)0))
119 return NULL((void *)0);
120 for (tp = type_list; tp; tp = tp->tp_next) {
121 v = Py_BuildValue("(snnn)", tp->tp_name, tp->tp_allocs,
122 tp->tp_frees, tp->tp_maxalloc);
123 if (v == NULL((void *)0)) {
124 Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt
!= 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 124, (PyObject *)(result)); } else _Py_Dealloc
((PyObject *)(result)); } while (0)
;
125 return NULL((void *)0);
126 }
127 if (PyList_Append(result, v) < 0) {
128 Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt !=
0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 128, (PyObject *)(v)); } else _Py_Dealloc
((PyObject *)(v)); } while (0)
;
129 Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt
!= 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 129, (PyObject *)(result)); } else _Py_Dealloc
((PyObject *)(result)); } while (0)
;
130 return NULL((void *)0);
131 }
132 Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt !=
0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 132, (PyObject *)(v)); } else _Py_Dealloc
((PyObject *)(v)); } while (0)
;
133 }
134 return result;
135}
136
137void
138inc_count(PyTypeObject *tp)
139{
140 if (tp->tp_next == NULL((void *)0) && tp->tp_prev == NULL((void *)0)) {
141 /* first time; insert in linked list */
142 if (tp->tp_next != NULL((void *)0)) /* sanity check */
143 Py_FatalError("XXX inc_count sanity check");
144 if (type_list)
145 type_list->tp_prev = tp;
146 tp->tp_next = type_list;
147 /* Note that as of Python 2.2, heap-allocated type objects
148 * can go away, but this code requires that they stay alive
149 * until program exit. That's why we're careful with
150 * refcounts here. type_list gets a new reference to tp,
151 * while ownership of the reference type_list used to hold
152 * (if any) was transferred to tp->tp_next in the line above.
153 * tp is thus effectively immortal after this.
154 */
155 Py_INCREF(tp)( _Py_RefTotal++ , ((PyObject*)(tp))->ob_refcnt++);
156 type_list = tp;
157#ifdef Py_TRACE_REFS
158 /* Also insert in the doubly-linked list of all objects,
159 * if not already there.
160 */
161 _Py_AddToAllObjects((PyObject *)tp, 0);
162#endif
163 }
164 tp->tp_allocs++;
165 if (tp->tp_allocs - tp->tp_frees > tp->tp_maxalloc)
166 tp->tp_maxalloc = tp->tp_allocs - tp->tp_frees;
167}
168
169void dec_count(PyTypeObject *tp)
170{
171 tp->tp_frees++;
172 if (unlist_types_without_objects &&
173 tp->tp_allocs == tp->tp_frees) {
174 /* unlink the type from type_list */
175 if (tp->tp_prev)
176 tp->tp_prev->tp_next = tp->tp_next;
177 else
178 type_list = tp->tp_next;
179 if (tp->tp_next)
180 tp->tp_next->tp_prev = tp->tp_prev;
181 tp->tp_next = tp->tp_prev = NULL((void *)0);
182 Py_DECREF(tp)do { if (_Py_RefTotal-- , --((PyObject*)(tp))->ob_refcnt !=
0) { if (((PyObject*)tp)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 182, (PyObject *)(tp)); } else _Py_Dealloc
((PyObject *)(tp)); } while (0)
;
183 }
184}
185
186#endif
187
188#ifdef Py_REF_DEBUG
189/* Log a fatal error; doesn't return. */
190void
191_Py_NegativeRefcount(const char *fname, int lineno, PyObject *op)
192{
193 char buf[300];
194
195 PyOS_snprintf(buf, sizeof(buf),
196 "%s:%i object at %p has negative ref count "
197 "%" PY_FORMAT_SIZE_T"l" "d",
198 fname, lineno, op, op->ob_refcnt);
199 Py_FatalError(buf);
200}
201
202#endif /* Py_REF_DEBUG */
203
204void
205Py_IncRef(PyObject *o)
206{
207 Py_XINCREF(o)do { if ((o) == ((void *)0)) ; else ( _Py_RefTotal++ , ((PyObject
*)(o))->ob_refcnt++); } while (0)
;
208}
209
210void
211Py_DecRef(PyObject *o)
212{
213 Py_XDECREF(o)do { if ((o) == ((void *)0)) ; else do { if (_Py_RefTotal-- ,
--((PyObject*)(o))->ob_refcnt != 0) { if (((PyObject*)o)->
ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c", 213
, (PyObject *)(o)); } else _Py_Dealloc((PyObject *)(o)); } while
(0); } while (0)
;
214}
215
216PyObject *
217PyObject_Init(PyObject *op, PyTypeObject *tp)
218{
219 if (op == NULL((void *)0))
220 return PyErr_NoMemory();
221 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
222 Py_TYPE(op)(((PyObject*)(op))->ob_type) = tp;
223 _Py_NewReference(op);
224 return op;
225}
226
227PyVarObject *
228PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)
229{
230 if (op == NULL((void *)0))
231 return (PyVarObject *) PyErr_NoMemory();
232 /* Any changes should be reflected in PyObject_INIT_VAR */
233 op->ob_size = size;
234 Py_TYPE(op)(((PyObject*)(op))->ob_type) = tp;
235 _Py_NewReference((PyObject *)op);
236 return op;
237}
238
239PyObject *
240_PyObject_New(PyTypeObject *tp)
241{
242 PyObject *op;
243 op = (PyObject *) PyObject_MALLOC_PyObject_DebugMalloc(_PyObject_SIZE(tp)( (tp)->tp_basicsize ));
244 if (op == NULL((void *)0))
245 return PyErr_NoMemory();
246 return PyObject_INIT(op, tp)( (((PyObject*)(op))->ob_type) = (tp), _Py_NewReference((PyObject
*)(op)), (op) )
;
247}
248
249PyVarObject *
250_PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
251{
252 PyVarObject *op;
253 const size_t size = _PyObject_VAR_SIZE(tp, nitems)(size_t) ( ( (tp)->tp_basicsize + (nitems)*(tp)->tp_itemsize
+ (8 - 1) ) & ~(8 - 1) )
;
254 op = (PyVarObject *) PyObject_MALLOC_PyObject_DebugMalloc(size);
255 if (op == NULL((void *)0))
256 return (PyVarObject *)PyErr_NoMemory();
257 return PyObject_INIT_VAR(op, tp, nitems)( (((PyVarObject*)(op))->ob_size) = (nitems), ( (((PyObject
*)((op)))->ob_type) = ((tp)), _Py_NewReference((PyObject *
)((op))), ((op)) ) )
;
258}
259
260int
261PyObject_Print(PyObject *op, FILE *fp, int flags)
262{
263 int ret = 0;
264 if (PyErr_CheckSignals())
265 return -1;
266#ifdef USE_STACKCHECK
267 if (PyOS_CheckStack()) {
268 PyErr_SetString(PyExc_MemoryError, "stack overflow");
269 return -1;
270 }
271#endif
272 clearerr(fp); /* Clear any previous error condition */
273 if (op == NULL((void *)0)) {
274 Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
275 fprintf(fp, "<nil>");
276 Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }
277 }
278 else {
279 if (op->ob_refcnt <= 0)
280 /* XXX(twouters) cast refcount to long until %zd is
281 universally available */
282 Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
283 fprintf(fp, "<refcnt %ld at %p>",
284 (long)op->ob_refcnt, op);
285 Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }
286 else {
287 PyObject *s;
288 if (flags & Py_PRINT_RAW1)
289 s = PyObject_Str(op);
290 else
291 s = PyObject_Repr(op);
292 if (s == NULL((void *)0))
293 ret = -1;
294 else if (PyBytes_Check(s)((((((PyObject*)(s))->ob_type))->tp_flags & ((1L<<
27))) != 0)
) {
295 fwrite(PyBytes_AS_STRING(s)((__builtin_expect(!(((((((PyObject*)(s))->ob_type))->tp_flags
& ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 295, "PyBytes_Check(s)") : (void)0), (((PyBytesObject *)(s)
)->ob_sval))
, 1,
296 PyBytes_GET_SIZE(s)((__builtin_expect(!(((((((PyObject*)(s))->ob_type))->tp_flags
& ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 296, "PyBytes_Check(s)") : (void)0),(((PyVarObject*)(s))->
ob_size))
, fp);
297 }
298 else if (PyUnicode_Check(s)((((((PyObject*)(s))->ob_type))->tp_flags & ((1L<<
28))) != 0)
) {
299 PyObject *t;
300 t = PyUnicode_EncodeUTF8PyUnicodeUCS2_EncodeUTF8(PyUnicode_AS_UNICODE(s)((__builtin_expect(!(((((((PyObject*)(s))->ob_type))->tp_flags
& ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 300, "PyUnicode_Check(s)") : (void)0),(((PyUnicodeObject *)
(s))->str))
,
301 PyUnicode_GET_SIZE(s)((__builtin_expect(!(((((((PyObject*)(s))->ob_type))->tp_flags
& ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 301, "PyUnicode_Check(s)") : (void)0),(((PyUnicodeObject *)
(s))->length))
,
302 "backslashreplace");
303 if (t == NULL((void *)0))
304 ret = 0;
305 else {
306 fwrite(PyBytes_AS_STRING(t)((__builtin_expect(!(((((((PyObject*)(t))->ob_type))->tp_flags
& ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 306, "PyBytes_Check(t)") : (void)0), (((PyBytesObject *)(t)
)->ob_sval))
, 1,
307 PyBytes_GET_SIZE(t)((__builtin_expect(!(((((((PyObject*)(t))->ob_type))->tp_flags
& ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 307, "PyBytes_Check(t)") : (void)0),(((PyVarObject*)(t))->
ob_size))
, fp);
308 Py_DECREF(t)do { if (_Py_RefTotal-- , --((PyObject*)(t))->ob_refcnt !=
0) { if (((PyObject*)t)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 308, (PyObject *)(t)); } else _Py_Dealloc
((PyObject *)(t)); } while (0)
;
309 }
310 }
311 else {
312 PyErr_Format(PyExc_TypeError,
313 "str() or repr() returned '%.100s'",
314 s->ob_type->tp_name);
315 ret = -1;
316 }
317 Py_XDECREF(s)do { if ((s) == ((void *)0)) ; else do { if (_Py_RefTotal-- ,
--((PyObject*)(s))->ob_refcnt != 0) { if (((PyObject*)s)->
ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c", 317
, (PyObject *)(s)); } else _Py_Dealloc((PyObject *)(s)); } while
(0); } while (0)
;
318 }
319 }
320 if (ret == 0) {
321 if (ferror(fp)) {
322 PyErr_SetFromErrno(PyExc_IOError);
323 clearerr(fp);
324 ret = -1;
325 }
326 }
327 return ret;
328}
329
330/* For debugging convenience. Set a breakpoint here and call it from your DLL */
331void
332_Py_BreakPoint(void)
333{
334}
335
336
337/* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
338void
339_PyObject_Dump(PyObject* op)
340{
341 if (op == NULL((void *)0))
342 fprintf(stderr__stderrp, "NULL\n");
343 else {
344#ifdef WITH_THREAD1
345 PyGILState_STATE gil;
346#endif
347 fprintf(stderr__stderrp, "object : ");
348#ifdef WITH_THREAD1
349 gil = PyGILState_Ensure();
350#endif
351 (void)PyObject_Print(op, stderr__stderrp, 0);
352#ifdef WITH_THREAD1
353 PyGILState_Release(gil);
354#endif
355 /* XXX(twouters) cast refcount to long until %zd is
356 universally available */
357 fprintf(stderr__stderrp, "\n"
358 "type : %s\n"
359 "refcount: %ld\n"
360 "address : %p\n",
361 Py_TYPE(op)(((PyObject*)(op))->ob_type)==NULL((void *)0) ? "NULL" : Py_TYPE(op)(((PyObject*)(op))->ob_type)->tp_name,
362 (long)op->ob_refcnt,
363 op);
364 }
365}
366
367PyObject *
368PyObject_Repr(PyObject *v)
369{
370 PyObject *res;
371 if (PyErr_CheckSignals())
372 return NULL((void *)0);
373#ifdef USE_STACKCHECK
374 if (PyOS_CheckStack()) {
375 PyErr_SetString(PyExc_MemoryError, "stack overflow");
376 return NULL((void *)0);
377 }
378#endif
379 if (v == NULL((void *)0))
380 return PyUnicode_FromStringPyUnicodeUCS2_FromString("<NULL>");
381 if (Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_repr == NULL((void *)0))
382 return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("<%s object at %p>",
383 v->ob_type->tp_name, v);
384 res = (*v->ob_type->tp_repr)(v);
385 if (res != NULL((void *)0) && !PyUnicode_Check(res)((((((PyObject*)(res))->ob_type))->tp_flags & ((1L<<
28))) != 0)
) {
386 PyErr_Format(PyExc_TypeError,
387 "__repr__ returned non-string (type %.200s)",
388 res->ob_type->tp_name);
389 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 389, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
390 return NULL((void *)0);
391 }
392 return res;
393}
394
395PyObject *
396PyObject_Str(PyObject *v)
397{
398 PyObject *res;
399 if (PyErr_CheckSignals())
400 return NULL((void *)0);
401#ifdef USE_STACKCHECK
402 if (PyOS_CheckStack()) {
403 PyErr_SetString(PyExc_MemoryError, "stack overflow");
404 return NULL((void *)0);
405 }
406#endif
407 if (v == NULL((void *)0))
408 return PyUnicode_FromStringPyUnicodeUCS2_FromString("<NULL>");
409 if (PyUnicode_CheckExact(v)((((PyObject*)(v))->ob_type) == &PyUnicode_Type)) {
410 Py_INCREF(v)( _Py_RefTotal++ , ((PyObject*)(v))->ob_refcnt++);
411 return v;
412 }
413 if (Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_str == NULL((void *)0))
414 return PyObject_Repr(v);
415
416 /* It is possible for a type to have a tp_str representation that loops
417 infinitely. */
418 if (Py_EnterRecursiveCall(" while getting the str of an object")((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while getting the str of an object"
))
)
419 return NULL((void *)0);
420 res = (*Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_str)(v);
421 Py_LeaveRecursiveCall()do{ if((--(PyThreadState_Get()->recursion_depth) < ((_Py_CheckRecursionLimit
> 100) ? (_Py_CheckRecursionLimit - 50) : (3 * (_Py_CheckRecursionLimit
>> 2))))) PyThreadState_Get()->overflowed = 0; } while
(0)
;
422 if (res == NULL((void *)0))
423 return NULL((void *)0);
424 if (!PyUnicode_Check(res)((((((PyObject*)(res))->ob_type))->tp_flags & ((1L<<
28))) != 0)
) {
425 PyErr_Format(PyExc_TypeError,
426 "__str__ returned non-string (type %.200s)",
427 Py_TYPE(res)(((PyObject*)(res))->ob_type)->tp_name);
428 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 428, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
429 return NULL((void *)0);
430 }
431 return res;
432}
433
434PyObject *
435PyObject_ASCII(PyObject *v)
436{
437 PyObject *repr, *ascii, *res;
438
439 repr = PyObject_Repr(v);
440 if (repr == NULL((void *)0))
441 return NULL((void *)0);
442
443 /* repr is guaranteed to be a PyUnicode object by PyObject_Repr */
444 ascii = PyUnicode_EncodeASCIIPyUnicodeUCS2_EncodeASCII(
445 PyUnicode_AS_UNICODE(repr)((__builtin_expect(!(((((((PyObject*)(repr))->ob_type))->
tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/object.c", 445, "PyUnicode_Check(repr)") : (void)0
),(((PyUnicodeObject *)(repr))->str))
,
446 PyUnicode_GET_SIZE(repr)((__builtin_expect(!(((((((PyObject*)(repr))->ob_type))->
tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/object.c", 446, "PyUnicode_Check(repr)") : (void)0
),(((PyUnicodeObject *)(repr))->length))
,
447 "backslashreplace");
448
449 Py_DECREF(repr)do { if (_Py_RefTotal-- , --((PyObject*)(repr))->ob_refcnt
!= 0) { if (((PyObject*)repr)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 449, (PyObject *)(repr)); } else _Py_Dealloc
((PyObject *)(repr)); } while (0)
;
450 if (ascii == NULL((void *)0))
451 return NULL((void *)0);
452
453 res = PyUnicode_DecodeASCIIPyUnicodeUCS2_DecodeASCII(
454 PyBytes_AS_STRING(ascii)((__builtin_expect(!(((((((PyObject*)(ascii))->ob_type))->
tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/object.c", 454, "PyBytes_Check(ascii)") : (void)0)
, (((PyBytesObject *)(ascii))->ob_sval))
,
455 PyBytes_GET_SIZE(ascii)((__builtin_expect(!(((((((PyObject*)(ascii))->ob_type))->
tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/object.c", 455, "PyBytes_Check(ascii)") : (void)0)
,(((PyVarObject*)(ascii))->ob_size))
,
456 NULL((void *)0));
457
458 Py_DECREF(ascii)do { if (_Py_RefTotal-- , --((PyObject*)(ascii))->ob_refcnt
!= 0) { if (((PyObject*)ascii)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 458, (PyObject *)(ascii)); } else _Py_Dealloc
((PyObject *)(ascii)); } while (0)
;
459 return res;
460}
461
462PyObject *
463PyObject_Bytes(PyObject *v)
464{
465 PyObject *result, *func;
466 static PyObject *bytesstring = NULL((void *)0);
467
468 if (v == NULL((void *)0))
469 return PyBytes_FromString("<NULL>");
470
471 if (PyBytes_CheckExact(v)((((PyObject*)(v))->ob_type) == &PyBytes_Type)) {
472 Py_INCREF(v)( _Py_RefTotal++ , ((PyObject*)(v))->ob_refcnt++);
473 return v;
474 }
475
476 func = _PyObject_LookupSpecial(v, "__bytes__", &bytesstring);
477 if (func != NULL((void *)0)) {
478 result = PyObject_CallFunctionObjArgs(func, NULL((void *)0));
479 Py_DECREF(func)do { if (_Py_RefTotal-- , --((PyObject*)(func))->ob_refcnt
!= 0) { if (((PyObject*)func)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 479, (PyObject *)(func)); } else _Py_Dealloc
((PyObject *)(func)); } while (0)
;
480 if (result == NULL((void *)0))
481 return NULL((void *)0);
482 if (!PyBytes_Check(result)((((((PyObject*)(result))->ob_type))->tp_flags & ((
1L<<27))) != 0)
) {
483 PyErr_Format(PyExc_TypeError,
484 "__bytes__ returned non-bytes (type %.200s)",
485 Py_TYPE(result)(((PyObject*)(result))->ob_type)->tp_name);
486 Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt
!= 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 486, (PyObject *)(result)); } else _Py_Dealloc
((PyObject *)(result)); } while (0)
;
487 return NULL((void *)0);
488 }
489 return result;
490 }
491 else if (PyErr_Occurred())
492 return NULL((void *)0);
493 return PyBytes_FromObject(v);
494}
495
496/* For Python 3.0.1 and later, the old three-way comparison has been
497 completely removed in favour of rich comparisons. PyObject_Compare() and
498 PyObject_Cmp() are gone, and the builtin cmp function no longer exists.
499 The old tp_compare slot has been renamed to tp_reserved, and should no
500 longer be used. Use tp_richcompare instead.
501
502 See (*) below for practical amendments.
503
504 tp_richcompare gets called with a first argument of the appropriate type
505 and a second object of an arbitrary type. We never do any kind of
506 coercion.
507
508 The tp_richcompare slot should return an object, as follows:
509
510 NULL if an exception occurred
511 NotImplemented if the requested comparison is not implemented
512 any other false value if the requested comparison is false
513 any other true value if the requested comparison is true
514
515 The PyObject_RichCompare[Bool]() wrappers raise TypeError when they get
516 NotImplemented.
517
518 (*) Practical amendments:
519
520 - If rich comparison returns NotImplemented, == and != are decided by
521 comparing the object pointer (i.e. falling back to the base object
522 implementation).
523
524*/
525
526/* Map rich comparison operators to their swapped version, e.g. LT <--> GT */
527int _Py_SwappedOp[] = {Py_GT4, Py_GE5, Py_EQ2, Py_NE3, Py_LT0, Py_LE1};
528
529static char *opstrings[] = {"<", "<=", "==", "!=", ">", ">="};
530
531/* Perform a rich comparison, raising TypeError when the requested comparison
532 operator is not supported. */
533static PyObject *
534do_richcompare(PyObject *v, PyObject *w, int op)
535{
536 richcmpfunc f;
537 PyObject *res;
538 int checked_reverse_op = 0;
539
540 if (v->ob_type != w->ob_type &&
541 PyType_IsSubtype(w->ob_type, v->ob_type) &&
542 (f = w->ob_type->tp_richcompare) != NULL((void *)0)) {
543 checked_reverse_op = 1;
544 res = (*f)(w, v, _Py_SwappedOp[op]);
545 if (res != Py_NotImplemented(&_Py_NotImplementedStruct))
546 return res;
547 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 547, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
548 }
549 if ((f = v->ob_type->tp_richcompare) != NULL((void *)0)) {
550 res = (*f)(v, w, op);
551 if (res != Py_NotImplemented(&_Py_NotImplementedStruct))
552 return res;
553 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 553, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
554 }
555 if (!checked_reverse_op && (f = w->ob_type->tp_richcompare) != NULL((void *)0)) {
556 res = (*f)(w, v, _Py_SwappedOp[op]);
557 if (res != Py_NotImplemented(&_Py_NotImplementedStruct))
558 return res;
559 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 559, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
560 }
561 /* If neither object implements it, provide a sensible default
562 for == and !=, but raise an exception for ordering. */
563 switch (op) {
564 case Py_EQ2:
565 res = (v == w) ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_FalseStruct);
566 break;
567 case Py_NE3:
568 res = (v != w) ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_FalseStruct);
569 break;
570 default:
571 /* XXX Special-case None so it doesn't show as NoneType() */
572 PyErr_Format(PyExc_TypeError,
573 "unorderable types: %.100s() %s %.100s()",
574 v->ob_type->tp_name,
575 opstrings[op],
576 w->ob_type->tp_name);
577 return NULL((void *)0);
578 }
579 Py_INCREF(res)( _Py_RefTotal++ , ((PyObject*)(res))->ob_refcnt++);
580 return res;
581}
582
583/* Perform a rich comparison with object result. This wraps do_richcompare()
584 with a check for NULL arguments and a recursion check. */
585
586PyObject *
587PyObject_RichCompare(PyObject *v, PyObject *w, int op)
588{
589 PyObject *res;
590
591 assert(Py_LT <= op && op <= Py_GE)(__builtin_expect(!(0 <= op && op <= 5), 0) ? __assert_rtn
(__func__, "Objects/object.c", 591, "Py_LT <= op && op <= Py_GE"
) : (void)0)
;
592 if (v == NULL((void *)0) || w == NULL((void *)0)) {
593 if (!PyErr_Occurred())
594 PyErr_BadInternalCall()_PyErr_BadInternalCall("Objects/object.c", 594);
595 return NULL((void *)0);
596 }
597 if (Py_EnterRecursiveCall(" in comparison")((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" in comparison"))
)
598 return NULL((void *)0);
599 res = do_richcompare(v, w, op);
600 Py_LeaveRecursiveCall()do{ if((--(PyThreadState_Get()->recursion_depth) < ((_Py_CheckRecursionLimit
> 100) ? (_Py_CheckRecursionLimit - 50) : (3 * (_Py_CheckRecursionLimit
>> 2))))) PyThreadState_Get()->overflowed = 0; } while
(0)
;
601 return res;
602}
603
604/* Perform a rich comparison with integer result. This wraps
605 PyObject_RichCompare(), returning -1 for error, 0 for false, 1 for true. */
606int
607PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
608{
609 PyObject *res;
610 int ok;
611
612 /* Quick result when objects are the same.
613 Guarantees that identity implies equality. */
614 if (v == w) {
615 if (op == Py_EQ2)
616 return 1;
617 else if (op == Py_NE3)
618 return 0;
619 }
620
621 res = PyObject_RichCompare(v, w, op);
622 if (res == NULL((void *)0))
623 return -1;
624 if (PyBool_Check(res)((((PyObject*)(res))->ob_type) == &PyBool_Type))
625 ok = (res == Py_True((PyObject *) &_Py_TrueStruct));
626 else
627 ok = PyObject_IsTrue(res);
628 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 628, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
629 return ok;
630}
631
632/* Set of hash utility functions to help maintaining the invariant that
633 if a==b then hash(a)==hash(b)
634
635 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
636*/
637
638/* For numeric types, the hash of a number x is based on the reduction
639 of x modulo the prime P = 2**_PyHASH_BITS - 1. It's designed so that
640 hash(x) == hash(y) whenever x and y are numerically equal, even if
641 x and y have different types.
642
643 A quick summary of the hashing strategy:
644
645 (1) First define the 'reduction of x modulo P' for any rational
646 number x; this is a standard extension of the usual notion of
647 reduction modulo P for integers. If x == p/q (written in lowest
648 terms), the reduction is interpreted as the reduction of p times
649 the inverse of the reduction of q, all modulo P; if q is exactly
650 divisible by P then define the reduction to be infinity. So we've
651 got a well-defined map
652
653 reduce : { rational numbers } -> { 0, 1, 2, ..., P-1, infinity }.
654
655 (2) Now for a rational number x, define hash(x) by:
656
657 reduce(x) if x >= 0
658 -reduce(-x) if x < 0
659
660 If the result of the reduction is infinity (this is impossible for
661 integers, floats and Decimals) then use the predefined hash value
662 _PyHASH_INF for x >= 0, or -_PyHASH_INF for x < 0, instead.
663 _PyHASH_INF, -_PyHASH_INF and _PyHASH_NAN are also used for the
664 hashes of float and Decimal infinities and nans.
665
666 A selling point for the above strategy is that it makes it possible
667 to compute hashes of decimal and binary floating-point numbers
668 efficiently, even if the exponent of the binary or decimal number
669 is large. The key point is that
670
671 reduce(x * y) == reduce(x) * reduce(y) (modulo _PyHASH_MODULUS)
672
673 provided that {reduce(x), reduce(y)} != {0, infinity}. The reduction of a
674 binary or decimal float is never infinity, since the denominator is a power
675 of 2 (for binary) or a divisor of a power of 10 (for decimal). So we have,
676 for nonnegative x,
677
678 reduce(x * 2**e) == reduce(x) * reduce(2**e) % _PyHASH_MODULUS
679
680 reduce(x * 10**e) == reduce(x) * reduce(10**e) % _PyHASH_MODULUS
681
682 and reduce(10**e) can be computed efficiently by the usual modular
683 exponentiation algorithm. For reduce(2**e) it's even better: since
684 P is of the form 2**n-1, reduce(2**e) is 2**(e mod n), and multiplication
685 by 2**(e mod n) modulo 2**n-1 just amounts to a rotation of bits.
686
687 */
688
689Py_hash_t
690_Py_HashDouble(double v)
691{
692 int e, sign;
693 double m;
694 Py_uhash_t x, y;
695
696 if (!Py_IS_FINITE(v)( sizeof (v) == sizeof(float ) ? __inline_isfinitef((float)(v
)) : sizeof (v) == sizeof(double) ? __inline_isfinited((double
)(v)) : __inline_isfinite ((long double)(v)))
) {
697 if (Py_IS_INFINITY(v)( sizeof (v) == sizeof(float ) ? __inline_isinff((float)(v)) :
sizeof (v) == sizeof(double) ? __inline_isinfd((double)(v)) :
__inline_isinf ((long double)(v)))
)
698 return v > 0 ? _PyHASH_INF314159 : -_PyHASH_INF314159;
699 else
700 return _PyHASH_NAN0;
701 }
702
703 m = frexp(v, &e);
704
705 sign = 1;
706 if (m < 0) {
707 sign = -1;
708 m = -m;
709 }
710
711 /* process 28 bits at a time; this should work well both for binary
712 and hexadecimal floating point. */
713 x = 0;
714 while (m) {
715 x = ((x << 28) & _PyHASH_MODULUS(((size_t)1 << 61) - 1)) | x >> (_PyHASH_BITS61 - 28);
716 m *= 268435456.0; /* 2**28 */
717 e -= 28;
718 y = (Py_uhash_t)m; /* pull out integer part */
719 m -= y;
720 x += y;
721 if (x >= _PyHASH_MODULUS(((size_t)1 << 61) - 1))
722 x -= _PyHASH_MODULUS(((size_t)1 << 61) - 1);
723 }
724
725 /* adjust for the exponent; first reduce it modulo _PyHASH_BITS */
726 e = e >= 0 ? e % _PyHASH_BITS61 : _PyHASH_BITS61-1-((-1-e) % _PyHASH_BITS61);
727 x = ((x << e) & _PyHASH_MODULUS(((size_t)1 << 61) - 1)) | x >> (_PyHASH_BITS61 - e);
728
729 x = x * sign;
730 if (x == (Py_uhash_t)-1)
731 x = (Py_uhash_t)-2;
732 return (Py_hash_t)x;
733}
734
735Py_hash_t
736_Py_HashPointer(void *p)
737{
738 Py_hash_t x;
739 size_t y = (size_t)p;
740 /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
741 excessive hash collisions for dicts and sets */
742 y = (y >> 4) | (y << (8 * SIZEOF_VOID_P8 - 4));
743 x = (Py_hash_t)y;
744 if (x == -1)
745 x = -2;
746 return x;
747}
748
749Py_hash_t
750PyObject_HashNotImplemented(PyObject *v)
751{
752 PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
753 Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_name);
754 return -1;
755}
756
757Py_hash_t
758PyObject_Hash(PyObject *v)
759{
760 PyTypeObject *tp = Py_TYPE(v)(((PyObject*)(v))->ob_type);
761 if (tp->tp_hash != NULL((void *)0))
762 return (*tp->tp_hash)(v);
763 /* To keep to the general practice that inheriting
764 * solely from object in C code should work without
765 * an explicit call to PyType_Ready, we implicitly call
766 * PyType_Ready here and then check the tp_hash slot again
767 */
768 if (tp->tp_dict == NULL((void *)0)) {
769 if (PyType_Ready(tp) < 0)
770 return -1;
771 if (tp->tp_hash != NULL((void *)0))
772 return (*tp->tp_hash)(v);
773 }
774 /* Otherwise, the object can't be hashed */
775 return PyObject_HashNotImplemented(v);
776}
777
778PyObject *
779PyObject_GetAttrString(PyObject *v, const char *name)
780{
781 PyObject *w, *res;
782
783 if (Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_getattr != NULL((void *)0))
784 return (*Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_getattr)(v, (char*)name);
785 w = PyUnicode_InternFromString(name);
786 if (w == NULL((void *)0))
787 return NULL((void *)0);
788 res = PyObject_GetAttr(v, w);
789 Py_XDECREF(w)do { if ((w) == ((void *)0)) ; else do { if (_Py_RefTotal-- ,
--((PyObject*)(w))->ob_refcnt != 0) { if (((PyObject*)w)->
ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c", 789
, (PyObject *)(w)); } else _Py_Dealloc((PyObject *)(w)); } while
(0); } while (0)
;
790 return res;
791}
792
793int
794PyObject_HasAttrString(PyObject *v, const char *name)
795{
796 PyObject *res = PyObject_GetAttrString(v, name);
797 if (res != NULL((void *)0)) {
798 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 798, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
799 return 1;
800 }
801 PyErr_Clear();
802 return 0;
803}
804
805int
806PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
807{
808 PyObject *s;
809 int res;
810
811 if (Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_setattr != NULL((void *)0))
812 return (*Py_TYPE(v)(((PyObject*)(v))->ob_type)->tp_setattr)(v, (char*)name, w);
813 s = PyUnicode_InternFromString(name);
814 if (s == NULL((void *)0))
815 return -1;
816 res = PyObject_SetAttr(v, s, w);
817 Py_XDECREF(s)do { if ((s) == ((void *)0)) ; else do { if (_Py_RefTotal-- ,
--((PyObject*)(s))->ob_refcnt != 0) { if (((PyObject*)s)->
ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c", 817
, (PyObject *)(s)); } else _Py_Dealloc((PyObject *)(s)); } while
(0); } while (0)
;
818 return res;
819}
820
821PyObject *
822PyObject_GetAttr(PyObject *v, PyObject *name)
823{
824 PyTypeObject *tp = Py_TYPE(v)(((PyObject*)(v))->ob_type);
825
826 if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L
<<28))) != 0)
) {
827 PyErr_Format(PyExc_TypeError,
828 "attribute name must be string, not '%.200s'",
829 name->ob_type->tp_name);
830 return NULL((void *)0);
831 }
832 if (tp->tp_getattro != NULL((void *)0))
833 return (*tp->tp_getattro)(v, name);
834 if (tp->tp_getattr != NULL((void *)0)) {
835 char *name_str = _PyUnicode_AsString(name);
836 if (name_str == NULL((void *)0))
837 return NULL((void *)0);
838 return (*tp->tp_getattr)(v, name_str);
839 }
840 PyErr_Format(PyExc_AttributeError,
841 "'%.50s' object has no attribute '%U'",
842 tp->tp_name, name);
843 return NULL((void *)0);
844}
845
846int
847PyObject_HasAttr(PyObject *v, PyObject *name)
848{
849 PyObject *res = PyObject_GetAttr(v, name);
850 if (res != NULL((void *)0)) {
851 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 851, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
852 return 1;
853 }
854 PyErr_Clear();
855 return 0;
856}
857
858int
859PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
860{
861 PyTypeObject *tp = Py_TYPE(v)(((PyObject*)(v))->ob_type);
862 int err;
863
864 if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L
<<28))) != 0)
) {
865 PyErr_Format(PyExc_TypeError,
866 "attribute name must be string, not '%.200s'",
867 name->ob_type->tp_name);
868 return -1;
869 }
870 Py_INCREF(name)( _Py_RefTotal++ , ((PyObject*)(name))->ob_refcnt++);
871
872 PyUnicode_InternInPlace(&name);
873 if (tp->tp_setattro != NULL((void *)0)) {
874 err = (*tp->tp_setattro)(v, name, value);
875 Py_DECREF(name)do { if (_Py_RefTotal-- , --((PyObject*)(name))->ob_refcnt
!= 0) { if (((PyObject*)name)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 875, (PyObject *)(name)); } else _Py_Dealloc
((PyObject *)(name)); } while (0)
;
876 return err;
877 }
878 if (tp->tp_setattr != NULL((void *)0)) {
879 char *name_str = _PyUnicode_AsString(name);
880 if (name_str == NULL((void *)0))
881 return -1;
882 err = (*tp->tp_setattr)(v, name_str, value);
883 Py_DECREF(name)do { if (_Py_RefTotal-- , --((PyObject*)(name))->ob_refcnt
!= 0) { if (((PyObject*)name)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 883, (PyObject *)(name)); } else _Py_Dealloc
((PyObject *)(name)); } while (0)
;
884 return err;
885 }
886 Py_DECREF(name)do { if (_Py_RefTotal-- , --((PyObject*)(name))->ob_refcnt
!= 0) { if (((PyObject*)name)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 886, (PyObject *)(name)); } else _Py_Dealloc
((PyObject *)(name)); } while (0)
;
887 assert(name->ob_refcnt >= 1)(__builtin_expect(!(name->ob_refcnt >= 1), 0) ? __assert_rtn
(__func__, "Objects/object.c", 887, "name->ob_refcnt >= 1"
) : (void)0)
;
888 if (tp->tp_getattr == NULL((void *)0) && tp->tp_getattro == NULL((void *)0))
889 PyErr_Format(PyExc_TypeError,
890 "'%.100s' object has no attributes "
891 "(%s .%U)",
892 tp->tp_name,
893 value==NULL((void *)0) ? "del" : "assign to",
894 name);
895 else
896 PyErr_Format(PyExc_TypeError,
897 "'%.100s' object has only read-only attributes "
898 "(%s .%U)",
899 tp->tp_name,
900 value==NULL((void *)0) ? "del" : "assign to",
901 name);
902 return -1;
903}
904
905/* Helper to get a pointer to an object's __dict__ slot, if any */
906
907PyObject **
908_PyObject_GetDictPtr(PyObject *obj)
909{
910 Py_ssize_t dictoffset;
911 PyTypeObject *tp = Py_TYPE(obj)(((PyObject*)(obj))->ob_type);
912
913 dictoffset = tp->tp_dictoffset;
914 if (dictoffset == 0)
915 return NULL((void *)0);
916 if (dictoffset < 0) {
917 Py_ssize_t tsize;
918 size_t size;
919
920 tsize = ((PyVarObject *)obj)->ob_size;
921 if (tsize < 0)
922 tsize = -tsize;
923 size = _PyObject_VAR_SIZE(tp, tsize)(size_t) ( ( (tp)->tp_basicsize + (tsize)*(tp)->tp_itemsize
+ (8 - 1) ) & ~(8 - 1) )
;
924
925 dictoffset += (long)size;
926 assert(dictoffset > 0)(__builtin_expect(!(dictoffset > 0), 0) ? __assert_rtn(__func__
, "Objects/object.c", 926, "dictoffset > 0") : (void)0)
;
927 assert(dictoffset % SIZEOF_VOID_P == 0)(__builtin_expect(!(dictoffset % 8 == 0), 0) ? __assert_rtn(__func__
, "Objects/object.c", 927, "dictoffset % SIZEOF_VOID_P == 0")
: (void)0)
;
928 }
929 return (PyObject **) ((char *)obj + dictoffset);
930}
931
932PyObject *
933PyObject_SelfIter(PyObject *obj)
934{
935 Py_INCREF(obj)( _Py_RefTotal++ , ((PyObject*)(obj))->ob_refcnt++);
936 return obj;
937}
938
939/* Helper used when the __next__ method is removed from a type:
940 tp_iternext is never NULL and can be safely called without checking
941 on every iteration.
942 */
943
944PyObject *
945_PyObject_NextNotImplemented(PyObject *self)
946{
947 PyErr_Format(PyExc_TypeError,
948 "'%.200s' object is not iterable",
949 Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name);
950 return NULL((void *)0);
951}
952
953/* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
954
955PyObject *
956_PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name, PyObject *dict)
957{
958 PyTypeObject *tp = Py_TYPE(obj)(((PyObject*)(obj))->ob_type);
959 PyObject *descr = NULL((void *)0);
960 PyObject *res = NULL((void *)0);
961 descrgetfunc f;
962 Py_ssize_t dictoffset;
963 PyObject **dictptr;
964
965 if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L
<<28))) != 0)
){
966 PyErr_Format(PyExc_TypeError,
967 "attribute name must be string, not '%.200s'",
968 name->ob_type->tp_name);
969 return NULL((void *)0);
970 }
971 else
972 Py_INCREF(name)( _Py_RefTotal++ , ((PyObject*)(name))->ob_refcnt++);
973
974 if (tp->tp_dict == NULL((void *)0)) {
975 if (PyType_Ready(tp) < 0)
976 goto done;
977 }
978
979 descr = _PyType_Lookup(tp, name);
980 Py_XINCREF(descr)do { if ((descr) == ((void *)0)) ; else ( _Py_RefTotal++ , ((
PyObject*)(descr))->ob_refcnt++); } while (0)
;
981
982 f = NULL((void *)0);
983 if (descr != NULL((void *)0)) {
984 f = descr->ob_type->tp_descr_get;
985 if (f != NULL((void *)0) && PyDescr_IsData(descr)((((PyObject*)(descr))->ob_type)->tp_descr_set != ((void
*)0))
) {
986 res = f(descr, obj, (PyObject *)obj->ob_type);
987 Py_DECREF(descr)do { if (_Py_RefTotal-- , --((PyObject*)(descr))->ob_refcnt
!= 0) { if (((PyObject*)descr)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 987, (PyObject *)(descr)); } else _Py_Dealloc
((PyObject *)(descr)); } while (0)
;
988 goto done;
989 }
990 }
991
992 if (dict == NULL((void *)0)) {
993 /* Inline _PyObject_GetDictPtr */
994 dictoffset = tp->tp_dictoffset;
995 if (dictoffset != 0) {
996 if (dictoffset < 0) {
997 Py_ssize_t tsize;
998 size_t size;
999
1000 tsize = ((PyVarObject *)obj)->ob_size;
1001 if (tsize < 0)
1002 tsize = -tsize;
1003 size = _PyObject_VAR_SIZE(tp, tsize)(size_t) ( ( (tp)->tp_basicsize + (tsize)*(tp)->tp_itemsize
+ (8 - 1) ) & ~(8 - 1) )
;
1004
1005 dictoffset += (long)size;
1006 assert(dictoffset > 0)(__builtin_expect(!(dictoffset > 0), 0) ? __assert_rtn(__func__
, "Objects/object.c", 1006, "dictoffset > 0") : (void)0)
;
1007 assert(dictoffset % SIZEOF_VOID_P == 0)(__builtin_expect(!(dictoffset % 8 == 0), 0) ? __assert_rtn(__func__
, "Objects/object.c", 1007, "dictoffset % SIZEOF_VOID_P == 0"
) : (void)0)
;
1008 }
1009 dictptr = (PyObject **) ((char *)obj + dictoffset);
1010 dict = *dictptr;
1011 }
1012 }
1013 if (dict != NULL((void *)0)) {
1014 Py_INCREF(dict)( _Py_RefTotal++ , ((PyObject*)(dict))->ob_refcnt++);
1015 res = PyDict_GetItem(dict, name);
1016 if (res != NULL((void *)0)) {
1017 Py_INCREF(res)( _Py_RefTotal++ , ((PyObject*)(res))->ob_refcnt++);
1018 Py_XDECREF(descr)do { if ((descr) == ((void *)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(descr))->ob_refcnt != 0) { if (((PyObject
*)descr)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c"
, 1018, (PyObject *)(descr)); } else _Py_Dealloc((PyObject *)
(descr)); } while (0); } while (0)
;
1019 Py_DECREF(dict)do { if (_Py_RefTotal-- , --((PyObject*)(dict))->ob_refcnt
!= 0) { if (((PyObject*)dict)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1019, (PyObject *)(dict)); } else _Py_Dealloc
((PyObject *)(dict)); } while (0)
;
1020 goto done;
1021 }
1022 Py_DECREF(dict)do { if (_Py_RefTotal-- , --((PyObject*)(dict))->ob_refcnt
!= 0) { if (((PyObject*)dict)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1022, (PyObject *)(dict)); } else _Py_Dealloc
((PyObject *)(dict)); } while (0)
;
1023 }
1024
1025 if (f != NULL((void *)0)) {
1026 res = f(descr, obj, (PyObject *)Py_TYPE(obj)(((PyObject*)(obj))->ob_type));
1027 Py_DECREF(descr)do { if (_Py_RefTotal-- , --((PyObject*)(descr))->ob_refcnt
!= 0) { if (((PyObject*)descr)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1027, (PyObject *)(descr)); } else _Py_Dealloc
((PyObject *)(descr)); } while (0)
;
1028 goto done;
1029 }
1030
1031 if (descr != NULL((void *)0)) {
1032 res = descr;
1033 /* descr was already increfed above */
1034 goto done;
1035 }
1036
1037 PyErr_Format(PyExc_AttributeError,
1038 "'%.50s' object has no attribute '%U'",
1039 tp->tp_name, name);
1040 done:
1041 Py_DECREF(name)do { if (_Py_RefTotal-- , --((PyObject*)(name))->ob_refcnt
!= 0) { if (((PyObject*)name)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1041, (PyObject *)(name)); } else _Py_Dealloc
((PyObject *)(name)); } while (0)
;
1042 return res;
1043}
1044
1045PyObject *
1046PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
1047{
1048 return _PyObject_GenericGetAttrWithDict(obj, name, NULL((void *)0));
1049}
1050
1051int
1052_PyObject_GenericSetAttrWithDict(PyObject *obj, PyObject *name,
1053 PyObject *value, PyObject *dict)
1054{
1055 PyTypeObject *tp = Py_TYPE(obj)(((PyObject*)(obj))->ob_type);
1056 PyObject *descr;
1057 descrsetfunc f;
1058 PyObject **dictptr;
1059 int res = -1;
1060
1061 if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1L
<<28))) != 0)
){
1062 PyErr_Format(PyExc_TypeError,
1063 "attribute name must be string, not '%.200s'",
1064 name->ob_type->tp_name);
1065 return -1;
1066 }
1067 else
1068 Py_INCREF(name)( _Py_RefTotal++ , ((PyObject*)(name))->ob_refcnt++);
1069
1070 if (tp->tp_dict == NULL((void *)0)) {
1071 if (PyType_Ready(tp) < 0)
1072 goto done;
1073 }
1074
1075 descr = _PyType_Lookup(tp, name);
1076 f = NULL((void *)0);
1077 if (descr != NULL((void *)0)) {
1078 f = descr->ob_type->tp_descr_set;
1079 if (f != NULL((void *)0) && PyDescr_IsData(descr)((((PyObject*)(descr))->ob_type)->tp_descr_set != ((void
*)0))
) {
1080 res = f(descr, obj, value);
1081 goto done;
1082 }
1083 }
1084
1085 if (dict == NULL((void *)0)) {
1086 dictptr = _PyObject_GetDictPtr(obj);
1087 if (dictptr != NULL((void *)0)) {
1088 dict = *dictptr;
1089 if (dict == NULL((void *)0) && value != NULL((void *)0)) {
1090 dict = PyDict_New();
1091 if (dict == NULL((void *)0))
1092 goto done;
1093 *dictptr = dict;
1094 }
1095 }
1096 }
1097 if (dict != NULL((void *)0)) {
1098 Py_INCREF(dict)( _Py_RefTotal++ , ((PyObject*)(dict))->ob_refcnt++);
1099 if (value == NULL((void *)0))
1100 res = PyDict_DelItem(dict, name);
1101 else
1102 res = PyDict_SetItem(dict, name, value);
1103 if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError))
1104 PyErr_SetObject(PyExc_AttributeError, name);
1105 Py_DECREF(dict)do { if (_Py_RefTotal-- , --((PyObject*)(dict))->ob_refcnt
!= 0) { if (((PyObject*)dict)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1105, (PyObject *)(dict)); } else _Py_Dealloc
((PyObject *)(dict)); } while (0)
;
1106 goto done;
1107 }
1108
1109 if (f != NULL((void *)0)) {
1110 res = f(descr, obj, value);
1111 goto done;
1112 }
1113
1114 if (descr == NULL((void *)0)) {
1115 PyErr_Format(PyExc_AttributeError,
1116 "'%.100s' object has no attribute '%U'",
1117 tp->tp_name, name);
1118 goto done;
1119 }
1120
1121 PyErr_Format(PyExc_AttributeError,
1122 "'%.50s' object attribute '%U' is read-only",
1123 tp->tp_name, name);
1124 done:
1125 Py_DECREF(name)do { if (_Py_RefTotal-- , --((PyObject*)(name))->ob_refcnt
!= 0) { if (((PyObject*)name)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1125, (PyObject *)(name)); } else _Py_Dealloc
((PyObject *)(name)); } while (0)
;
1126 return res;
1127}
1128
1129int
1130PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
1131{
1132 return _PyObject_GenericSetAttrWithDict(obj, name, value, NULL((void *)0));
1133}
1134
1135
1136/* Test a value used as condition, e.g., in a for or if statement.
1137 Return -1 if an error occurred */
1138
1139int
1140PyObject_IsTrue(PyObject *v)
1141{
1142 Py_ssize_t res;
1143 if (v == Py_True((PyObject *) &_Py_TrueStruct))
1144 return 1;
1145 if (v == Py_False((PyObject *) &_Py_FalseStruct))
1146 return 0;
1147 if (v == Py_None(&_Py_NoneStruct))
1148 return 0;
1149 else if (v->ob_type->tp_as_number != NULL((void *)0) &&
1150 v->ob_type->tp_as_number->nb_bool != NULL((void *)0))
1151 res = (*v->ob_type->tp_as_number->nb_bool)(v);
1152 else if (v->ob_type->tp_as_mapping != NULL((void *)0) &&
1153 v->ob_type->tp_as_mapping->mp_length != NULL((void *)0))
1154 res = (*v->ob_type->tp_as_mapping->mp_length)(v);
1155 else if (v->ob_type->tp_as_sequence != NULL((void *)0) &&
1156 v->ob_type->tp_as_sequence->sq_length != NULL((void *)0))
1157 res = (*v->ob_type->tp_as_sequence->sq_length)(v);
1158 else
1159 return 1;
1160 /* if it is negative, it should be either -1 or -2 */
1161 return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int)((__builtin_expect(!((Py_ssize_t)(int)(res) == (res)), 0) ? __assert_rtn
(__func__, "Objects/object.c", 1161, "(Py_ssize_t)(int)(res) == (res)"
) : (void)0), (int)(res))
;
1162}
1163
1164/* equivalent of 'not v'
1165 Return -1 if an error occurred */
1166
1167int
1168PyObject_Not(PyObject *v)
1169{
1170 int res;
1171 res = PyObject_IsTrue(v);
1172 if (res < 0)
1173 return res;
1174 return res == 0;
1175}
1176
1177/* Test whether an object can be called */
1178
1179int
1180PyCallable_Check(PyObject *x)
1181{
1182 if (x == NULL((void *)0))
1183 return 0;
1184 return x->ob_type->tp_call != NULL((void *)0);
1185}
1186
1187/* ------------------------- PyObject_Dir() helpers ------------------------- */
1188
1189/* Helper for PyObject_Dir.
1190 Merge the __dict__ of aclass into dict, and recursively also all
1191 the __dict__s of aclass's base classes. The order of merging isn't
1192 defined, as it's expected that only the final set of dict keys is
1193 interesting.
1194 Return 0 on success, -1 on error.
1195*/
1196
1197static int
1198merge_class_dict(PyObject* dict, PyObject* aclass)
1199{
1200 PyObject *classdict;
1201 PyObject *bases;
1202
1203 assert(PyDict_Check(dict))(__builtin_expect(!(((((((PyObject*)(dict))->ob_type))->
tp_flags & ((1L<<29))) != 0)), 0) ? __assert_rtn(__func__
, "Objects/object.c", 1203, "PyDict_Check(dict)") : (void)0)
;
1204 assert(aclass)(__builtin_expect(!(aclass), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 1204, "aclass") : (void)0)
;
1205
1206 /* Merge in the type's dict (if any). */
1207 classdict = PyObject_GetAttrString(aclass, "__dict__");
1208 if (classdict == NULL((void *)0))
1209 PyErr_Clear();
1210 else {
1211 int status = PyDict_Update(dict, classdict);
1212 Py_DECREF(classdict)do { if (_Py_RefTotal-- , --((PyObject*)(classdict))->ob_refcnt
!= 0) { if (((PyObject*)classdict)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1212, (PyObject *)(classdict)); } else _Py_Dealloc
((PyObject *)(classdict)); } while (0)
;
1213 if (status < 0)
1214 return -1;
1215 }
1216
1217 /* Recursively merge in the base types' (if any) dicts. */
1218 bases = PyObject_GetAttrString(aclass, "__bases__");
1219 if (bases == NULL((void *)0))
1220 PyErr_Clear();
1221 else {
1222 /* We have no guarantee that bases is a real tuple */
1223 Py_ssize_t i, n;
1224 n = PySequence_Size(bases); /* This better be right */
1225 if (n < 0)
1226 PyErr_Clear();
1227 else {
1228 for (i = 0; i < n; i++) {
1229 int status;
1230 PyObject *base = PySequence_GetItem(bases, i);
1231 if (base == NULL((void *)0)) {
1232 Py_DECREF(bases)do { if (_Py_RefTotal-- , --((PyObject*)(bases))->ob_refcnt
!= 0) { if (((PyObject*)bases)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1232, (PyObject *)(bases)); } else _Py_Dealloc
((PyObject *)(bases)); } while (0)
;
1233 return -1;
1234 }
1235 status = merge_class_dict(dict, base);
1236 Py_DECREF(base)do { if (_Py_RefTotal-- , --((PyObject*)(base))->ob_refcnt
!= 0) { if (((PyObject*)base)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1236, (PyObject *)(base)); } else _Py_Dealloc
((PyObject *)(base)); } while (0)
;
1237 if (status < 0) {
1238 Py_DECREF(bases)do { if (_Py_RefTotal-- , --((PyObject*)(bases))->ob_refcnt
!= 0) { if (((PyObject*)bases)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1238, (PyObject *)(bases)); } else _Py_Dealloc
((PyObject *)(bases)); } while (0)
;
1239 return -1;
1240 }
1241 }
1242 }
1243 Py_DECREF(bases)do { if (_Py_RefTotal-- , --((PyObject*)(bases))->ob_refcnt
!= 0) { if (((PyObject*)bases)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1243, (PyObject *)(bases)); } else _Py_Dealloc
((PyObject *)(bases)); } while (0)
;
1244 }
1245 return 0;
1246}
1247
1248/* Helper for PyObject_Dir without arguments: returns the local scope. */
1249static PyObject *
1250_dir_locals(void)
1251{
1252 PyObject *names;
1253 PyObject *locals = PyEval_GetLocals();
1254
1255 if (locals == NULL((void *)0)) {
1256 PyErr_SetString(PyExc_SystemError, "frame does not exist");
1257 return NULL((void *)0);
1258 }
1259
1260 names = PyMapping_Keys(locals);
1261 if (!names)
1262 return NULL((void *)0);
1263 if (!PyList_Check(names)((((((PyObject*)(names))->ob_type))->tp_flags & ((1L
<<25))) != 0)
) {
1264 PyErr_Format(PyExc_TypeError,
1265 "dir(): expected keys() of locals to be a list, "
1266 "not '%.200s'", Py_TYPE(names)(((PyObject*)(names))->ob_type)->tp_name);
1267 Py_DECREF(names)do { if (_Py_RefTotal-- , --((PyObject*)(names))->ob_refcnt
!= 0) { if (((PyObject*)names)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1267, (PyObject *)(names)); } else _Py_Dealloc
((PyObject *)(names)); } while (0)
;
1268 return NULL((void *)0);
1269 }
1270 /* the locals don't need to be DECREF'd */
1271 return names;
1272}
1273
1274/* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__.
1275 We deliberately don't suck up its __class__, as methods belonging to the
1276 metaclass would probably be more confusing than helpful.
1277*/
1278static PyObject *
1279_specialized_dir_type(PyObject *obj)
1280{
1281 PyObject *result = NULL((void *)0);
1282 PyObject *dict = PyDict_New();
1283
1284 if (dict != NULL((void *)0) && merge_class_dict(dict, obj) == 0)
1285 result = PyDict_Keys(dict);
1286
1287 Py_XDECREF(dict)do { if ((dict) == ((void *)0)) ; else do { if (_Py_RefTotal--
, --((PyObject*)(dict))->ob_refcnt != 0) { if (((PyObject
*)dict)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c"
, 1287, (PyObject *)(dict)); } else _Py_Dealloc((PyObject *)(
dict)); } while (0); } while (0)
;
1288 return result;
1289}
1290
1291/* Helper for PyObject_Dir of module objects: returns the module's __dict__. */
1292static PyObject *
1293_specialized_dir_module(PyObject *obj)
1294{
1295 PyObject *result = NULL((void *)0);
1296 PyObject *dict = PyObject_GetAttrString(obj, "__dict__");
1297
1298 if (dict != NULL((void *)0)) {
1299 if (PyDict_Check(dict)((((((PyObject*)(dict))->ob_type))->tp_flags & ((1L
<<29))) != 0)
)
1300 result = PyDict_Keys(dict);
1301 else {
1302 const char *name = PyModule_GetName(obj);
1303 if (name)
1304 PyErr_Format(PyExc_TypeError,
1305 "%.200s.__dict__ is not a dictionary",
1306 name);
1307 }
1308 }
1309
1310 Py_XDECREF(dict)do { if ((dict) == ((void *)0)) ; else do { if (_Py_RefTotal--
, --((PyObject*)(dict))->ob_refcnt != 0) { if (((PyObject
*)dict)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c"
, 1310, (PyObject *)(dict)); } else _Py_Dealloc((PyObject *)(
dict)); } while (0); } while (0)
;
1311 return result;
1312}
1313
1314/* Helper for PyObject_Dir of generic objects: returns __dict__, __class__,
1315 and recursively up the __class__.__bases__ chain.
1316*/
1317static PyObject *
1318_generic_dir(PyObject *obj)
1319{
1320 PyObject *result = NULL((void *)0);
1321 PyObject *dict = NULL((void *)0);
1322 PyObject *itsclass = NULL((void *)0);
1323
1324 /* Get __dict__ (which may or may not be a real dict...) */
1325 dict = PyObject_GetAttrString(obj, "__dict__");
1326 if (dict == NULL((void *)0)) {
1327 PyErr_Clear();
1328 dict = PyDict_New();
1329 }
1330 else if (!PyDict_Check(dict)((((((PyObject*)(dict))->ob_type))->tp_flags & ((1L
<<29))) != 0)
) {
1331 Py_DECREF(dict)do { if (_Py_RefTotal-- , --((PyObject*)(dict))->ob_refcnt
!= 0) { if (((PyObject*)dict)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1331, (PyObject *)(dict)); } else _Py_Dealloc
((PyObject *)(dict)); } while (0)
;
1332 dict = PyDict_New();
1333 }
1334 else {
1335 /* Copy __dict__ to avoid mutating it. */
1336 PyObject *temp = PyDict_Copy(dict);
1337 Py_DECREF(dict)do { if (_Py_RefTotal-- , --((PyObject*)(dict))->ob_refcnt
!= 0) { if (((PyObject*)dict)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1337, (PyObject *)(dict)); } else _Py_Dealloc
((PyObject *)(dict)); } while (0)
;
1338 dict = temp;
1339 }
1340
1341 if (dict == NULL((void *)0))
1342 goto error;
1343
1344 /* Merge in attrs reachable from its class. */
1345 itsclass = PyObject_GetAttrString(obj, "__class__");
1346 if (itsclass == NULL((void *)0))
1347 /* XXX(tomer): Perhaps fall back to obj->ob_type if no
1348 __class__ exists? */
1349 PyErr_Clear();
1350 else {
1351 if (merge_class_dict(dict, itsclass) != 0)
1352 goto error;
1353 }
1354
1355 result = PyDict_Keys(dict);
1356 /* fall through */
1357error:
1358 Py_XDECREF(itsclass)do { if ((itsclass) == ((void *)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(itsclass))->ob_refcnt != 0) { if (((PyObject
*)itsclass)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c"
, 1358, (PyObject *)(itsclass)); } else _Py_Dealloc((PyObject
*)(itsclass)); } while (0); } while (0)
;
1359 Py_XDECREF(dict)do { if ((dict) == ((void *)0)) ; else do { if (_Py_RefTotal--
, --((PyObject*)(dict))->ob_refcnt != 0) { if (((PyObject
*)dict)->ob_refcnt < 0) _Py_NegativeRefcount("Objects/object.c"
, 1359, (PyObject *)(dict)); } else _Py_Dealloc((PyObject *)(
dict)); } while (0); } while (0)
;
1360 return result;
1361}
1362
1363/* Helper for PyObject_Dir: object introspection.
1364 This calls one of the above specialized versions if no __dir__ method
1365 exists. */
1366static PyObject *
1367_dir_object(PyObject *obj)
1368{
1369 PyObject * result = NULL((void *)0);
1370 PyObject * dirfunc = PyObject_GetAttrString((PyObject*)obj->ob_type,
1371 "__dir__");
1372
1373 assert(obj)(__builtin_expect(!(obj), 0) ? __assert_rtn(__func__, "Objects/object.c"
, 1373, "obj") : (void)0)
;
1374 if (dirfunc == NULL((void *)0)) {
1375 /* use default implementation */
1376 PyErr_Clear();
1377 if (PyModule_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyModule_Type) || PyType_IsSubtype
((((PyObject*)(obj))->ob_type), (&PyModule_Type)))
)
1378 result = _specialized_dir_module(obj);
1379 else if (PyType_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<<
31))) != 0)
)
1380 result = _specialized_dir_type(obj);
1381 else
1382 result = _generic_dir(obj);
1383 }
1384 else {
1385 /* use __dir__ */
1386 result = PyObject_CallFunctionObjArgs(dirfunc, obj, NULL((void *)0));
1387 Py_DECREF(dirfunc)do { if (_Py_RefTotal-- , --((PyObject*)(dirfunc))->ob_refcnt
!= 0) { if (((PyObject*)dirfunc)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1387, (PyObject *)(dirfunc)); } else _Py_Dealloc
((PyObject *)(dirfunc)); } while (0)
;
1388 if (result == NULL((void *)0))
1389 return NULL((void *)0);
1390
1391 /* result must be a list */
1392 /* XXX(gbrandl): could also check if all items are strings */
1393 if (!PyList_Check(result)((((((PyObject*)(result))->ob_type))->tp_flags & ((
1L<<25))) != 0)
) {
1394 PyErr_Format(PyExc_TypeError,
1395 "__dir__() must return a list, not %.200s",
1396 Py_TYPE(result)(((PyObject*)(result))->ob_type)->tp_name);
1397 Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt
!= 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1397, (PyObject *)(result)); } else _Py_Dealloc
((PyObject *)(result)); } while (0)
;
1398 result = NULL((void *)0);
1399 }
1400 }
1401
1402 return result;
1403}
1404
1405/* Implementation of dir() -- if obj is NULL, returns the names in the current
1406 (local) scope. Otherwise, performs introspection of the object: returns a
1407 sorted list of attribute names (supposedly) accessible from the object
1408*/
1409PyObject *
1410PyObject_Dir(PyObject *obj)
1411{
1412 PyObject * result;
1413
1414 if (obj == NULL((void *)0))
1415 /* no object -- introspect the locals */
1416 result = _dir_locals();
1417 else
1418 /* object -- introspect the object */
1419 result = _dir_object(obj);
1420
1421 assert(result == NULL || PyList_Check(result))(__builtin_expect(!(result == ((void *)0) || ((((((PyObject*)
(result))->ob_type))->tp_flags & ((1L<<25))) !=
0)), 0) ? __assert_rtn(__func__, "Objects/object.c", 1421, "result == NULL || PyList_Check(result)"
) : (void)0)
;
1422
1423 if (result != NULL((void *)0) && PyList_Sort(result) != 0) {
1424 /* sorting the list failed */
1425 Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt
!= 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1425, (PyObject *)(result)); } else _Py_Dealloc
((PyObject *)(result)); } while (0)
;
1426 result = NULL((void *)0);
1427 }
1428
1429 return result;
1430}
1431
1432/*
1433NoObject is usable as a non-NULL undefined value, used by the macro None.
1434There is (and should be!) no way to create other objects of this type,
1435so there is exactly one (which is indestructible, by the way).
1436(XXX This type and the type of NotImplemented below should be unified.)
1437*/
1438
1439/* ARGSUSED */
1440static PyObject *
1441none_repr(PyObject *op)
1442{
1443 return PyUnicode_FromStringPyUnicodeUCS2_FromString("None");
1444}
1445
1446/* ARGUSED */
1447static void
1448none_dealloc(PyObject* ignore)
1449{
1450 /* This should never get called, but we also don't want to SEGV if
1451 * we accidentally decref None out of existence.
1452 */
1453 Py_FatalError("deallocating None");
1454}
1455
1456
1457static PyTypeObject PyNone_Type = {
1458 PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
1459 "NoneType",
1460 0,
1461 0,
1462 none_dealloc, /*tp_dealloc*/ /*never called*/
1463 0, /*tp_print*/
1464 0, /*tp_getattr*/
1465 0, /*tp_setattr*/
1466 0, /*tp_reserved*/
1467 none_repr, /*tp_repr*/
1468 0, /*tp_as_number*/
1469 0, /*tp_as_sequence*/
1470 0, /*tp_as_mapping*/
1471 0, /*tp_hash */
1472};
1473
1474PyObject _Py_NoneStruct = {
1475 _PyObject_EXTRA_INIT0, 0,
1476 1, &PyNone_Type
1477};
1478
1479/* NotImplemented is an object that can be used to signal that an
1480 operation is not implemented for the given type combination. */
1481
1482static PyObject *
1483NotImplemented_repr(PyObject *op)
1484{
1485 return PyUnicode_FromStringPyUnicodeUCS2_FromString("NotImplemented");
1486}
1487
1488static PyTypeObject PyNotImplemented_Type = {
1489 PyVarObject_HEAD_INIT(&PyType_Type, 0){ { 0, 0, 1, &PyType_Type }, 0 },
1490 "NotImplementedType",
1491 0,
1492 0,
1493 none_dealloc, /*tp_dealloc*/ /*never called*/
1494 0, /*tp_print*/
1495 0, /*tp_getattr*/
1496 0, /*tp_setattr*/
1497 0, /*tp_reserved*/
1498 NotImplemented_repr, /*tp_repr*/
1499 0, /*tp_as_number*/
1500 0, /*tp_as_sequence*/
1501 0, /*tp_as_mapping*/
1502 0, /*tp_hash */
1503};
1504
1505PyObject _Py_NotImplementedStruct = {
1506 _PyObject_EXTRA_INIT0, 0,
1507 1, &PyNotImplemented_Type
1508};
1509
1510void
1511_Py_ReadyTypes(void)
1512{
1513 if (PyType_Ready(&PyType_Type) < 0)
1514 Py_FatalError("Can't initialize type type");
1515
1516 if (PyType_Ready(&_PyWeakref_RefType) < 0)
1517 Py_FatalError("Can't initialize weakref type");
1518
1519 if (PyType_Ready(&_PyWeakref_CallableProxyType) < 0)
1520 Py_FatalError("Can't initialize callable weakref proxy type");
1521
1522 if (PyType_Ready(&_PyWeakref_ProxyType) < 0)
1523 Py_FatalError("Can't initialize weakref proxy type");
1524
1525 if (PyType_Ready(&PyBool_Type) < 0)
1526 Py_FatalError("Can't initialize bool type");
1527
1528 if (PyType_Ready(&PyByteArray_Type) < 0)
1529 Py_FatalError("Can't initialize bytearray type");
1530
1531 if (PyType_Ready(&PyBytes_Type) < 0)
1532 Py_FatalError("Can't initialize 'str'");
1533
1534 if (PyType_Ready(&PyList_Type) < 0)
1535 Py_FatalError("Can't initialize list type");
1536
1537 if (PyType_Ready(&PyNone_Type) < 0)
1538 Py_FatalError("Can't initialize None type");
1539
1540 if (PyType_Ready(Py_Ellipsis(&_Py_EllipsisObject)->ob_type) < 0)
1541 Py_FatalError("Can't initialize type(Ellipsis)");
1542
1543 if (PyType_Ready(&PyNotImplemented_Type) < 0)
1544 Py_FatalError("Can't initialize NotImplemented type");
1545
1546 if (PyType_Ready(&PyTraceBack_Type) < 0)
1547 Py_FatalError("Can't initialize traceback type");
1548
1549 if (PyType_Ready(&PySuper_Type) < 0)
1550 Py_FatalError("Can't initialize super type");
1551
1552 if (PyType_Ready(&PyBaseObject_Type) < 0)
1553 Py_FatalError("Can't initialize object type");
1554
1555 if (PyType_Ready(&PyRange_Type) < 0)
1556 Py_FatalError("Can't initialize range type");
1557
1558 if (PyType_Ready(&PyDict_Type) < 0)
1559 Py_FatalError("Can't initialize dict type");
1560
1561 if (PyType_Ready(&PySet_Type) < 0)
1562 Py_FatalError("Can't initialize set type");
1563
1564 if (PyType_Ready(&PyUnicode_Type) < 0)
1565 Py_FatalError("Can't initialize str type");
1566
1567 if (PyType_Ready(&PySlice_Type) < 0)
1568 Py_FatalError("Can't initialize slice type");
1569
1570 if (PyType_Ready(&PyStaticMethod_Type) < 0)
1571 Py_FatalError("Can't initialize static method type");
1572
1573 if (PyType_Ready(&PyComplex_Type) < 0)
1574 Py_FatalError("Can't initialize complex type");
1575
1576 if (PyType_Ready(&PyFloat_Type) < 0)
1577 Py_FatalError("Can't initialize float type");
1578
1579 if (PyType_Ready(&PyLong_Type) < 0)
1580 Py_FatalError("Can't initialize int type");
1581
1582 if (PyType_Ready(&PyFrozenSet_Type) < 0)
1583 Py_FatalError("Can't initialize frozenset type");
1584
1585 if (PyType_Ready(&PyProperty_Type) < 0)
1586 Py_FatalError("Can't initialize property type");
1587
1588 if (PyType_Ready(&PyMemoryView_Type) < 0)
1589 Py_FatalError("Can't initialize memoryview type");
1590
1591 if (PyType_Ready(&PyTuple_Type) < 0)
1592 Py_FatalError("Can't initialize tuple type");
1593
1594 if (PyType_Ready(&PyEnum_Type) < 0)
1595 Py_FatalError("Can't initialize enumerate type");
1596
1597 if (PyType_Ready(&PyReversed_Type) < 0)
1598 Py_FatalError("Can't initialize reversed type");
1599
1600 if (PyType_Ready(&PyStdPrinter_Type) < 0)
1601 Py_FatalError("Can't initialize StdPrinter");
1602
1603 if (PyType_Ready(&PyCode_Type) < 0)
1604 Py_FatalError("Can't initialize code type");
1605
1606 if (PyType_Ready(&PyFrame_Type) < 0)
1607 Py_FatalError("Can't initialize frame type");
1608
1609 if (PyType_Ready(&PyCFunction_Type) < 0)
1610 Py_FatalError("Can't initialize builtin function type");
1611
1612 if (PyType_Ready(&PyMethod_Type) < 0)
1613 Py_FatalError("Can't initialize method type");
1614
1615 if (PyType_Ready(&PyFunction_Type) < 0)
1616 Py_FatalError("Can't initialize function type");
1617
1618 if (PyType_Ready(&PyDictProxy_Type) < 0)
1619 Py_FatalError("Can't initialize dict proxy type");
1620
1621 if (PyType_Ready(&PyGen_Type) < 0)
1622 Py_FatalError("Can't initialize generator type");
1623
1624 if (PyType_Ready(&PyGetSetDescr_Type) < 0)
1625 Py_FatalError("Can't initialize get-set descriptor type");
1626
1627 if (PyType_Ready(&PyWrapperDescr_Type) < 0)
1628 Py_FatalError("Can't initialize wrapper type");
1629
1630 if (PyType_Ready(&PyEllipsis_Type) < 0)
1631 Py_FatalError("Can't initialize ellipsis type");
1632
1633 if (PyType_Ready(&PyMemberDescr_Type) < 0)
1634 Py_FatalError("Can't initialize member descriptor type");
1635
1636 if (PyType_Ready(&PyFilter_Type) < 0)
1637 Py_FatalError("Can't initialize filter type");
1638
1639 if (PyType_Ready(&PyMap_Type) < 0)
1640 Py_FatalError("Can't initialize map type");
1641
1642 if (PyType_Ready(&PyZip_Type) < 0)
1643 Py_FatalError("Can't initialize zip type");
1644}
1645
1646
1647#ifdef Py_TRACE_REFS
1648
1649void
1650_Py_NewReference(PyObject *op)
1651{
1652 _Py_INC_REFTOTAL_Py_RefTotal++;
1653 op->ob_refcnt = 1;
1654 _Py_AddToAllObjects(op, 1);
1655 _Py_INC_TPALLOCS(op);
1656}
1657
1658void
1659_Py_ForgetReference(register PyObject *op)
1660{
1661#ifdef SLOW_UNREF_CHECK
1662 register PyObject *p;
1663#endif
1664 if (op->ob_refcnt < 0)
1665 Py_FatalError("UNREF negative refcnt");
1666 if (op == &refchain ||
1667 op->_ob_prev->_ob_next != op || op->_ob_next->_ob_prev != op) {
1668 fprintf(stderr__stderrp, "* ob\n");
1669 _PyObject_Dump(op);
1670 fprintf(stderr__stderrp, "* op->_ob_prev->_ob_next\n");
1671 _PyObject_Dump(op->_ob_prev->_ob_next);
1672 fprintf(stderr__stderrp, "* op->_ob_next->_ob_prev\n");
1673 _PyObject_Dump(op->_ob_next->_ob_prev);
1674 Py_FatalError("UNREF invalid object");
1675 }
1676#ifdef SLOW_UNREF_CHECK
1677 for (p = refchain._ob_next; p != &refchain; p = p->_ob_next) {
1678 if (p == op)
1679 break;
1680 }
1681 if (p == &refchain) /* Not found */
1682 Py_FatalError("UNREF unknown object");
1683#endif
1684 op->_ob_next->_ob_prev = op->_ob_prev;
1685 op->_ob_prev->_ob_next = op->_ob_next;
1686 op->_ob_next = op->_ob_prev = NULL((void *)0);
1687 _Py_INC_TPFREES(op);
1688}
1689
1690void
1691_Py_Dealloc(PyObject *op)
1692{
1693 destructor dealloc = Py_TYPE(op)(((PyObject*)(op))->ob_type)->tp_dealloc;
1694 _Py_ForgetReference(op);
1695 (*dealloc)(op);
1696}
1697
1698/* Print all live objects. Because PyObject_Print is called, the
1699 * interpreter must be in a healthy state.
1700 */
1701void
1702_Py_PrintReferences(FILE *fp)
1703{
1704 PyObject *op;
1705 fprintf(fp, "Remaining objects:\n");
1706 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) {
1707 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T"l" "d] ", op, op->ob_refcnt);
1708 if (PyObject_Print(op, fp, 0) != 0)
1709 PyErr_Clear();
1710 putc('\n', fp);
1711 }
1712}
1713
1714/* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
1715 * doesn't make any calls to the Python C API, so is always safe to call.
1716 */
1717void
1718_Py_PrintReferenceAddresses(FILE *fp)
1719{
1720 PyObject *op;
1721 fprintf(fp, "Remaining object addresses:\n");
1722 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
1723 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T"l" "d] %s\n", op,
1724 op->ob_refcnt, Py_TYPE(op)(((PyObject*)(op))->ob_type)->tp_name);
1725}
1726
1727PyObject *
1728_Py_GetObjects(PyObject *self, PyObject *args)
1729{
1730 int i, n;
1731 PyObject *t = NULL((void *)0);
1732 PyObject *res, *op;
1733
1734 if (!PyArg_ParseTuple(args, "i|O", &n, &t))
1
Taking false branch
1735 return NULL((void *)0);
1736 op = refchain._ob_next;
1737 res = PyList_New(0);
1738 if (res == NULL((void *)0))
2
Taking false branch
1739 return NULL((void *)0);
1740 for (i = 0; (n == 0 || i < n) && op != &refchain; i++) {
3
Loop condition is true. Entering loop body
6
Loop condition is true. Entering loop body
1741 while (op == self || op == args || op == res || op == t ||
4
Loop condition is false. Execution continues on line 1747
7
Loop condition is true. Entering loop body
1742 (t != NULL((void *)0) && Py_TYPE(op)(((PyObject*)(op))->ob_type) != (PyTypeObject *) t)) {
1743 op = op->_ob_next;
8
Access to field '_ob_next' results in a dereference of a null pointer (loaded from variable 'op')
1744 if (op == &refchain)
1745 return res;
1746 }
1747 if (PyList_Append(res, op) < 0) {
5
Taking false branch
1748 Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt !=
0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1748, (PyObject *)(res)); } else _Py_Dealloc
((PyObject *)(res)); } while (0)
;
1749 return NULL((void *)0);
1750 }
1751 op = op->_ob_next;
1752 }
1753 return res;
1754}
1755
1756#endif
1757
1758/* Hack to force loading of pycapsule.o */
1759PyTypeObject *_PyCapsule_hack = &PyCapsule_Type;
1760
1761
1762/* Hack to force loading of abstract.o */
1763Py_ssize_t (*_Py_abstract_hack)(PyObject *) = PyObject_Size;
1764
1765
1766/* Python's malloc wrappers (see pymem.h) */
1767
1768void *
1769PyMem_Malloc(size_t nbytes)
1770{
1771 return PyMem_MALLOC_PyMem_DebugMalloc(nbytes);
1772}
1773
1774void *
1775PyMem_Realloc(void *p, size_t nbytes)
1776{
1777 return PyMem_REALLOC_PyMem_DebugRealloc(p, nbytes);
1778}
1779
1780void
1781PyMem_Free(void *p)
1782{
1783 PyMem_FREE_PyMem_DebugFree(p);
1784}
1785
1786
1787/* These methods are used to control infinite recursion in repr, str, print,
1788 etc. Container objects that may recursively contain themselves,
1789 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
1790 Py_ReprLeave() to avoid infinite recursion.
1791
1792 Py_ReprEnter() returns 0 the first time it is called for a particular
1793 object and 1 every time thereafter. It returns -1 if an exception
1794 occurred. Py_ReprLeave() has no return value.
1795
1796 See dictobject.c and listobject.c for examples of use.
1797*/
1798
1799#define KEY"Py_Repr" "Py_Repr"
1800
1801int
1802Py_ReprEnter(PyObject *obj)
1803{
1804 PyObject *dict;
1805 PyObject *list;
1806 Py_ssize_t i;
1807
1808 dict = PyThreadState_GetDict();
1809 if (dict == NULL((void *)0))
1810 return 0;
1811 list = PyDict_GetItemString(dict, KEY"Py_Repr");
1812 if (list == NULL((void *)0)) {
1813 list = PyList_New(0);
1814 if (list == NULL((void *)0))
1815 return -1;
1816 if (PyDict_SetItemString(dict, KEY"Py_Repr", list) < 0)
1817 return -1;
1818 Py_DECREF(list)do { if (_Py_RefTotal-- , --((PyObject*)(list))->ob_refcnt
!= 0) { if (((PyObject*)list)->ob_refcnt < 0) _Py_NegativeRefcount
("Objects/object.c", 1818, (PyObject *)(list)); } else _Py_Dealloc
((PyObject *)(list)); } while (0)
;
1819 }
1820 i = PyList_GET_SIZE(list)(((PyVarObject*)(list))->ob_size);
1821 while (--i >= 0) {
1822 if (PyList_GET_ITEM(list, i)(((PyListObject *)(list))->ob_item[i]) == obj)
1823 return 1;
1824 }
1825 PyList_Append(list, obj);
1826 return 0;
1827}
1828
1829void
1830Py_ReprLeave(PyObject *obj)
1831{
1832 PyObject *dict;
1833 PyObject *list;
1834 Py_ssize_t i;
1835
1836 dict = PyThreadState_GetDict();
1837 if (dict == NULL((void *)0))
1838 return;
1839 list = PyDict_GetItemString(dict, KEY"Py_Repr");
1840 if (list == NULL((void *)0) || !PyList_Check(list)((((((PyObject*)(list))->ob_type))->tp_flags & ((1L
<<25))) != 0)
)
1841 return;
1842 i = PyList_GET_SIZE(list)(((PyVarObject*)(list))->ob_size);
1843 /* Count backwards because we always expect obj to be list[-1] */
1844 while (--i >= 0) {
1845 if (PyList_GET_ITEM(list, i)(((PyListObject *)(list))->ob_item[i]) == obj) {
1846 PyList_SetSlice(list, i, i + 1, NULL((void *)0));
1847 break;
1848 }
1849 }
1850}
1851
1852/* Trashcan support. */
1853
1854/* Current call-stack depth of tp_dealloc calls. */
1855int _PyTrash_delete_nesting = 0;
1856
1857/* List of objects that still need to be cleaned up, singly linked via their
1858 * gc headers' gc_prev pointers.
1859 */
1860PyObject *_PyTrash_delete_later = NULL((void *)0);
1861
1862/* Add op to the _PyTrash_delete_later list. Called when the current
1863 * call-stack depth gets large. op must be a currently untracked gc'ed
1864 * object, with refcount 0. Py_DECREF must already have been called on it.
1865 */
1866void
1867_PyTrash_deposit_object(PyObject *op)
1868{
1869 assert(PyObject_IS_GC(op))(__builtin_expect(!(((((((((PyObject*)(op))->ob_type)))->
tp_flags & ((1L<<14))) != 0) && ((((PyObject
*)(op))->ob_type)->tp_is_gc == ((void *)0) || (((PyObject
*)(op))->ob_type)->tp_is_gc(op)))), 0) ? __assert_rtn(__func__
, "Objects/object.c", 1869, "PyObject_IS_GC(op)") : (void)0)
;
1870 assert(_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED)(__builtin_expect(!(((PyGC_Head *)(op)-1)->gc.gc_refs == (
-2)), 0) ? __assert_rtn(__func__, "Objects/object.c", 1870, "_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED"
) : (void)0)
;
1871 assert(op->ob_refcnt == 0)(__builtin_expect(!(op->ob_refcnt == 0), 0) ? __assert_rtn
(__func__, "Objects/object.c", 1871, "op->ob_refcnt == 0")
: (void)0)
;
1872 _Py_AS_GC(op)((PyGC_Head *)(op)-1)->gc.gc_prev = (PyGC_Head *)_PyTrash_delete_later;
1873 _PyTrash_delete_later = op;
1874}
1875
1876/* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
1877 * the call-stack unwinds again.
1878 */
1879void
1880_PyTrash_destroy_chain(void)
1881{
1882 while (_PyTrash_delete_later) {
1883 PyObject *op = _PyTrash_delete_later;
1884 destructor dealloc = Py_TYPE(op)(((PyObject*)(op))->ob_type)->tp_dealloc;
1885
1886 _PyTrash_delete_later =
1887 (PyObject*) _Py_AS_GC(op)((PyGC_Head *)(op)-1)->gc.gc_prev;
1888
1889 /* Call the deallocator directly. This used to try to
1890 * fool Py_DECREF into calling it indirectly, but
1891 * Py_DECREF was already called on this object, and in
1892 * assorted non-release builds calling Py_DECREF again ends
1893 * up distorting allocation statistics.
1894 */
1895 assert(op->ob_refcnt == 0)(__builtin_expect(!(op->ob_refcnt == 0), 0) ? __assert_rtn
(__func__, "Objects/object.c", 1895, "op->ob_refcnt == 0")
: (void)0)
;
1896 ++_PyTrash_delete_nesting;
1897 (*dealloc)(op);
1898 --_PyTrash_delete_nesting;
1899 }
1900}
1901
1902#ifndef Py_TRACE_REFS
1903/* For Py_LIMITED_API, we need an out-of-line version of _Py_Dealloc.
1904 Define this here, so we can undefine the macro. */
1905#undef _Py_Dealloc
1906PyAPI_FUNC(void)void _Py_Dealloc(PyObject *);
1907void
1908_Py_Dealloc(PyObject *op)
1909{
1910 _Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA
1911 (*Py_TYPE(op)(((PyObject*)(op))->ob_type)->tp_dealloc)(op);
1912}
1913#endif
1914
1915#ifdef __cplusplus
1916}
1917#endif