diff options
| -rw-r--r-- | Modules/arraymodule.c | 535 |
1 files changed, 270 insertions, 265 deletions
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c index 19ffe47..194d76b 100644 --- a/Modules/arraymodule.c +++ b/Modules/arraymodule.c @@ -34,7 +34,7 @@ PERFORMANCE OF THIS SOFTWARE. /* An array is a uniform list -- all items have the same type. The item type is restricted to simple C types like int or float */ -#include "allobjects.h" +#include "Python.h" #include "modsupport.h" #include "ceval.h" #ifdef STDC_HEADERS @@ -48,55 +48,55 @@ struct arrayobject; /* Forward */ struct arraydescr { int typecode; int itemsize; - object * (*getitem) FPROTO((struct arrayobject *, int)); - int (*setitem) FPROTO((struct arrayobject *, int, object *)); + PyObject * (*getitem) Py_FPROTO((struct arrayobject *, int)); + int (*setitem) Py_FPROTO((struct arrayobject *, int, PyObject *)); }; typedef struct arrayobject { - OB_VARHEAD + PyObject_VAR_HEAD char *ob_item; struct arraydescr *ob_descr; } arrayobject; -staticforward typeobject Arraytype; +staticforward PyTypeObject Arraytype; #define is_arrayobject(op) ((op)->ob_type == &Arraytype) /* Forward */ -static object *newarrayobject PROTO((int, struct arraydescr *)); +static PyObject *newarrayobject Py_PROTO((int, struct arraydescr *)); #if 0 -static int getarraysize PROTO((object *)); +static int getarraysize Py_PROTO((PyObject *)); #endif -static object *getarrayitem PROTO((object *, int)); -static int setarrayitem PROTO((object *, int, object *)); +static PyObject *getarrayitem Py_PROTO((PyObject *, int)); +static int setarrayitem Py_PROTO((PyObject *, int, PyObject *)); #if 0 -static int insarrayitem PROTO((object *, int, object *)); -static int addarrayitem PROTO((object *, object *)); +static int insarrayitem Py_PROTO((PyObject *, int, PyObject *)); +static int addarrayitem Py_PROTO((PyObject *, PyObject *)); #endif -static object * +static PyObject * c_getitem(ap, i) arrayobject *ap; int i; { - return newsizedstringobject(&((char *)ap->ob_item)[i], 1); + return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1); } static int c_setitem(ap, i, v) arrayobject *ap; int i; - object *v; + PyObject *v; { char x; - if (!getargs(v, "c;array item must be char", &x)) + if (!PyArg_Parse(v, "c;array item must be char", &x)) return -1; if (i >= 0) ((char *)ap->ob_item)[i] = x; return 0; } -static object * +static PyObject * b_getitem(ap, i) arrayobject *ap; int i; @@ -104,127 +104,127 @@ b_getitem(ap, i) long x = ((char *)ap->ob_item)[i]; if (x >= 128) x -= 256; - return newintobject(x); + return PyInt_FromLong(x); } static int b_setitem(ap, i, v) arrayobject *ap; int i; - object *v; + PyObject *v; { char x; - if (!getargs(v, "b;array item must be integer", &x)) + if (!PyArg_Parse(v, "b;array item must be integer", &x)) return -1; if (i >= 0) ((char *)ap->ob_item)[i] = x; return 0; } -static object * +static PyObject * h_getitem(ap, i) arrayobject *ap; int i; { - return newintobject((long) ((short *)ap->ob_item)[i]); + return PyInt_FromLong((long) ((short *)ap->ob_item)[i]); } static int h_setitem(ap, i, v) arrayobject *ap; int i; - object *v; + PyObject *v; { short x; - if (!getargs(v, "h;array item must be integer", &x)) + if (!PyArg_Parse(v, "h;array item must be integer", &x)) return -1; if (i >= 0) ((short *)ap->ob_item)[i] = x; return 0; } -static object * +static PyObject * i_getitem(ap, i) arrayobject *ap; int i; { - return newintobject((long) ((int *)ap->ob_item)[i]); + return PyInt_FromLong((long) ((int *)ap->ob_item)[i]); } static int i_setitem(ap, i, v) arrayobject *ap; int i; - object *v; + PyObject *v; { int x; - if (!getargs(v, "i;array item must be integer", &x)) + if (!PyArg_Parse(v, "i;array item must be integer", &x)) return -1; if (i >= 0) ((int *)ap->ob_item)[i] = x; return 0; } -static object * +static PyObject * l_getitem(ap, i) arrayobject *ap; int i; { - return newintobject(((long *)ap->ob_item)[i]); + return PyInt_FromLong(((long *)ap->ob_item)[i]); } static int l_setitem(ap, i, v) arrayobject *ap; int i; - object *v; + PyObject *v; { long x; - if (!getargs(v, "l;array item must be integer", &x)) + if (!PyArg_Parse(v, "l;array item must be integer", &x)) return -1; if (i >= 0) ((long *)ap->ob_item)[i] = x; return 0; } -static object * +static PyObject * f_getitem(ap, i) arrayobject *ap; int i; { - return newfloatobject((double) ((float *)ap->ob_item)[i]); + return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]); } static int f_setitem(ap, i, v) arrayobject *ap; int i; - object *v; + PyObject *v; { float x; - if (!getargs(v, "f;array item must be float", &x)) + if (!PyArg_Parse(v, "f;array item must be float", &x)) return -1; if (i >= 0) ((float *)ap->ob_item)[i] = x; return 0; } -static object * +static PyObject * d_getitem(ap, i) arrayobject *ap; int i; { - return newfloatobject(((double *)ap->ob_item)[i]); + return PyFloat_FromDouble(((double *)ap->ob_item)[i]); } static int d_setitem(ap, i, v) arrayobject *ap; int i; - object *v; + PyObject *v; { double x; - if (!getargs(v, "d;array item must be float", &x)) + if (!PyArg_Parse(v, "d;array item must be float", &x)) return -1; if (i >= 0) ((double *)ap->ob_item)[i] = x; @@ -245,7 +245,7 @@ static struct arraydescr descriptors[] = { /* If we ever allow items larger than double, we must change reverse()! */ -static object * +static PyObject * newarrayobject(size, descr) int size; struct arraydescr *descr; @@ -253,61 +253,61 @@ newarrayobject(size, descr) arrayobject *op; size_t nbytes; if (size < 0) { - err_badcall(); + PyErr_BadInternalCall(); return NULL; } nbytes = size * descr->itemsize; /* Check for overflow */ if (nbytes / descr->itemsize != size) { - return err_nomem(); + return PyErr_NoMemory(); } - op = NEW(arrayobject, 1); + op = PyMem_NEW(arrayobject, 1); if (op == NULL) { - return err_nomem(); + return PyErr_NoMemory(); } if (size <= 0) { op->ob_item = NULL; } else { - op->ob_item = NEW(char, nbytes); + op->ob_item = PyMem_NEW(char, nbytes); if (op->ob_item == NULL) { - DEL(op); - return err_nomem(); + PyMem_DEL(op); + return PyErr_NoMemory(); } } op->ob_type = &Arraytype; op->ob_size = size; op->ob_descr = descr; - NEWREF(op); - return (object *) op; + _Py_NewReference(op); + return (PyObject *) op; } #if 0 static int getarraysize(op) - object *op; + PyObject *op; { if (!is_arrayobject(op)) { - err_badcall(); + PyErr_BadInternalCall(); return -1; } return ((arrayobject *)op) -> ob_size; } #endif -static object * +static PyObject * getarrayitem(op, i) - object *op; + PyObject *op; int i; { register arrayobject *ap; if (!is_arrayobject(op)) { - err_badcall(); + PyErr_BadInternalCall(); return NULL; } ap = (arrayobject *)op; if (i < 0 || i >= ap->ob_size) { - err_setstr(IndexError, "array index out of range"); + PyErr_SetString(PyExc_IndexError, "array index out of range"); return NULL; } return (*ap->ob_descr->getitem)(ap, i); @@ -317,19 +317,19 @@ static int ins1(self, where, v) arrayobject *self; int where; - object *v; + PyObject *v; { char *items; if (v == NULL) { - err_badcall(); + PyErr_BadInternalCall(); return -1; } if ((*self->ob_descr->setitem)(self, -1, v) < 0) return -1; items = self->ob_item; - RESIZE(items, char, (self->ob_size+1) * self->ob_descr->itemsize); + PyMem_RESIZE(items, char, (self->ob_size+1) * self->ob_descr->itemsize); if (items == NULL) { - err_nomem(); + PyErr_NoMemory(); return -1; } if (where < 0) @@ -347,12 +347,12 @@ ins1(self, where, v) #if 0 static int insarrayitem(op, where, newitem) - object *op; + PyObject *op; int where; - object *newitem; + PyObject *newitem; { if (!is_arrayobject(op)) { - err_badcall(); + PyErr_BadInternalCall(); return -1; } return ins1((arrayobject *)op, where, newitem); @@ -360,11 +360,11 @@ insarrayitem(op, where, newitem) static int addarrayitem(op, newitem) - object *op; - object *newitem; + PyObject *op; + PyObject *newitem; { if (!is_arrayobject(op)) { - err_badcall(); + PyErr_BadInternalCall(); return -1; } return ins1((arrayobject *)op, @@ -379,8 +379,8 @@ array_dealloc(op) arrayobject *op; { if (op->ob_item != NULL) - DEL(op->ob_item); - DEL(op); + PyMem_DEL(op->ob_item); + PyMem_DEL(op); } static int @@ -390,18 +390,18 @@ array_compare(v, w) int len = (v->ob_size < w->ob_size) ? v->ob_size : w->ob_size; int i; for (i = 0; i < len; i++) { - object *ai, *bi; + PyObject *ai, *bi; int cmp; - ai = getarrayitem((object *)v, i); - bi = getarrayitem((object *)w, i); + ai = getarrayitem((PyObject *)v, i); + bi = getarrayitem((PyObject *)w, i); if (ai && bi) - cmp = cmpobject(ai, bi); + cmp = PyObject_Compare(ai, bi); else cmp = -1; - XDECREF(ai); - XDECREF(bi); + Py_XDECREF(ai); + Py_XDECREF(bi); if (cmp != 0) { - err_clear(); /* XXX Can't report errors here */ + PyErr_Clear(); /* XXX Can't report errors here */ return cmp; } } @@ -415,19 +415,19 @@ array_length(a) return a->ob_size; } -static object * +static PyObject * array_item(a, i) arrayobject *a; int i; { if (i < 0 || i >= a->ob_size) { - err_setstr(IndexError, "array index out of range"); + PyErr_SetString(PyExc_IndexError, "array index out of range"); return NULL; } - return getarrayitem((object *)a, i); + return getarrayitem((PyObject *)a, i); } -static object * +static PyObject * array_slice(a, ilow, ihigh) arrayobject *a; int ilow, ihigh; @@ -448,23 +448,23 @@ array_slice(a, ilow, ihigh) return NULL; memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize, (ihigh-ilow) * a->ob_descr->itemsize); - return (object *)np; + return (PyObject *)np; } -static object * +static PyObject * array_concat(a, bb) arrayobject *a; - object *bb; + PyObject *bb; { int size; arrayobject *np; if (!is_arrayobject(bb)) { - err_badarg(); + PyErr_BadArgument(); return NULL; } #define b ((arrayobject *)bb) if (a->ob_descr != b->ob_descr) { - err_badarg(); + PyErr_BadArgument(); return NULL; } size = a->ob_size + b->ob_size; @@ -475,11 +475,11 @@ array_concat(a, bb) memcpy(np->ob_item, a->ob_item, a->ob_size*a->ob_descr->itemsize); memcpy(np->ob_item + a->ob_size*a->ob_descr->itemsize, b->ob_item, b->ob_size*b->ob_descr->itemsize); - return (object *)np; + return (PyObject *)np; #undef b } -static object * +static PyObject * array_repeat(a, n) arrayobject *a; int n; @@ -501,14 +501,14 @@ array_repeat(a, n) memcpy(p, a->ob_item, nbytes); p += nbytes; } - return (object *) np; + return (PyObject *) np; } static int array_ass_slice(a, ilow, ihigh, v) arrayobject *a; int ilow, ihigh; - object *v; + PyObject *v; { char *item; int n; /* Size of replacement array */ @@ -523,16 +523,16 @@ array_ass_slice(a, ilow, ihigh, v) int ret; v = array_slice(b, 0, n); ret = array_ass_slice(a, ilow, ihigh, v); - DECREF(v); + Py_DECREF(v); return ret; } if (b->ob_descr != a->ob_descr) { - err_badarg(); + PyErr_BadArgument(); return -1; } } else { - err_badarg(); + PyErr_BadArgument(); return -1; } if (ilow < 0) @@ -552,14 +552,15 @@ array_ass_slice(a, ilow, ihigh, v) item + ihigh*a->ob_descr->itemsize, (a->ob_size-ihigh)*a->ob_descr->itemsize); a->ob_size += d; - RESIZE(item, char, a->ob_size*a->ob_descr->itemsize); + PyMem_RESIZE(item, char, a->ob_size*a->ob_descr->itemsize); /* Can't fail */ a->ob_item = item; } else if (d > 0) { /* Insert d items */ - RESIZE(item, char, (a->ob_size + d)*a->ob_descr->itemsize); + PyMem_RESIZE(item, char, + (a->ob_size + d)*a->ob_descr->itemsize); if (item == NULL) { - err_nomem(); + PyErr_NoMemory(); return -1; } memmove(item + (ihigh+d)*a->ob_descr->itemsize, @@ -579,10 +580,11 @@ static int array_ass_item(a, i, v) arrayobject *a; int i; - object *v; + PyObject *v; { if (i < 0 || i >= a->ob_size) { - err_setstr(IndexError, "array assignment index out of range"); + PyErr_SetString(PyExc_IndexError, + "array assignment index out of range"); return -1; } if (v == NULL) @@ -592,56 +594,56 @@ array_ass_item(a, i, v) static int setarrayitem(a, i, v) - object *a; + PyObject *a; int i; - object *v; + PyObject *v; { if (!is_arrayobject(a)) { - err_badcall(); + PyErr_BadInternalCall(); return -1; } return array_ass_item((arrayobject *)a, i, v); } -static object * +static PyObject * ins(self, where, v) arrayobject *self; int where; - object *v; + PyObject *v; { if (ins1(self, where, v) != 0) return NULL; - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * array_insert(self, args) arrayobject *self; - object *args; + PyObject *args; { int i; - object *v; - if (!getargs(args, "(iO)", &i, &v)) + PyObject *v; + if (!PyArg_Parse(args, "(iO)", &i, &v)) return NULL; return ins(self, i, v); } -static object * +static PyObject * array_append(self, args) arrayobject *self; - object *args; + PyObject *args; { - object *v; - if (!getargs(args, "O", &v)) + PyObject *v; + if (!PyArg_Parse(args, "O", &v)) return NULL; return ins(self, (int) self->ob_size, v); } -static object * +static PyObject * array_byteswap(self, args) arrayobject *self; - object *args; + PyObject *args; { char *p; int i; @@ -682,25 +684,25 @@ array_byteswap(self, args) } break; default: - err_setstr(RuntimeError, + PyErr_SetString(PyExc_RuntimeError, "don't know how to byteswap this array type"); return NULL; } - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * array_reverse(self, args) arrayobject *self; - object *args; + PyObject *args; { register int itemsize = self->ob_descr->itemsize; register char *p, *q; char tmp[sizeof(double)]; /* Assume that's the max item size */ if (args != NULL) { - err_badarg(); + PyErr_BadArgument(); return NULL; } @@ -715,103 +717,103 @@ array_reverse(self, args) } } - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } /* The following routines were adapted from listobject.c but not converted. To make them work you will have to work! */ #if 0 -static object * +static PyObject * array_index(self, args) arrayobject *self; - object *args; + PyObject *args; { int i; if (args == NULL) { - err_badarg(); + PyErr_BadArgument(); return NULL; } for (i = 0; i < self->ob_size; i++) { - if (cmpobject(self->ob_item[i], args) == 0) - return newintobject((long)i); + if (PyObject_Compare(self->ob_item[i], args) == 0) + return PyInt_FromLong((long)i); } - err_setstr(ValueError, "array.index(x): x not in array"); + PyErr_SetString(PyExc_ValueError, "array.index(x): x not in array"); return NULL; } #endif #if 0 -static object * +static PyObject * array_count(self, args) arrayobject *self; - object *args; + PyObject *args; { int count = 0; int i; if (args == NULL) { - err_badarg(); + PyErr_BadArgument(); return NULL; } for (i = 0; i < self->ob_size; i++) { - if (cmpobject(self->ob_item[i], args) == 0) + if (PyObject_Compare(self->ob_item[i], args) == 0) count++; } - return newintobject((long)count); + return PyInt_FromLong((long)count); } #endif #if 0 -static object * +static PyObject * array_remove(self, args) arrayobject *self; - object *args; + PyObject *args; { int i; if (args == NULL) { - err_badarg(); + PyErr_BadArgument(); return NULL; } for (i = 0; i < self->ob_size; i++) { - if (cmpobject(self->ob_item[i], args) == 0) { - if (array_ass_slice(self, i, i+1, (object *)NULL) != 0) + if (PyObject_Compare(self->ob_item[i], args) == 0) { + if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) return NULL; - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } } - err_setstr(ValueError, "array.remove(x): x not in array"); + PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in array"); return NULL; } #endif -static object * +static PyObject * array_fromfile(self, args) arrayobject *self; - object *args; + PyObject *args; { - object *f; + PyObject *f; int n; FILE *fp; - if (!getargs(args, "(Oi)", &f, &n)) + if (!PyArg_Parse(args, "(Oi)", &f, &n)) return NULL; - fp = getfilefile(f); + fp = PyFile_AsFile(f); if (fp == NULL) { - err_setstr(TypeError, "arg1 must be open file"); + PyErr_SetString(PyExc_TypeError, "arg1 must be open file"); return NULL; } if (n > 0) { char *item = self->ob_item; int itemsize = self->ob_descr->itemsize; int nread; - RESIZE(item, char, (self->ob_size + n) * itemsize); + PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize); if (item == NULL) { - err_nomem(); + PyErr_NoMemory(); return NULL; } self->ob_item = item; @@ -820,189 +822,191 @@ array_fromfile(self, args) itemsize, n, fp); if (nread < n) { self->ob_size -= (n - nread); - RESIZE(item, char, self->ob_size*itemsize); + PyMem_RESIZE(item, char, self->ob_size*itemsize); self->ob_item = item; - err_setstr(EOFError, "not enough items in file"); + PyErr_SetString(PyExc_EOFError, + "not enough items in file"); return NULL; } } - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * array_tofile(self, args) arrayobject *self; - object *args; + PyObject *args; { - object *f; + PyObject *f; FILE *fp; - if (!getargs(args, "O", &f)) + if (!PyArg_Parse(args, "O", &f)) return NULL; - fp = getfilefile(f); + fp = PyFile_AsFile(f); if (fp == NULL) { - err_setstr(TypeError, "arg must be open file"); + PyErr_SetString(PyExc_TypeError, "arg must be open file"); return NULL; } if (self->ob_size > 0) { if (fwrite(self->ob_item, self->ob_descr->itemsize, self->ob_size, fp) != self->ob_size) { - err_errno(IOError); + PyErr_SetFromErrno(PyExc_IOError); clearerr(fp); return NULL; } } - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * array_fromlist(self, args) arrayobject *self; - object *args; + PyObject *args; { int n; - object *list; + PyObject *list; int itemsize = self->ob_descr->itemsize; - if (!getargs(args, "O", &list)) + if (!PyArg_Parse(args, "O", &list)) return NULL; - if (!is_listobject(list)) { - err_setstr(TypeError, "arg must be list"); + if (!PyList_Check(list)) { + PyErr_SetString(PyExc_TypeError, "arg must be list"); return NULL; } - n = getlistsize(list); + n = PyList_Size(list); if (n > 0) { char *item = self->ob_item; int i; - RESIZE(item, char, (self->ob_size + n) * itemsize); + PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize); if (item == NULL) { - err_nomem(); + PyErr_NoMemory(); return NULL; } self->ob_item = item; self->ob_size += n; for (i = 0; i < n; i++) { - object *v = getlistitem(list, i); + PyObject *v = PyList_GetItem(list, i); if ((*self->ob_descr->setitem)(self, self->ob_size - n + i, v) != 0) { self->ob_size -= n; - RESIZE(item, char, self->ob_size * itemsize); + PyMem_RESIZE(item, char, + self->ob_size * itemsize); self->ob_item = item; return NULL; } } } - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * array_tolist(self, args) arrayobject *self; - object *args; + PyObject *args; { - object *list = newlistobject(self->ob_size); + PyObject *list = PyList_New(self->ob_size); int i; if (list == NULL) return NULL; for (i = 0; i < self->ob_size; i++) { - object *v = getarrayitem((object *)self, i); + PyObject *v = getarrayitem((PyObject *)self, i); if (v == NULL) { - DECREF(list); + Py_DECREF(list); return NULL; } - setlistitem(list, i, v); + PyList_SetItem(list, i, v); } return list; } -static object * +static PyObject * array_fromstring(self, args) arrayobject *self; - object *args; + PyObject *args; { char *str; int n; int itemsize = self->ob_descr->itemsize; - if (!getargs(args, "s#", &str, &n)) + if (!PyArg_Parse(args, "s#", &str, &n)) return NULL; if (n % itemsize != 0) { - err_setstr(ValueError, + PyErr_SetString(PyExc_ValueError, "string length not a multiple of item size"); return NULL; } n = n / itemsize; if (n > 0) { char *item = self->ob_item; - RESIZE(item, char, (self->ob_size + n) * itemsize); + PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize); if (item == NULL) { - err_nomem(); + PyErr_NoMemory(); return NULL; } self->ob_item = item; self->ob_size += n; memcpy(item + (self->ob_size - n) * itemsize, str, itemsize*n); } - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * array_tostring(self, args) arrayobject *self; - object *args; + PyObject *args; { - if (!getargs(args, "")) + if (!PyArg_Parse(args, "")) return NULL; - return newsizedstringobject(self->ob_item, + return PyString_FromStringAndSize(self->ob_item, self->ob_size * self->ob_descr->itemsize); } -static struct methodlist array_methods[] = { - {"append", (method)array_append}, - {"byteswap", (method)array_byteswap}, +static PyMethodDef array_methods[] = { + {"append", (PyCFunction)array_append}, + {"byteswap", (PyCFunction)array_byteswap}, /* {"count", (method)array_count},*/ - {"fromfile", (method)array_fromfile}, - {"fromlist", (method)array_fromlist}, - {"fromstring", (method)array_fromstring}, + {"fromfile", (PyCFunction)array_fromfile}, + {"fromlist", (PyCFunction)array_fromlist}, + {"fromstring", (PyCFunction)array_fromstring}, /* {"index", (method)array_index},*/ - {"insert", (method)array_insert}, - {"read", (method)array_fromfile}, + {"insert", (PyCFunction)array_insert}, + {"read", (PyCFunction)array_fromfile}, /* {"remove", (method)array_remove},*/ - {"reverse", (method)array_reverse}, + {"reverse", (PyCFunction)array_reverse}, /* {"sort", (method)array_sort},*/ - {"tofile", (method)array_tofile}, - {"tolist", (method)array_tolist}, - {"tostring", (method)array_tostring}, - {"write", (method)array_tofile}, + {"tofile", (PyCFunction)array_tofile}, + {"tolist", (PyCFunction)array_tolist}, + {"tostring", (PyCFunction)array_tostring}, + {"write", (PyCFunction)array_tofile}, {NULL, NULL} /* sentinel */ }; -static object * +static PyObject * array_getattr(a, name) arrayobject *a; char *name; { if (strcmp(name, "typecode") == 0) { char tc = a->ob_descr->typecode; - return newsizedstringobject(&tc, 1); + return PyString_FromStringAndSize(&tc, 1); } if (strcmp(name, "itemsize") == 0) { - return newintobject((long)a->ob_descr->itemsize); + return PyInt_FromLong((long)a->ob_descr->itemsize); } if (strcmp(name, "__members__") == 0) { - object *list = newlistobject(2); + PyObject *list = PyList_New(2); if (list) { - setlistitem(list, 0, newstringobject("typecode")); - setlistitem(list, 1, newstringobject("itemsize")); - if (err_occurred()) { - DECREF(list); + PyList_SetItem(list, 0, PyString_FromString("typecode")); + PyList_SetItem(list, 1, PyString_FromString("itemsize")); + if (PyErr_Occurred()) { + Py_DECREF(list); list = NULL; } } return list; } - return findmethod(array_methods, (object *)a, name); + return Py_FindMethod(array_methods, (PyObject *)a, name); } static int @@ -1013,7 +1017,7 @@ array_print(a, fp, flags) { int ok = 0; int i, len; - object *v; + PyObject *v; len = a->ob_size; if (len == 0) { fprintf(fp, "array('%c')", a->ob_descr->typecode); @@ -1021,9 +1025,9 @@ array_print(a, fp, flags) } if (a->ob_descr->typecode == 'c') { fprintf(fp, "array('c', "); - v = array_tostring(a, (object *)NULL); - ok = printobject(v, fp, 0); - XDECREF(v); + v = array_tostring(a, (PyObject *)NULL); + ok = PyObject_Print(v, fp, 0); + Py_XDECREF(v); fprintf(fp, ")"); return ok; } @@ -1032,70 +1036,70 @@ array_print(a, fp, flags) if (i > 0) fprintf(fp, ", "); v = (a->ob_descr->getitem)(a, i); - ok = printobject(v, fp, 0); - XDECREF(v); + ok = PyObject_Print(v, fp, 0); + Py_XDECREF(v); } fprintf(fp, "])"); return ok; } -static object * +static PyObject * array_repr(a) arrayobject *a; { char buf[256]; - object *s, *t, *comma, *v; + PyObject *s, *t, *comma, *v; int i, len; len = a->ob_size; if (len == 0) { sprintf(buf, "array('%c')", a->ob_descr->typecode); - return newstringobject(buf); + return PyString_FromString(buf); } if (a->ob_descr->typecode == 'c') { sprintf(buf, "array('c', "); - s = newstringobject(buf); - v = array_tostring(a, (object *)NULL); - t = reprobject(v); - XDECREF(v); - joinstring_decref(&s, t); - joinstring_decref(&s, newstringobject(")")); + s = PyString_FromString(buf); + v = array_tostring(a, (PyObject *)NULL); + t = PyObject_Repr(v); + Py_XDECREF(v); + PyString_ConcatAndDel(&s, t); + PyString_ConcatAndDel(&s, PyString_FromString(")")); return s; } sprintf(buf, "array('%c', [", a->ob_descr->typecode); - s = newstringobject(buf); - comma = newstringobject(", "); - for (i = 0; i < len && !err_occurred(); i++) { + s = PyString_FromString(buf); + comma = PyString_FromString(", "); + for (i = 0; i < len && !PyErr_Occurred(); i++) { if (i > 0) - joinstring(&s, comma); + PyString_Concat(&s, comma); v = (a->ob_descr->getitem)(a, i); - t = reprobject(v); - XDECREF(v); - joinstring_decref(&s, t); + t = PyObject_Repr(v); + Py_XDECREF(v); + PyString_ConcatAndDel(&s, t); } - XDECREF(comma); - joinstring_decref(&s, newstringobject("])")); + Py_XDECREF(comma); + PyString_ConcatAndDel(&s, PyString_FromString("])")); return s; } -static sequence_methods array_as_sequence = { - (inquiry)array_length, /*sq_length*/ +static PySequenceMethods array_as_sequence = { + (inquiry)array_length, /*sq_length*/ (binaryfunc)array_concat, /*sq_concat*/ (intargfunc)array_repeat, /*sq_repeat*/ - (intargfunc)array_item, /*sq_item*/ + (intargfunc)array_item, /*sq_item*/ (intintargfunc)array_slice, /*sq_slice*/ (intobjargproc)array_ass_item, /*sq_ass_item*/ (intintobjargproc)array_ass_slice, /*sq_ass_slice*/ }; -statichere typeobject Arraytype = { - OB_HEAD_INIT(&Typetype) +statichere PyTypeObject Arraytype = { + PyObject_HEAD_INIT(&PyType_Type) 0, "array", sizeof(arrayobject), 0, - (destructor)array_dealloc, /*tp_dealloc*/ + (destructor)array_dealloc, /*tp_dealloc*/ (printfunc)array_print, /*tp_print*/ - (getattrfunc)array_getattr, /*tp_getattr*/ + (getattrfunc)array_getattr, /*tp_getattr*/ 0, /*tp_setattr*/ (cmpfunc)array_compare, /*tp_compare*/ (reprfunc)array_repr, /*tp_repr*/ @@ -1105,62 +1109,63 @@ statichere typeobject Arraytype = { }; -static object * +static PyObject * a_array(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { char c; - object *initial = NULL; + PyObject *initial = NULL; struct arraydescr *descr; - if (!getargs(args, "c", &c)) { - err_clear(); - if (!getargs(args, "(cO)", &c, &initial)) + if (!PyArg_Parse(args, "c", &c)) { + PyErr_Clear(); + if (!PyArg_Parse(args, "(cO)", &c, &initial)) return NULL; - if (!is_listobject(initial) && !is_stringobject(initial)) { - err_setstr(TypeError, + if (!PyList_Check(initial) && !PyString_Check(initial)) { + PyErr_SetString(PyExc_TypeError, "array initializer must be list or string"); return NULL; } } for (descr = descriptors; descr->typecode != '\0'; descr++) { if (descr->typecode == c) { - object *a; + PyObject *a; int len; - if (initial == NULL || !is_listobject(initial)) + if (initial == NULL || !PyList_Check(initial)) len = 0; else - len = getlistsize(initial); + len = PyList_Size(initial); a = newarrayobject(len, descr); if (a == NULL) return NULL; if (len > 0) { int i; for (i = 0; i < len; i++) { - object *v = getlistitem(initial, i); + PyObject *v = + PyList_GetItem(initial, i); if (setarrayitem(a, i, v) != 0) { - DECREF(a); + Py_DECREF(a); return NULL; } } } - if (initial != NULL && is_stringobject(initial)) { - object *v = + if (initial != NULL && PyString_Check(initial)) { + PyObject *v = array_fromstring((arrayobject *)a, initial); if (v == NULL) { - DECREF(a); + Py_DECREF(a); return NULL; } - DECREF(v); + Py_DECREF(v); } return a; } } - err_setstr(ValueError, "bad typecode (must be c, b, h, l, f or d)"); + PyErr_SetString(PyExc_ValueError, "bad typecode (must be c, b, h, l, f or d)"); return NULL; } -static struct methodlist a_methods[] = { +static PyMethodDef a_methods[] = { {"array", a_array}, {NULL, NULL} /* sentinel */ }; @@ -1168,5 +1173,5 @@ static struct methodlist a_methods[] = { void initarray() { - initmodule("array", a_methods); + Py_InitModule("array", a_methods); } |