diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index b2ee5b0..5655644 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -39,7 +39,7 @@
 static PyTypeObject Arraytype;
 
 #define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
-#define array_CheckExact(op) (Py_Type(op) == &Arraytype)
+#define array_CheckExact(op) (Py_TYPE(op) == &Arraytype)
 
 static int
 array_resize(arrayobject *self, Py_ssize_t newsize)
@@ -53,9 +53,9 @@
 	*/
 
 	if (self->allocated >= newsize &&
-	    Py_Size(self) < newsize + 16 &&
+	    Py_SIZE(self) < newsize + 16 &&
 	    self->ob_item != NULL) {
-		Py_Size(self) = newsize;
+		Py_SIZE(self) = newsize;
 		return 0;
 	}
 
@@ -71,7 +71,7 @@
 	 * memory critical.
 	 */
 
-	_new_size = (newsize >> 4) + (Py_Size(self) < 8 ? 3 : 7) + newsize;
+	_new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
 	items = self->ob_item;
 	/* XXX The following multiplication and division does not optimize away 
 	   like it does for lists since the size is not known at compile time */
@@ -84,7 +84,7 @@
 		return -1;
 	}
 	self->ob_item = items;
-	Py_Size(self) = newsize;
+	Py_SIZE(self) = newsize;
 	self->allocated = _new_size;
 	return 0;
 }
@@ -432,7 +432,7 @@
 	if (op == NULL) {
 		return NULL;
 	}
-	Py_Size(op) = size;
+	Py_SIZE(op) = size;
 	if (size <= 0) {
 		op->ob_item = NULL;
 	}
@@ -455,7 +455,7 @@
 	register arrayobject *ap;
 	assert(array_Check(op));
 	ap = (arrayobject *)op;
-	assert(i>=0 && i<Py_Size(ap));
+	assert(i>=0 && i<Py_SIZE(ap));
 	return (*ap->ob_descr->getitem)(ap, i);
 }
 
