object with room for n items. In addition to the refcount and type pointer
fields, this also fills in the ob_size field.
- - PyObject_Del(op) releases the memory allocated for an object. It does not
+ - PyObject_Free(op) releases the memory allocated for an object. It does not
run a destructor -- it only frees the memory. PyObject_Free is identical.
- PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't
// Deprecated aliases only kept for backward compatibility.
+// PyObject_Del and PyObject_DEL are defined with no parameter to be able to
+// use them as function pointers (ex: tp_free = PyObject_Del).
#define PyObject_MALLOC PyObject_Malloc
#define PyObject_REALLOC PyObject_Realloc
#define PyObject_FREE PyObject_Free
// Deprecated aliases only kept for backward compatibility.
+// PyMem_Del and PyMem_DEL are defined with no parameter to be able to use
+// them as function pointers (ex: dealloc = PyMem_Del).
#define PyMem_MALLOC(n) PyMem_Malloc(n)
#define PyMem_NEW(type, n) PyMem_New(type, n)
#define PyMem_REALLOC(p, n) PyMem_Realloc(p, n)
#define PyMem_RESIZE(p, type, n) PyMem_Resize(p, type, n)
#define PyMem_FREE(p) PyMem_Free(p)
-#define PyMem_Del(p) PyMem_Free(p)
-#define PyMem_DEL(p) PyMem_Free(p)
+#define PyMem_Del PyMem_Free
+#define PyMem_DEL PyMem_Free
#ifndef Py_LIMITED_API
}
PyTypeObject *type = Py_TYPE(self);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(type);
}
}
PyTypeObject *type = Py_TYPE(self);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(type);
}
PyCArg_dealloc(PyCArgObject *self)
{
Py_XDECREF(self->obj);
- PyObject_Del(self);
+ PyObject_Free(self);
}
static int
Py_DECREF(po->wo);
remove_lop(po);
}
- PyObject_DEL(po);
+ PyObject_Free(po);
Py_DECREF(tp);
}
if (wo->win != stdscr) delwin(wo->win);
if (wo->encoding != NULL)
PyMem_Free(wo->encoding);
- PyObject_DEL(wo);
+ PyObject_Free(wo);
}
/* Addch, Addstr, Addnstr */
{
Py_XDECREF(self->local);
Py_XDECREF(self->global);
- PyObject_Del(self);
+ PyObject_Free(self);
}
static PyObject *
{
Py_DECREF(ko->cmp);
Py_XDECREF(ko->object);
- PyObject_FREE(ko);
+ PyObject_Free(ko);
}
static int
{
Py_XDECREF(link->key);
Py_XDECREF(link->result);
- PyObject_Del(link);
+ PyObject_Free(link);
}
static PyTypeObject lru_list_elem_type = {
if (self->lock != NULL)
PyThread_free_lock(self->lock);
EVP_MD_CTX_free(self->ctx);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
error:
if (ctx) HMAC_CTX_free(ctx);
- if (self) PyObject_Del(self);
+ if (self) PyObject_Free(self);
return NULL;
}
PyThread_free_lock(self->lock);
}
HMAC_CTX_free(self->ctx);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
if (self->handle != SEM_FAILED)
SEM_CLOSE(self->handle);
PyMem_Free(self->name);
- PyObject_Del(self);
+ PyObject_Free(self);
}
/*[clinic input]
Py_DECREF(self->data[i]);
}
PyMem_Free(self->data);
- PyObject_Del(self);
+ PyObject_Free(self);
}
static PyTypeObject Pdata_Type = {
}
PyTypeObject *tp = Py_TYPE(self);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
Py_XDECREF(self->pattern);
Py_XDECREF(self->groupindex);
Py_XDECREF(self->indexgroup);
- PyObject_DEL(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
Py_XDECREF(self->regs);
Py_XDECREF(self->string);
Py_DECREF(self->pattern);
- PyObject_DEL(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
state_fini(&self->state);
Py_XDECREF(self->pattern);
- PyObject_DEL(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
Py_XDECREF(self->ctx);
Py_XDECREF(self->server_hostname);
Py_XDECREF(self->owner);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
ndbuf_pop(self);
}
}
- PyObject_Del(self);
+ PyObject_Free(self);
}
static int
static void
staticarray_dealloc(StaticArrayObject *self)
{
- PyObject_Del(self);
+ PyObject_Free(self);
}
/* Return a buffer for a PyBUF_FULL_RO request. Flags are not checked,
static void
test_structmembers_free(PyObject *ob)
{
- PyObject_FREE(ob);
+ PyObject_Free(ob);
}
static PyTypeObject test_structmembersType = {
heapctype_dealloc(HeapCTypeObject *self)
{
PyTypeObject *tp = Py_TYPE(self);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
PyTypeObject *tp = Py_TYPE(self);
Py_XDECREF(self->dict);
- PyObject_DEL(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
if (self->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self);
Py_XDECREF(self->weakreflist);
- PyObject_DEL(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
heapctypesetattr_dealloc(HeapCTypeSetattrObject *self)
{
PyTypeObject *tp = Py_TYPE(self);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
PyThread_release_lock(self->lock_lock);
PyThread_free_lock(self->lock_lock);
}
- PyObject_Del(self);
+ PyObject_Free(self);
}
/* Helper to acquire an interruptible lock with a timeout. If the lock acquire
PyObject *tp = (PyObject *) Py_TYPE(self);
Tcl_DecrRefCount(self->value);
Py_XDECREF(self->string);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
Py_XDECREF(func);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
ENTER_TCL
Tcl_DeleteInterp(Tkapp_Interp(self));
LEAVE_TCL
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
DisableEventHook();
}
static void
multibytecodec_dealloc(MultibyteCodecObject *self)
{
- PyObject_Del(self);
+ PyObject_Free(self);
}
static PyTypeObject MultibyteCodec_Type = {
}
PyGC_Head *g = AS_GC(op);
- g = (PyGC_Head *)PyObject_REALLOC(g, sizeof(PyGC_Head) + basicsize);
+ g = (PyGC_Head *)PyObject_Realloc(g, sizeof(PyGC_Head) + basicsize);
if (g == NULL)
return (PyVarObject *)PyErr_NoMemory();
op = (PyVarObject *) FROM_GC(g);
if (gcstate->generations[0].count > 0) {
gcstate->generations[0].count--;
}
- PyObject_FREE(g);
+ PyObject_Free(g);
}
int
MD5_dealloc(PyObject *ptr)
{
PyTypeObject *tp = Py_TYPE(ptr);
- PyObject_Del(ptr);
+ PyObject_Free(ptr);
Py_DECREF(tp);
}
/* if already closed, don't reclose it */
if (self->fd != -1)
close(self->fd);
- PyObject_Del(self);
+ PyObject_Free(self);
}
/* if already closed, don't reclose it */
if (self->fd != -1)
close(self->fd);
- PyObject_Del(self);
+ PyObject_Free(self);
}
SetLastError(olderr);
PyTypeObject *tp = Py_TYPE(self);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
if (self->ufds != NULL)
PyMem_Free(self->ufds);
Py_XDECREF(self->dict);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(type);
}
PyObject *type = (PyObject *)Py_TYPE(self);
(void)devpoll_internal_close(self);
PyMem_Free(self->fds);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(type);
}
SHA1_dealloc(PyObject *ptr)
{
PyTypeObject *tp = Py_TYPE(ptr);
- PyObject_Del(ptr);
+ PyObject_Free(ptr);
Py_DECREF(tp);
}
SHA_dealloc(PyObject *ptr)
{
PyTypeObject *tp = Py_TYPE(ptr);
- PyObject_Del(ptr);
+ PyObject_Free(ptr);
Py_DECREF(tp);
}
SHA512_dealloc(PyObject *ptr)
{
PyTypeObject *tp = Py_TYPE(ptr);
- PyObject_Del(ptr);
+ PyObject_Free(ptr);
Py_DECREF(tp);
}
ctx->pattern[1], ctx->pattern[2]));
/* install new repeat context */
- ctx->u.rep = (SRE_REPEAT*) PyObject_MALLOC(sizeof(*ctx->u.rep));
+ ctx->u.rep = (SRE_REPEAT*) PyObject_Malloc(sizeof(*ctx->u.rep));
if (!ctx->u.rep) {
PyErr_NoMemory();
RETURN_FAILURE;
state->ptr = ctx->ptr;
DO_JUMP(JUMP_REPEAT, jump_repeat, ctx->pattern+ctx->pattern[0]);
state->repeat = ctx->u.rep->prev;
- PyObject_FREE(ctx->u.rep);
+ PyObject_Free(ctx->u.rep);
if (ret) {
RETURN_ON_ERROR(ret);
ucd_dealloc(PreviousDBVersion *self)
{
PyTypeObject *tp = Py_TYPE(self);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(tp);
}
Xxo_dealloc(XxoObject *self)
{
Py_XDECREF(self->x_attr);
- PyObject_Del(self);
+ PyObject_Free(self);
}
static PyObject *
Py_XDECREF(self->unused_data);
Py_XDECREF(self->unconsumed_tail);
Py_XDECREF(self->zdict);
- PyObject_Del(self);
+ PyObject_Free(self);
Py_DECREF(type);
}
}
/* Inline PyObject_NewVar */
- op = (PyBytesObject *)PyObject_MALLOC(PyBytesObject_SIZE + size);
+ op = (PyBytesObject *)PyObject_Malloc(PyBytesObject_SIZE + size);
if (op == NULL) {
return PyErr_NoMemory();
}
"repeated bytes are too long");
return NULL;
}
- op = (PyBytesObject *)PyObject_MALLOC(PyBytesObject_SIZE + nbytes);
+ op = (PyBytesObject *)PyObject_Malloc(PyBytesObject_SIZE + nbytes);
if (op == NULL) {
return PyErr_NoMemory();
}
_Py_ForgetReference(v);
#endif
*pv = (PyObject *)
- PyObject_REALLOC(v, PyBytesObject_SIZE + newsize);
+ PyObject_Realloc(v, PyBytesObject_SIZE + newsize);
if (*pv == NULL) {
- PyObject_Del(v);
+ PyObject_Free(v);
PyErr_NoMemory();
return -1;
}
if (capsule->destructor) {
capsule->destructor(o);
}
- PyObject_DEL(o);
+ PyObject_Free(o);
}
PyObject_GC_Del(co->co_zombieframe);
if (co->co_weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject*)co);
- PyObject_DEL(co);
+ PyObject_Free(co);
}
static PyObject *
PyComplex_FromCComplex(Py_complex cval)
{
/* Inline PyObject_New */
- PyComplexObject *op = PyObject_MALLOC(sizeof(PyComplexObject));
+ PyComplexObject *op = PyObject_Malloc(sizeof(PyComplexObject));
if (op == NULL) {
return PyErr_NoMemory();
}
PyObject_GC_Del(op);
}
while (state->keys_numfree) {
- PyObject_FREE(state->keys_free_list[--state->keys_numfree]);
+ PyObject_Free(state->keys_free_list[--state->keys_numfree]);
}
}
}
else
{
- dk = PyObject_MALLOC(sizeof(PyDictKeysObject)
+ dk = PyObject_Malloc(sizeof(PyDictKeysObject)
+ es * size
+ sizeof(PyDictKeyEntry) * usable);
if (dk == NULL) {
state->keys_free_list[state->keys_numfree++] = keys;
return;
}
- PyObject_FREE(keys);
+ PyObject_Free(keys);
}
#define new_values(size) PyMem_NEW(PyObject *, size)
state->keys_free_list[state->keys_numfree++] = oldkeys;
}
else {
- PyObject_FREE(oldkeys);
+ PyObject_Free(oldkeys);
}
}
assert(state->numfree != -1);
#endif
if (state->numfree >= PyFloat_MAXFREELIST) {
- PyObject_FREE(op);
+ PyObject_Free(op);
return;
}
state->numfree++;
PyFloatObject *f = state->free_list;
while (f != NULL) {
PyFloatObject *next = (PyFloatObject*) Py_TYPE(f);
- PyObject_FREE(f);
+ PyObject_Free(f);
f = next;
}
state->free_list = NULL;
"too many digits in integer");
return NULL;
}
- result = PyObject_MALLOC(offsetof(PyLongObject, ob_digit) +
+ result = PyObject_Malloc(offsetof(PyLongObject, ob_digit) +
size*sizeof(digit));
if (!result) {
PyErr_NoMemory();
PyObject *
_PyObject_New(PyTypeObject *tp)
{
- PyObject *op = (PyObject *) PyObject_MALLOC(_PyObject_SIZE(tp));
+ PyObject *op = (PyObject *) PyObject_Malloc(_PyObject_SIZE(tp));
if (op == NULL) {
return PyErr_NoMemory();
}
{
PyVarObject *op;
const size_t size = _PyObject_VAR_SIZE(tp, nitems);
- op = (PyVarObject *) PyObject_MALLOC(size);
+ op = (PyVarObject *) PyObject_Malloc(size);
if (op == NULL) {
return (PyVarObject *)PyErr_NoMemory();
}
- implement a fuller MutableMapping API in C?
- move the MutableMapping implementation to abstract.c?
- optimize mutablemapping_update
-- use PyObject_MALLOC (small object allocator) for odict nodes?
+- use PyObject_Malloc (small object allocator) for odict nodes?
- support subclasses better (e.g. in odict_richcompare)
*/
Py_DECREF(r->stop);
Py_DECREF(r->step);
Py_DECREF(r->length);
- PyObject_Del(r);
+ PyObject_Free(r);
}
/* Return number of items in range (lo, hi, step) as a PyLong object,
Py_XDECREF(r->start);
Py_XDECREF(r->step);
Py_XDECREF(r->len);
- PyObject_Del(r);
+ PyObject_Free(r);
}
static PyObject *
formatteriter_dealloc(formatteriterobject *it)
{
Py_XDECREF(it->str);
- PyObject_FREE(it);
+ PyObject_Free(it);
}
/* returns a tuple:
fieldnameiter_dealloc(fieldnameiterobject *it)
{
Py_XDECREF(it->str);
- PyObject_FREE(it);
+ PyObject_Free(it);
}
/* returns a tuple:
obj = _PyObject_GC_Malloc(size);
}
else {
- obj = (PyObject *)PyObject_MALLOC(size);
+ obj = (PyObject *)PyObject_Malloc(size);
}
if (obj == NULL) {
goto error;
/* Silently truncate the docstring if it contains null bytes. */
len = strlen(doc_str);
- tp_doc = (char *)PyObject_MALLOC(len + 1);
+ tp_doc = (char *)PyObject_Malloc(len + 1);
if (tp_doc == NULL) {
PyErr_NoMemory();
goto error;
continue;
}
size_t len = strlen(slot->pfunc)+1;
- char *tp_doc = PyObject_MALLOC(len);
+ char *tp_doc = PyObject_Malloc(len);
if (tp_doc == NULL) {
type->tp_doc = NULL;
PyErr_NoMemory();
new_size = (struct_size + (length + 1) * char_size);
if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {
- PyObject_DEL(_PyUnicode_UTF8(unicode));
+ PyObject_Free(_PyUnicode_UTF8(unicode));
_PyUnicode_UTF8(unicode) = NULL;
_PyUnicode_UTF8_LENGTH(unicode) = 0;
}
_Py_ForgetReference(unicode);
#endif
- new_unicode = (PyObject *)PyObject_REALLOC(unicode, new_size);
+ new_unicode = (PyObject *)PyObject_Realloc(unicode, new_size);
if (new_unicode == NULL) {
_Py_NewReference(unicode);
PyErr_NoMemory();
_PyUnicode_WSTR_LENGTH(unicode) = length;
}
else if (_PyUnicode_HAS_WSTR_MEMORY(unicode)) {
- PyObject_DEL(_PyUnicode_WSTR(unicode));
+ PyObject_Free(_PyUnicode_WSTR(unicode));
_PyUnicode_WSTR(unicode) = NULL;
if (!PyUnicode_IS_ASCII(unicode))
_PyUnicode_WSTR_LENGTH(unicode) = 0;
if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode))
{
- PyObject_DEL(_PyUnicode_UTF8(unicode));
+ PyObject_Free(_PyUnicode_UTF8(unicode));
_PyUnicode_UTF8(unicode) = NULL;
_PyUnicode_UTF8_LENGTH(unicode) = 0;
}
- data = (PyObject *)PyObject_REALLOC(data, new_size);
+ data = (PyObject *)PyObject_Realloc(data, new_size);
if (data == NULL) {
PyErr_NoMemory();
return -1;
}
new_size = sizeof(wchar_t) * (length + 1);
wstr = _PyUnicode_WSTR(unicode);
- wstr = PyObject_REALLOC(wstr, new_size);
+ wstr = PyObject_Realloc(wstr, new_size);
if (!wstr) {
PyErr_NoMemory();
return -1;
_PyUnicode_UTF8(unicode) = NULL;
_PyUnicode_UTF8_LENGTH(unicode) = 0;
- _PyUnicode_WSTR(unicode) = (Py_UNICODE*) PyObject_MALLOC(new_size);
+ _PyUnicode_WSTR(unicode) = (Py_UNICODE*) PyObject_Malloc(new_size);
if (!_PyUnicode_WSTR(unicode)) {
Py_DECREF(unicode);
PyErr_NoMemory();
* PyObject_New() so we are able to allocate space for the object and
* it's data buffer.
*/
- obj = (PyObject *) PyObject_MALLOC(struct_size + (size + 1) * char_size);
+ obj = (PyObject *) PyObject_Malloc(struct_size + (size + 1) * char_size);
if (obj == NULL) {
return PyErr_NoMemory();
}
return -1;
if (maxchar < 256) {
- _PyUnicode_DATA_ANY(unicode) = PyObject_MALLOC(_PyUnicode_WSTR_LENGTH(unicode) + 1);
+ _PyUnicode_DATA_ANY(unicode) = PyObject_Malloc(_PyUnicode_WSTR_LENGTH(unicode) + 1);
if (!_PyUnicode_DATA_ANY(unicode)) {
PyErr_NoMemory();
return -1;
_PyUnicode_UTF8(unicode) = NULL;
_PyUnicode_UTF8_LENGTH(unicode) = 0;
}
- PyObject_FREE(_PyUnicode_WSTR(unicode));
+ PyObject_Free(_PyUnicode_WSTR(unicode));
_PyUnicode_WSTR(unicode) = NULL;
_PyUnicode_WSTR_LENGTH(unicode) = 0;
}
_PyUnicode_UTF8_LENGTH(unicode) = 0;
#else
/* sizeof(wchar_t) == 4 */
- _PyUnicode_DATA_ANY(unicode) = PyObject_MALLOC(
+ _PyUnicode_DATA_ANY(unicode) = PyObject_Malloc(
2 * (_PyUnicode_WSTR_LENGTH(unicode) + 1));
if (!_PyUnicode_DATA_ANY(unicode)) {
PyErr_NoMemory();
_PyUnicode_STATE(unicode).kind = PyUnicode_2BYTE_KIND;
_PyUnicode_UTF8(unicode) = NULL;
_PyUnicode_UTF8_LENGTH(unicode) = 0;
- PyObject_FREE(_PyUnicode_WSTR(unicode));
+ PyObject_Free(_PyUnicode_WSTR(unicode));
_PyUnicode_WSTR(unicode) = NULL;
_PyUnicode_WSTR_LENGTH(unicode) = 0;
#endif
PyErr_NoMemory();
return -1;
}
- _PyUnicode_DATA_ANY(unicode) = PyObject_MALLOC(4 * (length_wo_surrogates + 1));
+ _PyUnicode_DATA_ANY(unicode) = PyObject_Malloc(4 * (length_wo_surrogates + 1));
if (!_PyUnicode_DATA_ANY(unicode)) {
PyErr_NoMemory();
return -1;
/* unicode_convert_wchar_to_ucs4() requires a ready string */
_PyUnicode_STATE(unicode).ready = 1;
unicode_convert_wchar_to_ucs4(_PyUnicode_WSTR(unicode), end, unicode);
- PyObject_FREE(_PyUnicode_WSTR(unicode));
+ PyObject_Free(_PyUnicode_WSTR(unicode));
_PyUnicode_WSTR(unicode) = NULL;
_PyUnicode_WSTR_LENGTH(unicode) = 0;
#else
}
if (_PyUnicode_HAS_WSTR_MEMORY(unicode)) {
- PyObject_DEL(_PyUnicode_WSTR(unicode));
+ PyObject_Free(_PyUnicode_WSTR(unicode));
}
if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {
- PyObject_DEL(_PyUnicode_UTF8(unicode));
+ PyObject_Free(_PyUnicode_UTF8(unicode));
}
if (!PyUnicode_IS_COMPACT(unicode) && _PyUnicode_DATA_ANY(unicode)) {
- PyObject_DEL(_PyUnicode_DATA_ANY(unicode));
+ PyObject_Free(_PyUnicode_DATA_ANY(unicode));
}
Py_TYPE(unicode)->tp_free(unicode);
PyErr_NoMemory();
return NULL;
}
- w = (wchar_t *) PyObject_MALLOC(sizeof(wchar_t) * (wlen + 1));
+ w = (wchar_t *) PyObject_Malloc(sizeof(wchar_t) * (wlen + 1));
if (w == NULL) {
PyErr_NoMemory();
return NULL;
PyBytes_AS_STRING(writer.buffer);
Py_ssize_t len = end - start;
- char *cache = PyObject_MALLOC(len + 1);
+ char *cache = PyObject_Malloc(len + 1);
if (cache == NULL) {
_PyBytesWriter_Dealloc(&writer);
PyErr_NoMemory();
}
/* Create a three-level trie */
- result = PyObject_MALLOC(sizeof(struct encoding_map) +
+ result = PyObject_Malloc(sizeof(struct encoding_map) +
16*count2 + 128*count3 - 1);
if (!result) {
return PyErr_NoMemory();
PyErr_NoMemory();
goto onError;
}
- data = PyObject_MALLOC((length + 1) * char_size);
+ data = PyObject_Malloc((length + 1) * char_size);
if (data == NULL) {
PyErr_NoMemory();
goto onError;
{
MsiCloseHandle(msidb->h);
msidb->h = 0;
- PyObject_Del(msidb);
+ PyObject_Free(msidb);
}
static PyObject*
PyHKEYObject *obkey = (PyHKEYObject *)ob;
if (obkey->hkey)
RegCloseKey((HKEY)obkey->hkey);
- PyObject_DEL(ob);
+ PyObject_Free(ob);
}
static int
PyHKEY_FromHKEY(HKEY h)
{
/* Inline PyObject_New */
- PyHKEYObject *op = (PyHKEYObject *) PyObject_MALLOC(sizeof(PyHKEYObject));
+ PyHKEYObject *op = (PyHKEYObject *) PyObject_Malloc(sizeof(PyHKEYObject));
if (op == NULL) {
return PyErr_NoMemory();
}
Py_XDECREF(ste->ste_varnames);
Py_XDECREF(ste->ste_children);
Py_XDECREF(ste->ste_directives);
- PyObject_Del(ste);
+ PyObject_Free(ste);
}
#define OFF(x) offsetof(PySTEntryObject, x)
projects / thirdparty / Python / cpython.git / commitdiff
