/* 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
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;
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;
/* If we ever allow items larger than double, we must change reverse()! */
-static object *
+static PyObject *
newarrayobject(size, descr)
int size;
struct arraydescr *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);
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)
#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);
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,
arrayobject *op;
{
if (op->ob_item != NULL)
- DEL(op->ob_item);
- DEL(op);
+ PyMem_DEL(op->ob_item);
+ PyMem_DEL(op);
}
static int
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;
}
}
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;
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;
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;
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 */
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)
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,
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)
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;
}
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;
}
}
}
- 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;
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
{
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);
}
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;
}
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*/
};
-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 */
};
void
initarray()
{
- initmodule("array", a_methods);
+ Py_InitModule("array", a_methods);
}
projects / python / commitdiff