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);
 }