For more comments, read the patches@python.org archives.
For documentation read the comments in mymalloc.h and objimpl.h.
(This is not exactly what Vladimir posted to the patches list; I've
made a few changes, and Vladimir sent me a fix in private email for a
problem that only occurs in debug mode. I'm also holding back on his
change to main.c, which seems unnecessary to me.)
#include <stdlib.h>
#endif
+#include "myproto.h"
+
#ifdef __cplusplus
/* Move this down here since some C++ #include's don't like to be included
inside an extern "C" */
#pragma lib_export on
#endif
-/* The following should never be necessary */
-#ifdef NEED_TO_DECLARE_MALLOC_AND_FRIEND
-extern ANY *malloc Py_PROTO((size_t));
-extern ANY *calloc Py_PROTO((size_t, size_t));
-extern ANY *realloc Py_PROTO((ANY *, size_t));
-extern void free Py_PROTO((ANY *)); /* XXX sometimes int on Unix old systems */
+#ifndef DL_IMPORT /* declarations for DLL import */
+#define DL_IMPORT(RTYPE) RTYPE
#endif
#ifndef NULL
#define _PyMem_EXTRA 0
#endif
-#define PyMem_NEW(type, n) \
- ( (type *) malloc(_PyMem_EXTRA + (n) * sizeof(type)) )
-#define PyMem_RESIZE(p, type, n) \
- if ((p) == NULL) \
- (p) = (type *) malloc(_PyMem_EXTRA + (n) * sizeof(type)); \
- else \
- (p) = (type *) realloc((ANY *)(p), \
- _PyMem_EXTRA + (n) * sizeof(type))
-#define PyMem_DEL(p) free((ANY *)p)
-#define PyMem_XDEL(p) if ((p) == NULL) ; else PyMem_DEL(p)
+/*
+ * Core memory allocator
+ * =====================
+ */
+/* To make sure the interpreter is user-malloc friendly, all memory
+ APIs are implemented on top of this one.
-/* Two sets of function wrappers around malloc and friends; useful if
- you need to be sure that you are using the same memory allocator as
- Python. Note that the wrappers make sure that allocating 0 bytes
- returns a non-NULL pointer, even if the underlying malloc doesn't.
- The Python interpreter continues to use PyMem_NEW etc. */
+ The PyCore_* macros can be defined to make the interpreter use a
+ custom allocator. Note that they are for internal use only. Both
+ the core and extension modules should use the PyMem_* API. */
+
+#ifndef PyCore_MALLOC_FUNC
+#undef PyCore_REALLOC_FUNC
+#undef PyCore_FREE_FUNC
+#define PyCore_MALLOC_FUNC malloc
+#define PyCore_REALLOC_FUNC realloc
+#define PyCore_FREE_FUNC free
+#endif
+
+#ifndef PyCore_MALLOC_PROTO
+#undef PyCore_REALLOC_PROTO
+#undef PyCore_FREE_PROTO
+#define PyCore_MALLOC_PROTO Py_PROTO((size_t))
+#define PyCore_REALLOC_PROTO Py_PROTO((ANY *, size_t))
+#define PyCore_FREE_PROTO Py_PROTO((ANY *))
+#endif
+
+#ifdef NEED_TO_DECLARE_MALLOC_AND_FRIEND
+extern ANY *PyCore_MALLOC_FUNC PyCore_MALLOC_PROTO;
+extern ANY *PyCore_REALLOC_FUNC PyCore_REALLOC_PROTO;
+extern void PyCore_FREE_FUNC PyCore_FREE_PROTO;
+#endif
+
+#ifndef PyCore_MALLOC
+#undef PyCore_REALLOC
+#undef PyCore_FREE
+#define PyCore_MALLOC(n) PyCore_MALLOC_FUNC(n)
+#define PyCore_REALLOC(p, n) PyCore_REALLOC_FUNC((p), (n))
+#define PyCore_FREE(p) PyCore_FREE_FUNC(p)
+#endif
-/* These wrappers around malloc call PyErr_NoMemory() on failure */
-extern DL_IMPORT(ANY *) Py_Malloc Py_PROTO((size_t));
-extern DL_IMPORT(ANY *) Py_Realloc Py_PROTO((ANY *, size_t));
-extern DL_IMPORT(void) Py_Free Py_PROTO((ANY *));
+/* BEWARE:
-/* These wrappers around malloc *don't* call anything on failure */
+ Each interface exports both functions and macros. Extension modules
+ should normally use the functions for ensuring binary compatibility
+ of the user's code across Python versions. Subsequently, if the
+ Python runtime switches to its own malloc (different from standard
+ malloc), no recompilation is required for the extensions.
+
+ The macro versions trade compatibility for speed. They can be used
+ whenever there is a performance problem, but their use implies
+ recompilation of the code for each new Python release. The Python
+ core uses the macros because it *is* compiled on every upgrade.
+ This might not be the case with 3rd party extensions in a custom
+ setup (for example, a customer does not always have access to the
+ source of 3rd party deliverables). You have been warned! */
+
+/*
+ * Raw memory interface
+ * ====================
+ */
+
+/* Functions */
+
+/* Function wrappers around PyCore_MALLOC and friends; useful if you
+ need to be sure that you are using the same memory allocator as
+ Python. Note that the wrappers make sure that allocating 0 bytes
+ returns a non-NULL pointer, even if the underlying malloc
+ doesn't. Returned pointers must be checked for NULL explicitly.
+ No action is performed on failure. */
extern DL_IMPORT(ANY *) PyMem_Malloc Py_PROTO((size_t));
extern DL_IMPORT(ANY *) PyMem_Realloc Py_PROTO((ANY *, size_t));
extern DL_IMPORT(void) PyMem_Free Py_PROTO((ANY *));
+/* Starting from Python 1.6, the wrappers Py_{Malloc,Realloc,Free} are
+ no longer supported. They used to call PyErr_NoMemory() on failure. */
+
+/* Macros */
+#define PyMem_MALLOC(n) PyCore_MALLOC(n)
+#define PyMem_REALLOC(p, n) PyCore_REALLOC((ANY *)(p), (n))
+#define PyMem_FREE(p) PyCore_FREE((ANY *)(p))
+
+/*
+ * Type-oriented memory interface
+ * ==============================
+ */
+
+/* Functions */
+#define PyMem_New(type, n) \
+ ( (type *) PyMem_Malloc((n) * sizeof(type)) )
+#define PyMem_Resize(p, type, n) \
+ ( (p) = (type *) PyMem_Realloc((n) * sizeof(type)) )
+#define PyMem_Del(p) PyMem_Free(p)
+
+/* Macros */
+#define PyMem_NEW(type, n) \
+ ( (type *) PyMem_MALLOC(_PyMem_EXTRA + (n) * sizeof(type)) )
+#define PyMem_RESIZE(p, type, n) \
+ if ((p) == NULL) \
+ (p) = (type *)(PyMem_MALLOC( \
+ _PyMem_EXTRA + (n) * sizeof(type))); \
+ else \
+ (p) = (type *)(PyMem_REALLOC((p), \
+ _PyMem_EXTRA + (n) * sizeof(type)))
+#define PyMem_DEL(p) PyMem_FREE(p)
+
+/* PyMem_XDEL is deprecated. To avoid the call when p is NULL,
+ it is recommended to write the test explicitly in the code.
+ Note that according to ANSI C, free(NULL) has no effect. */
+
#ifdef __cplusplus
}
#endif
******************************************************************/
+#include "mymalloc.h"
+
/*
-Additional macros for modules that implement new object types.
+Functions and macros for modules that implement new object types.
You must first include "object.h".
-PyObject_NEW(type, typeobj) allocates memory for a new object of the given
-type; here 'type' must be the C structure type used to represent the
-object and 'typeobj' the address of the corresponding type object.
-Reference count and type pointer are filled in; the rest of the bytes of
-the object are *undefined*! The resulting expression type is 'type *'.
-The size of the object is actually determined by the tp_basicsize field
-of the type object.
+ - PyObject_New(type, typeobj) allocates memory for a new object of
+ the given type; here 'type' must be the C structure type used to
+ represent the object and 'typeobj' the address of the corresponding
+ type object. Reference count and type pointer are filled in; the
+ rest of the bytes of the object are *undefined*! The resulting
+ expression type is 'type *'. The size of the object is actually
+ determined by the tp_basicsize field of the type object.
+
+ - PyObject_NewVar(type, typeobj, n) is similar but allocates a
+ variable-size object with n extra items. The size is computed as
+ tp_basicsize plus n * tp_itemsize. This fills in the ob_size field
+ as well.
+
+ - PyObject_Del(op) releases the memory allocated for an object.
+
+ - PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) are
+ similar to PyObject_{New, NewVar} except that they don't allocate
+ the memory needed for an object. Instead of the 'type' parameter,
+ they accept the pointer of a new object (allocated by an arbitrary
+ allocator) and initialize its object header fields.
+
+Note that objects created with PyObject_{New, NewVar} are allocated
+within the Python heap by an object allocator, the latter being
+implemented (by default) on top of the Python raw memory
+allocator. This ensures that Python keeps control on the user's
+objects regarding their memory management; for instance, they may be
+subject to automatic garbage collection.
+
+In case a specific form of memory management is needed, implying that
+the objects would not reside in the Python heap (for example standard
+malloc heap(s) are mandatory, use of shared memory, C++ local storage
+or operator new), you must first allocate the object with your custom
+allocator, then pass its pointer to PyObject_{Init, InitVar} for
+filling in its Python-specific fields: reference count, type pointer,
+possibly others. You should be aware that Python has very limited
+control over these objects because they don't cooperate with the
+Python memory manager. Such objects may not be eligible for automatic
+garbage collection and you have to make sure that they are released
+accordingly whenever their destructor gets called (cf. the specific
+form of memory management you're using).
+
+Unless you have specific memory management requirements, it is
+recommended to use PyObject_{New, NewVar, Del}. */
+
+/*
+ * Core object memory allocator
+ * ============================
+ */
-PyObject_NEW_VAR(type, typeobj, n) is similar but allocates a variable-size
-object with n extra items. The size is computed as tp_basicsize plus
-n * tp_itemsize. This fills in the ob_size field as well.
-*/
+/* The purpose of the object allocator is to make make the distinction
+ between "object memory" and the rest within the Python heap.
+
+ Object memory is the one allocated by PyObject_{New, NewVar}, i.e.
+ the one that holds the object's representation defined by its C
+ type structure, *excluding* any object-specific memory buffers that
+ might be referenced by the structure (for type structures that have
+ pointer fields). By default, the object memory allocator is
+ implemented on top of the raw memory allocator.
-#ifndef MS_COREDLL
+ The PyCore_* macros can be defined to make the interpreter use a
+ custom object memory allocator. They are reserved for internal
+ memory management purposes exclusively. Both the core and extension
+ modules should use the PyObject_* API. */
+
+#ifndef PyCore_OBJECT_MALLOC_FUNC
+#undef PyCore_OBJECT_REALLOC_FUNC
+#undef PyCore_OBJECT_FREE_FUNC
+#define PyCore_OBJECT_MALLOC_FUNC PyCore_MALLOC_FUNC
+#define PyCore_OBJECT_REALLOC_FUNC PyCore_REALLOC_FUNC
+#define PyCore_OBJECT_FREE_FUNC PyCore_FREE_FUNC
+#endif
+
+#ifndef PyCore_OBJECT_MALLOC_PROTO
+#undef PyCore_OBJECT_REALLOC_PROTO
+#undef PyCore_OBJECT_FREE_PROTO
+#define PyCore_OBJECT_MALLOC_PROTO PyCore_MALLOC_PROTO
+#define PyCore_OBJECT_REALLOC_PROTO PyCore_REALLOC_PROTO
+#define PyCore_OBJECT_FREE_PROTO PyCore_FREE_PROTO
+#endif
+
+#ifdef NEED_TO_DECLARE_OBJECT_MALLOC_AND_FRIEND
+extern ANY *PyCore_OBJECT_MALLOC_FUNC PyCore_OBJECT_MALLOC_PROTO;
+extern ANY *PyCore_OBJECT_REALLOC_FUNC PyCore_OBJECT_REALLOC_PROTO;
+extern void PyCore_OBJECT_FREE_FUNC PyCore_OBJECT_FREE_PROTO;
+#endif
+
+#ifndef PyCore_OBJECT_MALLOC
+#undef PyCore_OBJECT_REALLOC
+#undef PyCore_OBJECT_FREE
+#define PyCore_OBJECT_MALLOC(n) PyCore_OBJECT_MALLOC_FUNC(n)
+#define PyCore_OBJECT_REALLOC(p, n) PyCore_OBJECT_REALLOC_FUNC((p), (n))
+#define PyCore_OBJECT_FREE(p) PyCore_OBJECT_FREE_FUNC(p)
+#endif
+
+/*
+ * Raw object memory interface
+ * ===========================
+ */
+
+/* The use of this API should be avoided, unless a builtin object
+ constructor inlines PyObject_{New, NewVar}, either because the
+ latter functions cannot allocate the exact amount of needed memory,
+ either for speed. This situation is exceptional, but occurs for
+ some object constructors (PyBuffer_New, PyList_New...). Inlining
+ PyObject_{New, NewVar} for objects that are supposed to belong to
+ the Python heap is discouraged. If you really have to, make sure
+ the object is initialized with PyObject_{Init, InitVar}. Do *not*
+ inline PyObject_{Init, InitVar} for user-extension types or you
+ might seriously interfere with Python's memory management. */
+
+/* Functions */
+
+/* Wrappers around PyCore_OBJECT_MALLOC and friends; useful if you
+ need to be sure that you are using the same object memory allocator
+ as Python. These wrappers *do not* make sure that allocating 0
+ bytes returns a non-NULL pointer. Returned pointers must be checked
+ for NULL explicitly; no action is performed on failure. */
+extern DL_IMPORT(ANY *) PyObject_Malloc Py_PROTO((size_t));
+extern DL_IMPORT(ANY *) PyObject_Realloc Py_PROTO((ANY *, size_t));
+extern DL_IMPORT(void) PyObject_Free Py_PROTO((ANY *));
+
+/* Macros */
+#define PyObject_MALLOC(n) PyCore_OBJECT_MALLOC(n)
+#define PyObject_REALLOC(op, n) PyCore_OBJECT_REALLOC((ANY *)(op), (n))
+#define PyObject_FREE(op) PyCore_OBJECT_FREE((ANY *)(op))
+
+/*
+ * Generic object allocator interface
+ * ==================================
+ */
+
+/* Functions */
+extern DL_IMPORT(PyObject *) PyObject_Init Py_PROTO((PyObject *, PyTypeObject *));
+extern DL_IMPORT(PyVarObject *) PyObject_InitVar Py_PROTO((PyVarObject *, PyTypeObject *, int));
extern DL_IMPORT(PyObject *) _PyObject_New Py_PROTO((PyTypeObject *));
extern DL_IMPORT(PyVarObject *) _PyObject_NewVar Py_PROTO((PyTypeObject *, int));
+extern DL_IMPORT(void) _PyObject_Del Py_PROTO((PyObject *));
+
+#define PyObject_New(type, typeobj) \
+ ( (type *) _PyObject_New(typeobj) )
+#define PyObject_NewVar(type, typeobj, n) \
+ ( (type *) _PyObject_NewVar((typeobj), (n)) )
+#define PyObject_Del(op) _PyObject_Del((PyObject *)(op))
+
+/* Macros trading binary compatibility for speed. See also mymalloc.h.
+ Note that these macros expect non-NULL object pointers.*/
+#define PyObject_INIT(op, typeobj) \
+ ( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
+#define PyObject_INIT_VAR(op, typeobj, size) \
+ ( (op)->ob_size = (size), PyObject_INIT((op), (typeobj)) )
+
+#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
+#define _PyObject_VAR_SIZE(typeobj, n) \
+ ( (typeobj)->tp_basicsize + (n) * (typeobj)->tp_itemsize )
+
+#define PyObject_NEW(type, typeobj) \
+( (type *) PyObject_Init( \
+ (PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )
+#define PyObject_NEW_VAR(type, typeobj, n) \
+( (type *) PyObject_InitVar( \
+ (PyVarObject *) PyObject_MALLOC( _PyObject_VAR_SIZE((typeobj),(n)) ),\
+ (typeobj), (n)) )
+#define PyObject_DEL(op) PyObject_FREE(op)
+
+/* This example code implements an object constructor with a custom
+ allocator, where PyObject_New is inlined, and shows the important
+ distinction between two steps (at least):
+ 1) the actual allocation of the object storage;
+ 2) the initialization of the Python specific fields
+ in this storage with PyObject_{Init, InitVar}.
+
+ PyObject *
+ YourObject_New(...)
+ {
+ PyObject *op;
-#define PyObject_NEW(type, typeobj) ((type *) _PyObject_New(typeobj))
-#define PyObject_NEW_VAR(type, typeobj, n) ((type *) _PyObject_NewVar(typeobj, n))
+ op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));
+ if (op == NULL)
+ return PyErr_NoMemory();
-#else
-/* For an MS-Windows DLL, we change the way an object is created, so that the
- extension module's malloc is used, rather than the core DLL malloc, as there is
- no guarantee they will use the same heap
-*/
-extern DL_IMPORT(PyObject *) _PyObject_New Py_PROTO((PyTypeObject *, PyObject *));
-extern DL_IMPORT(PyVarObject *) _PyObject_NewVar Py_PROTO((PyTypeObject *, int, PyVarObject *));
+ op = PyObject_Init(op, &YourTypeStruct);
+ if (op == NULL)
+ return NULL;
-#define PyObject_NEW(type, typeobj) ((type *) _PyObject_New(typeobj,(PyObject *)malloc((typeobj)->tp_basicsize)))
-#define PyObject_NEW_VAR(type, typeobj, n) ((type *) _PyObject_NewVar(typeobj, n, (PyVarObject *)malloc((typeobj)->tp_basicsize + n * (typeobj)->tp_itemsize)))
+ op->ob_field = value;
+ ...
+ return op;
+ }
-#endif /* MS_COREDLL */
+ Note that in C++, the use of the new operator usually implies that
+ the 1st step is performed automatically for you, so in a C++ class
+ constructor you would start directly with PyObject_Init/InitVar. */
#ifdef __cplusplus
}
PyFileObject *in_fo;
PyFileObject *out_fo;
PyCursesScreenObject *xp;
- xp = PyObject_NEW(PyCursesScreenObject, &PyCursesScreen_Type);
+ xp = PyObject_New(PyCursesScreenObject, &PyCursesScreen_Type);
if (xp == NULL)
return NULL;
return (PyObject *)xp;
{
PyCursesWindowObject *wo;
- wo = PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);
+ wo = PyObject_New(PyCursesWindowObject, &PyCursesWindow_Type);
if (wo == NULL)
return NULL;
wo->win = win;
{
if (wo->win != stdscr)
delwin(wo->win);
- PyMem_DEL(wo);
+ PyObject_Del(wo);
}
static PyObject *
WINDOW *pad;
{
PyCursesPadObject *po;
- po = PyObject_NEW(PyCursesPadObject, &PyCursesPad_Type);
+ po = PyObject_New(PyCursesPadObject, &PyCursesPad_Type);
if (po == NULL)
return NULL;
po->pad = pad;
&PyString_Type, &code, &groups, &groupindex))
return NULL;
- self = PyObject_NEW(PatternObject, &Pattern_Type);
+ self = PyObject_New(PatternObject, &Pattern_Type);
if (self == NULL)
return NULL;
if (status > 0) {
/* create match object (with room for extra group marks) */
- match = PyObject_NEW_VAR(MatchObject, &Match_Type, 2*pattern->groups);
+ match = PyObject_NewVar(MatchObject, &Match_Type, 2*pattern->groups);
if (match == NULL)
return NULL;
Py_XDECREF(self->code);
Py_XDECREF(self->pattern);
Py_XDECREF(self->groupindex);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject*
{
Py_XDECREF(self->string);
Py_DECREF(self->pattern);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject*
TkappObject *v;
char *argv0;
- v = PyObject_NEW(TkappObject, &Tkapp_Type);
+ v = PyObject_New(TkappObject, &Tkapp_Type);
if (v == NULL)
return NULL;
{
TkttObject *v;
- v = PyObject_NEW(TkttObject, &Tktt_Type);
+ v = PyObject_New(TkttObject, &Tktt_Type);
if (v == NULL)
return NULL;
Py_XDECREF(func);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
ENTER_TCL
Tcl_DeleteInterp(Tkapp_Interp(self));
LEAVE_TCL
- PyMem_DEL(self);
+ PyObject_Del(self);
DisableEventHook();
}
{
alcobject *self;
- self = PyObject_NEW(alcobject, &Alctype);
+ self = PyObject_New(alcobject, &Alctype);
if (self == NULL)
return NULL;
/* XXXX Add your own initializers here */
#else
(void) ALfreeconfig(self->config); /* ignore errors */
#endif
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
{
alpobject *self;
- self = PyObject_NEW(alpobject, &Alptype);
+ self = PyObject_New(alpobject, &Alptype);
if (self == NULL)
return NULL;
/* XXXX Add your own initializers here */
ALcloseport(self->port);
#endif
}
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
if (nbytes / descr->itemsize != (size_t)size) {
return PyErr_NoMemory();
}
- op = PyMem_NEW(arrayobject, 1);
+ op = PyObject_NewVar(arrayobject, &Arraytype, size);
if (op == NULL) {
return PyErr_NoMemory();
}
else {
op->ob_item = PyMem_NEW(char, nbytes);
if (op->ob_item == NULL) {
- PyMem_DEL(op);
+ PyObject_Del(op);
return PyErr_NoMemory();
}
}
- op->ob_type = &Arraytype;
- op->ob_size = size;
op->ob_descr = descr;
- _Py_NewReference((PyObject *)op);
return (PyObject *) op;
}
{
if (op->ob_item != NULL)
PyMem_DEL(op->ob_item);
- PyMem_DEL(op);
+ PyObject_Del(op);
}
static int
bsddbobject *dp;
HASHINFO info;
- if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
+ if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
return NULL;
info.bsize = bsize;
bsddbobject *dp;
BTREEINFO info;
- if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
+ if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
return NULL;
info.flags = btflags;
bsddbobject *dp;
RECNOINFO info;
- if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
+ if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
return NULL;
info.flags = rnflags;
"Python bsddb: close errno %d in dealloc\n",
errno);
}
- PyMem_DEL(dp);
+ PyObject_Del(dp);
}
#ifdef WITH_THREAD
if (self->data) free(self->data);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyTypeObject PdataType = {
Pdata_New() {
Pdata *self;
- UNLESS (self = PyObject_NEW(Pdata, &PdataType)) return NULL;
+ UNLESS (self = PyObject_New(Pdata, &PdataType)) return NULL;
self->size=8;
self->length=0;
self->data=malloc(self->size * sizeof(PyObject*));
newPicklerobject(PyObject *file, int bin) {
Picklerobject *self;
- UNLESS (self = PyObject_NEW(Picklerobject, &Picklertype))
+ UNLESS (self = PyObject_New(Picklerobject, &Picklertype))
return NULL;
self->fp = NULL;
free(self->write_buf);
}
- PyMem_DEL(self);
+ PyObject_Del(self);
}
PyInstanceObject *inst;
PyErr_Clear();
- UNLESS (inst=PyObject_NEW(PyInstanceObject, &PyInstance_Type))
+ UNLESS (inst=PyObject_New(PyInstanceObject, &PyInstance_Type))
goto err;
inst->in_class=(PyClassObject*)cls;
Py_INCREF(cls);
newUnpicklerobject(PyObject *f) {
Unpicklerobject *self;
- UNLESS (self = PyObject_NEW(Unpicklerobject, &Unpicklertype))
+ UNLESS (self = PyObject_New(Unpicklerobject, &Unpicklertype))
return NULL;
self->file = NULL;
free(self->buf);
}
- PyMem_DEL(self);
+ PyObject_Del(self);
}
"\n"
"This module provides a simple useful replacement for\n"
"the StringIO module that is written in C. It does not provide the\n"
-"full generality if StringIO, but it provides anough for most\n"
+"full generality if StringIO, but it provides enough for most\n"
"applications and is especially useful in conjuction with the\n"
"pickle module.\n"
"\n"
O_dealloc(Oobject *self) {
if (self->buf != NULL)
free(self->buf);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
newOobject(int size) {
Oobject *self;
- self = PyObject_NEW(Oobject, &Otype);
+ self = PyObject_New(Oobject, &Otype);
if (self == NULL)
return NULL;
self->pos=0;
static void
I_dealloc(Iobject *self) {
Py_XDECREF(self->pbuf);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
}
buf = PyString_AS_STRING(s);
size = PyString_GET_SIZE(s);
- UNLESS(self = PyObject_NEW(Iobject, &Itype)) return NULL;
+ UNLESS(self = PyObject_New(Iobject, &Itype)) return NULL;
Py_INCREF(s);
self->buf=buf;
self->string_size=size;
{
if (self->ob_cdplayer != NULL)
CDclose(self->ob_cdplayer);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
{
cdplayerobject *p;
- p = PyObject_NEW(cdplayerobject, &CdPlayertype);
+ p = PyObject_New(cdplayerobject, &CdPlayertype);
if (p == NULL)
return NULL;
p->ob_cdplayer = cdp;
self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
}
CDdeleteparser(self->ob_cdparser);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
cdparserobject *p;
int i;
- p = PyObject_NEW(cdparserobject, &CdParsertype);
+ p = PyObject_New(cdparserobject, &CdParsertype);
if (p == NULL)
return NULL;
p->ob_cdparser = cdp;
else
clCloseDecompressor(SELF->ob_compressorHdl);
}
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
if (!PyArg_Parse(args, "i", &scheme))
return NULL;
- new = PyObject_NEW(clobject, &Cltype);
+ new = PyObject_New(clobject, &Cltype);
if (new == NULL)
return NULL;
{
dbmobject *dp;
- dp = PyObject_NEW(dbmobject, &Dbmtype);
+ dp = PyObject_New(dbmobject, &Dbmtype);
if (dp == NULL)
return NULL;
dp->di_size = -1;
{
if ( dp->di_dbm )
dbm_close(dp->di_dbm);
- PyMem_DEL(dp);
+ PyObject_Del(dp);
}
static int
PyUnivPtr *handle;
{
dlobject *xp;
- xp = PyObject_NEW(dlobject, &Dltype);
+ xp = PyObject_New(dlobject, &Dltype);
if (xp == NULL)
return NULL;
xp->dl_handle = handle;
{
if (xp->dl_handle != NULL)
dlclose(xp->dl_handle);
- PyMem_DEL(xp);
+ PyObject_Del(xp);
}
static PyObject *
fl_free_object(g->ob_generic);
Py_XDECREF(g->ob_callback);
Py_XDECREF(g->ob_callback_arg);
- PyMem_DEL(g);
+ PyObject_Del(g);
}
#define OFF(x) offsetof(FL_OBJECT, x)
PyMethodDef *methods;
{
genericobject *g;
- g = PyObject_NEW(genericobject, &GenericObjecttype);
+ g = PyObject_New(genericobject, &GenericObjecttype);
if (g == NULL)
return NULL;
g-> ob_generic = generic;
if (f->ob_form->visible)
fl_hide_form(f->ob_form);
fl_free_form(f->ob_form);
- PyMem_DEL(f);
+ PyObject_Del(f);
}
#define OFF(x) offsetof(FL_FORM, x)
FL_FORM *form;
{
formobject *f;
- f = PyObject_NEW(formobject, &Formtype);
+ f = PyObject_New(formobject, &Formtype);
if (f == NULL)
return NULL;
f->ob_form = form;
"error creating new font handle");
return NULL;
}
- fhp = PyObject_NEW(fhobject, &Fhtype);
+ fhp = PyObject_New(fhobject, &Fhtype);
if (fhp == NULL)
return NULL;
fhp->fh_fh = fh;
fhobject *fhp;
{
fmfreefont(fhp->fh_fh);
- PyMem_DEL(fhp);
+ PyObject_Del(fhp);
}
static PyTypeObject Fhtype = {
{
dbmobject *dp;
- dp = PyObject_NEW(dbmobject, &Dbmtype);
+ dp = PyObject_New(dbmobject, &Dbmtype);
if (dp == NULL)
return NULL;
dp->di_size = -1;
{
if ( dp->di_dbm )
gdbm_close(dp->di_dbm);
- PyMem_DEL(dp);
+ PyObject_Del(dp);
}
static int
bufsz += strlen(exec_prefix) + 1;
/* This is the only malloc call in this file */
- buf = malloc(bufsz);
+ buf = PyMem_Malloc(bufsz);
if (buf == NULL) {
/* We can't exit, so print a warning and limp along */
}
/* Create and initialize the object */
- if ((xp = PyObject_NEW(lad_t, &Ladtype)) == NULL) {
+ if ((xp = PyObject_New(lad_t, &Ladtype)) == NULL) {
close(fd);
return NULL;
}
lad_dealloc(lad_t *xp)
{
close(xp->x_fd);
- PyMem_DEL(xp);
+ PyObject_Del(xp);
}
static PyObject *
{
md5object *md5p;
- md5p = PyObject_NEW(md5object, &MD5type);
+ md5p = PyObject_New(md5object, &MD5type);
if (md5p == NULL)
return NULL;
md5_dealloc(md5p)
md5object *md5p;
{
- PyMem_DEL(md5p);
+ PyObject_Del(md5p);
}
}
#endif /* UNIX */
- PyMem_DEL(m_obj);
+ PyObject_Del(m_obj);
}
static PyObject *
)
return NULL;
- m_obj = PyObject_NEW (mmap_object, &mmap_object_type);
+ m_obj = PyObject_New (mmap_object, &mmap_object_type);
if (m_obj == NULL) {return NULL;}
m_obj->size = (size_t) map_size;
m_obj->pos = (size_t) 0;
fseek(&_iob[fileno], 0, SEEK_SET);
}
- m_obj = PyObject_NEW (mmap_object, &mmap_object_type);
+ m_obj = PyObject_New (mmap_object, &mmap_object_type);
if (fh) {
m_obj->file_handle = fh;
#ifdef MPZ_DEBUG
fputs( "mpz_object() called...\n", stderr );
#endif /* def MPZ_DEBUG */
- mpzp = PyObject_NEW(mpzobject, &MPZtype);
+ mpzp = PyObject_New(mpzobject, &MPZtype);
if (mpzp == NULL)
return NULL;
fputs( "mpz_dealloc() called...\n", stderr );
#endif /* def MPZ_DEBUG */
mpz_clear(&mpzp->mpz);
- PyMem_DEL(mpzp);
+ PyObject_Del(mpzp);
} /* mpz_dealloc() */
&PyClass_Type, &klass,
&PyDict_Type, &dict))
return NULL;
- inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
+ inst = PyObject_New(PyInstanceObject, &PyInstance_Type);
if (inst == NULL)
return NULL;
Py_INCREF(klass);
if (list->stat != NIS_TRUE)
goto finally;
- PyMem_DEL(server);
+ free(server);
return list->maps;
finally:
- PyMem_DEL(server);
+ free(server);
return NULL;
}
static PyObject*
parser_newastobject(node *ast, int type)
{
- PyAST_Object* o = PyObject_NEW(PyAST_Object, &PyAST_Type);
+ PyAST_Object* o = PyObject_New(PyAST_Object, &PyAST_Type);
if (o != 0) {
o->ast_node = ast;
parser_free(PyAST_Object *ast)
{
PyNode_Free(ast->ast_node);
- PyMem_DEL(ast);
+ PyObject_Del(ast);
}
PyObject *temp = PySequence_GetItem(elem, 1);
/* check_terminal_tuple() already verified it's a string */
- strn = (char *)malloc(PyString_GET_SIZE(temp) + 1);
+ strn = (char *)PyMem_MALLOC(PyString_GET_SIZE(temp) + 1);
if (strn != NULL)
(void) strcpy(strn, PyString_AS_STRING(temp));
- Py_XDECREF(temp);
+ Py_DECREF(temp);
if (PyObject_Length(elem) == 3) {
PyObject* temp = PySequence_GetItem(elem, 2);
PyObject *arg;
{
PcreObject *self;
- self = PyObject_NEW(PcreObject, &Pcre_Type);
+ self = PyObject_New(PcreObject, &Pcre_Type);
if (self == NULL)
return NULL;
self->regex = NULL;
{
if (self->regex) (pcre_free)(self->regex);
if (self->regex_extra) (pcre_free)(self->regex_extra);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
int i;
xmlparseobject *self;
- self = PyObject_NEW(xmlparseobject, &Xmlparsetype);
+ self = PyObject_New(xmlparseobject, &Xmlparsetype);
if (self == NULL)
return NULL;
for( i=0; handler_info[i].name!=NULL; i++ ){
Py_XDECREF( self->handlers[i] );
}
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static int handlername2int( const char *name ){
char *prompt;
{
int n;
- char *p;
+ char *p, *q;
RETSIGTYPE (*old_inthandler)();
old_inthandler = signal(SIGINT, onintr);
if (setjmp(jbuf)) {
rl_event_hook = PyOS_InputHook;
p = readline(prompt);
signal(SIGINT, old_inthandler);
+
+ /* We must return a buffer allocated with PyMem_Malloc. */
if (p == NULL) {
- p = malloc(1);
+ p = PyMem_Malloc(1);
if (p != NULL)
*p = '\0';
return p;
n = strlen(p);
if (n > 0)
add_history(p);
- if ((p = realloc(p, n+2)) != NULL) {
+ /* Copy the malloc'ed buffer into a PyMem_Malloc'ed one and
+ release the original. */
+ q = p;
+ p = PyMem_Malloc(n+2);
+ if (p != NULL) {
+ strncpy(p, q, n);
p[n] = '\n';
p[n+1] = '\0';
}
+ free(q);
return p;
}
reg_dealloc(re)
regexobject *re;
{
- PyMem_XDEL(re->re_patbuf.buffer);
+ if (re->re_patbuf.buffer)
+ PyMem_DEL(re->re_patbuf.buffer);
Py_XDECREF(re->re_translate);
Py_XDECREF(re->re_lastok);
Py_XDECREF(re->re_groupindex);
Py_XDECREF(re->re_givenpat);
Py_XDECREF(re->re_realpat);
- PyMem_DEL(re);
+ PyObject_Del(re);
}
static PyObject *
"translation table must be 256 bytes");
return NULL;
}
- re = PyObject_NEW(regexobject, &Regextype);
+ re = PyObject_New(regexobject, &Regextype);
if (re != NULL) {
char *error;
re->re_patbuf.buffer = NULL;
{
Rotorobj *xp;
- xp = PyObject_NEW(Rotorobj, &Rotor_Type);
+ xp = PyObject_New(Rotorobj, &Rotor_Type);
if (xp == NULL)
return NULL;
set_key(xp, key);
return xp;
finally:
- PyMem_XDEL(xp->e_rotor);
- PyMem_XDEL(xp->d_rotor);
- PyMem_XDEL(xp->positions);
- PyMem_XDEL(xp->advances);
+ if (xp->e_rotor)
+ PyMem_DEL(xp->e_rotor);
+ if (xp->d_rotor)
+ PyMem_DEL(xp->d_rotor);
+ if (xp->positions)
+ PyMem_DEL(xp->positions);
+ if (xp->advances)
+ PyMem_DEL(xp->advances);
Py_DECREF(xp);
return (Rotorobj*)PyErr_NoMemory();
}
rotor_dealloc(xp)
Rotorobj *xp;
{
- PyMem_XDEL(xp->e_rotor);
- PyMem_XDEL(xp->d_rotor);
- PyMem_XDEL(xp->positions);
- PyMem_XDEL(xp->advances);
- PyMem_DEL(xp);
+ if (xp->e_rotor)
+ PyMem_DEL(xp->e_rotor);
+ if (xp->d_rotor)
+ PyMem_DEL(xp->d_rotor);
+ if (xp->positions)
+ PyMem_DEL(xp->positions);
+ if (xp->advances)
+ PyMem_DEL(xp->advances);
+ PyObject_Del(xp);
}
static PyObject *
wfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 3);
efd2obj = PyMem_NEW(pylist, FD_SETSIZE + 3);
if (rfd2obj == NULL || wfd2obj == NULL || efd2obj == NULL) {
- PyMem_XDEL(rfd2obj);
- PyMem_XDEL(wfd2obj);
- PyMem_XDEL(efd2obj);
+ if (rfd2obj) PyMem_DEL(rfd2obj);
+ if (wfd2obj) PyMem_DEL(wfd2obj);
+ if (efd2obj) PyMem_DEL(efd2obj);
return NULL;
}
#endif
static SHAobject *
newSHAobject()
{
- return (SHAobject *)PyObject_NEW(SHAobject, &SHAtype);
+ return (SHAobject *)PyObject_New(SHAobject, &SHAtype);
}
/* Internal methods for a hashing object */
SHA_dealloc(ptr)
PyObject *ptr;
{
- PyMem_DEL(ptr);
+ PyObject_Del(ptr);
}
{
PySocketSockObject *s;
PySocketSock_Type.ob_type = &PyType_Type;
- s = PyObject_NEW(PySocketSockObject, &PySocketSock_Type);
+ s = PyObject_New(PySocketSockObject, &PySocketSock_Type);
if (s != NULL) {
s->sock_fd = fd;
s->sock_family = family;
{
if (s->sock_fd != -1)
(void) SOCKETCLOSE(s->sock_fd);
- PyMem_DEL(s);
+ PyObject_Del(s);
}
meth=SSLv2_client_method();
#endif
- self = PyObject_NEW(SSLObject, &SSL_Type); /* Create new object */
+ self = PyObject_New(SSLObject, &SSL_Type); /* Create new object */
if (self == NULL){
PyErr_SetObject(SSLErrorObject,
PyString_FromString("newSSLObject error"));
if (self->ctx == NULL) {
PyErr_SetObject(SSLErrorObject,
PyString_FromString("SSL_CTX_new error"));
- PyMem_DEL(self);
+ PyObject_Del(self);
return NULL;
}
PyErr_SetObject(SSLErrorObject,
PyString_FromString(
"Both the key & certificate files must be specified"));
- PyMem_DEL(self);
+ PyObject_Del(self);
return NULL;
}
PyErr_SetObject(SSLErrorObject,
PyString_FromString(
"SSL_CTX_use_PrivateKey_file error"));
- PyMem_DEL(self);
+ PyObject_Del(self);
return NULL;
}
PyErr_SetObject(SSLErrorObject,
PyString_FromString(
"SSL_CTX_use_certificate_chain_file error"));
- PyMem_DEL(self);
+ PyObject_Del(self);
return NULL;
}
}
/* Actually negotiate SSL connection */
PyErr_SetObject(SSLErrorObject,
PyString_FromString("SSL_connect error"));
- PyMem_DEL(self);
+ PyObject_Del(self);
return NULL;
}
self->ssl->debug = 1;
SSL_free(self->ssl);
Py_XDECREF(self->x_attr);
Py_XDECREF(self->Socket);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *SSL_getattr(SSLObject *self, char *name)
goto return_same;
new_len = len + nfound*(sub_len - pat_len);
- new_s = (char *)malloc(new_len);
+ new_s = (char *)PyMem_MALLOC(new_len);
if (new_s == NULL) return NULL;
*out_len = new_len;
}
else {
new = PyString_FromStringAndSize(new_s, out_len);
- free(new_s);
+ PyMem_FREE(new_s);
}
return new;
}
PyMem_DEL(ctldev);
/* Create and initialize the object */
- xp = PyObject_NEW(sadobject, &Sadtype);
+ xp = PyObject_New(sadobject, &Sadtype);
if (xp == NULL) {
close(fd);
return NULL;
sadobject *xp;
{
close(xp->x_fd);
- PyMem_DEL(xp);
+ PyObject_Del(xp);
}
static PyObject *
static sadstatusobject *
sads_alloc() {
- return PyObject_NEW(sadstatusobject, &Sadstatustype);
+ return PyObject_New(sadstatusobject, &Sadstatustype);
}
static void
Py_DECREF(self->ob_svideo);
self->ob_svideo = NULL;
}
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
{
captureobject *p;
- p = PyObject_NEW(captureobject, &Capturetype);
+ p = PyObject_New(captureobject, &Capturetype);
if (p == NULL)
return NULL;
p->ob_svideo = self;
{
if (self->ob_svideo != NULL)
(void) svCloseVideo(self->ob_svideo);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
{
svobject *p;
- p = PyObject_NEW(svobject, &Svtype);
+ p = PyObject_New(svobject, &Svtype);
if (p == NULL)
return NULL;
p->ob_svideo = svp;
newlockobject()
{
lockobject *self;
- self = PyObject_NEW(lockobject, &Locktype);
+ self = PyObject_New(lockobject, &Locktype);
if (self == NULL)
return NULL;
self->lock_lock = PyThread_allocate_lock();
if (self->lock_lock == NULL) {
- PyMem_DEL(self);
+ PyObject_Del(self);
self = NULL;
PyErr_SetString(ThreadError, "can't allocate lock");
}
PyThread_release_lock(self->lock_lock);
PyThread_free_lock(self->lock_lock);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
PyObject *arg;
{
XxoObject *self;
- self = PyObject_NEW(XxoObject, &Xxo_Type);
+ self = PyObject_New(XxoObject, &Xxo_Type);
if (self == NULL)
return NULL;
self->x_attr = NULL;
XxoObject *self;
{
Py_XDECREF(self->x_attr);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static PyObject *
PyTypeObject *type;
{
compobject *self;
- self = PyObject_NEW(compobject, type);
+ self = PyObject_New(compobject, type);
if (self == NULL)
return NULL;
self->is_initialised = 0;
if (self->is_initialised)
deflateEnd(&self->zst);
Py_XDECREF(self->unused_data);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static void
{
inflateEnd(&self->zst);
Py_XDECREF(self->unused_data);
- PyMem_DEL(self);
+ PyObject_Del(self);
}
static char comp_compress__doc__[] =
"size must be zero or positive");
return NULL;
}
- b = (PyBufferObject *)malloc(sizeof(*b) + size);
+ /* PyObject_New is inlined */
+ b = (PyBufferObject *) PyObject_MALLOC(sizeof(*b) + size);
if ( b == NULL )
return PyErr_NoMemory();
- b->ob_type = &PyBuffer_Type;
- _Py_NewReference((PyObject *)b);
+ PyObject_INIT((PyObject *)b, &PyBuffer_Type);
b->b_base = NULL;
b->b_ptr = (void *)(b + 1);
PyBufferObject *self;
{
Py_XDECREF(self->b_base);
- free((void *)self);
+ PyObject_DEL(self);
}
static int
Py_XDECREF(op->cl_getattr);
Py_XDECREF(op->cl_setattr);
Py_XDECREF(op->cl_delattr);
- free((ANY *)op);
+ PyObject_DEL(op);
}
static PyObject *
#endif /* Py_TRACE_REFS */
Py_DECREF(inst->in_class);
Py_XDECREF(inst->in_dict);
- free((ANY *)inst);
+ PyObject_DEL(inst);
}
static PyObject *
im = free_list;
if (im != NULL) {
free_list = (PyMethodObject *)(im->im_self);
- im->ob_type = &PyMethod_Type;
- _Py_NewReference((PyObject *)im);
+ PyObject_INIT(im, &PyMethod_Type);
}
else {
im = PyObject_NEW(PyMethodObject, &PyMethod_Type);
PyMethod_Fini()
{
while (free_list) {
- PyMethodObject *v = free_list;
- free_list = (PyMethodObject *)(v->im_self);
- PyMem_DEL(v);
+ PyMethodObject *im = free_list;
+ free_list = (PyMethodObject *)(im->im_self);
+ PyObject_DEL(im);
}
}
else
(self->destructor)(self->cobject);
}
- PyMem_DEL(self);
+ PyObject_DEL(self);
}
PyComplex_FromCComplex(cval)
Py_complex cval;
{
- register PyComplexObject *op =
- (PyComplexObject *) malloc(sizeof(PyComplexObject));
+ register PyComplexObject *op;
+
+ /* PyObject_New is inlined */
+ op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyComplex_Type;
+ PyObject_INIT(op, &PyComplex_Type);
op->cval = cval;
- _Py_NewReference((PyObject *)op);
return (PyObject *) op;
}
complex_dealloc(op)
PyObject *op;
{
- PyMem_DEL(op);
+ PyObject_DEL(op);
}
break;
}
}
- newtable = (dictentry *) malloc(sizeof(dictentry) * newsize);
+ newtable = PyMem_NEW(dictentry, newsize);
if (newtable == NULL) {
PyErr_NoMemory();
return -1;
}
}
- PyMem_XDEL(oldtable);
+ if (oldtable != NULL)
+ PyMem_DEL(oldtable);
return 0;
}
Py_DECREF(ep->me_value);
}
}
- PyMem_XDEL(mp->ma_table);
- PyMem_DEL(mp);
+ if (mp->ma_table != NULL)
+ PyMem_DEL(mp->ma_table);
+ PyObject_DEL(mp);
Py_TRASHCAN_SAFE_END(mp)
}
if (f->f_mode != NULL) {
Py_DECREF(f->f_mode);
}
- free((char *)f);
+ PyObject_DEL(f);
}
static PyObject *
#define BHEAD_SIZE 8 /* Enough for a 64-bit pointer */
#define N_FLOATOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyFloatObject))
-#define PyMem_MALLOC malloc
-#define PyMem_FREE free
-
struct _floatblock {
struct _floatblock *next;
PyFloatObject objects[N_FLOATOBJECTS];
fill_free_list()
{
PyFloatObject *p, *q;
- p = (PyFloatObject *)PyMem_MALLOC(sizeof(PyFloatBlock));
+ /* XXX Float blocks escape the object heap. Use PyObject_MALLOC ??? */
+ p = (PyFloatObject *) PyMem_MALLOC(sizeof(PyFloatBlock));
if (p == NULL)
- return (PyFloatObject *)PyErr_NoMemory();
+ return (PyFloatObject *) PyErr_NoMemory();
((PyFloatBlock *)p)->next = block_list;
block_list = (PyFloatBlock *)p;
p = &((PyFloatBlock *)p)->objects[0];
if ((free_list = fill_free_list()) == NULL)
return NULL;
}
+ /* PyObject_New is inlined */
op = free_list;
free_list = (PyFloatObject *)op->ob_type;
- op->ob_type = &PyFloat_Type;
+ PyObject_INIT(op, &PyFloat_Type);
op->ob_fval = fval;
- _Py_NewReference((PyObject *)op);
return (PyObject *) op;
}
}
}
else {
- PyMem_FREE(list);
+ PyMem_FREE(list); /* XXX PyObject_FREE ??? */
bf++;
}
fsum += frem;
if (builtins != NULL && !PyDict_Check(builtins))
builtins = NULL;
if (free_list == NULL) {
+ /* PyObject_New is inlined */
f = (PyFrameObject *)
- malloc(sizeof(PyFrameObject) +
- extras*sizeof(PyObject *));
+ PyObject_MALLOC(sizeof(PyFrameObject) +
+ extras*sizeof(PyObject *));
if (f == NULL)
return (PyFrameObject *)PyErr_NoMemory();
- f->ob_type = &PyFrame_Type;
- _Py_NewReference((PyObject *)f);
+ PyObject_INIT(f, &PyFrame_Type);
}
else {
f = free_list;
free_list = free_list->f_back;
if (f->f_nlocals + f->f_stacksize < extras) {
f = (PyFrameObject *)
- realloc(f, sizeof(PyFrameObject) +
- extras*sizeof(PyObject *));
+ PyObject_REALLOC(f, sizeof(PyFrameObject) +
+ extras*sizeof(PyObject *));
if (f == NULL)
return (PyFrameObject *)PyErr_NoMemory();
}
else
extras = f->f_nlocals + f->f_stacksize;
- f->ob_type = &PyFrame_Type;
- _Py_NewReference((PyObject *)f);
+ PyObject_INIT(f, &PyFrame_Type);
}
if (builtins == NULL) {
/* No builtins! Make up a minimal one. */
while (free_list != NULL) {
PyFrameObject *f = free_list;
free_list = free_list->f_back;
- PyMem_DEL(f);
+ PyObject_DEL(f);
}
}
Py_DECREF(op->func_name);
Py_XDECREF(op->func_defaults);
Py_XDECREF(op->func_doc);
- PyMem_DEL(op);
+ PyObject_DEL(op);
}
static PyObject*
#define BHEAD_SIZE 8 /* Enough for a 64-bit pointer */
#define N_INTOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyIntObject))
-#define PyMem_MALLOC malloc
-#define PyMem_FREE free
-
struct _intblock {
struct _intblock *next;
PyIntObject objects[N_INTOBJECTS];
fill_free_list()
{
PyIntObject *p, *q;
- p = (PyIntObject *)PyMem_MALLOC(sizeof(PyIntBlock));
+ /* XXX Int blocks escape the object heap. Use PyObject_MALLOC ??? */
+ p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
if (p == NULL)
- return (PyIntObject *)PyErr_NoMemory();
+ return (PyIntObject *) PyErr_NoMemory();
((PyIntBlock *)p)->next = block_list;
block_list = (PyIntBlock *)p;
p = &((PyIntBlock *)p)->objects[0];
if ((free_list = fill_free_list()) == NULL)
return NULL;
}
+ /* PyObject_New is inlined */
v = free_list;
free_list = (PyIntObject *)v->ob_type;
- v->ob_type = &PyInt_Type;
+ PyObject_INIT(v, &PyInt_Type);
v->ob_ival = ival;
- _Py_NewReference((PyObject *)v);
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
/* save this one for a following allocation */
}
}
else {
- PyMem_FREE(list);
+ PyMem_FREE(list); /* XXX PyObject_FREE ??? */
bf++;
}
isum += irem;
if (nbytes / sizeof(PyObject *) != (size_t)size) {
return PyErr_NoMemory();
}
- op = (PyListObject *) malloc(sizeof(PyListObject));
+ /* PyObject_NewVar is inlined */
+ op = (PyListObject *) PyObject_MALLOC(sizeof(PyListObject));
if (op == NULL) {
return PyErr_NoMemory();
}
op->ob_item = NULL;
}
else {
- op->ob_item = (PyObject **) malloc(nbytes);
+ op->ob_item = (PyObject **) PyMem_MALLOC(nbytes);
if (op->ob_item == NULL) {
- free((ANY *)op);
+ PyObject_FREE(op);
return PyErr_NoMemory();
}
}
- op->ob_type = &PyList_Type;
- op->ob_size = size;
+ PyObject_INIT_VAR(op, &PyList_Type, size);
for (i = 0; i < size; i++)
op->ob_item[i] = NULL;
- _Py_NewReference((PyObject *)op);
return (PyObject *) op;
}
while (--i >= 0) {
Py_XDECREF(op->ob_item[i]);
}
- free((ANY *)op->ob_item);
+ PyMem_FREE(op->ob_item);
}
- free((ANY *)op);
+ PyObject_DEL(op);
Py_TRASHCAN_SAFE_END(op)
}
else { /* Insert d items; recycle ihigh-ilow items */
NRESIZE(item, PyObject *, a->ob_size + d);
if (item == NULL) {
- PyMem_XDEL(recycle);
+ if (recycle != NULL)
+ PyMem_DEL(recycle);
PyErr_NoMemory();
return -1;
}
long_dealloc(v)
PyObject *v;
{
- PyMem_DEL(v);
+ PyObject_DEL(v);
}
static PyObject *
op = free_list;
if (op != NULL) {
free_list = (PyCFunctionObject *)(op->m_self);
- op->ob_type = &PyCFunction_Type;
- _Py_NewReference((PyObject *)op);
+ PyObject_INIT(op, &PyCFunction_Type);
}
else {
op = PyObject_NEW(PyCFunctionObject, &PyCFunction_Type);
while (free_list) {
PyCFunctionObject *v = free_list;
free_list = (PyCFunctionObject *)(v->m_self);
- PyMem_DEL(v);
+ PyObject_DEL(v);
}
}
_PyModule_Clear((PyObject *)m);
Py_DECREF(m->md_dict);
}
- free((char *)m);
+ PyObject_DEL(m);
}
static PyObject *
}
#endif
-#ifndef MS_COREDLL
PyObject *
-_PyObject_New(tp)
- PyTypeObject *tp;
-#else
-PyObject *
-_PyObject_New(tp,op)
- PyTypeObject *tp;
+PyObject_Init(op, tp)
PyObject *op;
-#endif
+ PyTypeObject *tp;
{
-#ifndef MS_COREDLL
- PyObject *op = (PyObject *) malloc(tp->tp_basicsize);
-#endif
- if (op == NULL)
- return PyErr_NoMemory();
+ if (op == NULL) {
+ PyErr_SetString(PyExc_SystemError,
+ "NULL object passed to PyObject_Init");
+ return op;
+ }
+ /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
op->ob_type = tp;
_Py_NewReference(op);
return op;
}
-#ifndef MS_COREDLL
PyVarObject *
-_PyObject_NewVar(tp, size)
+PyObject_InitVar(op, tp, size)
+ PyVarObject *op;
PyTypeObject *tp;
int size;
-#else
+{
+ if (op == NULL) {
+ PyErr_SetString(PyExc_SystemError,
+ "NULL object passed to PyObject_InitVar");
+ return op;
+ }
+ /* Any changes should be reflected in PyObject_INIT_VAR */
+ op->ob_size = size;
+ op->ob_type = tp;
+ _Py_NewReference((PyObject *)op);
+ return op;
+}
+
+PyObject *
+_PyObject_New(tp)
+ PyTypeObject *tp;
+{
+ PyObject *op;
+ op = (PyObject *) PyObject_MALLOC(_PyObject_SIZE(tp));
+ if (op == NULL)
+ return PyErr_NoMemory();
+ return PyObject_INIT(op, tp);
+}
+
PyVarObject *
-_PyObject_NewVar(tp, size, op)
+_PyObject_NewVar(tp, size)
PyTypeObject *tp;
int size;
- PyVarObject *op;
-#endif
{
-#ifndef MS_COREDLL
- PyVarObject *op = (PyVarObject *)
- malloc(tp->tp_basicsize + size * tp->tp_itemsize);
-#endif
+ PyVarObject *op;
+ op = (PyVarObject *) PyObject_MALLOC(_PyObject_VAR_SIZE(tp, size));
if (op == NULL)
return (PyVarObject *)PyErr_NoMemory();
- op->ob_type = tp;
- op->ob_size = size;
- _Py_NewReference((PyObject *)op);
- return op;
+ return PyObject_INIT_VAR(op, tp, size);
+}
+
+void
+_PyObject_Del(op)
+ PyObject *op;
+{
+ PyObject_FREE(op);
}
int
int (*_Py_abstract_hack) Py_FPROTO((PyObject *)) = &PyObject_Length;
-/* Malloc wrappers (see mymalloc.h) */
-
-/* The Py_{Malloc,Realloc} wrappers call PyErr_NoMemory() on failure */
+/* Python's malloc wrappers (see mymalloc.h) */
ANY *
-Py_Malloc(nbytes)
+PyMem_Malloc(nbytes)
size_t nbytes;
{
- ANY *p;
#if _PyMem_EXTRA > 0
if (nbytes == 0)
nbytes = _PyMem_EXTRA;
#endif
- p = malloc(nbytes);
- if (p != NULL)
- return p;
- else {
- PyErr_NoMemory();
- return NULL;
- }
+ return PyMem_MALLOC(nbytes);
}
ANY *
-Py_Realloc(p, nbytes)
+PyMem_Realloc(p, nbytes)
ANY *p;
size_t nbytes;
{
if (nbytes == 0)
nbytes = _PyMem_EXTRA;
#endif
- p = realloc(p, nbytes);
- if (p != NULL)
- return p;
- else {
- PyErr_NoMemory();
- return NULL;
- }
+ return PyMem_REALLOC(p, nbytes);
}
void
-Py_Free(p)
+PyMem_Free(p)
ANY *p;
{
- free(p);
+ PyMem_FREE(p);
}
-/* The PyMem_{Malloc,Realloc} wrappers don't call anything on failure */
+
+/* Python's object malloc wrappers (see objimpl.h) */
ANY *
-PyMem_Malloc(nbytes)
+PyObject_Malloc(nbytes)
size_t nbytes;
{
-#if _PyMem_EXTRA > 0
- if (nbytes == 0)
- nbytes = _PyMem_EXTRA;
-#endif
- return malloc(nbytes);
+ return PyObject_MALLOC(nbytes);
}
ANY *
-PyMem_Realloc(p, nbytes)
+PyObject_Realloc(p, nbytes)
ANY *p;
size_t nbytes;
{
-#if _PyMem_EXTRA > 0
- if (nbytes == 0)
- nbytes = _PyMem_EXTRA;
-#endif
- return realloc(p, nbytes);
+ return PyObject_REALLOC(p, nbytes);
}
void
-PyMem_Free(p)
+PyObject_Free(p)
ANY *p;
{
- free(p);
+ PyObject_FREE(p);
}
range_dealloc(r)
rangeobject *r;
{
- PyMem_DEL(r);
+ PyObject_DEL(r);
}
static PyObject *
PyObject *stop;
PyObject *step;
{
- PySliceObject *obj =
- (PySliceObject *) PyObject_NEW(PySliceObject, &PySlice_Type);
+ PySliceObject *obj = PyObject_NEW(PySliceObject, &PySlice_Type);
if (step == NULL) step = Py_None;
Py_INCREF(step);
Py_DECREF(r->step);
Py_DECREF(r->start);
Py_DECREF(r->stop);
- PyMem_DEL(r);
+ PyObject_DEL(r);
}
static PyObject *
return (PyObject *)op;
}
#endif /* DONT_SHARE_SHORT_STRINGS */
+
+ /* PyObject_NewVar is inlined */
op = (PyStringObject *)
- malloc(sizeof(PyStringObject) + size * sizeof(char));
+ PyObject_MALLOC(sizeof(PyStringObject) + size * sizeof(char));
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyString_Type;
- op->ob_size = size;
+ PyObject_INIT_VAR(op, &PyString_Type, size);
#ifdef CACHE_HASH
op->ob_shash = -1;
#endif
#ifdef INTERN_STRINGS
op->ob_sinterned = NULL;
#endif
- _Py_NewReference((PyObject *)op);
if (str != NULL)
memcpy(op->ob_sval, str, size);
op->ob_sval[size] = '\0';
return (PyObject *)op;
}
#endif /* DONT_SHARE_SHORT_STRINGS */
+
+ /* PyObject_NewVar is inlined */
op = (PyStringObject *)
- malloc(sizeof(PyStringObject) + size * sizeof(char));
+ PyObject_MALLOC(sizeof(PyStringObject) + size * sizeof(char));
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyString_Type;
- op->ob_size = size;
+ PyObject_INIT_VAR(op, &PyString_Type, size);
#ifdef CACHE_HASH
op->ob_shash = -1;
#endif
#ifdef INTERN_STRINGS
op->ob_sinterned = NULL;
#endif
- _Py_NewReference((PyObject *)op);
strcpy(op->ob_sval, str);
#ifndef DONT_SHARE_SHORT_STRINGS
if (size == 0) {
string_dealloc(op)
PyObject *op;
{
- PyMem_DEL(op);
+ PyObject_DEL(op);
}
int
return (PyObject *)a;
}
size = a->ob_size + b->ob_size;
+ /* PyObject_NewVar is inlined */
op = (PyStringObject *)
- malloc(sizeof(PyStringObject) + size * sizeof(char));
+ PyObject_MALLOC(sizeof(PyStringObject) + size * sizeof(char));
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyString_Type;
- op->ob_size = size;
+ PyObject_INIT_VAR(op, &PyString_Type, size);
#ifdef CACHE_HASH
op->ob_shash = -1;
#endif
#ifdef INTERN_STRINGS
op->ob_sinterned = NULL;
#endif
- _Py_NewReference((PyObject *)op);
memcpy(op->ob_sval, a->ob_sval, (int) a->ob_size);
memcpy(op->ob_sval + a->ob_size, b->ob_sval, (int) b->ob_size);
op->ob_sval[size] = '\0';
Py_INCREF(a);
return (PyObject *)a;
}
+ /* PyObject_NewVar is inlined */
op = (PyStringObject *)
- malloc(sizeof(PyStringObject) + size * sizeof(char));
+ PyObject_MALLOC(sizeof(PyStringObject) + size * sizeof(char));
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyString_Type;
- op->ob_size = size;
+ PyObject_INIT_VAR(op, &PyString_Type, size);
#ifdef CACHE_HASH
op->ob_shash = -1;
#endif
#ifdef INTERN_STRINGS
op->ob_sinterned = NULL;
#endif
- _Py_NewReference((PyObject *)op);
for (i = 0; i < size; i += a->ob_size)
memcpy(op->ob_sval+i, a->ob_sval, (int) a->ob_size);
op->ob_sval[size] = '\0';
goto return_same;
new_len = len + nfound*(sub_len - pat_len);
- new_s = (char *)malloc(new_len);
+ new_s = (char *)PyMem_MALLOC(new_len);
if (new_s == NULL) return NULL;
*out_len = new_len;
}
else {
new = PyString_FromStringAndSize(new_s, out_len);
- free(new_s);
+ PyMem_FREE(new_s);
}
return new;
}
#endif
_Py_ForgetReference(v);
*pv = (PyObject *)
- realloc((char *)v,
+ PyObject_REALLOC((char *)v,
sizeof(PyStringObject) + newsize * sizeof(char));
if (*pv == NULL) {
- PyMem_DEL(v);
+ PyObject_DEL(v);
PyErr_NoMemory();
return -1;
}
#ifdef COUNT_ALLOCS
fast_tuple_allocs++;
#endif
+ /* PyObject_InitVar is inlined */
#ifdef Py_TRACE_REFS
- op->ob_type = &PyTuple_Type;
op->ob_size = size;
+ op->ob_type = &PyTuple_Type;
#endif
+ _Py_NewReference((PyObject *)op);
}
else
#endif
{
return PyErr_NoMemory();
}
- ;
- op = (PyTupleObject *) malloc(nbytes);
+ /* PyObject_NewVar is inlined */
+ op = (PyTupleObject *) PyObject_MALLOC(nbytes);
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyTuple_Type;
- op->ob_size = size;
+ PyObject_INIT_VAR(op, &PyTuple_Type, size);
}
for (i = 0; i < size; i++)
op->ob_item[i] = NULL;
- _Py_NewReference((PyObject *)op);
#if MAXSAVESIZE > 0
if (size == 0) {
free_tuples[0] = op;
}
#endif
}
- free((ANY *)op);
+ PyObject_DEL(op);
done:
Py_TRASHCAN_SAFE_END(op)
}
#endif
{
sv = (PyTupleObject *)
- realloc((char *)v,
+ PyObject_REALLOC((char *)v,
sizeof(PyTupleObject) + newsize * sizeof(PyObject *));
*pv = (PyObject *) sv;
if (sv == NULL) {
- PyMem_DEL(v);
+ PyObject_DEL(v);
PyErr_NoMemory();
return -1;
}
while (p) {
q = p;
p = (PyTupleObject *)(p->ob_item[0]);
- PyMem_DEL(q);
+ PyObject_DEL(q);
}
}
#endif
unicode = unicode_freelist;
unicode_freelist = *(PyUnicodeObject **)unicode_freelist;
unicode_freelist_size--;
- unicode->ob_type = &PyUnicode_Type;
- _Py_NewReference((PyObject *)unicode);
+ PyObject_INIT(unicode, &PyUnicode_Type);
if (unicode->str) {
/* Keep-Alive optimization: we only upsize the buffer,
never downsize it. */
if ((unicode->length < length) &&
_PyUnicode_Resize(unicode, length)) {
- free(unicode->str);
+ PyMem_DEL(unicode->str);
goto onError;
}
}
onError:
_Py_ForgetReference((PyObject *)unicode);
- PyMem_DEL(unicode);
+ PyObject_DEL(unicode);
return NULL;
}
if (unicode_freelist_size < MAX_UNICODE_FREELIST_SIZE) {
/* Keep-Alive optimization */
if (unicode->length >= KEEPALIVE_SIZE_LIMIT) {
- free(unicode->str);
+ PyMem_DEL(unicode->str);
unicode->str = NULL;
unicode->length = 0;
}
unicode_freelist_size++;
}
else {
- free(unicode->str);
+ PyMem_DEL(unicode->str);
Py_XDECREF(unicode->utf8str);
- PyMem_DEL(unicode);
+ PyObject_DEL(unicode);
}
}
PyUnicodeObject *v = u;
u = *(PyUnicodeObject **)u;
if (v->str)
- free(v->str);
+ PyMem_DEL(v->str);
Py_XDECREF(v->utf8str);
- free(v);
+ PyObject_DEL(v);
}
Py_XDECREF(unicode_empty);
}
xxobject *xp;
{
Py_XDECREF(xp->x_attr);
- PyMem_DEL(xp);
+ PyObject_DEL(xp);
}
static PyObject *
PyHKEYObject *obkey = (PyHKEYObject *)ob;
if (obkey->hkey)
RegCloseKey((HKEY)obkey->hkey);
- PyMem_DEL(ob);
+ PyObject_DEL(ob);
}
static int
PyObject *
PyHKEY_FromHKEY(HKEY h)
{
- PyHKEYObject *op = (PyHKEYObject *) malloc(sizeof(PyHKEYObject));
+ PyHKEYObject *op;
+
+ /* PyObject_New is inlined */
+ op = (PyHKEYObject *) PyObject_MALLOC(sizeof(PyHKEYObject));
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyHKEY_Type;
+ PyObject_INIT(op, &PyHKEY_Type);
op->hkey = h;
- _Py_NewReference((PyObject *)op);
return (PyObject *)op;
}
Py_BEGIN_ALLOW_THREADS
rc = RegSetValueEx(hKey, valueName, 0, typ, data, len);
Py_END_ALLOW_THREADS
- PyMem_Free(data);
+ PyMem_DEL(data);
if (rc != ERROR_SUCCESS)
return PyErr_SetFromWindowsErrWithFunction(rc,
"RegSetValueEx");
PyHKEYObject *obkey = (PyHKEYObject *)ob;
if (obkey->hkey)
RegCloseKey((HKEY)obkey->hkey);
- PyMem_DEL(ob);
+ PyObject_DEL(ob);
}
static int
PyObject *
PyHKEY_FromHKEY(HKEY h)
{
- PyHKEYObject *op = (PyHKEYObject *) malloc(sizeof(PyHKEYObject));
+ PyHKEYObject *op;
+
+ /* PyObject_New is inlined */
+ op = (PyHKEYObject *) PyObject_MALLOC(sizeof(PyHKEYObject));
if (op == NULL)
return PyErr_NoMemory();
- op->ob_type = &PyHKEY_Type;
+ PyObject_INIT(op, &PyHKEY_Type);
op->hkey = h;
- _Py_NewReference((PyObject *)op);
return (PyObject *)op;
}
Py_BEGIN_ALLOW_THREADS
rc = RegSetValueEx(hKey, valueName, 0, typ, data, len);
Py_END_ALLOW_THREADS
- PyMem_Free(data);
+ PyMem_DEL(data);
if (rc != ERROR_SUCCESS)
return PyErr_SetFromWindowsErrWithFunction(rc,
"RegSetValueEx");
int n;
char *p;
n = 100;
- if ((p = malloc(n)) == NULL)
+ if ((p = PyMem_MALLOC(n)) == NULL)
return NULL;
fflush(stdout);
if (prompt)
case 0: /* Normal case */
break;
case 1: /* Interrupt */
- free(p);
+ PyMem_FREE(p);
return NULL;
case -1: /* EOF */
case -2: /* Error */
n = strlen(p);
while (n > 0 && p[n-1] != '\n') {
int incr = n+2;
- p = realloc(p, n + incr);
+ p = PyMem_REALLOC(p, n + incr);
if (p == NULL)
return NULL;
if (my_fgets(p+n, incr, stdin) != 0)
break;
n += strlen(p+n);
}
- return realloc(p, n+1);
+ return PyMem_REALLOC(p, n+1);
}
/* By initializing this function pointer, systems embedding Python can
- override the readline function. */
+ override the readline function.
+
+ Note: Python expects in return a buffer allocated with PyMem_Malloc. */
char *(*PyOS_ReadlineFunctionPointer) Py_PROTO((char *));
err_ret->offset = tok->cur - tok->buf;
if (tok->buf != NULL) {
int len = tok->inp - tok->buf;
- err_ret->text = malloc(len + 1);
+ err_ret->text = PyMem_NEW(char, len + 1);
if (err_ret->text != NULL) {
if (len > 0)
strncpy(err_ret->text, tok->buf, len);
putc(' ', stderr);
}
fprintf(stderr, "^\n");
- free(err.text);
+ PyMem_DEL(err.text);
}
Py_Exit(1);
}
char *prompt;
{
int n = 1000;
- char *p = malloc(n);
+ char *p = PyMem_MALLOC(n);
char *q;
if (p == NULL)
return NULL;
n = strlen(p);
if (n > 0 && p[n-1] != '\n')
p[n-1] = '\n';
- return realloc(p, n+1);
+ return PyMem_REALLOC(p, n+1);
}
#ifdef HAVE_STDARG_PROTOTYPES
if (new == NULL)
tok->done = E_INTR;
else if (*new == '\0') {
- free(new);
+ PyMem_FREE(new);
tok->done = E_EOF;
}
else if (tok->start != NULL) {
int start = tok->start - tok->buf;
int oldlen = tok->cur - tok->buf;
int newlen = oldlen + strlen(new);
- char *buf = realloc(tok->buf, newlen+1);
+ char *buf = tok->buf;
+ PyMem_RESIZE(buf, char, newlen+1);
tok->lineno++;
if (buf == NULL) {
- free(tok->buf);
+ PyMem_DEL(tok->buf);
tok->buf = NULL;
- free(new);
+ PyMem_FREE(new);
tok->done = E_NOMEM;
return EOF;
}
tok->buf = buf;
tok->cur = tok->buf + oldlen;
strcpy(tok->buf + oldlen, new);
- free(new);
+ PyMem_FREE(new);
tok->inp = tok->buf + newlen;
tok->end = tok->inp + 1;
tok->start = tok->buf + start;
else {
tok->lineno++;
if (tok->buf != NULL)
- free(tok->buf);
+ PyMem_DEL(tok->buf);
tok->buf = new;
tok->cur = tok->buf;
tok->inp = strchr(tok->buf, '\0');
else { /* strip trailing '\n' */
result = PyString_FromStringAndSize(s, strlen(s)-1);
}
- free(s);
+ PyMem_FREE(s);
return result;
}
if (v != NULL) {
class);
Py_DECREF(arg);
- PyMem_XDEL(k);
+ if (k != NULL)
+ PyMem_DEL(k);
return result;
}
Py_XDECREF(co->co_filename);
Py_XDECREF(co->co_name);
Py_XDECREF(co->co_lnotab);
- PyMem_DEL(co);
+ PyObject_DEL(co);
}
static PyObject *
++countD;
for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
++countS;
- filetab = malloc((countD + countS + 1) * sizeof(struct filedescr));
+ filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
memcpy(filetab, _PyImport_DynLoadFiletab,
countD * sizeof(struct filedescr));
memcpy(filetab + countD, _PyImport_StandardFiletab,
}
-/* API for embedding applications that want to add their own entries to the
- table of built-in modules. This should normally be called *before*
- Py_Initialize(). When the malloc() or realloc() call fails, -1 is returned
- and the existing table is unchanged.
+/* API for embedding applications that want to add their own entries
+ to the table of built-in modules. This should normally be called
+ *before* Py_Initialize(). When the table resize fails, -1 is
+ returned and the existing table is unchanged.
After a similar function by Just van Rossum. */
;
/* Allocate new memory for the combined table */
- if (our_copy == NULL)
- p = malloc((i+n+1) * sizeof(struct _inittab));
- else
- p = realloc(our_copy, (i+n+1) * sizeof(struct _inittab));
+ p = our_copy;
+ PyMem_RESIZE(p, struct _inittab, i+n+1);
if (p == NULL)
return -1;
PyErr_SetString(PyExc_ValueError, "bad marshal data");
return NULL;
}
- buffer = (char *)Py_Malloc(n);
+ buffer = PyMem_NEW(char, n);
if (buffer == NULL)
- return NULL;
+ return PyErr_NoMemory();
if (r_string(buffer, (int)n, p) != n) {
- free(buffer);
+ PyMem_DEL(buffer);
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
return NULL;
}
v = PyUnicode_DecodeUTF8(buffer, n, NULL);
- free(buffer);
+ PyMem_DEL(buffer);
return v;
}
if (n == NULL) {
if (err.error == E_EOF) {
if (err.text)
- free(err.text);
+ PyMem_DEL(err.text);
return E_EOF;
}
err_input(&err);
v = Py_BuildValue("(ziiz)", err->filename,
err->lineno, err->offset, err->text);
if (err->text != NULL) {
- free(err->text);
+ PyMem_DEL(err->text);
err->text = NULL;
}
switch (err->error) {
Py_TRASHCAN_SAFE_BEGIN(tb)
Py_XDECREF(tb->tb_next);
Py_XDECREF(tb->tb_frame);
- PyMem_DEL(tb);
+ PyObject_DEL(tb);
Py_TRASHCAN_SAFE_END(tb)
}
projects / thirdparty / Python / cpython.git / commitdiff