@@ -463,7 +463,7 @@
 ins1(arrayobject *self, Py_ssize_t where, PyObject *v)
 {
 	char *items;
-	Py_ssize_t n = Py_Size(self);
+	Py_ssize_t n = Py_SIZE(self);
 	if (v == NULL) {
 		PyErr_BadInternalCall();
 		return -1;
@@ -498,7 +498,7 @@
 		PyObject_ClearWeakRefs((PyObject *) op);
 	if (op->ob_item != NULL)
 		PyMem_DEL(op->ob_item);
-	Py_Type(op)->tp_free((PyObject *)op);
+	Py_TYPE(op)->tp_free((PyObject *)op);
 }
 
 static PyObject *
@@ -518,7 +518,7 @@
 	va = (arrayobject *)v;
 	wa = (arrayobject *)w;
 
-	if (Py_Size(va) != Py_Size(wa) && (op == Py_EQ || op == Py_NE)) {
+	if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) {
 		/* Shortcut: if the lengths differ, the arrays differ */
 		if (op == Py_EQ)
 			res = Py_False;
@@ -530,7 +530,7 @@
 
 	/* Search for the first index where items are different */
 	k = 1;
-	for (i = 0; i < Py_Size(va) && i < Py_Size(wa); i++) {
+	for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
 		vi = getarrayitem(v, i);
 		wi = getarrayitem(w, i);
 		if (vi == NULL || wi == NULL) {
@@ -549,8 +549,8 @@
 
 	if (k) {
 		/* No more items to compare -- compare sizes */
-		Py_ssize_t vs = Py_Size(va);
-		Py_ssize_t ws = Py_Size(wa);
+		Py_ssize_t vs = Py_SIZE(va);
+		Py_ssize_t ws = Py_SIZE(wa);
 		int cmp;
 		switch (op) {
 		case Py_LT: cmp = vs <  ws; break;
@@ -590,13 +590,13 @@
 static Py_ssize_t
 array_length(arrayobject *a)
 {
-	return Py_Size(a);
+	return Py_SIZE(a);
 }
 
 static PyObject *
 array_item(arrayobject *a, Py_ssize_t i)
 {
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		PyErr_SetString(PyExc_IndexError, "array index out of range");
 		return NULL;
 	}
@@ -609,14 +609,14 @@
 	arrayobject *np;
 	if (ilow < 0)
 		ilow = 0;
-	else if (ilow > Py_Size(a))
-		ilow = Py_Size(a);
+	else if (ilow > Py_SIZE(a))
+		ilow = Py_SIZE(a);
 	if (ihigh < 0)
 		ihigh = 0;
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > Py_Size(a))
-		ihigh = Py_Size(a);
+	else if (ihigh > Py_SIZE(a))
+		ihigh = Py_SIZE(a);
 	np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
 	if (np == NULL)
 		return NULL;
@@ -628,7 +628,7 @@
 static PyObject *
 array_copy(arrayobject *a, PyObject *unused)
 {
-	return array_slice(a, 0, Py_Size(a));
+	return array_slice(a, 0, Py_SIZE(a));
 }
 
 PyDoc_STRVAR(copy_doc,
@@ -644,7 +644,7 @@
 	if (!array_Check(bb)) {
 		PyErr_Format(PyExc_TypeError,
 		     "can only append array (not \"%.200s\") to array",
-			     Py_Type(bb)->tp_name);
+			     Py_TYPE(bb)->tp_name);
 		return NULL;
 	}
 #define b ((arrayobject *)bb)
@@ -652,14 +652,14 @@
 		PyErr_BadArgument();
 		return NULL;
 	}
-	size = Py_Size(a) + Py_Size(b);
+	size = Py_SIZE(a) + Py_SIZE(b);
 	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
 	if (np == NULL) {
 		return NULL;
 	}
-	memcpy(np->ob_item, a->ob_item, Py_Size(a)*a->ob_descr->itemsize);
-	memcpy(np->ob_item + Py_Size(a)*a->ob_descr->itemsize,
-	       b->ob_item, Py_Size(b)*b->ob_descr->itemsize);
+	memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
+	memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
+	       b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
 	return (PyObject *)np;
 #undef b
 }
@@ -674,12 +674,12 @@
 	Py_ssize_t nbytes;
 	if (n < 0)
 		n = 0;
-	size = Py_Size(a) * n;
+	size = Py_SIZE(a) * n;
 	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
 	if (np == NULL)
 		return NULL;
 	p = np->ob_item;
-	nbytes = Py_Size(a) * a->ob_descr->itemsize;
+	nbytes = Py_SIZE(a) * a->ob_descr->itemsize;
 	for (i = 0; i < n; i++) {
 		memcpy(p, a->ob_item, nbytes);
 		p += nbytes;
@@ -697,7 +697,7 @@
 	if (v == NULL)
 		n = 0;
 	else if (array_Check(v)) {
-		n = Py_Size(b);
+		n = Py_SIZE(b);
 		if (a == b) {
 			/* Special case "a[i:j] = a" -- copy b first */
 			int ret;
@@ -716,44 +716,44 @@
 	else {
 		PyErr_Format(PyExc_TypeError,
 	     "can only assign array (not \"%.200s\") to array slice",
-			     Py_Type(v)->tp_name);
+			     Py_TYPE(v)->tp_name);
 		return -1;
 	}
 	if (ilow < 0)
 		ilow = 0;
-	else if (ilow > Py_Size(a))
-		ilow = Py_Size(a);
+	else if (ilow > Py_SIZE(a))
+		ilow = Py_SIZE(a);
 	if (ihigh < 0)
 		ihigh = 0;
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > Py_Size(a))
-		ihigh = Py_Size(a);
+	else if (ihigh > Py_SIZE(a))
+		ihigh = Py_SIZE(a);
 	item = a->ob_item;
 	d = n - (ihigh-ilow);
 	if (d < 0) { /* Delete -d items */
 		memmove(item + (ihigh+d)*a->ob_descr->itemsize,
 			item + ihigh*a->ob_descr->itemsize,
-			(Py_Size(a)-ihigh)*a->ob_descr->itemsize);
-		Py_Size(a) += d;
-		PyMem_RESIZE(item, char, Py_Size(a)*a->ob_descr->itemsize);
+			(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
+		Py_SIZE(a) += d;
+		PyMem_RESIZE(item, char, Py_SIZE(a)*a->ob_descr->itemsize);
 						/* Can't fail */
 		a->ob_item = item;
-		a->allocated = Py_Size(a);
+		a->allocated = Py_SIZE(a);
 	}
 	else if (d > 0) { /* Insert d items */
 		PyMem_RESIZE(item, char,
-			     (Py_Size(a) + d)*a->ob_descr->itemsize);
+			     (Py_SIZE(a) + d)*a->ob_descr->itemsize);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return -1;
 		}
 		memmove(item + (ihigh+d)*a->ob_descr->itemsize,
 			item + ihigh*a->ob_descr->itemsize,
-			(Py_Size(a)-ihigh)*a->ob_descr->itemsize);
+			(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
 		a->ob_item = item;
-		Py_Size(a) += d;
-		a->allocated = Py_Size(a);
+		Py_SIZE(a) += d;
+		a->allocated = Py_SIZE(a);
 	}
 	if (n > 0)
 		memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
@@ -765,7 +765,7 @@
 static int
 array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
 {
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		PyErr_SetString(PyExc_IndexError,
 			         "array assignment index out of range");
 		return -1;
@@ -792,7 +792,7 @@
 		return -1;
 
 	while ((v = PyIter_Next(it)) != NULL) {
-		if (ins1(self, (int) Py_Size(self), v) != 0) {
+		if (ins1(self, (int) Py_SIZE(self), v) != 0) {
 			Py_DECREF(v);
 			Py_DECREF(it);
 			return -1;
@@ -818,16 +818,16 @@
 			     "can only extend with array of same kind");
 		return -1;
 	}
-	size = Py_Size(self) + Py_Size(b);
+	size = Py_SIZE(self) + Py_SIZE(b);
         PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
         if (self->ob_item == NULL) {
                 PyObject_Del(self);
                 PyErr_NoMemory();
 		return -1;
         }
-	memcpy(self->ob_item + Py_Size(self)*self->ob_descr->itemsize,
-               b->ob_item, Py_Size(b)*b->ob_descr->itemsize);
-	Py_Size(self) = size;
+	memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
+               b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
+	Py_SIZE(self) = size;
 	self->allocated = size;
 
 	return 0;
@@ -840,7 +840,7 @@
 	if (!array_Check(bb)) {
 		PyErr_Format(PyExc_TypeError,
 			"can only extend array with array (not \"%.200s\")",
-			Py_Type(bb)->tp_name);
+			Py_TYPE(bb)->tp_name);
 		return NULL;
 	}
 	if (array_do_extend(self, bb) == -1)
@@ -855,15 +855,15 @@
 	char *items, *p;
 	Py_ssize_t size, i;
 
-	if (Py_Size(self) > 0) {
+	if (Py_SIZE(self) > 0) {
 		if (n < 0)
 			n = 0;
 		items = self->ob_item;
-		size = Py_Size(self) * self->ob_descr->itemsize;
+		size = Py_SIZE(self) * self->ob_descr->itemsize;
 		if (n == 0) {
 			PyMem_FREE(items);
 			self->ob_item = NULL;
-			Py_Size(self) = 0;
+			Py_SIZE(self) = 0;
 			self->allocated = 0;
 		}
 		else {
@@ -876,8 +876,8 @@
 				memcpy(p, items, size);
 			}
 			self->ob_item = items;
-			Py_Size(self) *= n;
-			self->allocated = Py_Size(self);
+			Py_SIZE(self) *= n;
+			self->allocated = Py_SIZE(self);
 		}
 	}
 	Py_INCREF(self);
@@ -900,7 +900,7 @@
 	Py_ssize_t count = 0;
 	Py_ssize_t i;
 
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self, i);
 		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -922,7 +922,7 @@
 {
 	Py_ssize_t i;
 
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self, i);
 		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -947,7 +947,7 @@
 	Py_ssize_t i;
 	int cmp;
 
-	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(self); i++) {
+	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self, i);
 		cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -960,7 +960,7 @@
 {
 	int i;
 
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self,i);
 		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -990,14 +990,14 @@
 	PyObject *v;
 	if (!PyArg_ParseTuple(args, "|n:pop", &i))
 		return NULL;
-	if (Py_Size(self) == 0) {
+	if (Py_SIZE(self) == 0) {
 		/* Special-case most common failure cause */
 		PyErr_SetString(PyExc_IndexError, "pop from empty array");
 		return NULL;
 	}
 	if (i < 0)
-		i += Py_Size(self);
-	if (i < 0 || i >= Py_Size(self)) {
+		i += Py_SIZE(self);
+	if (i < 0 || i >= Py_SIZE(self)) {
 		PyErr_SetString(PyExc_IndexError, "pop index out of range");
 		return NULL;
 	}
@@ -1053,7 +1053,7 @@
 		return NULL;
 
 	PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
-	PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_Size(self))));
+	PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_SIZE(self))));
 
 	return retval;
 }
