Branch data Line data Source code
1 : :
2 : : /* Generic object operations; and implementation of None */
3 : :
4 : : #include "Python.h"
5 : : #include "pycore_call.h" // _PyObject_CallNoArgs()
6 : : #include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate()
7 : : #include "pycore_context.h" // _PyContextTokenMissing_Type
8 : : #include "pycore_dict.h" // _PyObject_MakeDictFromInstanceAttributes()
9 : : #include "pycore_floatobject.h" // _PyFloat_DebugMallocStats()
10 : : #include "pycore_initconfig.h" // _PyStatus_EXCEPTION()
11 : : #include "pycore_namespace.h" // _PyNamespace_Type
12 : : #include "pycore_object.h" // _PyType_CheckConsistency(), _Py_FatalRefcountError()
13 : : #include "pycore_pyerrors.h" // _PyErr_Occurred()
14 : : #include "pycore_pymem.h" // _PyMem_IsPtrFreed()
15 : : #include "pycore_pystate.h" // _PyThreadState_GET()
16 : : #include "pycore_symtable.h" // PySTEntry_Type
17 : : #include "pycore_typeobject.h" // _PyTypes_InitSlotDefs()
18 : : #include "pycore_unionobject.h" // _PyUnion_Type
19 : : #include "pycore_interpreteridobject.h" // _PyInterpreterID_Type
20 : :
21 : : #ifdef Py_LIMITED_API
22 : : // Prevent recursive call _Py_IncRef() <=> Py_INCREF()
23 : : # error "Py_LIMITED_API macro must not be defined"
24 : : #endif
25 : :
26 : : #ifdef __cplusplus
27 : : extern "C" {
28 : : #endif
29 : :
30 : : /* Defined in tracemalloc.c */
31 : : extern void _PyMem_DumpTraceback(int fd, const void *ptr);
32 : :
33 : :
34 : : int
35 : 0 : _PyObject_CheckConsistency(PyObject *op, int check_content)
36 : : {
37 : : #define CHECK(expr) \
38 : : do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0)
39 : :
40 [ # # ]: 0 : CHECK(!_PyObject_IsFreed(op));
41 [ # # ]: 0 : CHECK(Py_REFCNT(op) >= 1);
42 : :
43 : 0 : _PyType_CheckConsistency(Py_TYPE(op));
44 : :
45 [ # # ]: 0 : if (PyUnicode_Check(op)) {
46 : 0 : _PyUnicode_CheckConsistency(op, check_content);
47 : : }
48 [ # # ]: 0 : else if (PyDict_Check(op)) {
49 : 0 : _PyDict_CheckConsistency(op, check_content);
50 : : }
51 : 0 : return 1;
52 : :
53 : : #undef CHECK
54 : : }
55 : :
56 : :
57 : : #ifdef Py_REF_DEBUG
58 : : Py_ssize_t _Py_RefTotal;
59 : :
60 : : Py_ssize_t
61 : : _Py_GetRefTotal(void)
62 : : {
63 : : return _Py_RefTotal;
64 : : }
65 : :
66 : : void
67 : : _PyDebug_PrintTotalRefs(void) {
68 : : fprintf(stderr,
69 : : "[%zd refs, %zd blocks]\n",
70 : : _Py_GetRefTotal(), _Py_GetAllocatedBlocks());
71 : : }
72 : : #endif /* Py_REF_DEBUG */
73 : :
74 : : /* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
75 : : These are used by the individual routines for object creation.
76 : : Do not call them otherwise, they do not initialize the object! */
77 : :
78 : : #ifdef Py_TRACE_REFS
79 : : /* Head of circular doubly-linked list of all objects. These are linked
80 : : * together via the _ob_prev and _ob_next members of a PyObject, which
81 : : * exist only in a Py_TRACE_REFS build.
82 : : */
83 : : static PyObject refchain = {&refchain, &refchain};
84 : :
85 : : /* Insert op at the front of the list of all objects. If force is true,
86 : : * op is added even if _ob_prev and _ob_next are non-NULL already. If
87 : : * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.
88 : : * force should be true if and only if op points to freshly allocated,
89 : : * uninitialized memory, or you've unlinked op from the list and are
90 : : * relinking it into the front.
91 : : * Note that objects are normally added to the list via _Py_NewReference,
92 : : * which is called by PyObject_Init. Not all objects are initialized that
93 : : * way, though; exceptions include statically allocated type objects, and
94 : : * statically allocated singletons (like Py_True and Py_None).
95 : : */
96 : : void
97 : : _Py_AddToAllObjects(PyObject *op, int force)
98 : : {
99 : : #ifdef Py_DEBUG
100 : : if (!force) {
101 : : /* If it's initialized memory, op must be in or out of
102 : : * the list unambiguously.
103 : : */
104 : : _PyObject_ASSERT(op, (op->_ob_prev == NULL) == (op->_ob_next == NULL));
105 : : }
106 : : #endif
107 : : if (force || op->_ob_prev == NULL) {
108 : : op->_ob_next = refchain._ob_next;
109 : : op->_ob_prev = &refchain;
110 : : refchain._ob_next->_ob_prev = op;
111 : : refchain._ob_next = op;
112 : : }
113 : : }
114 : : #endif /* Py_TRACE_REFS */
115 : :
116 : : #ifdef Py_REF_DEBUG
117 : : /* Log a fatal error; doesn't return. */
118 : : void
119 : : _Py_NegativeRefcount(const char *filename, int lineno, PyObject *op)
120 : : {
121 : : _PyObject_AssertFailed(op, NULL, "object has negative ref count",
122 : : filename, lineno, __func__);
123 : : }
124 : :
125 : : #endif /* Py_REF_DEBUG */
126 : :
127 : : void
128 : 1 : Py_IncRef(PyObject *o)
129 : : {
130 : 1 : Py_XINCREF(o);
131 : 1 : }
132 : :
133 : : void
134 : 6 : Py_DecRef(PyObject *o)
135 : : {
136 : 6 : Py_XDECREF(o);
137 : 6 : }
138 : :
139 : : void
140 : 0 : _Py_IncRef(PyObject *o)
141 : : {
142 : 0 : Py_INCREF(o);
143 : 0 : }
144 : :
145 : : void
146 : 0 : _Py_DecRef(PyObject *o)
147 : : {
148 : 0 : Py_DECREF(o);
149 : 0 : }
150 : :
151 : : PyObject *
152 : 2 : PyObject_Init(PyObject *op, PyTypeObject *tp)
153 : : {
154 [ - + ]: 2 : if (op == NULL) {
155 : : return PyErr_NoMemory();
156 : : }
157 : :
158 : 2 : _PyObject_Init(op, tp);
159 : 2 : return op;
160 : : }
161 : :
162 : : PyVarObject *
163 : 0 : PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)
164 : : {
165 [ # # ]: 0 : if (op == NULL) {
166 : : return (PyVarObject *) PyErr_NoMemory();
167 : : }
168 : :
169 : 0 : _PyObject_InitVar(op, tp, size);
170 : 0 : return op;
171 : : }
172 : :
173 : : PyObject *
174 : 4731571 : _PyObject_New(PyTypeObject *tp)
175 : : {
176 : 4731571 : PyObject *op = (PyObject *) PyObject_Malloc(_PyObject_SIZE(tp));
177 [ - + ]: 4731571 : if (op == NULL) {
178 : : return PyErr_NoMemory();
179 : : }
180 : 4731571 : _PyObject_Init(op, tp);
181 : 4731571 : return op;
182 : : }
183 : :
184 : : PyVarObject *
185 : 7507390 : _PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
186 : : {
187 : : PyVarObject *op;
188 : 7507390 : const size_t size = _PyObject_VAR_SIZE(tp, nitems);
189 : 7507390 : op = (PyVarObject *) PyObject_Malloc(size);
190 [ - + ]: 7507390 : if (op == NULL) {
191 : : return (PyVarObject *)PyErr_NoMemory();
192 : : }
193 : 7507390 : _PyObject_InitVar(op, tp, nitems);
194 : 7507390 : return op;
195 : : }
196 : :
197 : : void
198 : 22600823 : PyObject_CallFinalizer(PyObject *self)
199 : : {
200 : 22600823 : PyTypeObject *tp = Py_TYPE(self);
201 : :
202 [ - + ]: 22600823 : if (tp->tp_finalize == NULL)
203 : 0 : return;
204 : : /* tp_finalize should only be called once. */
205 [ + + + + ]: 22600823 : if (_PyType_IS_GC(tp) && _PyGC_FINALIZED(self))
206 : 225711 : return;
207 : :
208 : 22375112 : tp->tp_finalize(self);
209 [ + + ]: 22375112 : if (_PyType_IS_GC(tp)) {
210 : 22190732 : _PyGC_SET_FINALIZED(self);
211 : : }
212 : : }
213 : :
214 : : int
215 : 22600823 : PyObject_CallFinalizerFromDealloc(PyObject *self)
216 : : {
217 [ - + ]: 22600823 : if (Py_REFCNT(self) != 0) {
218 : 0 : _PyObject_ASSERT_FAILED_MSG(self,
219 : : "PyObject_CallFinalizerFromDealloc called "
220 : : "on object with a non-zero refcount");
221 : : }
222 : :
223 : : /* Temporarily resurrect the object. */
224 : 22600823 : Py_SET_REFCNT(self, 1);
225 : :
226 : 22600823 : PyObject_CallFinalizer(self);
227 : :
228 : : _PyObject_ASSERT_WITH_MSG(self,
229 : : Py_REFCNT(self) > 0,
230 : : "refcount is too small");
231 : :
232 : : /* Undo the temporary resurrection; can't use DECREF here, it would
233 : : * cause a recursive call. */
234 : 22600823 : Py_SET_REFCNT(self, Py_REFCNT(self) - 1);
235 [ + + ]: 22600823 : if (Py_REFCNT(self) == 0) {
236 : 22600722 : return 0; /* this is the normal path out */
237 : : }
238 : :
239 : : /* tp_finalize resurrected it! Make it look like the original Py_DECREF
240 : : * never happened. */
241 : 101 : Py_ssize_t refcnt = Py_REFCNT(self);
242 : 101 : _Py_NewReference(self);
243 : 101 : Py_SET_REFCNT(self, refcnt);
244 : :
245 : : _PyObject_ASSERT(self,
246 : : (!_PyType_IS_GC(Py_TYPE(self))
247 : : || _PyObject_GC_IS_TRACKED(self)));
248 : : /* If Py_REF_DEBUG macro is defined, _Py_NewReference() increased
249 : : _Py_RefTotal, so we need to undo that. */
250 : : #ifdef Py_REF_DEBUG
251 : : _Py_RefTotal--;
252 : : #endif
253 : 101 : return -1;
254 : : }
255 : :
256 : : int
257 : 33 : PyObject_Print(PyObject *op, FILE *fp, int flags)
258 : : {
259 : 33 : int ret = 0;
260 [ - + ]: 33 : if (PyErr_CheckSignals())
261 : 0 : return -1;
262 : : #ifdef USE_STACKCHECK
263 : : if (PyOS_CheckStack()) {
264 : : PyErr_SetString(PyExc_MemoryError, "stack overflow");
265 : : return -1;
266 : : }
267 : : #endif
268 : 33 : clearerr(fp); /* Clear any previous error condition */
269 [ - + ]: 33 : if (op == NULL) {
270 : 0 : Py_BEGIN_ALLOW_THREADS
271 : 0 : fprintf(fp, "<nil>");
272 : 0 : Py_END_ALLOW_THREADS
273 : : }
274 : : else {
275 [ - + ]: 33 : if (Py_REFCNT(op) <= 0) {
276 : 0 : Py_BEGIN_ALLOW_THREADS
277 : 0 : fprintf(fp, "<refcnt %zd at %p>", Py_REFCNT(op), (void *)op);
278 : 0 : Py_END_ALLOW_THREADS
279 : : }
280 : : else {
281 : : PyObject *s;
282 [ - + ]: 33 : if (flags & Py_PRINT_RAW)
283 : 0 : s = PyObject_Str(op);
284 : : else
285 : 33 : s = PyObject_Repr(op);
286 [ + + ]: 33 : if (s == NULL)
287 : 32 : ret = -1;
288 [ - + ]: 1 : else if (PyBytes_Check(s)) {
289 : 0 : fwrite(PyBytes_AS_STRING(s), 1,
290 : 0 : PyBytes_GET_SIZE(s), fp);
291 : : }
292 [ + - ]: 1 : else if (PyUnicode_Check(s)) {
293 : : PyObject *t;
294 : 1 : t = PyUnicode_AsEncodedString(s, "utf-8", "backslashreplace");
295 [ - + ]: 1 : if (t == NULL) {
296 : 0 : ret = -1;
297 : : }
298 : : else {
299 : 1 : fwrite(PyBytes_AS_STRING(t), 1,
300 : 1 : PyBytes_GET_SIZE(t), fp);
301 : 1 : Py_DECREF(t);
302 : : }
303 : : }
304 : : else {
305 : 0 : PyErr_Format(PyExc_TypeError,
306 : : "str() or repr() returned '%.100s'",
307 : 0 : Py_TYPE(s)->tp_name);
308 : 0 : ret = -1;
309 : : }
310 : 33 : Py_XDECREF(s);
311 : : }
312 : : }
313 [ + + ]: 33 : if (ret == 0) {
314 [ - + ]: 1 : if (ferror(fp)) {
315 : 0 : PyErr_SetFromErrno(PyExc_OSError);
316 : 0 : clearerr(fp);
317 : 0 : ret = -1;
318 : : }
319 : : }
320 : 33 : return ret;
321 : : }
322 : :
323 : : /* For debugging convenience. Set a breakpoint here and call it from your DLL */
324 : : void
325 : 0 : _Py_BreakPoint(void)
326 : : {
327 : 0 : }
328 : :
329 : :
330 : : /* Heuristic checking if the object memory is uninitialized or deallocated.
331 : : Rely on the debug hooks on Python memory allocators:
332 : : see _PyMem_IsPtrFreed().
333 : :
334 : : The function can be used to prevent segmentation fault on dereferencing
335 : : pointers like 0xDDDDDDDDDDDDDDDD. */
336 : : int
337 : 33 : _PyObject_IsFreed(PyObject *op)
338 : : {
339 [ + - - + ]: 33 : if (_PyMem_IsPtrFreed(op) || _PyMem_IsPtrFreed(Py_TYPE(op))) {
340 : 0 : return 1;
341 : : }
342 : : /* ignore op->ob_ref: its value can have be modified
343 : : by Py_INCREF() and Py_DECREF(). */
344 : : #ifdef Py_TRACE_REFS
345 : : if (op->_ob_next != NULL && _PyMem_IsPtrFreed(op->_ob_next)) {
346 : : return 1;
347 : : }
348 : : if (op->_ob_prev != NULL && _PyMem_IsPtrFreed(op->_ob_prev)) {
349 : : return 1;
350 : : }
351 : : #endif
352 : 33 : return 0;
353 : : }
354 : :
355 : :
356 : : /* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
357 : : void
358 : 33 : _PyObject_Dump(PyObject* op)
359 : : {
360 [ - + ]: 33 : if (_PyObject_IsFreed(op)) {
361 : : /* It seems like the object memory has been freed:
362 : : don't access it to prevent a segmentation fault. */
363 : 0 : fprintf(stderr, "<object at %p is freed>\n", op);
364 : 0 : fflush(stderr);
365 : 0 : return;
366 : : }
367 : :
368 : : /* first, write fields which are the least likely to crash */
369 : 33 : fprintf(stderr, "object address : %p\n", (void *)op);
370 : 33 : fprintf(stderr, "object refcount : %zd\n", Py_REFCNT(op));
371 : 33 : fflush(stderr);
372 : :
373 : 33 : PyTypeObject *type = Py_TYPE(op);
374 : 33 : fprintf(stderr, "object type : %p\n", type);
375 [ + - ]: 33 : fprintf(stderr, "object type name: %s\n",
376 : : type==NULL ? "NULL" : type->tp_name);
377 : :
378 : : /* the most dangerous part */
379 : 33 : fprintf(stderr, "object repr : ");
380 : 33 : fflush(stderr);
381 : :
382 : 33 : PyGILState_STATE gil = PyGILState_Ensure();
383 : : PyObject *error_type, *error_value, *error_traceback;
384 : 33 : PyErr_Fetch(&error_type, &error_value, &error_traceback);
385 : :
386 : 33 : (void)PyObject_Print(op, stderr, 0);
387 : 33 : fflush(stderr);
388 : :
389 : 33 : PyErr_Restore(error_type, error_value, error_traceback);
390 : 33 : PyGILState_Release(gil);
391 : :
392 : 33 : fprintf(stderr, "\n");
393 : 33 : fflush(stderr);
394 : : }
395 : :
396 : : PyObject *
397 : 5086603 : PyObject_Repr(PyObject *v)
398 : : {
399 : : PyObject *res;
400 [ - + ]: 5086603 : if (PyErr_CheckSignals())
401 : 0 : return NULL;
402 : : #ifdef USE_STACKCHECK
403 : : if (PyOS_CheckStack()) {
404 : : PyErr_SetString(PyExc_MemoryError, "stack overflow");
405 : : return NULL;
406 : : }
407 : : #endif
408 [ + + ]: 5086603 : if (v == NULL)
409 : 1 : return PyUnicode_FromString("<NULL>");
410 [ - + ]: 5086602 : if (Py_TYPE(v)->tp_repr == NULL)
411 : 0 : return PyUnicode_FromFormat("<%s object at %p>",
412 : 0 : Py_TYPE(v)->tp_name, v);
413 : :
414 : 5086602 : PyThreadState *tstate = _PyThreadState_GET();
415 : : #ifdef Py_DEBUG
416 : : /* PyObject_Repr() must not be called with an exception set,
417 : : because it can clear it (directly or indirectly) and so the
418 : : caller loses its exception */
419 : : assert(!_PyErr_Occurred(tstate));
420 : : #endif
421 : :
422 : : /* It is possible for a type to have a tp_repr representation that loops
423 : : infinitely. */
424 [ + + ]: 5086602 : if (_Py_EnterRecursiveCallTstate(tstate,
425 : : " while getting the repr of an object")) {
426 : 3 : return NULL;
427 : : }
428 : 5086599 : res = (*Py_TYPE(v)->tp_repr)(v);
429 : 5086599 : _Py_LeaveRecursiveCallTstate(tstate);
430 : :
431 [ + + ]: 5086599 : if (res == NULL) {
432 : 6217 : return NULL;
433 : : }
434 [ + + ]: 5080382 : if (!PyUnicode_Check(res)) {
435 : 3 : _PyErr_Format(tstate, PyExc_TypeError,
436 : : "__repr__ returned non-string (type %.200s)",
437 : 3 : Py_TYPE(res)->tp_name);
438 : 3 : Py_DECREF(res);
439 : 3 : return NULL;
440 : : }
441 : : #ifndef Py_DEBUG
442 [ - + ]: 5080379 : if (PyUnicode_READY(res) < 0) {
443 : 0 : return NULL;
444 : : }
445 : : #endif
446 : 5080379 : return res;
447 : : }
448 : :
449 : : PyObject *
450 : 6552708 : PyObject_Str(PyObject *v)
451 : : {
452 : : PyObject *res;
453 [ - + ]: 6552708 : if (PyErr_CheckSignals())
454 : 0 : return NULL;
455 : : #ifdef USE_STACKCHECK
456 : : if (PyOS_CheckStack()) {
457 : : PyErr_SetString(PyExc_MemoryError, "stack overflow");
458 : : return NULL;
459 : : }
460 : : #endif
461 [ + + ]: 6552708 : if (v == NULL)
462 : 1 : return PyUnicode_FromString("<NULL>");
463 [ + + ]: 6552707 : if (PyUnicode_CheckExact(v)) {
464 : : #ifndef Py_DEBUG
465 [ - + ]: 2048023 : if (PyUnicode_READY(v) < 0)
466 : 0 : return NULL;
467 : : #endif
468 : 2048023 : Py_INCREF(v);
469 : 2048023 : return v;
470 : : }
471 [ - + ]: 4504684 : if (Py_TYPE(v)->tp_str == NULL)
472 : 0 : return PyObject_Repr(v);
473 : :
474 : 4504684 : PyThreadState *tstate = _PyThreadState_GET();
475 : : #ifdef Py_DEBUG
476 : : /* PyObject_Str() must not be called with an exception set,
477 : : because it can clear it (directly or indirectly) and so the
478 : : caller loses its exception */
479 : : assert(!_PyErr_Occurred(tstate));
480 : : #endif
481 : :
482 : : /* It is possible for a type to have a tp_str representation that loops
483 : : infinitely. */
484 [ - + ]: 4504684 : if (_Py_EnterRecursiveCallTstate(tstate, " while getting the str of an object")) {
485 : 0 : return NULL;
486 : : }
487 : 4504684 : res = (*Py_TYPE(v)->tp_str)(v);
488 : 4504684 : _Py_LeaveRecursiveCallTstate(tstate);
489 : :
490 [ + + ]: 4504684 : if (res == NULL) {
491 : 31 : return NULL;
492 : : }
493 [ + + ]: 4504653 : if (!PyUnicode_Check(res)) {
494 : 1 : _PyErr_Format(tstate, PyExc_TypeError,
495 : : "__str__ returned non-string (type %.200s)",
496 : 1 : Py_TYPE(res)->tp_name);
497 : 1 : Py_DECREF(res);
498 : 1 : return NULL;
499 : : }
500 : : #ifndef Py_DEBUG
501 [ - + ]: 4504652 : if (PyUnicode_READY(res) < 0) {
502 : 0 : return NULL;
503 : : }
504 : : #endif
505 : : assert(_PyUnicode_CheckConsistency(res, 1));
506 : 4504652 : return res;
507 : : }
508 : :
509 : : PyObject *
510 : 5982 : PyObject_ASCII(PyObject *v)
511 : : {
512 : : PyObject *repr, *ascii, *res;
513 : :
514 : 5982 : repr = PyObject_Repr(v);
515 [ + + ]: 5982 : if (repr == NULL)
516 : 1 : return NULL;
517 : :
518 [ + + ]: 5981 : if (PyUnicode_IS_ASCII(repr))
519 : 2366 : return repr;
520 : :
521 : : /* repr is guaranteed to be a PyUnicode object by PyObject_Repr */
522 : 3615 : ascii = _PyUnicode_AsASCIIString(repr, "backslashreplace");
523 : 3615 : Py_DECREF(repr);
524 [ - + ]: 3615 : if (ascii == NULL)
525 : 0 : return NULL;
526 : :
527 : 7230 : res = PyUnicode_DecodeASCII(
528 : 3615 : PyBytes_AS_STRING(ascii),
529 : : PyBytes_GET_SIZE(ascii),
530 : : NULL);
531 : :
532 : 3615 : Py_DECREF(ascii);
533 : 3615 : return res;
534 : : }
535 : :
536 : : PyObject *
537 : 705019 : PyObject_Bytes(PyObject *v)
538 : : {
539 : : PyObject *result, *func;
540 : :
541 [ + + ]: 705019 : if (v == NULL)
542 : 1 : return PyBytes_FromString("<NULL>");
543 : :
544 [ + + ]: 705018 : if (PyBytes_CheckExact(v)) {
545 : 703455 : Py_INCREF(v);
546 : 703455 : return v;
547 : : }
548 : :
549 : 1563 : func = _PyObject_LookupSpecial(v, &_Py_ID(__bytes__));
550 [ - + ]: 1563 : if (func != NULL) {
551 : 0 : result = _PyObject_CallNoArgs(func);
552 : 0 : Py_DECREF(func);
553 [ # # ]: 0 : if (result == NULL)
554 : 0 : return NULL;
555 [ # # ]: 0 : if (!PyBytes_Check(result)) {
556 : 0 : PyErr_Format(PyExc_TypeError,
557 : : "__bytes__ returned non-bytes (type %.200s)",
558 : 0 : Py_TYPE(result)->tp_name);
559 : 0 : Py_DECREF(result);
560 : 0 : return NULL;
561 : : }
562 : 0 : return result;
563 : : }
564 [ - + ]: 1563 : else if (PyErr_Occurred())
565 : 0 : return NULL;
566 : 1563 : return PyBytes_FromObject(v);
567 : : }
568 : :
569 : :
570 : : /*
571 : : def _PyObject_FunctionStr(x):
572 : : try:
573 : : qualname = x.__qualname__
574 : : except AttributeError:
575 : : return str(x)
576 : : try:
577 : : mod = x.__module__
578 : : if mod is not None and mod != 'builtins':
579 : : return f"{x.__module__}.{qualname}()"
580 : : except AttributeError:
581 : : pass
582 : : return qualname
583 : : */
584 : : PyObject *
585 : 552 : _PyObject_FunctionStr(PyObject *x)
586 : : {
587 : : assert(!PyErr_Occurred());
588 : : PyObject *qualname;
589 : 552 : int ret = _PyObject_LookupAttr(x, &_Py_ID(__qualname__), &qualname);
590 [ + + ]: 552 : if (qualname == NULL) {
591 [ - + ]: 2 : if (ret < 0) {
592 : 0 : return NULL;
593 : : }
594 : 2 : return PyObject_Str(x);
595 : : }
596 : : PyObject *module;
597 : 550 : PyObject *result = NULL;
598 : 550 : ret = _PyObject_LookupAttr(x, &_Py_ID(__module__), &module);
599 [ + + + + ]: 550 : if (module != NULL && module != Py_None) {
600 : 147 : ret = PyObject_RichCompareBool(module, &_Py_ID(builtins), Py_NE);
601 [ - + ]: 147 : if (ret < 0) {
602 : : // error
603 : 0 : goto done;
604 : : }
605 [ + + ]: 147 : if (ret > 0) {
606 : 128 : result = PyUnicode_FromFormat("%S.%S()", module, qualname);
607 : 128 : goto done;
608 : : }
609 : : }
610 [ - + ]: 403 : else if (ret < 0) {
611 : 0 : goto done;
612 : : }
613 : 422 : result = PyUnicode_FromFormat("%S()", qualname);
614 : 550 : done:
615 : 550 : Py_DECREF(qualname);
616 : 550 : Py_XDECREF(module);
617 : 550 : return result;
618 : : }
619 : :
620 : : /* For Python 3.0.1 and later, the old three-way comparison has been
621 : : completely removed in favour of rich comparisons. PyObject_Compare() and
622 : : PyObject_Cmp() are gone, and the builtin cmp function no longer exists.
623 : : The old tp_compare slot has been renamed to tp_as_async, and should no
624 : : longer be used. Use tp_richcompare instead.
625 : :
626 : : See (*) below for practical amendments.
627 : :
628 : : tp_richcompare gets called with a first argument of the appropriate type
629 : : and a second object of an arbitrary type. We never do any kind of
630 : : coercion.
631 : :
632 : : The tp_richcompare slot should return an object, as follows:
633 : :
634 : : NULL if an exception occurred
635 : : NotImplemented if the requested comparison is not implemented
636 : : any other false value if the requested comparison is false
637 : : any other true value if the requested comparison is true
638 : :
639 : : The PyObject_RichCompare[Bool]() wrappers raise TypeError when they get
640 : : NotImplemented.
641 : :
642 : : (*) Practical amendments:
643 : :
644 : : - If rich comparison returns NotImplemented, == and != are decided by
645 : : comparing the object pointer (i.e. falling back to the base object
646 : : implementation).
647 : :
648 : : */
649 : :
650 : : /* Map rich comparison operators to their swapped version, e.g. LT <--> GT */
651 : : int _Py_SwappedOp[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
652 : :
653 : : static const char * const opstrings[] = {"<", "<=", "==", "!=", ">", ">="};
654 : :
655 : : /* Perform a rich comparison, raising TypeError when the requested comparison
656 : : operator is not supported. */
657 : : static PyObject *
658 : 162272377 : do_richcompare(PyThreadState *tstate, PyObject *v, PyObject *w, int op)
659 : : {
660 : : richcmpfunc f;
661 : : PyObject *res;
662 : 162272377 : int checked_reverse_op = 0;
663 : :
664 [ + + + + ]: 168555662 : if (!Py_IS_TYPE(v, Py_TYPE(w)) &&
665 : 6283285 : PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v)) &&
666 [ + - ]: 170638 : (f = Py_TYPE(w)->tp_richcompare) != NULL) {
667 : 170638 : checked_reverse_op = 1;
668 : 170638 : res = (*f)(w, v, _Py_SwappedOp[op]);
669 [ + + ]: 170638 : if (res != Py_NotImplemented)
670 : 54259 : return res;
671 : 116379 : Py_DECREF(res);
672 : : }
673 [ + + ]: 162218118 : if ((f = Py_TYPE(v)->tp_richcompare) != NULL) {
674 : 162218101 : res = (*f)(v, w, op);
675 [ + + ]: 162218101 : if (res != Py_NotImplemented)
676 : 154676503 : return res;
677 : 7541598 : Py_DECREF(res);
678 : : }
679 [ + + + + ]: 7541615 : if (!checked_reverse_op && (f = Py_TYPE(w)->tp_richcompare) != NULL) {
680 : 7425229 : res = (*f)(w, v, _Py_SwappedOp[op]);
681 [ + + ]: 7425229 : if (res != Py_NotImplemented)
682 : 185686 : return res;
683 : 7239543 : Py_DECREF(res);
684 : : }
685 : : /* If neither object implements it, provide a sensible default
686 : : for == and !=, but raise an exception for ordering. */
687 [ + + + ]: 7355929 : switch (op) {
688 : 7328927 : case Py_EQ:
689 [ - + ]: 7328927 : res = (v == w) ? Py_True : Py_False;
690 : 7328927 : break;
691 : 24644 : case Py_NE:
692 [ + - ]: 24644 : res = (v != w) ? Py_True : Py_False;
693 : 24644 : break;
694 : 2358 : default:
695 : 4716 : _PyErr_Format(tstate, PyExc_TypeError,
696 : : "'%s' not supported between instances of '%.100s' and '%.100s'",
697 : 2358 : opstrings[op],
698 : 2358 : Py_TYPE(v)->tp_name,
699 : 2358 : Py_TYPE(w)->tp_name);
700 : 2358 : return NULL;
701 : : }
702 : 7353571 : Py_INCREF(res);
703 : 7353571 : return res;
704 : : }
705 : :
706 : : /* Perform a rich comparison with object result. This wraps do_richcompare()
707 : : with a check for NULL arguments and a recursion check. */
708 : :
709 : : PyObject *
710 : 162272392 : PyObject_RichCompare(PyObject *v, PyObject *w, int op)
711 : : {
712 : 162272392 : PyThreadState *tstate = _PyThreadState_GET();
713 : :
714 : : assert(Py_LT <= op && op <= Py_GE);
715 [ + - - + ]: 162272392 : if (v == NULL || w == NULL) {
716 [ # # ]: 0 : if (!_PyErr_Occurred(tstate)) {
717 : 0 : PyErr_BadInternalCall();
718 : : }
719 : 0 : return NULL;
720 : : }
721 [ + + ]: 162272392 : if (_Py_EnterRecursiveCallTstate(tstate, " in comparison")) {
722 : 15 : return NULL;
723 : : }
724 : 162272377 : PyObject *res = do_richcompare(tstate, v, w, op);
725 : 162272377 : _Py_LeaveRecursiveCallTstate(tstate);
726 : 162272377 : return res;
727 : : }
728 : :
729 : : /* Perform a rich comparison with integer result. This wraps
730 : : PyObject_RichCompare(), returning -1 for error, 0 for false, 1 for true. */
731 : : int
732 : 136440779 : PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
733 : : {
734 : : PyObject *res;
735 : : int ok;
736 : :
737 : : /* Quick result when objects are the same.
738 : : Guarantees that identity implies equality. */
739 [ + + ]: 136440779 : if (v == w) {
740 [ + + ]: 31891306 : if (op == Py_EQ)
741 : 31644413 : return 1;
742 [ + + ]: 246893 : else if (op == Py_NE)
743 : 8 : return 0;
744 : : }
745 : :
746 : 104796358 : res = PyObject_RichCompare(v, w, op);
747 [ + + ]: 104796358 : if (res == NULL)
748 : 20042 : return -1;
749 [ + + ]: 104776316 : if (PyBool_Check(res))
750 : 104776300 : ok = (res == Py_True);
751 : : else
752 : 16 : ok = PyObject_IsTrue(res);
753 : 104776316 : Py_DECREF(res);
754 : 104776316 : return ok;
755 : : }
756 : :
757 : : Py_hash_t
758 : 162 : PyObject_HashNotImplemented(PyObject *v)
759 : : {
760 : 162 : PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
761 : 162 : Py_TYPE(v)->tp_name);
762 : 162 : return -1;
763 : : }
764 : :
765 : : Py_hash_t
766 : 300552363 : PyObject_Hash(PyObject *v)
767 : : {
768 : 300552363 : PyTypeObject *tp = Py_TYPE(v);
769 [ + + ]: 300552363 : if (tp->tp_hash != NULL)
770 : 300552362 : return (*tp->tp_hash)(v);
771 : : /* To keep to the general practice that inheriting
772 : : * solely from object in C code should work without
773 : : * an explicit call to PyType_Ready, we implicitly call
774 : : * PyType_Ready here and then check the tp_hash slot again
775 : : */
776 [ + - ]: 1 : if (tp->tp_dict == NULL) {
777 [ - + ]: 1 : if (PyType_Ready(tp) < 0)
778 : 0 : return -1;
779 [ + - ]: 1 : if (tp->tp_hash != NULL)
780 : 1 : return (*tp->tp_hash)(v);
781 : : }
782 : : /* Otherwise, the object can't be hashed */
783 : 0 : return PyObject_HashNotImplemented(v);
784 : : }
785 : :
786 : : PyObject *
787 : 3635910 : PyObject_GetAttrString(PyObject *v, const char *name)
788 : : {
789 : : PyObject *w, *res;
790 : :
791 [ - + ]: 3635910 : if (Py_TYPE(v)->tp_getattr != NULL)
792 : 0 : return (*Py_TYPE(v)->tp_getattr)(v, (char*)name);
793 : 3635910 : w = PyUnicode_FromString(name);
794 [ + + ]: 3635910 : if (w == NULL)
795 : 31 : return NULL;
796 : 3635879 : res = PyObject_GetAttr(v, w);
797 : 3635879 : Py_DECREF(w);
798 : 3635879 : return res;
799 : : }
800 : :
801 : : int
802 : 0 : PyObject_HasAttrString(PyObject *v, const char *name)
803 : : {
804 : 0 : PyObject *res = PyObject_GetAttrString(v, name);
805 [ # # ]: 0 : if (res != NULL) {
806 : 0 : Py_DECREF(res);
807 : 0 : return 1;
808 : : }
809 : 0 : PyErr_Clear();
810 : 0 : return 0;
811 : : }
812 : :
813 : : int
814 : 1929595 : PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
815 : : {
816 : : PyObject *s;
817 : : int res;
818 : :
819 [ - + ]: 1929595 : if (Py_TYPE(v)->tp_setattr != NULL)
820 : 0 : return (*Py_TYPE(v)->tp_setattr)(v, (char*)name, w);
821 : 1929595 : s = PyUnicode_InternFromString(name);
822 [ - + ]: 1929595 : if (s == NULL)
823 : 0 : return -1;
824 : 1929595 : res = PyObject_SetAttr(v, s, w);
825 : 1929595 : Py_XDECREF(s);
826 : 1929595 : return res;
827 : : }
828 : :
829 : : int
830 : 2002612 : _PyObject_IsAbstract(PyObject *obj)
831 : : {
832 : : int res;
833 : : PyObject* isabstract;
834 : :
835 [ + + ]: 2002612 : if (obj == NULL)
836 : 30862 : return 0;
837 : :
838 : 1971750 : res = _PyObject_LookupAttr(obj, &_Py_ID(__isabstractmethod__), &isabstract);
839 [ + + ]: 1971750 : if (res > 0) {
840 : 282764 : res = PyObject_IsTrue(isabstract);
841 : 282764 : Py_DECREF(isabstract);
842 : : }
843 : 1971750 : return res;
844 : : }
845 : :
846 : : PyObject *
847 : 29494 : _PyObject_GetAttrId(PyObject *v, _Py_Identifier *name)
848 : : {
849 : : PyObject *result;
850 : 29494 : PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
851 [ - + ]: 29494 : if (!oname)
852 : 0 : return NULL;
853 : 29494 : result = PyObject_GetAttr(v, oname);
854 : 29494 : return result;
855 : : }
856 : :
857 : : int
858 : 954 : _PyObject_SetAttrId(PyObject *v, _Py_Identifier *name, PyObject *w)
859 : : {
860 : : int result;
861 : 954 : PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
862 [ - + ]: 954 : if (!oname)
863 : 0 : return -1;
864 : 954 : result = PyObject_SetAttr(v, oname, w);
865 : 954 : return result;
866 : : }
867 : :
868 : : static inline int
869 : 1427478 : set_attribute_error_context(PyObject* v, PyObject* name)
870 : : {
871 : : assert(PyErr_Occurred());
872 [ + + ]: 1427478 : if (!PyErr_ExceptionMatches(PyExc_AttributeError)){
873 : 740 : return 0;
874 : : }
875 : : // Intercept AttributeError exceptions and augment them to offer suggestions later.
876 : : PyObject *type, *value, *traceback;
877 : 1426738 : PyErr_Fetch(&type, &value, &traceback);
878 : 1426738 : PyErr_NormalizeException(&type, &value, &traceback);
879 : : // Check if the normalized exception is indeed an AttributeError
880 [ + + ]: 1426738 : if (!PyErr_GivenExceptionMatches(value, PyExc_AttributeError)) {
881 : 1 : goto restore;
882 : : }
883 : 1426737 : PyAttributeErrorObject* the_exc = (PyAttributeErrorObject*) value;
884 : : // Check if this exception was already augmented
885 [ + + - + ]: 1426737 : if (the_exc->name || the_exc->obj) {
886 : 136 : goto restore;
887 : : }
888 : : // Augment the exception with the name and object
889 [ + - - + ]: 2853202 : if (PyObject_SetAttr(value, &_Py_ID(name), name) ||
890 : 1426601 : PyObject_SetAttr(value, &_Py_ID(obj), v)) {
891 : 0 : return 1;
892 : : }
893 : 1426601 : restore:
894 : 1426738 : PyErr_Restore(type, value, traceback);
895 : 1426738 : return 0;
896 : : }
897 : :
898 : : PyObject *
899 : 173122009 : PyObject_GetAttr(PyObject *v, PyObject *name)
900 : : {
901 : 173122009 : PyTypeObject *tp = Py_TYPE(v);
902 [ + + ]: 173122009 : if (!PyUnicode_Check(name)) {
903 : 4 : PyErr_Format(PyExc_TypeError,
904 : : "attribute name must be string, not '%.200s'",
905 : 4 : Py_TYPE(name)->tp_name);
906 : 4 : return NULL;
907 : : }
908 : :
909 : 173122005 : PyObject* result = NULL;
910 [ + - ]: 173122005 : if (tp->tp_getattro != NULL) {
911 : 173122005 : result = (*tp->tp_getattro)(v, name);
912 : : }
913 [ # # ]: 0 : else if (tp->tp_getattr != NULL) {
914 : 0 : const char *name_str = PyUnicode_AsUTF8(name);
915 [ # # ]: 0 : if (name_str == NULL) {
916 : 0 : return NULL;
917 : : }
918 : 0 : result = (*tp->tp_getattr)(v, (char *)name_str);
919 : : }
920 : : else {
921 : 0 : PyErr_Format(PyExc_AttributeError,
922 : : "'%.50s' object has no attribute '%U'",
923 : : tp->tp_name, name);
924 : : }
925 : :
926 [ + + ]: 173121997 : if (result == NULL) {
927 : 1414586 : set_attribute_error_context(v, name);
928 : : }
929 : 173121997 : return result;
930 : : }
931 : :
932 : : int
933 : 64436041 : _PyObject_LookupAttr(PyObject *v, PyObject *name, PyObject **result)
934 : : {
935 : 64436041 : PyTypeObject *tp = Py_TYPE(v);
936 : :
937 [ + + ]: 64436041 : if (!PyUnicode_Check(name)) {
938 : 2 : PyErr_Format(PyExc_TypeError,
939 : : "attribute name must be string, not '%.200s'",
940 : 2 : Py_TYPE(name)->tp_name);
941 : 2 : *result = NULL;
942 : 2 : return -1;
943 : : }
944 : :
945 [ + + ]: 64436039 : if (tp->tp_getattro == PyObject_GenericGetAttr) {
946 : 53757037 : *result = _PyObject_GenericGetAttrWithDict(v, name, NULL, 1);
947 [ + + ]: 53757037 : if (*result != NULL) {
948 : 41960949 : return 1;
949 : : }
950 [ + + ]: 11796088 : if (PyErr_Occurred()) {
951 : 607 : return -1;
952 : : }
953 : 11795481 : return 0;
954 : : }
955 [ + - ]: 10679002 : if (tp->tp_getattro != NULL) {
956 : 10679002 : *result = (*tp->tp_getattro)(v, name);
957 : : }
958 [ # # ]: 0 : else if (tp->tp_getattr != NULL) {
959 : 0 : const char *name_str = PyUnicode_AsUTF8(name);
960 [ # # ]: 0 : if (name_str == NULL) {
961 : 0 : *result = NULL;
962 : 0 : return -1;
963 : : }
964 : 0 : *result = (*tp->tp_getattr)(v, (char *)name_str);
965 : : }
966 : : else {
967 : 0 : *result = NULL;
968 : 0 : return 0;
969 : : }
970 : :
971 [ + + ]: 10679002 : if (*result != NULL) {
972 : 8483896 : return 1;
973 : : }
974 [ + + ]: 2195106 : if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
975 : 26 : return -1;
976 : : }
977 : 2195080 : PyErr_Clear();
978 : 2195080 : return 0;
979 : : }
980 : :
981 : : int
982 : 20090 : _PyObject_LookupAttrId(PyObject *v, _Py_Identifier *name, PyObject **result)
983 : : {
984 : 20090 : PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
985 [ - + ]: 20090 : if (!oname) {
986 : 0 : *result = NULL;
987 : 0 : return -1;
988 : : }
989 : 20090 : return _PyObject_LookupAttr(v, oname, result);
990 : : }
991 : :
992 : : int
993 : 839 : PyObject_HasAttr(PyObject *v, PyObject *name)
994 : : {
995 : : PyObject *res;
996 [ - + ]: 839 : if (_PyObject_LookupAttr(v, name, &res) < 0) {
997 : 0 : PyErr_Clear();
998 : 0 : return 0;
999 : : }
1000 [ + + ]: 839 : if (res == NULL) {
1001 : 787 : return 0;
1002 : : }
1003 : 52 : Py_DECREF(res);
1004 : 52 : return 1;
1005 : : }
1006 : :
1007 : : int
1008 : 69719662 : PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
1009 : : {
1010 : 69719662 : PyTypeObject *tp = Py_TYPE(v);
1011 : : int err;
1012 : :
1013 [ + + ]: 69719662 : if (!PyUnicode_Check(name)) {
1014 : 4 : PyErr_Format(PyExc_TypeError,
1015 : : "attribute name must be string, not '%.200s'",
1016 : 4 : Py_TYPE(name)->tp_name);
1017 : 4 : return -1;
1018 : : }
1019 : 69719658 : Py_INCREF(name);
1020 : :
1021 : 69719658 : PyUnicode_InternInPlace(&name);
1022 [ + + ]: 69719658 : if (tp->tp_setattro != NULL) {
1023 : 69719653 : err = (*tp->tp_setattro)(v, name, value);
1024 : 69719653 : Py_DECREF(name);
1025 : 69719653 : return err;
1026 : : }
1027 [ + - ]: 5 : if (tp->tp_setattr != NULL) {
1028 : 5 : const char *name_str = PyUnicode_AsUTF8(name);
1029 [ - + ]: 5 : if (name_str == NULL) {
1030 : 0 : Py_DECREF(name);
1031 : 0 : return -1;
1032 : : }
1033 : 5 : err = (*tp->tp_setattr)(v, (char *)name_str, value);
1034 : 5 : Py_DECREF(name);
1035 : 5 : return err;
1036 : : }
1037 : 0 : Py_DECREF(name);
1038 : : _PyObject_ASSERT(name, Py_REFCNT(name) >= 1);
1039 [ # # # # ]: 0 : if (tp->tp_getattr == NULL && tp->tp_getattro == NULL)
1040 [ # # ]: 0 : PyErr_Format(PyExc_TypeError,
1041 : : "'%.100s' object has no attributes "
1042 : : "(%s .%U)",
1043 : : tp->tp_name,
1044 : : value==NULL ? "del" : "assign to",
1045 : : name);
1046 : : else
1047 [ # # ]: 0 : PyErr_Format(PyExc_TypeError,
1048 : : "'%.100s' object has only read-only attributes "
1049 : : "(%s .%U)",
1050 : : tp->tp_name,
1051 : : value==NULL ? "del" : "assign to",
1052 : : name);
1053 : 0 : return -1;
1054 : : }
1055 : :
1056 : : PyObject **
1057 : 297469890 : _PyObject_DictPointer(PyObject *obj)
1058 : : {
1059 : : Py_ssize_t dictoffset;
1060 : 297469890 : PyTypeObject *tp = Py_TYPE(obj);
1061 : :
1062 [ + + ]: 297469890 : if (tp->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
1063 : 131755803 : return _PyObject_ManagedDictPointer(obj);
1064 : : }
1065 : 165714087 : dictoffset = tp->tp_dictoffset;
1066 [ + + ]: 165714087 : if (dictoffset == 0)
1067 : 21164001 : return NULL;
1068 [ + + ]: 144550086 : if (dictoffset < 0) {
1069 : 34772307 : Py_ssize_t tsize = Py_SIZE(obj);
1070 [ + + ]: 34772307 : if (tsize < 0) {
1071 : 37204 : tsize = -tsize;
1072 : : }
1073 : 34772307 : size_t size = _PyObject_VAR_SIZE(tp, tsize);
1074 : :
1075 : 34772307 : dictoffset += (long)size;
1076 : : _PyObject_ASSERT(obj, dictoffset > 0);
1077 : : _PyObject_ASSERT(obj, dictoffset % SIZEOF_VOID_P == 0);
1078 : : }
1079 : 144550086 : return (PyObject **) ((char *)obj + dictoffset);
1080 : : }
1081 : :
1082 : : /* Helper to get a pointer to an object's __dict__ slot, if any.
1083 : : * Creates the dict from inline attributes if necessary.
1084 : : * Does not set an exception. */
1085 : : PyObject **
1086 : 1233 : _PyObject_GetDictPtr(PyObject *obj)
1087 : : {
1088 [ + + ]: 1233 : if ((Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0) {
1089 : 47 : return _PyObject_DictPointer(obj);
1090 : : }
1091 : 1186 : PyObject **dict_ptr = _PyObject_ManagedDictPointer(obj);
1092 : 1186 : PyDictValues **values_ptr = _PyObject_ValuesPointer(obj);
1093 [ + + ]: 1186 : if (*values_ptr == NULL) {
1094 : 612 : return dict_ptr;
1095 : : }
1096 : : assert(*dict_ptr == NULL);
1097 : 574 : PyObject *dict = _PyObject_MakeDictFromInstanceAttributes(obj, *values_ptr);
1098 [ - + ]: 574 : if (dict == NULL) {
1099 : 0 : PyErr_Clear();
1100 : 0 : return NULL;
1101 : : }
1102 : 574 : *values_ptr = NULL;
1103 : 574 : *dict_ptr = dict;
1104 : 574 : return dict_ptr;
1105 : : }
1106 : :
1107 : : PyObject *
1108 : 22126907 : PyObject_SelfIter(PyObject *obj)
1109 : : {
1110 : 22126907 : Py_INCREF(obj);
1111 : 22126907 : return obj;
1112 : : }
1113 : :
1114 : : /* Helper used when the __next__ method is removed from a type:
1115 : : tp_iternext is never NULL and can be safely called without checking
1116 : : on every iteration.
1117 : : */
1118 : :
1119 : : PyObject *
1120 : 1 : _PyObject_NextNotImplemented(PyObject *self)
1121 : : {
1122 : 1 : PyErr_Format(PyExc_TypeError,
1123 : : "'%.200s' object is not iterable",
1124 : 1 : Py_TYPE(self)->tp_name);
1125 : 1 : return NULL;
1126 : : }
1127 : :
1128 : :
1129 : : /* Specialized version of _PyObject_GenericGetAttrWithDict
1130 : : specifically for the LOAD_METHOD opcode.
1131 : :
1132 : : Return 1 if a method is found, 0 if it's a regular attribute
1133 : : from __dict__ or something returned by using a descriptor
1134 : : protocol.
1135 : :
1136 : : `method` will point to the resolved attribute or NULL. In the
1137 : : latter case, an error will be set.
1138 : : */
1139 : : int
1140 : 45843588 : _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
1141 : : {
1142 : 45843588 : int meth_found = 0;
1143 : :
1144 : : assert(*method == NULL);
1145 : :
1146 : 45843588 : PyTypeObject *tp = Py_TYPE(obj);
1147 [ - + ]: 45843588 : if (!_PyType_IsReady(tp)) {
1148 [ # # ]: 0 : if (PyType_Ready(tp) < 0) {
1149 : 0 : return 0;
1150 : : }
1151 : : }
1152 : :
1153 [ + + - + ]: 45843588 : if (tp->tp_getattro != PyObject_GenericGetAttr || !PyUnicode_CheckExact(name)) {
1154 : 15032553 : *method = PyObject_GetAttr(obj, name);
1155 : 15032553 : return 0;
1156 : : }
1157 : :
1158 : 30811035 : PyObject *descr = _PyType_Lookup(tp, name);
1159 : 30811035 : descrgetfunc f = NULL;
1160 [ + + ]: 30811035 : if (descr != NULL) {
1161 : 30667724 : Py_INCREF(descr);
1162 [ + + ]: 30667724 : if (_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) {
1163 : 29897137 : meth_found = 1;
1164 : : } else {
1165 : 770587 : f = Py_TYPE(descr)->tp_descr_get;
1166 [ + + + + ]: 770587 : if (f != NULL && PyDescr_IsData(descr)) {
1167 : 22828 : *method = f(descr, obj, (PyObject *)Py_TYPE(obj));
1168 : 22828 : Py_DECREF(descr);
1169 : 22828 : return 0;
1170 : : }
1171 : : }
1172 : : }
1173 : : PyDictValues *values;
1174 [ + + ]: 30788207 : if ((tp->tp_flags & Py_TPFLAGS_MANAGED_DICT) &&
1175 [ + + ]: 16501419 : (values = *_PyObject_ValuesPointer(obj)))
1176 : 9730750 : {
1177 : : assert(*_PyObject_DictPointer(obj) == NULL);
1178 : 9816164 : PyObject *attr = _PyObject_GetInstanceAttribute(obj, values, name);
1179 [ + + ]: 9816164 : if (attr != NULL) {
1180 : 85414 : *method = attr;
1181 : 85414 : Py_XDECREF(descr);
1182 : 85414 : return 0;
1183 : : }
1184 : : }
1185 : : else {
1186 : 20972043 : PyObject **dictptr = _PyObject_DictPointer(obj);
1187 : : PyObject *dict;
1188 [ + + + + ]: 20972043 : if (dictptr != NULL && (dict = *dictptr) != NULL) {
1189 : 10610366 : Py_INCREF(dict);
1190 : 10610366 : PyObject *attr = PyDict_GetItemWithError(dict, name);
1191 [ + + ]: 10610366 : if (attr != NULL) {
1192 : 92152 : *method = Py_NewRef(attr);
1193 : 92152 : Py_DECREF(dict);
1194 : 92152 : Py_XDECREF(descr);
1195 : 92152 : return 0;
1196 : : }
1197 : 10518214 : Py_DECREF(dict);
1198 : :
1199 [ - + ]: 10518214 : if (PyErr_Occurred()) {
1200 : 0 : Py_XDECREF(descr);
1201 : 0 : return 0;
1202 : : }
1203 : : }
1204 : : }
1205 : :
1206 [ + + ]: 30610641 : if (meth_found) {
1207 : 29851267 : *method = descr;
1208 : 29851267 : return 1;
1209 : : }
1210 : :
1211 [ + + ]: 759374 : if (f != NULL) {
1212 : 365493 : *method = f(descr, obj, (PyObject *)Py_TYPE(obj));
1213 : 365493 : Py_DECREF(descr);
1214 : 365493 : return 0;
1215 : : }
1216 : :
1217 [ + + ]: 393881 : if (descr != NULL) {
1218 : 380989 : *method = descr;
1219 : 380989 : return 0;
1220 : : }
1221 : :
1222 : 12892 : PyErr_Format(PyExc_AttributeError,
1223 : : "'%.50s' object has no attribute '%U'",
1224 : : tp->tp_name, name);
1225 : :
1226 : 12892 : set_attribute_error_context(obj, name);
1227 : 12892 : return 0;
1228 : : }
1229 : :
1230 : : /* Generic GetAttr functions - put these in your tp_[gs]etattro slot. */
1231 : :
1232 : : PyObject *
1233 : 183279645 : _PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name,
1234 : : PyObject *dict, int suppress)
1235 : : {
1236 : : /* Make sure the logic of _PyObject_GetMethod is in sync with
1237 : : this method.
1238 : :
1239 : : When suppress=1, this function suppresses AttributeError.
1240 : : */
1241 : :
1242 : 183279645 : PyTypeObject *tp = Py_TYPE(obj);
1243 : 183279645 : PyObject *descr = NULL;
1244 : 183279645 : PyObject *res = NULL;
1245 : : descrgetfunc f;
1246 : : PyObject **dictptr;
1247 : :
1248 [ - + ]: 183279645 : if (!PyUnicode_Check(name)){
1249 : 0 : PyErr_Format(PyExc_TypeError,
1250 : : "attribute name must be string, not '%.200s'",
1251 : 0 : Py_TYPE(name)->tp_name);
1252 : 0 : return NULL;
1253 : : }
1254 : 183279645 : Py_INCREF(name);
1255 : :
1256 [ + + ]: 183279645 : if (tp->tp_dict == NULL) {
1257 [ - + ]: 4 : if (PyType_Ready(tp) < 0)
1258 : 0 : goto done;
1259 : : }
1260 : :
1261 : 183279645 : descr = _PyType_Lookup(tp, name);
1262 : :
1263 : 183279645 : f = NULL;
1264 [ + + ]: 183279645 : if (descr != NULL) {
1265 : 108133455 : Py_INCREF(descr);
1266 : 108133455 : f = Py_TYPE(descr)->tp_descr_get;
1267 [ + + + + ]: 108133455 : if (f != NULL && PyDescr_IsData(descr)) {
1268 : 47430514 : res = f(descr, obj, (PyObject *)Py_TYPE(obj));
1269 [ + + + + : 47527338 : if (res == NULL && suppress &&
+ + ]
1270 : 96832 : PyErr_ExceptionMatches(PyExc_AttributeError)) {
1271 : 96225 : PyErr_Clear();
1272 : : }
1273 : 47430506 : goto done;
1274 : : }
1275 : : }
1276 [ + + ]: 135849131 : if (dict == NULL) {
1277 [ + + ]: 135838364 : if ((tp->tp_flags & Py_TPFLAGS_MANAGED_DICT) &&
1278 [ + + ]: 67855127 : *_PyObject_ValuesPointer(obj))
1279 : 33832361 : {
1280 : 52760879 : PyDictValues **values_ptr = _PyObject_ValuesPointer(obj);
1281 [ + + ]: 52760879 : if (PyUnicode_CheckExact(name)) {
1282 : : assert(*_PyObject_DictPointer(obj) == NULL);
1283 : 52760877 : res = _PyObject_GetInstanceAttribute(obj, *values_ptr, name);
1284 [ + + ]: 52760877 : if (res != NULL) {
1285 : 18928518 : goto done;
1286 : : }
1287 : : }
1288 : : else {
1289 : 2 : dictptr = _PyObject_DictPointer(obj);
1290 : : assert(dictptr != NULL && *dictptr == NULL);
1291 : 2 : *dictptr = dict = _PyObject_MakeDictFromInstanceAttributes(obj, *values_ptr);
1292 [ - + ]: 2 : if (dict == NULL) {
1293 : 0 : res = NULL;
1294 : 0 : goto done;
1295 : : }
1296 : 2 : *values_ptr = NULL;
1297 : : }
1298 : : }
1299 : : else {
1300 : 83077485 : dictptr = _PyObject_DictPointer(obj);
1301 [ + + ]: 83077485 : if (dictptr) {
1302 : 70382694 : dict = *dictptr;
1303 : : }
1304 : : }
1305 : : }
1306 [ + + ]: 116920613 : if (dict != NULL) {
1307 : 63718129 : Py_INCREF(dict);
1308 : 63718129 : res = PyDict_GetItemWithError(dict, name);
1309 [ + + ]: 63718129 : if (res != NULL) {
1310 : 49450258 : Py_INCREF(res);
1311 : 49450258 : Py_DECREF(dict);
1312 : 49450258 : goto done;
1313 : : }
1314 : : else {
1315 : 14267871 : Py_DECREF(dict);
1316 [ - + ]: 14267871 : if (PyErr_Occurred()) {
1317 [ # # # # ]: 0 : if (suppress && PyErr_ExceptionMatches(PyExc_AttributeError)) {
1318 : 0 : PyErr_Clear();
1319 : : }
1320 : : else {
1321 : 0 : goto done;
1322 : : }
1323 : : }
1324 : : }
1325 : : }
1326 : :
1327 [ + + ]: 67470355 : if (f != NULL) {
1328 : 30471383 : res = f(descr, obj, (PyObject *)Py_TYPE(obj));
1329 [ + + - + : 30471383 : if (res == NULL && suppress &&
- - ]
1330 : 0 : PyErr_ExceptionMatches(PyExc_AttributeError)) {
1331 : 0 : PyErr_Clear();
1332 : : }
1333 : 30471383 : goto done;
1334 : : }
1335 : :
1336 [ + + ]: 36998972 : if (descr != NULL) {
1337 : 22080034 : res = descr;
1338 : 22080034 : descr = NULL;
1339 : 22080034 : goto done;
1340 : : }
1341 : :
1342 [ + + ]: 14918938 : if (!suppress) {
1343 : 3219682 : PyErr_Format(PyExc_AttributeError,
1344 : : "'%.50s' object has no attribute '%U'",
1345 : : tp->tp_name, name);
1346 : : }
1347 : 11699256 : done:
1348 : 183279637 : Py_XDECREF(descr);
1349 : 183279637 : Py_DECREF(name);
1350 : 183279637 : return res;
1351 : : }
1352 : :
1353 : : PyObject *
1354 : 129511839 : PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
1355 : : {
1356 : 129511839 : return _PyObject_GenericGetAttrWithDict(obj, name, NULL, 0);
1357 : : }
1358 : :
1359 : : int
1360 : 69660747 : _PyObject_GenericSetAttrWithDict(PyObject *obj, PyObject *name,
1361 : : PyObject *value, PyObject *dict)
1362 : : {
1363 : 69660747 : PyTypeObject *tp = Py_TYPE(obj);
1364 : : PyObject *descr;
1365 : : descrsetfunc f;
1366 : 69660747 : int res = -1;
1367 : :
1368 [ + + ]: 69660747 : if (!PyUnicode_Check(name)){
1369 : 2 : PyErr_Format(PyExc_TypeError,
1370 : : "attribute name must be string, not '%.200s'",
1371 : 2 : Py_TYPE(name)->tp_name);
1372 : 2 : return -1;
1373 : : }
1374 : :
1375 [ - + - - ]: 69660745 : if (tp->tp_dict == NULL && PyType_Ready(tp) < 0)
1376 : 0 : return -1;
1377 : :
1378 : 69660745 : Py_INCREF(name);
1379 : 69660745 : Py_INCREF(tp);
1380 : 69660745 : descr = _PyType_Lookup(tp, name);
1381 : :
1382 [ + + ]: 69660745 : if (descr != NULL) {
1383 : 17556289 : Py_INCREF(descr);
1384 : 17556289 : f = Py_TYPE(descr)->tp_descr_set;
1385 [ + + ]: 17556289 : if (f != NULL) {
1386 : 4512319 : res = f(descr, obj, value);
1387 : 4512319 : goto done;
1388 : : }
1389 : : }
1390 : :
1391 [ + + ]: 65148426 : if (dict == NULL) {
1392 [ + + + + ]: 65133575 : if ((tp->tp_flags & Py_TPFLAGS_MANAGED_DICT) && *_PyObject_ValuesPointer(obj)) {
1393 : 7694002 : res = _PyObject_StoreInstanceAttribute(obj, *_PyObject_ValuesPointer(obj), name, value);
1394 : : }
1395 : : else {
1396 : 57439573 : PyObject **dictptr = _PyObject_DictPointer(obj);
1397 [ + + ]: 57439573 : if (dictptr == NULL) {
1398 [ + + ]: 97 : if (descr == NULL) {
1399 : 90 : PyErr_Format(PyExc_AttributeError,
1400 : : "'%.100s' object has no attribute '%U'",
1401 : : tp->tp_name, name);
1402 : : }
1403 : : else {
1404 : 7 : PyErr_Format(PyExc_AttributeError,
1405 : : "'%.50s' object attribute '%U' is read-only",
1406 : : tp->tp_name, name);
1407 : : }
1408 : 97 : goto done;
1409 : : }
1410 : : else {
1411 : 57439476 : res = _PyObjectDict_SetItem(tp, dictptr, name, value);
1412 : : }
1413 : : }
1414 : : }
1415 : : else {
1416 : 14851 : Py_INCREF(dict);
1417 [ + + ]: 14851 : if (value == NULL)
1418 : 165 : res = PyDict_DelItem(dict, name);
1419 : : else
1420 : 14686 : res = PyDict_SetItem(dict, name, value);
1421 : 14851 : Py_DECREF(dict);
1422 : : }
1423 [ + + + + ]: 65148329 : if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError)) {
1424 [ + + ]: 37 : if (PyType_IsSubtype(tp, &PyType_Type)) {
1425 : 14 : PyErr_Format(PyExc_AttributeError,
1426 : : "type object '%.50s' has no attribute '%U'",
1427 : : ((PyTypeObject*)obj)->tp_name, name);
1428 : : }
1429 : : else {
1430 : 23 : PyErr_Format(PyExc_AttributeError,
1431 : : "'%.100s' object has no attribute '%U'",
1432 : : tp->tp_name, name);
1433 : : }
1434 : : }
1435 : 65148292 : done:
1436 : 69660745 : Py_XDECREF(descr);
1437 : 69660745 : Py_DECREF(tp);
1438 : 69660745 : Py_DECREF(name);
1439 : 69660745 : return res;
1440 : : }
1441 : :
1442 : : int
1443 : 59707508 : PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
1444 : : {
1445 : 59707508 : return _PyObject_GenericSetAttrWithDict(obj, name, value, NULL);
1446 : : }
1447 : :
1448 : : int
1449 : 18 : PyObject_GenericSetDict(PyObject *obj, PyObject *value, void *context)
1450 : : {
1451 : 18 : PyObject **dictptr = _PyObject_GetDictPtr(obj);
1452 [ - + ]: 18 : if (dictptr == NULL) {
1453 [ # # ]: 0 : if (_PyType_HasFeature(Py_TYPE(obj), Py_TPFLAGS_MANAGED_DICT) &&
1454 [ # # ]: 0 : *_PyObject_ValuesPointer(obj) != NULL)
1455 : : {
1456 : : /* Was unable to convert to dict */
1457 : : PyErr_NoMemory();
1458 : : }
1459 : : else {
1460 : 0 : PyErr_SetString(PyExc_AttributeError,
1461 : : "This object has no __dict__");
1462 : : }
1463 : 0 : return -1;
1464 : : }
1465 [ + + ]: 18 : if (value == NULL) {
1466 : 11 : PyErr_SetString(PyExc_TypeError, "cannot delete __dict__");
1467 : 11 : return -1;
1468 : : }
1469 [ + + ]: 7 : if (!PyDict_Check(value)) {
1470 : 2 : PyErr_Format(PyExc_TypeError,
1471 : : "__dict__ must be set to a dictionary, "
1472 : 2 : "not a '%.200s'", Py_TYPE(value)->tp_name);
1473 : 2 : return -1;
1474 : : }
1475 : 5 : Py_INCREF(value);
1476 : 5 : Py_XSETREF(*dictptr, value);
1477 : 5 : return 0;
1478 : : }
1479 : :
1480 : :
1481 : : /* Test a value used as condition, e.g., in a while or if statement.
1482 : : Return -1 if an error occurred */
1483 : :
1484 : : int
1485 : 126184184 : PyObject_IsTrue(PyObject *v)
1486 : : {
1487 : : Py_ssize_t res;
1488 [ + + ]: 126184184 : if (v == Py_True)
1489 : 5749098 : return 1;
1490 [ + + ]: 120435086 : if (v == Py_False)
1491 : 7418387 : return 0;
1492 [ + + ]: 113016699 : if (v == Py_None)
1493 : 30897228 : return 0;
1494 [ + + ]: 82119471 : else if (Py_TYPE(v)->tp_as_number != NULL &&
1495 [ + + ]: 54464282 : Py_TYPE(v)->tp_as_number->nb_bool != NULL)
1496 : 21668007 : res = (*Py_TYPE(v)->tp_as_number->nb_bool)(v);
1497 [ + + ]: 60451464 : else if (Py_TYPE(v)->tp_as_mapping != NULL &&
1498 [ + + ]: 54843123 : Py_TYPE(v)->tp_as_mapping->mp_length != NULL)
1499 : 46228149 : res = (*Py_TYPE(v)->tp_as_mapping->mp_length)(v);
1500 [ + + ]: 14223315 : else if (Py_TYPE(v)->tp_as_sequence != NULL &&
1501 [ + + ]: 9674365 : Py_TYPE(v)->tp_as_sequence->sq_length != NULL)
1502 : 1059389 : res = (*Py_TYPE(v)->tp_as_sequence->sq_length)(v);
1503 : : else
1504 : 13163926 : return 1;
1505 : : /* if it is negative, it should be either -1 or -2 */
1506 [ + + ]: 68955545 : return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int);
1507 : : }
1508 : :
1509 : : /* equivalent of 'not v'
1510 : : Return -1 if an error occurred */
1511 : :
1512 : : int
1513 : 9647 : PyObject_Not(PyObject *v)
1514 : : {
1515 : : int res;
1516 : 9647 : res = PyObject_IsTrue(v);
1517 [ + + ]: 9647 : if (res < 0)
1518 : 1 : return res;
1519 : 9646 : return res == 0;
1520 : : }
1521 : :
1522 : : /* Test whether an object can be called */
1523 : :
1524 : : int
1525 : 1431904 : PyCallable_Check(PyObject *x)
1526 : : {
1527 [ - + ]: 1431904 : if (x == NULL)
1528 : 0 : return 0;
1529 : 1431904 : return Py_TYPE(x)->tp_call != NULL;
1530 : : }
1531 : :
1532 : :
1533 : : /* Helper for PyObject_Dir without arguments: returns the local scope. */
1534 : : static PyObject *
1535 : 761 : _dir_locals(void)
1536 : : {
1537 : : PyObject *names;
1538 : : PyObject *locals;
1539 : :
1540 : 761 : locals = PyEval_GetLocals();
1541 [ - + ]: 761 : if (locals == NULL)
1542 : 0 : return NULL;
1543 : :
1544 : 761 : names = PyMapping_Keys(locals);
1545 [ + + ]: 761 : if (!names)
1546 : 1 : return NULL;
1547 [ - + ]: 760 : if (!PyList_Check(names)) {
1548 : 0 : PyErr_Format(PyExc_TypeError,
1549 : : "dir(): expected keys() of locals to be a list, "
1550 : 0 : "not '%.200s'", Py_TYPE(names)->tp_name);
1551 : 0 : Py_DECREF(names);
1552 : 0 : return NULL;
1553 : : }
1554 [ - + ]: 760 : if (PyList_Sort(names)) {
1555 : 0 : Py_DECREF(names);
1556 : 0 : return NULL;
1557 : : }
1558 : : /* the locals don't need to be DECREF'd */
1559 : 760 : return names;
1560 : : }
1561 : :
1562 : : /* Helper for PyObject_Dir: object introspection. */
1563 : : static PyObject *
1564 : 26133 : _dir_object(PyObject *obj)
1565 : : {
1566 : : PyObject *result, *sorted;
1567 : 26133 : PyObject *dirfunc = _PyObject_LookupSpecial(obj, &_Py_ID(__dir__));
1568 : :
1569 : : assert(obj != NULL);
1570 [ + + ]: 26133 : if (dirfunc == NULL) {
1571 [ - + ]: 1 : if (!PyErr_Occurred())
1572 : 0 : PyErr_SetString(PyExc_TypeError, "object does not provide __dir__");
1573 : 1 : return NULL;
1574 : : }
1575 : : /* use __dir__ */
1576 : 26132 : result = _PyObject_CallNoArgs(dirfunc);
1577 : 26132 : Py_DECREF(dirfunc);
1578 [ + + ]: 26132 : if (result == NULL)
1579 : 5 : return NULL;
1580 : : /* return sorted(result) */
1581 : 26127 : sorted = PySequence_List(result);
1582 : 26127 : Py_DECREF(result);
1583 [ + + ]: 26127 : if (sorted == NULL)
1584 : 1 : return NULL;
1585 [ - + ]: 26126 : if (PyList_Sort(sorted)) {
1586 : 0 : Py_DECREF(sorted);
1587 : 0 : return NULL;
1588 : : }
1589 : 26126 : return sorted;
1590 : : }
1591 : :
1592 : : /* Implementation of dir() -- if obj is NULL, returns the names in the current
1593 : : (local) scope. Otherwise, performs introspection of the object: returns a
1594 : : sorted list of attribute names (supposedly) accessible from the object
1595 : : */
1596 : : PyObject *
1597 : 26894 : PyObject_Dir(PyObject *obj)
1598 : : {
1599 [ + + ]: 26894 : return (obj == NULL) ? _dir_locals() : _dir_object(obj);
1600 : : }
1601 : :
1602 : : /*
1603 : : None is a non-NULL undefined value.
1604 : : There is (and should be!) no way to create other objects of this type,
1605 : : so there is exactly one (which is indestructible, by the way).
1606 : : */
1607 : :
1608 : : /* ARGSUSED */
1609 : : static PyObject *
1610 : 210859 : none_repr(PyObject *op)
1611 : : {
1612 : 210859 : return PyUnicode_FromString("None");
1613 : : }
1614 : :
1615 : : static void _Py_NO_RETURN
1616 : 0 : none_dealloc(PyObject* Py_UNUSED(ignore))
1617 : : {
1618 : 0 : _Py_FatalRefcountError("deallocating None");
1619 : : }
1620 : :
1621 : : static PyObject *
1622 : 3 : none_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1623 : : {
1624 [ + + + + : 3 : if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
+ - ]
1625 : 2 : PyErr_SetString(PyExc_TypeError, "NoneType takes no arguments");
1626 : 2 : return NULL;
1627 : : }
1628 : 1 : Py_RETURN_NONE;
1629 : : }
1630 : :
1631 : : static int
1632 : 0 : none_bool(PyObject *v)
1633 : : {
1634 : 0 : return 0;
1635 : : }
1636 : :
1637 : : static PyNumberMethods none_as_number = {
1638 : : 0, /* nb_add */
1639 : : 0, /* nb_subtract */
1640 : : 0, /* nb_multiply */
1641 : : 0, /* nb_remainder */
1642 : : 0, /* nb_divmod */
1643 : : 0, /* nb_power */
1644 : : 0, /* nb_negative */
1645 : : 0, /* nb_positive */
1646 : : 0, /* nb_absolute */
1647 : : (inquiry)none_bool, /* nb_bool */
1648 : : 0, /* nb_invert */
1649 : : 0, /* nb_lshift */
1650 : : 0, /* nb_rshift */
1651 : : 0, /* nb_and */
1652 : : 0, /* nb_xor */
1653 : : 0, /* nb_or */
1654 : : 0, /* nb_int */
1655 : : 0, /* nb_reserved */
1656 : : 0, /* nb_float */
1657 : : 0, /* nb_inplace_add */
1658 : : 0, /* nb_inplace_subtract */
1659 : : 0, /* nb_inplace_multiply */
1660 : : 0, /* nb_inplace_remainder */
1661 : : 0, /* nb_inplace_power */
1662 : : 0, /* nb_inplace_lshift */
1663 : : 0, /* nb_inplace_rshift */
1664 : : 0, /* nb_inplace_and */
1665 : : 0, /* nb_inplace_xor */
1666 : : 0, /* nb_inplace_or */
1667 : : 0, /* nb_floor_divide */
1668 : : 0, /* nb_true_divide */
1669 : : 0, /* nb_inplace_floor_divide */
1670 : : 0, /* nb_inplace_true_divide */
1671 : : 0, /* nb_index */
1672 : : };
1673 : :
1674 : : PyTypeObject _PyNone_Type = {
1675 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
1676 : : "NoneType",
1677 : : 0,
1678 : : 0,
1679 : : none_dealloc, /*tp_dealloc*/ /*never called*/
1680 : : 0, /*tp_vectorcall_offset*/
1681 : : 0, /*tp_getattr*/
1682 : : 0, /*tp_setattr*/
1683 : : 0, /*tp_as_async*/
1684 : : none_repr, /*tp_repr*/
1685 : : &none_as_number, /*tp_as_number*/
1686 : : 0, /*tp_as_sequence*/
1687 : : 0, /*tp_as_mapping*/
1688 : : 0, /*tp_hash */
1689 : : 0, /*tp_call */
1690 : : 0, /*tp_str */
1691 : : 0, /*tp_getattro */
1692 : : 0, /*tp_setattro */
1693 : : 0, /*tp_as_buffer */
1694 : : Py_TPFLAGS_DEFAULT, /*tp_flags */
1695 : : 0, /*tp_doc */
1696 : : 0, /*tp_traverse */
1697 : : 0, /*tp_clear */
1698 : : 0, /*tp_richcompare */
1699 : : 0, /*tp_weaklistoffset */
1700 : : 0, /*tp_iter */
1701 : : 0, /*tp_iternext */
1702 : : 0, /*tp_methods */
1703 : : 0, /*tp_members */
1704 : : 0, /*tp_getset */
1705 : : 0, /*tp_base */
1706 : : 0, /*tp_dict */
1707 : : 0, /*tp_descr_get */
1708 : : 0, /*tp_descr_set */
1709 : : 0, /*tp_dictoffset */
1710 : : 0, /*tp_init */
1711 : : 0, /*tp_alloc */
1712 : : none_new, /*tp_new */
1713 : : };
1714 : :
1715 : : PyObject _Py_NoneStruct = {
1716 : : _PyObject_EXTRA_INIT
1717 : : 1, &_PyNone_Type
1718 : : };
1719 : :
1720 : : /* NotImplemented is an object that can be used to signal that an
1721 : : operation is not implemented for the given type combination. */
1722 : :
1723 : : static PyObject *
1724 : 22 : NotImplemented_repr(PyObject *op)
1725 : : {
1726 : 22 : return PyUnicode_FromString("NotImplemented");
1727 : : }
1728 : :
1729 : : static PyObject *
1730 : 72 : NotImplemented_reduce(PyObject *op, PyObject *Py_UNUSED(ignored))
1731 : : {
1732 : 72 : return PyUnicode_FromString("NotImplemented");
1733 : : }
1734 : :
1735 : : static PyMethodDef notimplemented_methods[] = {
1736 : : {"__reduce__", NotImplemented_reduce, METH_NOARGS, NULL},
1737 : : {NULL, NULL}
1738 : : };
1739 : :
1740 : : static PyObject *
1741 : 3 : notimplemented_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1742 : : {
1743 [ + + + + : 3 : if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
+ - ]
1744 : 2 : PyErr_SetString(PyExc_TypeError, "NotImplementedType takes no arguments");
1745 : 2 : return NULL;
1746 : : }
1747 : 1 : Py_RETURN_NOTIMPLEMENTED;
1748 : : }
1749 : :
1750 : : static void _Py_NO_RETURN
1751 : 0 : notimplemented_dealloc(PyObject* ignore)
1752 : : {
1753 : : /* This should never get called, but we also don't want to SEGV if
1754 : : * we accidentally decref NotImplemented out of existence.
1755 : : */
1756 : : Py_FatalError("deallocating NotImplemented");
1757 : : }
1758 : :
1759 : : static int
1760 : 3 : notimplemented_bool(PyObject *v)
1761 : : {
1762 [ - + ]: 3 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
1763 : : "NotImplemented should not be used in a boolean context",
1764 : : 1) < 0)
1765 : : {
1766 : 0 : return -1;
1767 : : }
1768 : 3 : return 1;
1769 : : }
1770 : :
1771 : : static PyNumberMethods notimplemented_as_number = {
1772 : : .nb_bool = notimplemented_bool,
1773 : : };
1774 : :
1775 : : PyTypeObject _PyNotImplemented_Type = {
1776 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
1777 : : "NotImplementedType",
1778 : : 0,
1779 : : 0,
1780 : : notimplemented_dealloc, /*tp_dealloc*/ /*never called*/
1781 : : 0, /*tp_vectorcall_offset*/
1782 : : 0, /*tp_getattr*/
1783 : : 0, /*tp_setattr*/
1784 : : 0, /*tp_as_async*/
1785 : : NotImplemented_repr, /*tp_repr*/
1786 : : ¬implemented_as_number, /*tp_as_number*/
1787 : : 0, /*tp_as_sequence*/
1788 : : 0, /*tp_as_mapping*/
1789 : : 0, /*tp_hash */
1790 : : 0, /*tp_call */
1791 : : 0, /*tp_str */
1792 : : 0, /*tp_getattro */
1793 : : 0, /*tp_setattro */
1794 : : 0, /*tp_as_buffer */
1795 : : Py_TPFLAGS_DEFAULT, /*tp_flags */
1796 : : 0, /*tp_doc */
1797 : : 0, /*tp_traverse */
1798 : : 0, /*tp_clear */
1799 : : 0, /*tp_richcompare */
1800 : : 0, /*tp_weaklistoffset */
1801 : : 0, /*tp_iter */
1802 : : 0, /*tp_iternext */
1803 : : notimplemented_methods, /*tp_methods */
1804 : : 0, /*tp_members */
1805 : : 0, /*tp_getset */
1806 : : 0, /*tp_base */
1807 : : 0, /*tp_dict */
1808 : : 0, /*tp_descr_get */
1809 : : 0, /*tp_descr_set */
1810 : : 0, /*tp_dictoffset */
1811 : : 0, /*tp_init */
1812 : : 0, /*tp_alloc */
1813 : : notimplemented_new, /*tp_new */
1814 : : };
1815 : :
1816 : : PyObject _Py_NotImplementedStruct = {
1817 : : _PyObject_EXTRA_INIT
1818 : : 1, &_PyNotImplemented_Type
1819 : : };
1820 : :
1821 : : PyStatus
1822 : 3138 : _PyTypes_InitState(PyInterpreterState *interp)
1823 : : {
1824 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
1825 : 171 : return _PyStatus_OK();
1826 : : }
1827 : :
1828 : 2967 : PyStatus status = _PyTypes_InitSlotDefs();
1829 [ - + ]: 2967 : if (_PyStatus_EXCEPTION(status)) {
1830 : 0 : return status;
1831 : : }
1832 : :
1833 : 2967 : return _PyStatus_OK();
1834 : : }
1835 : :
1836 : :
1837 : :
1838 : : #ifdef MS_WINDOWS
1839 : : extern PyTypeObject PyHKEY_Type;
1840 : : #endif
1841 : : extern PyTypeObject _Py_GenericAliasIterType;
1842 : : extern PyTypeObject _PyMemoryIter_Type;
1843 : : extern PyTypeObject _PyLineIterator;
1844 : : extern PyTypeObject _PyPositionsIterator;
1845 : :
1846 : : static PyTypeObject* static_types[] = {
1847 : : // The two most important base types: must be initialized first and
1848 : : // deallocated last.
1849 : : &PyBaseObject_Type,
1850 : : &PyType_Type,
1851 : :
1852 : : // Static types with base=&PyBaseObject_Type
1853 : : &PyAsyncGen_Type,
1854 : : &PyByteArrayIter_Type,
1855 : : &PyByteArray_Type,
1856 : : &PyBytesIter_Type,
1857 : : &PyBytes_Type,
1858 : : &PyCFunction_Type,
1859 : : &PyCallIter_Type,
1860 : : &PyCapsule_Type,
1861 : : &PyCell_Type,
1862 : : &PyClassMethodDescr_Type,
1863 : : &PyClassMethod_Type,
1864 : : &PyCode_Type,
1865 : : &PyComplex_Type,
1866 : : &PyContextToken_Type,
1867 : : &PyContextVar_Type,
1868 : : &PyContext_Type,
1869 : : &PyCoro_Type,
1870 : : &PyDictItems_Type,
1871 : : &PyDictIterItem_Type,
1872 : : &PyDictIterKey_Type,
1873 : : &PyDictIterValue_Type,
1874 : : &PyDictKeys_Type,
1875 : : &PyDictProxy_Type,
1876 : : &PyDictRevIterItem_Type,
1877 : : &PyDictRevIterKey_Type,
1878 : : &PyDictRevIterValue_Type,
1879 : : &PyDictValues_Type,
1880 : : &PyDict_Type,
1881 : : &PyEllipsis_Type,
1882 : : &PyEnum_Type,
1883 : : &PyFilter_Type,
1884 : : &PyFloat_Type,
1885 : : &PyFrame_Type,
1886 : : &PyFrozenSet_Type,
1887 : : &PyFunction_Type,
1888 : : &PyGen_Type,
1889 : : &PyGetSetDescr_Type,
1890 : : #ifdef MS_WINDOWS
1891 : : &PyHKEY_Type,
1892 : : #endif
1893 : : &PyInstanceMethod_Type,
1894 : : &PyListIter_Type,
1895 : : &PyListRevIter_Type,
1896 : : &PyList_Type,
1897 : : &PyLongRangeIter_Type,
1898 : : &PyLong_Type,
1899 : : &PyMap_Type,
1900 : : &PyMemberDescr_Type,
1901 : : &PyMemoryView_Type,
1902 : : &PyMethodDescr_Type,
1903 : : &PyMethod_Type,
1904 : : &PyModuleDef_Type,
1905 : : &PyModule_Type,
1906 : : &PyODictIter_Type,
1907 : : &PyPickleBuffer_Type,
1908 : : &PyProperty_Type,
1909 : : &PyRangeIter_Type,
1910 : : &PyRange_Type,
1911 : : &PyReversed_Type,
1912 : : &PySTEntry_Type,
1913 : : &PySeqIter_Type,
1914 : : &PySetIter_Type,
1915 : : &PySet_Type,
1916 : : &PySlice_Type,
1917 : : &PyStaticMethod_Type,
1918 : : &PyStdPrinter_Type,
1919 : : &PySuper_Type,
1920 : : &PyTraceBack_Type,
1921 : : &PyTupleIter_Type,
1922 : : &PyTuple_Type,
1923 : : &PyUnicodeIter_Type,
1924 : : &PyUnicode_Type,
1925 : : &PyWrapperDescr_Type,
1926 : : &PyZip_Type,
1927 : : &Py_GenericAliasType,
1928 : : &_PyAnextAwaitable_Type,
1929 : : &_PyAsyncGenASend_Type,
1930 : : &_PyAsyncGenAThrow_Type,
1931 : : &_PyAsyncGenWrappedValue_Type,
1932 : : &_PyContextTokenMissing_Type,
1933 : : &_PyCoroWrapper_Type,
1934 : : &_Py_GenericAliasIterType,
1935 : : &_PyHamtItems_Type,
1936 : : &_PyHamtKeys_Type,
1937 : : &_PyHamtValues_Type,
1938 : : &_PyHamt_ArrayNode_Type,
1939 : : &_PyHamt_BitmapNode_Type,
1940 : : &_PyHamt_CollisionNode_Type,
1941 : : &_PyHamt_Type,
1942 : : &_PyInterpreterID_Type,
1943 : : &_PyLineIterator,
1944 : : &_PyManagedBuffer_Type,
1945 : : &_PyMemoryIter_Type,
1946 : : &_PyMethodWrapper_Type,
1947 : : &_PyNamespace_Type,
1948 : : &_PyNone_Type,
1949 : : &_PyNotImplemented_Type,
1950 : : &_PyPositionsIterator,
1951 : : &_PyUnicodeASCIIIter_Type,
1952 : : &_PyUnion_Type,
1953 : : &_PyWeakref_CallableProxyType,
1954 : : &_PyWeakref_ProxyType,
1955 : : &_PyWeakref_RefType,
1956 : :
1957 : : // subclasses: _PyTypes_FiniTypes() deallocates them before their base
1958 : : // class
1959 : : &PyBool_Type, // base=&PyLong_Type
1960 : : &PyCMethod_Type, // base=&PyCFunction_Type
1961 : : &PyODictItems_Type, // base=&PyDictItems_Type
1962 : : &PyODictKeys_Type, // base=&PyDictKeys_Type
1963 : : &PyODictValues_Type, // base=&PyDictValues_Type
1964 : : &PyODict_Type, // base=&PyDict_Type
1965 : : };
1966 : :
1967 : :
1968 : : PyStatus
1969 : 3138 : _PyTypes_InitTypes(PyInterpreterState *interp)
1970 : : {
1971 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
1972 : 171 : return _PyStatus_OK();
1973 : : }
1974 : :
1975 : : // All other static types (unless initialized elsewhere)
1976 [ + + ]: 323403 : for (size_t i=0; i < Py_ARRAY_LENGTH(static_types); i++) {
1977 : 320436 : PyTypeObject *type = static_types[i];
1978 [ - + ]: 320436 : if (PyType_Ready(type) < 0) {
1979 : 0 : return _PyStatus_ERR("Can't initialize types");
1980 : : }
1981 : : if (type == &PyType_Type) {
1982 : : // Sanitify checks of the two most important types
1983 : : assert(PyBaseObject_Type.tp_base == NULL);
1984 : : assert(PyType_Type.tp_base == &PyBaseObject_Type);
1985 : : }
1986 : : }
1987 : :
1988 : 2967 : return _PyStatus_OK();
1989 : : }
1990 : :
1991 : :
1992 : : // Best-effort function clearing static types.
1993 : : //
1994 : : // Don't deallocate a type if it still has subclasses. If a Py_Finalize()
1995 : : // sub-function is interrupted by CTRL+C or fails with MemoryError, some
1996 : : // subclasses are not cleared properly. Leave the static type unchanged in this
1997 : : // case.
1998 : : void
1999 : 3125 : _PyTypes_FiniTypes(PyInterpreterState *interp)
2000 : : {
2001 [ + + ]: 3125 : if (!_Py_IsMainInterpreter(interp)) {
2002 : 169 : return;
2003 : : }
2004 : :
2005 : : // Deallocate types in the reverse order to deallocate subclasses before
2006 : : // their base classes.
2007 [ + + ]: 322204 : for (Py_ssize_t i=Py_ARRAY_LENGTH(static_types)-1; i>=0; i--) {
2008 : 319248 : PyTypeObject *type = static_types[i];
2009 : 319248 : _PyStaticType_Dealloc(type);
2010 : : }
2011 : : }
2012 : :
2013 : :
2014 : : void
2015 : 1261182315 : _Py_NewReference(PyObject *op)
2016 : : {
2017 [ + + ]: 1261182315 : if (_Py_tracemalloc_config.tracing) {
2018 : 987265 : _PyTraceMalloc_NewReference(op);
2019 : : }
2020 : : #ifdef Py_REF_DEBUG
2021 : : _Py_RefTotal++;
2022 : : #endif
2023 : 1261182315 : Py_SET_REFCNT(op, 1);
2024 : : #ifdef Py_TRACE_REFS
2025 : : _Py_AddToAllObjects(op, 1);
2026 : : #endif
2027 : 1261182315 : }
2028 : :
2029 : :
2030 : : #ifdef Py_TRACE_REFS
2031 : : void
2032 : : _Py_ForgetReference(PyObject *op)
2033 : : {
2034 : : if (Py_REFCNT(op) < 0) {
2035 : : _PyObject_ASSERT_FAILED_MSG(op, "negative refcnt");
2036 : : }
2037 : :
2038 : : if (op == &refchain ||
2039 : : op->_ob_prev->_ob_next != op || op->_ob_next->_ob_prev != op)
2040 : : {
2041 : : _PyObject_ASSERT_FAILED_MSG(op, "invalid object chain");
2042 : : }
2043 : :
2044 : : #ifdef SLOW_UNREF_CHECK
2045 : : PyObject *p;
2046 : : for (p = refchain._ob_next; p != &refchain; p = p->_ob_next) {
2047 : : if (p == op) {
2048 : : break;
2049 : : }
2050 : : }
2051 : : if (p == &refchain) {
2052 : : /* Not found */
2053 : : _PyObject_ASSERT_FAILED_MSG(op,
2054 : : "object not found in the objects list");
2055 : : }
2056 : : #endif
2057 : :
2058 : : op->_ob_next->_ob_prev = op->_ob_prev;
2059 : : op->_ob_prev->_ob_next = op->_ob_next;
2060 : : op->_ob_next = op->_ob_prev = NULL;
2061 : : }
2062 : :
2063 : : /* Print all live objects. Because PyObject_Print is called, the
2064 : : * interpreter must be in a healthy state.
2065 : : */
2066 : : void
2067 : : _Py_PrintReferences(FILE *fp)
2068 : : {
2069 : : PyObject *op;
2070 : : fprintf(fp, "Remaining objects:\n");
2071 : : for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) {
2072 : : fprintf(fp, "%p [%zd] ", (void *)op, Py_REFCNT(op));
2073 : : if (PyObject_Print(op, fp, 0) != 0) {
2074 : : PyErr_Clear();
2075 : : }
2076 : : putc('\n', fp);
2077 : : }
2078 : : }
2079 : :
2080 : : /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
2081 : : * doesn't make any calls to the Python C API, so is always safe to call.
2082 : : */
2083 : : void
2084 : : _Py_PrintReferenceAddresses(FILE *fp)
2085 : : {
2086 : : PyObject *op;
2087 : : fprintf(fp, "Remaining object addresses:\n");
2088 : : for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
2089 : : fprintf(fp, "%p [%zd] %s\n", (void *)op,
2090 : : Py_REFCNT(op), Py_TYPE(op)->tp_name);
2091 : : }
2092 : :
2093 : : PyObject *
2094 : : _Py_GetObjects(PyObject *self, PyObject *args)
2095 : : {
2096 : : int i, n;
2097 : : PyObject *t = NULL;
2098 : : PyObject *res, *op;
2099 : :
2100 : : if (!PyArg_ParseTuple(args, "i|O", &n, &t))
2101 : : return NULL;
2102 : : op = refchain._ob_next;
2103 : : res = PyList_New(0);
2104 : : if (res == NULL)
2105 : : return NULL;
2106 : : for (i = 0; (n == 0 || i < n) && op != &refchain; i++) {
2107 : : while (op == self || op == args || op == res || op == t ||
2108 : : (t != NULL && !Py_IS_TYPE(op, (PyTypeObject *) t))) {
2109 : : op = op->_ob_next;
2110 : : if (op == &refchain)
2111 : : return res;
2112 : : }
2113 : : if (PyList_Append(res, op) < 0) {
2114 : : Py_DECREF(res);
2115 : : return NULL;
2116 : : }
2117 : : op = op->_ob_next;
2118 : : }
2119 : : return res;
2120 : : }
2121 : :
2122 : : #endif
2123 : :
2124 : :
2125 : : /* Hack to force loading of abstract.o */
2126 : : Py_ssize_t (*_Py_abstract_hack)(PyObject *) = PyObject_Size;
2127 : :
2128 : :
2129 : : void
2130 : 1 : _PyObject_DebugTypeStats(FILE *out)
2131 : : {
2132 : 1 : _PyDict_DebugMallocStats(out);
2133 : 1 : _PyFloat_DebugMallocStats(out);
2134 : 1 : _PyList_DebugMallocStats(out);
2135 : 1 : _PyTuple_DebugMallocStats(out);
2136 : 1 : }
2137 : :
2138 : : /* These methods are used to control infinite recursion in repr, str, print,
2139 : : etc. Container objects that may recursively contain themselves,
2140 : : e.g. builtin dictionaries and lists, should use Py_ReprEnter() and
2141 : : Py_ReprLeave() to avoid infinite recursion.
2142 : :
2143 : : Py_ReprEnter() returns 0 the first time it is called for a particular
2144 : : object and 1 every time thereafter. It returns -1 if an exception
2145 : : occurred. Py_ReprLeave() has no return value.
2146 : :
2147 : : See dictobject.c and listobject.c for examples of use.
2148 : : */
2149 : :
2150 : : int
2151 : 119307 : Py_ReprEnter(PyObject *obj)
2152 : : {
2153 : : PyObject *dict;
2154 : : PyObject *list;
2155 : : Py_ssize_t i;
2156 : :
2157 : 119307 : dict = PyThreadState_GetDict();
2158 : : /* Ignore a missing thread-state, so that this function can be called
2159 : : early on startup. */
2160 [ - + ]: 119307 : if (dict == NULL)
2161 : 0 : return 0;
2162 : 119307 : list = PyDict_GetItemWithError(dict, &_Py_ID(Py_Repr));
2163 [ + + ]: 119307 : if (list == NULL) {
2164 [ - + ]: 399 : if (PyErr_Occurred()) {
2165 : 0 : return -1;
2166 : : }
2167 : 399 : list = PyList_New(0);
2168 [ - + ]: 399 : if (list == NULL)
2169 : 0 : return -1;
2170 [ - + ]: 399 : if (PyDict_SetItem(dict, &_Py_ID(Py_Repr), list) < 0)
2171 : 0 : return -1;
2172 : 399 : Py_DECREF(list);
2173 : : }
2174 : 119307 : i = PyList_GET_SIZE(list);
2175 [ + + ]: 1655688 : while (--i >= 0) {
2176 [ + + ]: 1536429 : if (PyList_GET_ITEM(list, i) == obj)
2177 : 48 : return 1;
2178 : : }
2179 [ - + ]: 119259 : if (PyList_Append(list, obj) < 0)
2180 : 0 : return -1;
2181 : 119259 : return 0;
2182 : : }
2183 : :
2184 : : void
2185 : 119260 : Py_ReprLeave(PyObject *obj)
2186 : : {
2187 : : PyObject *dict;
2188 : : PyObject *list;
2189 : : Py_ssize_t i;
2190 : : PyObject *error_type, *error_value, *error_traceback;
2191 : :
2192 : 119260 : PyErr_Fetch(&error_type, &error_value, &error_traceback);
2193 : :
2194 : 119260 : dict = PyThreadState_GetDict();
2195 [ - + ]: 119260 : if (dict == NULL)
2196 : 0 : goto finally;
2197 : :
2198 : 119260 : list = PyDict_GetItemWithError(dict, &_Py_ID(Py_Repr));
2199 [ + - - + ]: 119260 : if (list == NULL || !PyList_Check(list))
2200 : 0 : goto finally;
2201 : :
2202 : 119260 : i = PyList_GET_SIZE(list);
2203 : : /* Count backwards because we always expect obj to be list[-1] */
2204 [ + + ]: 119260 : while (--i >= 0) {
2205 [ + - ]: 119259 : if (PyList_GET_ITEM(list, i) == obj) {
2206 : 119259 : PyList_SetSlice(list, i, i + 1, NULL);
2207 : 119259 : break;
2208 : : }
2209 : : }
2210 : :
2211 : 1 : finally:
2212 : : /* ignore exceptions because there is no way to report them. */
2213 : 119260 : PyErr_Restore(error_type, error_value, error_traceback);
2214 : 119260 : }
2215 : :
2216 : : /* Trashcan support. */
2217 : :
2218 : : #define _PyTrash_UNWIND_LEVEL 50
2219 : :
2220 : : /* Add op to the gcstate->trash_delete_later list. Called when the current
2221 : : * call-stack depth gets large. op must be a currently untracked gc'ed
2222 : : * object, with refcount 0. Py_DECREF must already have been called on it.
2223 : : */
2224 : : static void
2225 : 231337 : _PyTrash_thread_deposit_object(PyObject *op)
2226 : : {
2227 : 231337 : PyThreadState *tstate = _PyThreadState_GET();
2228 : : _PyObject_ASSERT(op, _PyObject_IS_GC(op));
2229 : : _PyObject_ASSERT(op, !_PyObject_GC_IS_TRACKED(op));
2230 : : _PyObject_ASSERT(op, Py_REFCNT(op) == 0);
2231 : 231337 : _PyGCHead_SET_PREV(_Py_AS_GC(op), (PyGC_Head*)tstate->trash_delete_later);
2232 : 231337 : tstate->trash_delete_later = op;
2233 : 231337 : }
2234 : :
2235 : : /* Deallocate all the objects in the gcstate->trash_delete_later list.
2236 : : * Called when the call-stack unwinds again. */
2237 : : static void
2238 : 412 : _PyTrash_thread_destroy_chain(void)
2239 : : {
2240 : 412 : PyThreadState *tstate = _PyThreadState_GET();
2241 : : /* We need to increase trash_delete_nesting here, otherwise,
2242 : : _PyTrash_thread_destroy_chain will be called recursively
2243 : : and then possibly crash. An example that may crash without
2244 : : increase:
2245 : : N = 500000 # need to be large enough
2246 : : ob = object()
2247 : : tups = [(ob,) for i in range(N)]
2248 : : for i in range(49):
2249 : : tups = [(tup,) for tup in tups]
2250 : : del tups
2251 : : */
2252 : : assert(tstate->trash_delete_nesting == 0);
2253 : 412 : ++tstate->trash_delete_nesting;
2254 [ + + ]: 231749 : while (tstate->trash_delete_later) {
2255 : 231337 : PyObject *op = tstate->trash_delete_later;
2256 : 231337 : destructor dealloc = Py_TYPE(op)->tp_dealloc;
2257 : :
2258 : 231337 : tstate->trash_delete_later =
2259 : 231337 : (PyObject*) _PyGCHead_PREV(_Py_AS_GC(op));
2260 : :
2261 : : /* Call the deallocator directly. This used to try to
2262 : : * fool Py_DECREF into calling it indirectly, but
2263 : : * Py_DECREF was already called on this object, and in
2264 : : * assorted non-release builds calling Py_DECREF again ends
2265 : : * up distorting allocation statistics.
2266 : : */
2267 : : _PyObject_ASSERT(op, Py_REFCNT(op) == 0);
2268 : 231337 : (*dealloc)(op);
2269 : : assert(tstate->trash_delete_nesting == 1);
2270 : : }
2271 : 412 : --tstate->trash_delete_nesting;
2272 : 412 : }
2273 : :
2274 : :
2275 : : int
2276 : 451775438 : _PyTrash_begin(PyThreadState *tstate, PyObject *op)
2277 : : {
2278 [ + + ]: 451775438 : if (tstate->trash_delete_nesting >= _PyTrash_UNWIND_LEVEL) {
2279 : : /* Store the object (to be deallocated later) and jump past
2280 : : * Py_TRASHCAN_END, skipping the body of the deallocator */
2281 : 231337 : _PyTrash_thread_deposit_object(op);
2282 : 231337 : return 1;
2283 : : }
2284 : 451544101 : ++tstate->trash_delete_nesting;
2285 : 451544101 : return 0;
2286 : : }
2287 : :
2288 : :
2289 : : void
2290 : 451544101 : _PyTrash_end(PyThreadState *tstate)
2291 : : {
2292 : 451544101 : --tstate->trash_delete_nesting;
2293 [ + + + + ]: 451544101 : if (tstate->trash_delete_later && tstate->trash_delete_nesting <= 0) {
2294 : 412 : _PyTrash_thread_destroy_chain();
2295 : : }
2296 : 451544101 : }
2297 : :
2298 : :
2299 : : /* bpo-40170: It's only be used in Py_TRASHCAN_BEGIN macro to hide
2300 : : implementation details. */
2301 : : int
2302 : 464184329 : _PyTrash_cond(PyObject *op, destructor dealloc)
2303 : : {
2304 : 464184329 : return Py_TYPE(op)->tp_dealloc == dealloc;
2305 : : }
2306 : :
2307 : :
2308 : : void _Py_NO_RETURN
2309 : 0 : _PyObject_AssertFailed(PyObject *obj, const char *expr, const char *msg,
2310 : : const char *file, int line, const char *function)
2311 : : {
2312 : 0 : fprintf(stderr, "%s:%d: ", file, line);
2313 [ # # ]: 0 : if (function) {
2314 : 0 : fprintf(stderr, "%s: ", function);
2315 : : }
2316 : 0 : fflush(stderr);
2317 : :
2318 [ # # ]: 0 : if (expr) {
2319 : 0 : fprintf(stderr, "Assertion \"%s\" failed", expr);
2320 : : }
2321 : : else {
2322 : 0 : fprintf(stderr, "Assertion failed");
2323 : : }
2324 : 0 : fflush(stderr);
2325 : :
2326 [ # # ]: 0 : if (msg) {
2327 : 0 : fprintf(stderr, ": %s", msg);
2328 : : }
2329 : 0 : fprintf(stderr, "\n");
2330 : 0 : fflush(stderr);
2331 : :
2332 [ # # ]: 0 : if (_PyObject_IsFreed(obj)) {
2333 : : /* It seems like the object memory has been freed:
2334 : : don't access it to prevent a segmentation fault. */
2335 : 0 : fprintf(stderr, "<object at %p is freed>\n", obj);
2336 : 0 : fflush(stderr);
2337 : : }
2338 : : else {
2339 : : /* Display the traceback where the object has been allocated.
2340 : : Do it before dumping repr(obj), since repr() is more likely
2341 : : to crash than dumping the traceback. */
2342 : : void *ptr;
2343 : 0 : PyTypeObject *type = Py_TYPE(obj);
2344 [ # # ]: 0 : if (_PyType_IS_GC(type)) {
2345 : 0 : ptr = (void *)((char *)obj - sizeof(PyGC_Head));
2346 : : }
2347 : : else {
2348 : 0 : ptr = (void *)obj;
2349 : : }
2350 : 0 : _PyMem_DumpTraceback(fileno(stderr), ptr);
2351 : :
2352 : : /* This might succeed or fail, but we're about to abort, so at least
2353 : : try to provide any extra info we can: */
2354 : 0 : _PyObject_Dump(obj);
2355 : :
2356 : 0 : fprintf(stderr, "\n");
2357 : 0 : fflush(stderr);
2358 : : }
2359 : :
2360 : : Py_FatalError("_PyObject_AssertFailed");
2361 : : }
2362 : :
2363 : :
2364 : : void
2365 : 802763101 : _Py_Dealloc(PyObject *op)
2366 : : {
2367 : 802763101 : PyTypeObject *type = Py_TYPE(op);
2368 : 802763101 : destructor dealloc = type->tp_dealloc;
2369 : : #ifdef Py_DEBUG
2370 : : PyThreadState *tstate = _PyThreadState_GET();
2371 : : PyObject *old_exc_type = tstate->curexc_type;
2372 : : // Keep the old exception type alive to prevent undefined behavior
2373 : : // on (tstate->curexc_type != old_exc_type) below
2374 : : Py_XINCREF(old_exc_type);
2375 : : // Make sure that type->tp_name remains valid
2376 : : Py_INCREF(type);
2377 : : #endif
2378 : :
2379 : : #ifdef Py_TRACE_REFS
2380 : : _Py_ForgetReference(op);
2381 : : #endif
2382 : 802763101 : (*dealloc)(op);
2383 : :
2384 : : #ifdef Py_DEBUG
2385 : : // gh-89373: The tp_dealloc function must leave the current exception
2386 : : // unchanged.
2387 : : if (tstate->curexc_type != old_exc_type) {
2388 : : const char *err;
2389 : : if (old_exc_type == NULL) {
2390 : : err = "Deallocator of type '%s' raised an exception";
2391 : : }
2392 : : else if (tstate->curexc_type == NULL) {
2393 : : err = "Deallocator of type '%s' cleared the current exception";
2394 : : }
2395 : : else {
2396 : : // It can happen if dealloc() normalized the current exception.
2397 : : // A deallocator function must not change the current exception,
2398 : : // not even normalize it.
2399 : : err = "Deallocator of type '%s' overrode the current exception";
2400 : : }
2401 : : _Py_FatalErrorFormat(__func__, err, type->tp_name);
2402 : : }
2403 : : Py_XDECREF(old_exc_type);
2404 : : Py_DECREF(type);
2405 : : #endif
2406 : 802763101 : }
2407 : :
2408 : :
2409 : : PyObject **
2410 : 0 : PyObject_GET_WEAKREFS_LISTPTR(PyObject *op)
2411 : : {
2412 : 0 : return _PyObject_GET_WEAKREFS_LISTPTR(op);
2413 : : }
2414 : :
2415 : :
2416 : : #undef Py_NewRef
2417 : : #undef Py_XNewRef
2418 : :
2419 : : // Export Py_NewRef() and Py_XNewRef() as regular functions for the stable ABI.
2420 : : PyObject*
2421 : 11 : Py_NewRef(PyObject *obj)
2422 : : {
2423 : 11 : return _Py_NewRef(obj);
2424 : : }
2425 : :
2426 : : PyObject*
2427 : 2 : Py_XNewRef(PyObject *obj)
2428 : : {
2429 : 2 : return _Py_XNewRef(obj);
2430 : : }
2431 : :
2432 : : #undef Py_Is
2433 : : #undef Py_IsNone
2434 : : #undef Py_IsTrue
2435 : : #undef Py_IsFalse
2436 : :
2437 : : // Export Py_Is(), Py_IsNone(), Py_IsTrue(), Py_IsFalse() as regular functions
2438 : : // for the stable ABI.
2439 : 10 : int Py_Is(PyObject *x, PyObject *y)
2440 : : {
2441 : 10 : return (x == y);
2442 : : }
2443 : :
2444 : 0 : int Py_IsNone(PyObject *x)
2445 : : {
2446 : 0 : return Py_Is(x, Py_None);
2447 : : }
2448 : :
2449 : 0 : int Py_IsTrue(PyObject *x)
2450 : : {
2451 : 0 : return Py_Is(x, Py_True);
2452 : : }
2453 : :
2454 : 0 : int Py_IsFalse(PyObject *x)
2455 : : {
2456 : 0 : return Py_Is(x, Py_False);
2457 : : }
2458 : :
2459 : : #ifdef __cplusplus
2460 : : }
2461 : : #endif
|
