static void dealloc(Box* b) noexcept { BoxedFrame* f = static_cast<BoxedFrame*>(b); _PyObject_GC_UNTRACK(f); clear(b); f->cls->tp_free(b); }
static void sm_dealloc(staticmethod *sm) { _PyObject_GC_UNTRACK((PyObject *)sm); Py_XDECREF(sm->sm_callable); Py_TYPE(sm)->tp_free((PyObject *)sm); }
void _PyTuple_MaybeUntrack(PyObject *op) { PyTupleObject *t; Py_ssize_t i, n; if (!PyTuple_CheckExact(op) || !_PyObject_GC_IS_TRACKED(op)) return; t = (PyTupleObject *) op; n = Py_SIZE(t); for (i = 0; i < n; i++) { PyObject *elt = PyTuple_GET_ITEM(t, i); /* Tuple with NULL elements aren't fully constructed, don't untrack them yet. */ if (!elt || _PyObject_GC_MAY_BE_TRACKED(elt)) return; } #ifdef SHOW_TRACK_COUNT count_tracked--; count_untracked++; #endif _PyObject_GC_UNTRACK(op); }
static void coro_wrapper_dealloc(PyCoroWrapper *cw) { _PyObject_GC_UNTRACK((PyObject *)cw); Py_CLEAR(cw->cw_coroutine); PyObject_GC_Del(cw); }
static void iter_dealloc(seqiterobject *it) { _PyObject_GC_UNTRACK(it); Py_XDECREF(it->it_seq); PyObject_GC_Del(it); }
static void record_iter_dealloc(ApgRecordIterObject *it) { _PyObject_GC_UNTRACK(it); Py_CLEAR(it->it_seq); PyObject_GC_Del(it); }
static void cm_dealloc(classmethod *cm) { _PyObject_GC_UNTRACK((PyObject *)cm); Py_XDECREF(cm->cm_callable); Py_TYPE(cm)->tp_free((PyObject *)cm); }
static void proxy_dealloc(proxyobject *pp) { _PyObject_GC_UNTRACK(pp); Py_DECREF(pp->dict); PyObject_GC_Del(pp); }
static void cell_dealloc(PyCellObject *op) { _PyObject_GC_UNTRACK(op); Py_XDECREF(op->ob_ref); PyObject_GC_Del(op); }
static void calliter_dealloc(calliterobject *it) { _PyObject_GC_UNTRACK(it); Py_XDECREF(it->it_callable); Py_XDECREF(it->it_sentinel); PyObject_GC_Del(it); }
static void descr_dealloc(PyDescrObject *descr) { _PyObject_GC_UNTRACK(descr); Py_XDECREF(descr->d_type); Py_XDECREF(descr->d_name); PyObject_GC_Del(descr); }
static void lru_list_elem_dealloc(lru_list_elem *link) { _PyObject_GC_UNTRACK(link); Py_XDECREF(link->key); Py_XDECREF(link->result); PyObject_GC_Del(link); }
void PyObject_GC_UnTrack(void *op) { /* Obscure: the Py_TRASHCAN mechanism requires that we be able to * call PyObject_GC_UnTrack twice on an object. */ if (IS_TRACKED(op)) _PyObject_GC_UNTRACK(op); }
static void meth_dealloc(PyCFunctionObject *m) { _PyObject_GC_UNTRACK(m); Py_XDECREF(m->m_self); Py_XDECREF(m->m_module); m->m_self = (PyObject *)free_list; free_list = m; }
static void func_dealloc(PyFunctionObject *op) { _PyObject_GC_UNTRACK(op); if (op->func_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) op); } (void)func_clear(op); PyObject_GC_Del(op); }
int _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize) { PyTupleObject *v; PyTupleObject *sv; Py_ssize_t i; Py_ssize_t oldsize; v = (PyTupleObject *) *pv; if (v == NULL || Py_TYPE(v) != &PyTuple_Type || (Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) { *pv = 0; Py_XDECREF(v); PyErr_BadInternalCall(); return -1; } oldsize = Py_SIZE(v); if (oldsize == newsize) return 0; if (oldsize == 0) { /* Empty tuples are often shared, so we should never resize them in-place even if we do own the only (current) reference */ Py_DECREF(v); *pv = PyTuple_New(newsize); return *pv == NULL ? -1 : 0; } /* XXX UNREF/NEWREF interface should be more symmetrical */ _Py_DEC_REFTOTAL; if (_PyObject_GC_IS_TRACKED(v)) _PyObject_GC_UNTRACK(v); _Py_ForgetReference((PyObject *) v); /* DECREF items deleted by shrinkage */ for (i = newsize; i < oldsize; i++) { Py_XDECREF(v->ob_item[i]); v->ob_item[i] = NULL; } sv = PyObject_GC_Resize(PyTupleObject, v, newsize); if (sv == NULL) { *pv = NULL; PyObject_GC_Del(v); return -1; } _Py_NewReference((PyObject *) sv); /* Zero out items added by growing */ if (newsize > oldsize) memset(&sv->ob_item[oldsize], 0, sizeof(*sv->ob_item) * (newsize - oldsize)); *pv = (PyObject *) sv; _PyObject_GC_TRACK(sv); return 0; }
static void property_dealloc(PyObject *self) { propertyobject *gs = (propertyobject *)self; _PyObject_GC_UNTRACK(self); Py_XDECREF(gs->prop_get); Py_XDECREF(gs->prop_set); Py_XDECREF(gs->prop_del); Py_XDECREF(gs->prop_doc); self->ob_type->tp_free(self); }
static void slice_dealloc(PySliceObject *r) { _PyObject_GC_UNTRACK(r); Py_DECREF(r->step); Py_DECREF(r->start); Py_DECREF(r->stop); if (slice_cache == NULL) slice_cache = r; else PyObject_GC_Del(r); }
static void gen_dealloc(PyGenObject *gen) { PyObject *self = (PyObject *) gen; _PyObject_GC_UNTRACK(gen); if (gen->gi_weakreflist != NULL) PyObject_ClearWeakRefs(self); _PyObject_GC_TRACK(self); if (PyObject_CallFinalizerFromDealloc(self)) return; /* resurrected. :( */ _PyObject_GC_UNTRACK(self); Py_CLEAR(gen->gi_frame); Py_CLEAR(gen->gi_code); Py_CLEAR(gen->gi_name); Py_CLEAR(gen->gi_qualname); PyObject_GC_Del(gen); }
static void meth_dealloc(PyCFunctionObject *m) { _PyObject_GC_UNTRACK(m); Py_XDECREF(m->m_self); Py_XDECREF(m->m_module); if (numfree < PyCFunction_MAXFREELIST) { m->m_self = (PyObject *)free_list; free_list = m; numfree++; } else { PyObject_GC_Del(m); } }
static void bomb_dealloc(PyBombObject *bomb) { _PyObject_GC_UNTRACK(bomb); Py_XDECREF(bomb->curexc_type); Py_XDECREF(bomb->curexc_value); Py_XDECREF(bomb->curexc_traceback); if (numfree < MAXFREELIST) { ++numfree; bomb->curexc_type = (PyObject *) free_list; free_list = bomb; } else PyObject_GC_Del(bomb); }
static void gen_dealloc(PyGenObject *gen) { PyObject *self = (PyObject *) gen; _PyObject_GC_UNTRACK(gen); if (gen->gi_weakreflist != NULL) PyObject_ClearWeakRefs(self); _PyObject_GC_TRACK(self); if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) { /* Generator is paused, so we need to close */ Py_TYPE(gen)->tp_del(self); if (self->ob_refcnt > 0) return; /* resurrected. :( */ } _PyObject_GC_UNTRACK(self); Py_CLEAR(gen->gi_frame); Py_CLEAR(gen->gi_code); PyObject_GC_Del(gen); }
static void func_dealloc(PyFunctionObject *op) { _PyObject_GC_UNTRACK(op); if (op->func_weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *) op); Py_DECREF(op->func_code); Py_DECREF(op->func_globals); Py_XDECREF(op->func_module); Py_DECREF(op->func_name); Py_XDECREF(op->func_defaults); Py_XDECREF(op->func_doc); Py_XDECREF(op->func_dict); Py_XDECREF(op->func_closure); PyObject_GC_Del(op); }
static void method_dealloc(PyMethodObject *im) { _PyObject_GC_UNTRACK(im); if (im->im_weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *)im); Py_DECREF(im->im_func); Py_XDECREF(im->im_self); if (numfree < PyMethod_MAXFREELIST) { im->im_self = (PyObject *)free_list; free_list = im; numfree++; } else { PyObject_GC_Del(im); } }
static void context_tp_dealloc(PyContext *self) { _PyObject_GC_UNTRACK(self); if (self->ctx_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject*)self); } (void)context_tp_clear(self); if (ctx_freelist_len < CONTEXT_FREELIST_MAXLEN) { ctx_freelist_len++; self->ctx_weakreflist = (PyObject *)ctx_freelist; ctx_freelist = self; } else { Py_TYPE(self)->tp_free(self); } }
static void meth_dealloc(PyCFunctionObject *m) { Py_GUARD(); _PyObject_GC_UNTRACK(m); if (m->m_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject*) m); } Py_XDECREF(m->m_self); Py_XDECREF(m->m_module); if (numfree < PyCFunction_MAXFREELIST) { m->m_self = (PyObject *)free_list; free_list = m; numfree++; } else { PyObject_GC_Del(m); } }
static void _Py_HOT_FUNCTION frame_dealloc(PyFrameObject *f) { PyObject **p, **valuestack; PyCodeObject *co; if (_PyObject_GC_IS_TRACKED(f)) _PyObject_GC_UNTRACK(f); Py_TRASHCAN_SAFE_BEGIN(f) /* Kill all local variables */ valuestack = f->f_valuestack; for (p = f->f_localsplus; p < valuestack; p++) Py_CLEAR(*p); /* Free stack */ if (f->f_stacktop != NULL) { for (p = valuestack; p < f->f_stacktop; p++) Py_XDECREF(*p); } Py_XDECREF(f->f_back); Py_DECREF(f->f_builtins); Py_DECREF(f->f_globals); Py_CLEAR(f->f_locals); Py_CLEAR(f->f_trace); co = f->f_code; if (co->co_zombieframe == NULL) co->co_zombieframe = f; else if (numfree < PyFrame_MAXFREELIST) { ++numfree; f->f_back = free_list; free_list = f; } else PyObject_GC_Del(f); Py_DECREF(co); Py_TRASHCAN_SAFE_END(f) }
static void iobase_dealloc(iobase *self) { /* NOTE: since IOBaseObject has its own dict, Python-defined attributes are still available here for close() to use. However, if the derived class declares a __slots__, those slots are already gone. */ if (_PyIOBase_finalize((PyObject *) self) < 0) { /* When called from a heap type's dealloc, the type will be decref'ed on return (see e.g. subtype_dealloc in typeobject.c). */ if (PyType_HasFeature(Py_TYPE(self), Py_TPFLAGS_HEAPTYPE)) Py_INCREF(Py_TYPE(self)); return; } _PyObject_GC_UNTRACK(self); if (self->weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *) self); Py_CLEAR(self->dict); Py_TYPE(self)->tp_free((PyObject *) self); }
PyObject * PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { STACKLESS_GETARG(); PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); Py_ssize_t size; #ifdef STACKLESS switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS)) { #else switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) { #endif case METH_VARARGS: if (kw == NULL || PyDict_Size(kw) == 0) WRAP_RETURN( (*meth)(self, arg) ) break; case METH_VARARGS | METH_KEYWORDS: WRAP_RETURN( (*(PyCFunctionWithKeywords)meth)(self, arg, kw) ) case METH_NOARGS: if (kw == NULL || PyDict_Size(kw) == 0) { size = PyTuple_GET_SIZE(arg); if (size == 0) WRAP_RETURN( (*meth)(self, NULL) ) PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%zd given)", f->m_ml->ml_name, size); return NULL; } break; case METH_O: if (kw == NULL || PyDict_Size(kw) == 0) { size = PyTuple_GET_SIZE(arg); if (size == 1) WRAP_RETURN( (*meth)(self, PyTuple_GET_ITEM(arg, 0)) ) PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%zd given)", f->m_ml->ml_name, size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags in " "PyCFunction_Call. METH_OLDARGS is no " "longer supported!"); return NULL; } PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); return NULL; } /* Methods (the standard built-in methods, that is) */ static void meth_dealloc(PyCFunctionObject *m) { _PyObject_GC_UNTRACK(m); Py_XDECREF(m->m_self); Py_XDECREF(m->m_module); if (numfree < PyCFunction_MAXFREELIST) { m->m_self = (PyObject *)free_list; free_list = m; numfree++; } else { PyObject_GC_Del(m); } }
static void instancemethod_dealloc(PyObject *self) { _PyObject_GC_UNTRACK(self); Py_DECREF(PyInstanceMethod_GET_FUNCTION(self)); PyObject_GC_Del(self); }