@@ -1070,7 +1070,7 @@
 static PyObject *
 array_append(arrayobject *self, PyObject *v)
 {
-	return ins(self, (int) Py_Size(self), v);
+	return ins(self, (int) Py_SIZE(self), v);
 }
 
 PyDoc_STRVAR(append_doc,
@@ -1089,14 +1089,14 @@
 	case 1:
 		break;
 	case 2:
-		for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 2) {
+		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
 			char p0 = p[0];
 			p[0] = p[1];
 			p[1] = p0;
 		}
 		break;
 	case 4:
-		for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 4) {
+		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
 			char p0 = p[0];
 			char p1 = p[1];
 			p[0] = p[3];
@@ -1106,7 +1106,7 @@
 		}
 		break;
 	case 8:
-		for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 8) {
+		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
 			char p0 = p[0];
 			char p1 = p[1];
 			char p2 = p[2];
@@ -1147,16 +1147,16 @@
 		dict = Py_None;
 		Py_INCREF(dict);
 	}
-	if (Py_Size(array) > 0) {
+	if (Py_SIZE(array) > 0) {
 		result = Py_BuildValue("O(cs#)O", 
-			Py_Type(array), 
+			Py_TYPE(array), 
 			array->ob_descr->typecode,
 			array->ob_item,
-			Py_Size(array) * array->ob_descr->itemsize,
+			Py_SIZE(array) * array->ob_descr->itemsize,
 			dict);
 	} else {
 		result = Py_BuildValue("O(c)O", 
-			Py_Type(array), 
+			Py_TYPE(array), 
 			array->ob_descr->typecode,
 			dict);
 	}
@@ -1175,9 +1175,9 @@
 	char tmp[256];	/* 8 is probably enough -- but why skimp */
 	assert((size_t)itemsize <= sizeof(tmp));
 
-	if (Py_Size(self) > 1) {
+	if (Py_SIZE(self) > 1) {
 		for (p = self->ob_item,
-		     q = self->ob_item + (Py_Size(self) - 1)*itemsize;
+		     q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
 		     p < q;
 		     p += itemsize, q -= itemsize) {
 			/* memory areas guaranteed disjoint, so memcpy
@@ -1218,7 +1218,7 @@
 		Py_ssize_t newlength;
 		size_t newbytes;
 		/* Be careful here about overflow */
-		if ((newlength = Py_Size(self) + n) <= 0 ||
+		if ((newlength = Py_SIZE(self) + n) <= 0 ||
 		    (newbytes = newlength * itemsize) / itemsize !=
 		    (size_t)newlength)
 			goto nomem;
@@ -1229,15 +1229,15 @@
 			return NULL;
 		}
 		self->ob_item = item;
-		Py_Size(self) += n;
-		self->allocated = Py_Size(self);
-		nread = fread(item + (Py_Size(self) - n) * itemsize,
+		Py_SIZE(self) += n;
+		self->allocated = Py_SIZE(self);
+		nread = fread(item + (Py_SIZE(self) - n) * itemsize,
 			      itemsize, n, fp);
 		if (nread < (size_t)n) {
-		  Py_Size(self) -= (n - nread);
-			PyMem_RESIZE(item, char, Py_Size(self)*itemsize);
+		  Py_SIZE(self) -= (n - nread);
+			PyMem_RESIZE(item, char, Py_SIZE(self)*itemsize);
 			self->ob_item = item;
-			self->allocated = Py_Size(self);
+			self->allocated = Py_SIZE(self);
 			PyErr_SetString(PyExc_EOFError,
 				         "not enough items in file");
 			return NULL;
@@ -1297,23 +1297,23 @@
 	if (n > 0) {
 		char *item = self->ob_item;
 		Py_ssize_t i;
-		PyMem_RESIZE(item, char, (Py_Size(self) + n) * itemsize);
+		PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return NULL;
 		}
 		self->ob_item = item;
-		Py_Size(self) += n;
-		self->allocated = Py_Size(self);
+		Py_SIZE(self) += n;
+		self->allocated = Py_SIZE(self);
 		for (i = 0; i < n; i++) {
 			PyObject *v = PyList_GetItem(list, i);
 			if ((*self->ob_descr->setitem)(self,
-					Py_Size(self) - n + i, v) != 0) {
-				Py_Size(self) -= n;
+					Py_SIZE(self) - n + i, v) != 0) {
+				Py_SIZE(self) -= n;
 				PyMem_RESIZE(item, char,
-					          Py_Size(self) * itemsize);
+					          Py_SIZE(self) * itemsize);
 				self->ob_item = item;
-				self->allocated = Py_Size(self);
+				self->allocated = Py_SIZE(self);
 				return NULL;
 			}
 		}
@@ -1331,12 +1331,12 @@
 static PyObject *
 array_tolist(arrayobject *self, PyObject *unused)
 {
-	PyObject *list = PyList_New(Py_Size(self));
+	PyObject *list = PyList_New(Py_SIZE(self));
 	Py_ssize_t i;
 
 	if (list == NULL)
 		return NULL;
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *v = getarrayitem((PyObject *)self, i);
 		if (v == NULL) {
 			Py_DECREF(list);
@@ -1369,15 +1369,15 @@
 	n = n / itemsize;
 	if (n > 0) {
 		char *item = self->ob_item;
-		PyMem_RESIZE(item, char, (Py_Size(self) + n) * itemsize);
+		PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return NULL;
 		}
 		self->ob_item = item;
-		Py_Size(self) += n;
-		self->allocated = Py_Size(self);
-		memcpy(item + (Py_Size(self) - n) * itemsize,
+		Py_SIZE(self) += n;
+		self->allocated = Py_SIZE(self);
+		memcpy(item + (Py_SIZE(self) - n) * itemsize,
 		       str, itemsize*n);
 	}
 	Py_INCREF(Py_None);
@@ -1395,7 +1395,7 @@
 array_tostring(arrayobject *self, PyObject *unused)
 {
 	return PyString_FromStringAndSize(self->ob_item,
-				    Py_Size(self) * self->ob_descr->itemsize);
+				    Py_SIZE(self) * self->ob_descr->itemsize);
 }
 
 PyDoc_STRVAR(tostring_doc,
@@ -1423,15 +1423,15 @@
 	}
 	if (n > 0) {
 		Py_UNICODE *item = (Py_UNICODE *) self->ob_item;
-		PyMem_RESIZE(item, Py_UNICODE, Py_Size(self) + n);
+		PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return NULL;
 		}
 		self->ob_item = (char *) item;
-		Py_Size(self) += n;
-		self->allocated = Py_Size(self);
-		memcpy(item + Py_Size(self) - n,
+		Py_SIZE(self) += n;
+		self->allocated = Py_SIZE(self);
+		memcpy(item + Py_SIZE(self) - n,
 		       ustr, n * sizeof(Py_UNICODE));
 	}
 
@@ -1456,7 +1456,7 @@
 			"tounicode() may only be called on type 'u' arrays");
 		return NULL;
 	}
-	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_Size(self));
+	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
 }
 
 PyDoc_STRVAR(tounicode_doc,
@@ -1554,7 +1554,7 @@
 	PyObject *s, *t, *v = NULL;
 	Py_ssize_t len;
 
-	len = Py_Size(a);
+	len = Py_SIZE(a);
 	typecode = a->ob_descr->typecode;
 	if (len == 0) {
 		PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
@@ -1588,7 +1588,7 @@
 			return NULL;
 		}
 		if (i < 0)
-			i += Py_Size(self);
+			i += Py_SIZE(self);
 		return array_item(self, i);
 	}
 	else if (PySlice_Check(item)) {
@@ -1597,7 +1597,7 @@
 		arrayobject* ar;
 		int itemsize = self->ob_descr->itemsize;
 
-		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
+		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
 				 &start, &stop, &step, &slicelength) < 0) {
 			return NULL;
 		}
