static void resulttuple_dealloc(PyObject *self) {
Py_ssize_t i, len;
PyObject_GC_UnTrack (self);
Py_TRASHCAN_SAFE_BEGIN (self)
/* Free the tuple items and, if there is space, save the tuple object
* pointer to the front of the free list for its size. Otherwise free it.
*/
len = Py_SIZE (self);
if (len > 0) {
for (i=0; i < len; i++) {
Py_XDECREF (PyTuple_GET_ITEM (self, i));
}
if (len < PyGIResultTuple_MAXSAVESIZE && numfree[len] < PyGIResultTuple_MAXFREELIST) {
PyTuple_SET_ITEM (self, 0, free_list[len]);
numfree[len]++;
free_list[len] = self;
goto done;
}
}
Py_TYPE (self)->tp_free (self);
done:
Py_TRASHCAN_SAFE_END (self)
}
static void
frame_dealloc(PyFrameObject *f)
{
int i;
PyObject **fastlocals;
Py_TRASHCAN_SAFE_BEGIN(f)
/* Kill all local variables */
fastlocals = f->f_localsplus;
for (i = f->f_nlocals; --i >= 0; ++fastlocals) {
Py_XDECREF(*fastlocals);
}
Py_XDECREF(f->f_back);
Py_XDECREF(f->f_code);
Py_XDECREF(f->f_builtins);
Py_XDECREF(f->f_globals);
Py_XDECREF(f->f_locals);
Py_XDECREF(f->f_trace);
Py_XDECREF(f->f_exc_type);
Py_XDECREF(f->f_exc_value);
Py_XDECREF(f->f_exc_traceback);
f->f_back = free_list;
free_list = f;
Py_TRASHCAN_SAFE_END(f)
}
static void pair_dealloc(PyObject *self) {
// checked
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
Py_CLEAR(SibPair_CAR(self));
Py_CLEAR(SibPair_CDR(self));
Py_CLEAR(((SibPair *) self)->position);
if (pair_free_count < PAIR_MAX_FREE) {
SibPair_CDR(self) = (PyObject *) pair_free_list;
pair_free_list = (SibPair *) self;
pair_free_count++;
// printf("saving SibPair for later, count=%i\n", pair_free_count);
} else {
// printf("plenty of SibPair, not recycling\n");
// Py_TYPE(self)->tp_free(self);
PyObject_GC_Del(self);
}
Py_TRASHCAN_SAFE_END(self);
}
static void
cb_dealloc(ConnectionBaseObject *self)
{
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
Py_XDECREF(self->transaction_serial);
PyObject_GC_Del(self);
Py_TRASHCAN_SAFE_END(self);
}
static void
wrapper_dealloc(wrapperobject *wp)
{
PyObject_GC_UnTrack(wp);
Py_TRASHCAN_SAFE_BEGIN(wp)
Py_XDECREF(wp->descr);
Py_XDECREF(wp->self);
PyObject_GC_Del(wp);
Py_TRASHCAN_SAFE_END(wp)
}
static void
tb_dealloc(PyTracebackObject *tb)
{
PyObject_GC_UnTrack(tb);
Py_TRASHCAN_SAFE_BEGIN(tb)
Py_XDECREF(tb->tb_next);
Py_XDECREF(tb->tb_frame);
PyObject_GC_Del(tb);
Py_TRASHCAN_SAFE_END(tb)
}
static void
TimerObject_dealloc(TimerObject *self)
{
GDEBUG("self %p", self);
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
TimerObject_clear(self);
PyObject_GC_Del(self);
Py_TRASHCAN_SAFE_END(self);
}
static void m_deepin_lunar_dealloc(DeepinLunarObject *self)
{
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self)
ZAP(self->dict);
m_delete(self);
PyObject_GC_Del(self);
Py_TRASHCAN_SAFE_END(self)
}
static void
ConditionObject_dealloc(ConditionObject *self)
{
GDEBUG("self %p", self);
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
ConditionObject_clear(self);
Py_CLEAR(self->dict);
Py_TYPE(self)->tp_free((PyObject*)self);
Py_TRASHCAN_SAFE_END(self);
}
static void
pb_dealloc(PersistentBaseObject *self)
{
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
Py_XDECREF(self->p_connection);
Py_XDECREF(self->p_oid);
Py_XDECREF(self->p_serial);
PyObject_GC_Del(self);
Py_TRASHCAN_SAFE_END(self);
}
PYCURL_INTERNAL void
do_multi_dealloc(CurlMultiObject *self)
{
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
util_multi_xdecref(self);
util_multi_close(self);
Py_TRASHCAN_SAFE_END(self);
CurlMulti_Type.tp_free(self);
}
static void green_dealloc(PyGreenlet* self)
{
PyObject_GC_UnTrack((PyObject *)self);
if (PyObject_IS_GC((PyObject *)self)) {
Py_TRASHCAN_SAFE_BEGIN(self);
green_dealloc_safe(self);
Py_TRASHCAN_SAFE_END(self);
} else {
/* This object cannot be garbage collected, so trashcan is not allowed */
green_dealloc_safe(self);
}
}
static void
frame_dealloc(PyFrameObject *f)
{
PyObject **p, **valuestack;
PyCodeObject *co;
Py_GUARD();
#ifdef WITH_PARALLEL
/* We crash during shutdown if this isn't in place. */
if (_PyParallel_IsFinalized())
return;
#endif
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);
Py_CLEAR(f->f_exc_type);
Py_CLEAR(f->f_exc_value);
Py_CLEAR(f->f_exc_traceback);
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)
}
PYCURL_INTERNAL void
do_share_dealloc(CurlShareObject *self)
{
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
Py_CLEAR(self->dict);
util_share_close(self);
#ifdef WITH_THREAD
share_lock_destroy(self->lock);
#endif
CurlShare_Type.tp_free(self);
Py_TRASHCAN_SAFE_END(self);
}
static void
frame_dealloc(PyFrameObject *f)
{
PyObject **p, **valuestack;
PyCodeObject *co;
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);
Py_CLEAR(f->f_exc_type);
Py_CLEAR(f->f_exc_value);
Py_CLEAR(f->f_exc_traceback);
co = f->f_code;
if (co->co_zombieframe == NULL)
co->co_zombieframe = f;
else if (numfree < 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 green_dealloc(PyGreenlet* self)
{
PyObject *error_type, *error_value, *error_traceback;
#ifdef GREENLET_USE_GC
PyObject_GC_UnTrack((PyObject *)self);
Py_TRASHCAN_SAFE_BEGIN(self);
#endif /* GREENLET_USE_GC */
if (PyGreenlet_ACTIVE(self) && self->run_info != NULL && !PyGreenlet_MAIN(self)) {
/* Hacks hacks hacks copied from instance_dealloc() */
/* Temporarily resurrect the greenlet. */
assert(Py_REFCNT(self) == 0);
Py_REFCNT(self) = 1;
/* Save the current exception, if any. */
PyErr_Fetch(&error_type, &error_value, &error_traceback);
if (kill_greenlet(self) < 0) {
PyErr_WriteUnraisable((PyObject*) self);
/* XXX what else should we do? */
}
/* Check for no resurrection must be done while we keep
* our internal reference, otherwise PyFile_WriteObject
* causes recursion if using Py_INCREF/Py_DECREF
*/
if (Py_REFCNT(self) == 1 && PyGreenlet_ACTIVE(self)) {
/* Not resurrected, but still not dead!
XXX what else should we do? we complain. */
PyObject* f = PySys_GetObject("stderr");
Py_INCREF(self); /* leak! */
if (f != NULL) {
PyFile_WriteString("GreenletExit did not kill ",
f);
PyFile_WriteObject((PyObject*) self, f, 0);
PyFile_WriteString("\n", f);
}
}
/* Restore the saved exception. */
PyErr_Restore(error_type, error_value, error_traceback);
/* Undo the temporary resurrection; can't use DECREF here,
* it would cause a recursive call.
*/
assert(Py_REFCNT(self) > 0);
if (--Py_REFCNT(self) != 0) {
/* Resurrected! */
Py_ssize_t refcnt = Py_REFCNT(self);
_Py_NewReference((PyObject*) self);
Py_REFCNT(self) = refcnt;
#ifdef GREENLET_USE_GC
PyObject_GC_Track((PyObject *)self);
#endif
_Py_DEC_REFTOTAL;
#ifdef COUNT_ALLOCS
--Py_TYPE(self)->tp_frees;
--Py_TYPE(self)->tp_allocs;
#endif /* COUNT_ALLOCS */
goto green_dealloc_end;
}
}
if (self->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self);
Py_CLEAR(self->parent);
Py_CLEAR(self->run_info);
Py_CLEAR(self->exc_type);
Py_CLEAR(self->exc_value);
Py_CLEAR(self->exc_traceback);
Py_CLEAR(self->dict);
Py_TYPE(self)->tp_free((PyObject*) self);
green_dealloc_end:
#ifdef GREENLET_USE_GC
Py_TRASHCAN_SAFE_END(self);
#endif /* GREENLET_USE_GC */
return;
}