@@ -1651,8 +1651,8 @@
 		if (i == -1 && PyErr_Occurred())
 			return -1;
 		if (i < 0)
-			i += Py_Size(self);
-		if (i < 0 || i >= Py_Size(self)) {
+			i += Py_SIZE(self);
+		if (i < 0 || i >= Py_SIZE(self)) {
 			PyErr_SetString(PyExc_IndexError,
 				"array assignment index out of range");
 			return -1;
@@ -1669,7 +1669,7 @@
 	}
 	else if (PySlice_Check(item)) {
 		if (PySlice_GetIndicesEx((PySliceObject *)item,
-					 Py_Size(self), &start, &stop,
+					 Py_SIZE(self), &start, &stop,
 					 &step, &slicelength) < 0) {
 			return -1;
 		}
@@ -1685,7 +1685,7 @@
 	}
 	else if (array_Check(value)) {
 		other = (arrayobject *)value;
-		needed = Py_Size(other);
+		needed = Py_SIZE(other);
 		if (self == other) {
 			/* Special case "self[i:j] = self" -- copy self first */
 			int ret;
@@ -1704,7 +1704,7 @@
 	else {
 		PyErr_Format(PyExc_TypeError,
 	     "can only assign array (not \"%.200s\") to array slice",
-			     Py_Type(value)->tp_name);
+			     Py_TYPE(value)->tp_name);
 		return -1;
 	}
 	itemsize = self->ob_descr->itemsize;
@@ -1716,18 +1716,18 @@
 		if (slicelength > needed) {
 			memmove(self->ob_item + (start + needed) * itemsize,
 				self->ob_item + stop * itemsize,
-				(Py_Size(self) - stop) * itemsize);
-			if (array_resize(self, Py_Size(self) +
+				(Py_SIZE(self) - stop) * itemsize);
+			if (array_resize(self, Py_SIZE(self) +
 					 needed - slicelength) < 0)
 				return -1;
 		}
 		else if (slicelength < needed) {
-			if (array_resize(self, Py_Size(self) +
+			if (array_resize(self, Py_SIZE(self) +
 					 needed - slicelength) < 0)
 				return -1;
 			memmove(self->ob_item + (start + needed) * itemsize,
 				self->ob_item + stop * itemsize,
-				(Py_Size(self) - start - needed) * itemsize);
+				(Py_SIZE(self) - start - needed) * itemsize);
 		}
 		if (needed > 0)
 			memcpy(self->ob_item + start * itemsize,
@@ -1747,19 +1747,19 @@
 		     cur += step, i++) {
 			Py_ssize_t lim = step - 1;
 
-			if (cur + step >= Py_Size(self))
-				lim = Py_Size(self) - cur - 1;
+			if (cur + step >= Py_SIZE(self))
+				lim = Py_SIZE(self) - cur - 1;
 			memmove(self->ob_item + (cur - i) * itemsize,
 				self->ob_item + (cur + 1) * itemsize,
 				lim * itemsize);
 		}
 		cur = start + slicelength * step;
-		if (cur < Py_Size(self)) {
+		if (cur < Py_SIZE(self)) {
 			memmove(self->ob_item + (cur-slicelength) * itemsize,
 				self->ob_item + cur * itemsize,
-				(Py_Size(self) - cur) * itemsize);
+				(Py_SIZE(self) - cur) * itemsize);
 		}
-		if (array_resize(self, Py_Size(self) - slicelength) < 0)
+		if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
 			return -1;
 		return 0;
 	}
@@ -1802,7 +1802,7 @@
 	*ptr = (void *)self->ob_item;
 	if (*ptr == NULL)
 		*ptr = emptybuf;
-	return Py_Size(self)*self->ob_descr->itemsize;
+	return Py_SIZE(self)*self->ob_descr->itemsize;
 }
 
 static Py_ssize_t
@@ -1816,14 +1816,14 @@
 	*ptr = (void *)self->ob_item;
 	if (*ptr == NULL)
 		*ptr = emptybuf;
-	return Py_Size(self)*self->ob_descr->itemsize;
+	return Py_SIZE(self)*self->ob_descr->itemsize;
 }
 
 static Py_ssize_t
 array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp)
 {
 	if ( lenp )
-		*lenp = Py_Size(self)*self->ob_descr->itemsize;
+		*lenp = Py_SIZE(self)*self->ob_descr->itemsize;
 	return 1;
 }
 
@@ -1932,9 +1932,9 @@
 						return NULL;
 					}
 					self->ob_item = item;
-					Py_Size(self) = n / sizeof(Py_UNICODE);
+					Py_SIZE(self) = n / sizeof(Py_UNICODE);
 					memcpy(item, PyUnicode_AS_DATA(initial), n);
-					self->allocated = Py_Size(self);
+					self->allocated = Py_SIZE(self);
 				}
 #endif
 			}
@@ -2103,7 +2103,7 @@
 arrayiter_next(arrayiterobject *it)
 {
 	assert(PyArrayIter_Check(it));
-	if (it->index < Py_Size(it->ao))
+	if (it->index < Py_SIZE(it->ao))
 		return (*it->getitem)(it->ao, it->index++);
 	return NULL;
 }