Merged revisions 56467-56482 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/branches/p3yk

................
  r56477 | martin.v.loewis | 2007-07-21 09:04:38 +0200 (Sa, 21 Jul 2007) | 11 lines

  Merged revisions 56466-56476 via svnmerge from
  svn+ssh://pythondev@svn.python.org/python/trunk

  ........
    r56476 | martin.v.loewis | 2007-07-21 08:55:02 +0200 (Sa, 21 Jul 2007) | 4 lines

    PEP 3123: Provide forward compatibility with Python 3.0, while keeping
    backwards compatibility. Add Py_Refcnt, Py_Type, Py_Size, and
    PyVarObject_HEAD_INIT.
  ........
................
  r56478 | martin.v.loewis | 2007-07-21 09:47:23 +0200 (Sa, 21 Jul 2007) | 2 lines

  PEP 3123: Use proper C inheritance for PyObject.
................
  r56479 | martin.v.loewis | 2007-07-21 10:06:55 +0200 (Sa, 21 Jul 2007) | 3 lines

  Add longintrepr.h to Python.h, so that the compiler can
  see that PyFalse is really some kind of PyObject*.
................
  r56480 | martin.v.loewis | 2007-07-21 10:47:18 +0200 (Sa, 21 Jul 2007) | 2 lines

  Qualify SHIFT, MASK, BASE.
................
  r56482 | martin.v.loewis | 2007-07-21 19:10:57 +0200 (Sa, 21 Jul 2007) | 2 lines

  Correctly refer to _ob_next.
................

1 files changed, 285 insertions, 286 deletions

diff --git a/Objects/longobject.c b/Objects/longobject.c
index bfef437..930d07e 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -46,11 +46,11 @@ get_small_int(int ival)
 #define CHECK_SMALL_INT(ival)
 #endif
 
-#define MEDIUM_VALUE(x) ((x)->ob_size < 0 ? -(x)->ob_digit[0] : ((x)->ob_size == 0 ? 0 : (x)->ob_digit[0]))
+#define MEDIUM_VALUE(x) (Py_Size(x) < 0 ? -(x)->ob_digit[0] : (Py_Size(x) == 0 ? 0 : (x)->ob_digit[0]))
 /* If a freshly-allocated long is already shared, it must
    be a small integer, so negating it must go to PyLong_FromLong */
 #define NEGATE(x) \
-	do if ((x)->ob_refcnt == 1) (x)->ob_size = -(x)->ob_size;  \
+	do if (Py_Refcnt(x) == 1) Py_Size(x) = -Py_Size(x);  \
 	   else { PyObject* tmp=PyInt_FromLong(-MEDIUM_VALUE(x));  \
 		   Py_DECREF(x); (x) = (PyLongObject*)tmp; }	   \
         while(0)
@@ -94,13 +94,13 @@ static PyLongObject *divrem1(PyLongObject *, digit, digit *);
 static PyLongObject *
 long_normalize(register PyLongObject *v)
 {
-	Py_ssize_t j = ABS(v->ob_size);
+	Py_ssize_t j = ABS(Py_Size(v));
 	Py_ssize_t i = j;
 
 	while (i > 0 && v->ob_digit[i-1] == 0)
 		--i;
 	if (i != j)
-		v->ob_size = (v->ob_size < 0) ? -(i) : i;
+		Py_Size(v) = (Py_Size(v) < 0) ? -(i) : i;
 	return v;
 }
 
@@ -134,18 +134,18 @@ _PyLong_Copy(PyLongObject *src)
 	Py_ssize_t i;
 
 	assert(src != NULL);
-	i = src->ob_size;
+	i = Py_Size(src);
 	if (i < 0)
 		i = -(i);
 	if (i < 2) {
 		int ival = src->ob_digit[0];
-		if (src->ob_size < 0)
+		if (Py_Size(src) < 0)
 			ival = -ival;
 		CHECK_SMALL_INT(ival);
 	}
 	result = _PyLong_New(i);
 	if (result != NULL) {
-		result->ob_size = src->ob_size;
+		Py_Size(result) = Py_Size(src);
 		while (--i >= 0)
 			result->ob_digit[i] = src->ob_digit[i];
 	}
@@ -170,22 +170,22 @@ PyLong_FromLong(long ival)
 	}
 
 	/* Fast path for single-digits ints */
-	if (!(ival>>SHIFT)) {
+	if (!(ival>>PyLong_SHIFT)) {
 		v = _PyLong_New(1);
 		if (v) {
-			v->ob_size = sign;
+			Py_Size(v) = sign;
 			v->ob_digit[0] = ival;
 		}
 		return (PyObject*)v;
 	}
 
 	/* 2 digits */
-	if (!(ival >> 2*SHIFT)) {
+	if (!(ival >> 2*PyLong_SHIFT)) {
 		v = _PyLong_New(2);
 		if (v) {
-			v->ob_size = 2*sign;
-			v->ob_digit[0] = (digit)ival & MASK;
-			v->ob_digit[1] = ival >> SHIFT;
+			Py_Size(v) = 2*sign;
+			v->ob_digit[0] = (digit)ival & PyLong_MASK;
+			v->ob_digit[1] = ival >> PyLong_SHIFT;
 		}
 		return (PyObject*)v;
 	}
@@ -194,16 +194,16 @@ PyLong_FromLong(long ival)
 	t = (unsigned long)ival;
 	while (t) {
 		++ndigits;
-		t >>= SHIFT;
+		t >>= PyLong_SHIFT;
 	}
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		v->ob_size = ndigits*sign;
+		Py_Size(v) = ndigits*sign;
 		t = (unsigned long)ival;
 		while (t) {
-			*p++ = (digit)(t & MASK);
-			t >>= SHIFT;
+			*p++ = (digit)(t & PyLong_MASK);
+			t >>= PyLong_SHIFT;
 		}
 	}
 	return (PyObject *)v;
@@ -218,21 +218,21 @@ PyLong_FromUnsignedLong(unsigned long ival)
 	unsigned long t;
 	int ndigits = 0;
 
-	if (ival < BASE)
+	if (ival < PyLong_BASE)
 		return PyLong_FromLong(ival);
 	/* Count the number of Python digits. */
 	t = (unsigned long)ival;
 	while (t) {
 		++ndigits;
-		t >>= SHIFT;
+		t >>= PyLong_SHIFT;
 	}
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		v->ob_size = ndigits;
+		Py_Size(v) = ndigits;
 		while (ival) {
-			*p++ = (digit)(ival & MASK);
-			ival >>= SHIFT;
+			*p++ = (digit)(ival & PyLong_MASK);
+			ival >>= PyLong_SHIFT;
 		}
 	}
 	return (PyObject *)v;
@@ -260,19 +260,19 @@ PyLong_FromDouble(double dval)
 	frac = frexp(dval, &expo); /* dval = frac*2**expo; 0.0 <= frac < 1.0 */
 	if (expo <= 0)
 		return PyLong_FromLong(0L);
-	ndig = (expo-1) / SHIFT + 1; /* Number of 'digits' in result */
+	ndig = (expo-1) / PyLong_SHIFT + 1; /* Number of 'digits' in result */
 	v = _PyLong_New(ndig);
 	if (v == NULL)
 		return NULL;
-	frac = ldexp(frac, (expo-1) % SHIFT + 1);
+	frac = ldexp(frac, (expo-1) % PyLong_SHIFT + 1);
 	for (i = ndig; --i >= 0; ) {
 		long bits = (long)frac;
 		v->ob_digit[i] = (digit) bits;
 		frac = frac - (double)bits;
-		frac = ldexp(frac, SHIFT);
+		frac = ldexp(frac, PyLong_SHIFT);
 	}
 	if (neg)
-		v->ob_size = -(v->ob_size);
+		Py_Size(v) = -(Py_Size(v));
 	return (PyObject *)v;
 }
 
@@ -328,7 +328,7 @@ PyLong_AsLong(PyObject *vv)
 
 	res = -1;
 	v = (PyLongObject *)vv;
-	i = v->ob_size;
+	i = Py_Size(v);
 
 	switch (i) {
 	case -1:
@@ -349,8 +349,8 @@ PyLong_AsLong(PyObject *vv)
 		}
 		while (--i >= 0) {
 			prev = x;
-			x = (x << SHIFT) + v->ob_digit[i];
-			if ((x >> SHIFT) != prev) {
+			x = (x << PyLong_SHIFT) + v->ob_digit[i];
+			if ((x >> PyLong_SHIFT) != prev) {
 				PyErr_SetString(PyExc_OverflowError,
 					"Python int too large to convert to C long");
 				goto exit;
@@ -386,7 +386,7 @@ _PyLong_FitsInLong(PyObject *vv)
 		return 0;
 	}
 	/* conservative estimate */
-	size = ((PyLongObject*)vv)->ob_size;
+	size = Py_Size(vv);
 	return -2 <= size && size <= 2;
 }
 
@@ -405,7 +405,7 @@ PyLong_AsSsize_t(PyObject *vv) {
 		return -1;
 	}
 	v = (PyLongObject *)vv;
-	i = v->ob_size;
+	i = Py_Size(v);
 	switch (i) {
 	case -1: return -v->ob_digit[0];
 	case 0: return 0;
@@ -419,8 +419,8 @@ PyLong_AsSsize_t(PyObject *vv) {
 	}
 	while (--i >= 0) {
 		prev = x;
-		x = (x << SHIFT) + v->ob_digit[i];
-		if ((x >> SHIFT) != prev)
+		x = (x << PyLong_SHIFT) + v->ob_digit[i];
+		if ((x >> PyLong_SHIFT) != prev)
 			goto overflow;
 	}
 	/* Haven't lost any bits, but casting to a signed type requires
@@ -455,7 +455,7 @@ PyLong_AsUnsignedLong(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	i = v->ob_size;
+	i = Py_Size(v);
 	x = 0;
 	if (i < 0) {
 		PyErr_SetString(PyExc_OverflowError,
@@ -468,8 +468,8 @@ PyLong_AsUnsignedLong(PyObject *vv)
 	}
 	while (--i >= 0) {
 		prev = x;
-		x = (x << SHIFT) + v->ob_digit[i];
-		if ((x >> SHIFT) != prev) {
+		x = (x << PyLong_SHIFT) + v->ob_digit[i];
+		if ((x >> PyLong_SHIFT) != prev) {
 			PyErr_SetString(PyExc_OverflowError,
 			 "python int too large to convert to C unsigned long");
 			return (unsigned long) -1;
@@ -493,7 +493,7 @@ PyLong_AsSize_t(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	i = v->ob_size;
+	i = Py_Size(v);
 	x = 0;
 	if (i < 0) {
 		PyErr_SetString(PyExc_OverflowError,
@@ -506,8 +506,8 @@ PyLong_AsSize_t(PyObject *vv)
 	}
 	while (--i >= 0) {
 		prev = x;
-		x = (x << SHIFT) + v->ob_digit[i];
-		if ((x >> SHIFT) != prev) {
+		x = (x << PyLong_SHIFT) + v->ob_digit[i];
+		if ((x >> PyLong_SHIFT) != prev) {
 			PyErr_SetString(PyExc_OverflowError,
 			    "Python int too large to convert to C size_t");
 			return (unsigned long) -1;
@@ -532,7 +532,7 @@ _PyLong_AsUnsignedLongMask(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	i = v->ob_size;
+	i = Py_Size(v);
 	switch (i) {
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
@@ -544,7 +544,7 @@ _PyLong_AsUnsignedLongMask(PyObject *vv)
 		i = -i;
 	}
 	while (--i >= 0) {
-		x = (x << SHIFT) + v->ob_digit[i];
+		x = (x << PyLong_SHIFT) + v->ob_digit[i];
 	}
 	return x * sign;
 }
@@ -592,7 +592,7 @@ _PyLong_Sign(PyObject *vv)
 	assert(v != NULL);
 	assert(PyLong_Check(v));
 
-	return v->ob_size == 0 ? 0 : (v->ob_size < 0 ? -1 : 1);
+	return Py_Size(v) == 0 ? 0 : (Py_Size(v) < 0 ? -1 : 1);
 }
 
 size_t
@@ -604,13 +604,13 @@ _PyLong_NumBits(PyObject *vv)
 
 	assert(v != NULL);
 	assert(PyLong_Check(v));
-	ndigits = ABS(v->ob_size);
+	ndigits = ABS(Py_Size(v));
 	assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
 	if (ndigits > 0) {
 		digit msd = v->ob_digit[ndigits - 1];
 
-		result = (ndigits - 1) * SHIFT;
-		if (result / SHIFT != (size_t)(ndigits - 1))
+		result = (ndigits - 1) * PyLong_SHIFT;
+		if (result / PyLong_SHIFT != (size_t)(ndigits - 1))
 			goto Overflow;
 		do {
 			++result;
@@ -680,9 +680,9 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
 	}
 
 	/* How many Python long digits do we need?  We have
-	   8*numsignificantbytes bits, and each Python long digit has SHIFT
+	   8*numsignificantbytes bits, and each Python long digit has PyLong_SHIFT
 	   bits, so it's the ceiling of the quotient. */
-	ndigits = (numsignificantbytes * 8 + SHIFT - 1) / SHIFT;
+	ndigits = (numsignificantbytes * 8 + PyLong_SHIFT - 1) / PyLong_SHIFT;
 	if (ndigits > (size_t)INT_MAX)
 		return PyErr_NoMemory();
 	v = _PyLong_New((int)ndigits);
@@ -712,17 +712,17 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
 			   so needs to be prepended to accum. */
 			accum |= thisbyte << accumbits;
 			accumbits += 8;
-			if (accumbits >= SHIFT) {
+			if (accumbits >= PyLong_SHIFT) {
 				/* There's enough to fill a Python digit. */
 				assert(idigit < (int)ndigits);
-				v->ob_digit[idigit] = (digit)(accum & MASK);
+				v->ob_digit[idigit] = (digit)(accum & PyLong_MASK);
 				++idigit;
-				accum >>= SHIFT;
-				accumbits -= SHIFT;
-				assert(accumbits < SHIFT);
+				accum >>= PyLong_SHIFT;
+				accumbits -= PyLong_SHIFT;
+				assert(accumbits < PyLong_SHIFT);
 			}
 		}
-		assert(accumbits < SHIFT);
+		assert(accumbits < PyLong_SHIFT);
 		if (accumbits) {
 			assert(idigit < (int)ndigits);
 			v->ob_digit[idigit] = (digit)accum;
@@ -730,7 +730,7 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
 		}
 	}
 
-	v->ob_size = is_signed ? -idigit : idigit;
+	Py_Size(v) = is_signed ? -idigit : idigit;
 	return (PyObject *)long_normalize(v);
 }
 
@@ -751,8 +751,8 @@ _PyLong_AsByteArray(PyLongObject* v,
 
 	assert(v != NULL && PyLong_Check(v));
 
-	if (v->ob_size < 0) {
-		ndigits = -(v->ob_size);
+	if (Py_Size(v) < 0) {
+		ndigits = -(Py_Size(v));
 		if (!is_signed) {
 			PyErr_SetString(PyExc_TypeError,
 				"can't convert negative int to unsigned");
@@ -761,7 +761,7 @@ _PyLong_AsByteArray(PyLongObject* v,
 		do_twos_comp = 1;
 	}
 	else {
-		ndigits = v->ob_size;
+		ndigits = Py_Size(v);
 		do_twos_comp = 0;
 	}
 
@@ -776,7 +776,7 @@ _PyLong_AsByteArray(PyLongObject* v,
 
 	/* Copy over all the Python digits.
 	   It's crucial that every Python digit except for the MSD contribute
-	   exactly SHIFT bits to the total, so first assert that the long is
+	   exactly PyLong_SHIFT bits to the total, so first assert that the long is
 	   normalized. */
 	assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
 	j = 0;
@@ -786,15 +786,15 @@ _PyLong_AsByteArray(PyLongObject* v,
 	for (i = 0; i < ndigits; ++i) {
 		twodigits thisdigit = v->ob_digit[i];
 		if (do_twos_comp) {
-			thisdigit = (thisdigit ^ MASK) + carry;
-			carry = thisdigit >> SHIFT;
-			thisdigit &= MASK;
+			thisdigit = (thisdigit ^ PyLong_MASK) + carry;
+			carry = thisdigit >> PyLong_SHIFT;
+			thisdigit &= PyLong_MASK;
 		}
 		/* Because we're going LSB to MSB, thisdigit is more
 		   significant than what's already in accum, so needs to be
 		   prepended to accum. */
 		accum |= thisdigit << accumbits;
-		accumbits += SHIFT;
+		accumbits += PyLong_SHIFT;
 
 		/* The most-significant digit may be (probably is) at least
 		   partly empty. */
@@ -805,9 +805,9 @@ _PyLong_AsByteArray(PyLongObject* v,
 			 * First shift conceptual sign bit to real sign bit.
 			 */
 			stwodigits s = (stwodigits)(thisdigit <<
-				(8*sizeof(stwodigits) - SHIFT));
+				(8*sizeof(stwodigits) - PyLong_SHIFT));
 			unsigned int nsignbits = 0;
-			while ((s < 0) == do_twos_comp && nsignbits < SHIFT) {
+			while ((s < 0) == do_twos_comp && nsignbits < PyLong_SHIFT) {
 				++nsignbits;
 				s <<= 1;
 			}
@@ -887,7 +887,7 @@ _PyLong_AsScaledDouble(PyObject *vv, int *exponent)
 #define NBITS_WANTED 57
 	PyLongObject *v;
 	double x;
-	const double multiplier = (double)(1L << SHIFT);
+	const double multiplier = (double)(1L << PyLong_SHIFT);
 	Py_ssize_t i;
 	int sign;
 	int nbitsneeded;
@@ -897,7 +897,7 @@ _PyLong_AsScaledDouble(PyObject *vv, int *exponent)
 		return -1;
 	}
 	v = (PyLongObject *)vv;
-	i = v->ob_size;
+	i = Py_Size(v);
 	sign = 1;
 	if (i < 0) {
 		sign = -1;
@@ -914,10 +914,10 @@ _PyLong_AsScaledDouble(PyObject *vv, int *exponent)
 	while (i > 0 && nbitsneeded > 0) {
 		--i;
 		x = x * multiplier + (double)v->ob_digit[i];
-		nbitsneeded -= SHIFT;
+		nbitsneeded -= PyLong_SHIFT;
 	}
 	/* There are i digits we didn't shift in.  Pretending they're all
-	   zeroes, the true value is x * 2**(i*SHIFT). */
+	   zeroes, the true value is x * 2**(i*PyLong_SHIFT). */
 	*exponent = i;
 	assert(x > 0.0);
 	return x * sign;
@@ -942,10 +942,10 @@ PyLong_AsDouble(PyObject *vv)
 	/* 'e' initialized to -1 to silence gcc-4.0.x, but it should be
 	   set correctly after a successful _PyLong_AsScaledDouble() call */
 	assert(e >= 0);
-	if (e > INT_MAX / SHIFT)
+	if (e > INT_MAX / PyLong_SHIFT)
 		goto overflow;
 	errno = 0;
-	x = ldexp(x, e * SHIFT);
+	x = ldexp(x, e * PyLong_SHIFT);
 	if (Py_OVERFLOWED(x))
 		goto overflow;
 	return x;
@@ -1043,16 +1043,16 @@ PyLong_FromLongLong(PY_LONG_LONG ival)
 	t = (unsigned PY_LONG_LONG)ival;
 	while (t) {
 		++ndigits;
-		t >>= SHIFT;
+		t >>= PyLong_SHIFT;
 	}
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		v->ob_size = negative ? -ndigits : ndigits;
+		Py_Size(v) = negative ? -ndigits : ndigits;
 		t = (unsigned PY_LONG_LONG)ival;
 		while (t) {
-			*p++ = (digit)(t & MASK);
-			t >>= SHIFT;
+			*p++ = (digit)(t & PyLong_MASK);
+			t >>= PyLong_SHIFT;
 		}
 	}
 	return (PyObject *)v;
@@ -1067,21 +1067,21 @@ PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival)
 	unsigned PY_LONG_LONG t;
 	int ndigits = 0;
 
-	if (ival < BASE)
+	if (ival < PyLong_BASE)
 		return PyLong_FromLong(ival);
 	/* Count the number of Python digits. */
 	t = (unsigned PY_LONG_LONG)ival;
 	while (t) {
 		++ndigits;
-		t >>= SHIFT;
+		t >>= PyLong_SHIFT;
 	}
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		v->ob_size = ndigits;
+		Py_Size(v) = ndigits;
 		while (ival) {
-			*p++ = (digit)(ival & MASK);
-			ival >>= SHIFT;
+			*p++ = (digit)(ival & PyLong_MASK);
+			ival >>= PyLong_SHIFT;
 		}
 	}
 	return (PyObject *)v;
@@ -1094,7 +1094,7 @@ PyLong_FromSsize_t(Py_ssize_t ival)
 {
 	Py_ssize_t bytes = ival;
 	int one = 1;
-	if (ival < BASE)
+	if (ival < PyLong_BASE)
 		return PyLong_FromLong(ival);
 	return _PyLong_FromByteArray(
 			(unsigned char *)&bytes,
@@ -1108,7 +1108,7 @@ PyLong_FromSize_t(size_t ival)
 {
 	size_t bytes = ival;
 	int one = 1;
-	if (ival < BASE)
+	if (ival < PyLong_BASE)
 		return PyLong_FromLong(ival);
 	return _PyLong_FromByteArray(
 			(unsigned char *)&bytes,
@@ -1152,7 +1152,7 @@ PyLong_AsLongLong(PyObject *vv)
 	}
 
 	v = (PyLongObject*)vv;
-	switch(v->ob_size) {
+	switch(Py_Size(v)) {
 	case -1: return -v->ob_digit[0];
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
@@ -1185,7 +1185,7 @@ PyLong_AsUnsignedLongLong(PyObject *vv)
 	}
 
 	v = (PyLongObject*)vv;
-	switch(v->ob_size) {
+	switch(Py_Size(v)) {
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
 	}
@@ -1217,11 +1217,11 @@ _PyLong_AsUnsignedLongLongMask(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	switch(v->ob_size) {
+	switch(Py_Size(v)) {
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
 	}
-	i = v->ob_size;
+	i = Py_Size(v);
 	sign = 1;
 	x = 0;
 	if (i < 0) {
@@ -1229,7 +1229,7 @@ _PyLong_AsUnsignedLongLongMask(PyObject *vv)
 		i = -i;
 	}
 	while (--i >= 0) {
-		x = (x << SHIFT) + v->ob_digit[i];
+		x = (x << PyLong_SHIFT) + v->ob_digit[i];
 	}
 	return x * sign;
 }
@@ -1312,14 +1312,14 @@ v_iadd(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n)
 	assert(m >= n);
 	for (i = 0; i < n; ++i) {
 		carry += x[i] + y[i];
-		x[i] = carry & MASK;
-		carry >>= SHIFT;
+		x[i] = carry & PyLong_MASK;
+		carry >>= PyLong_SHIFT;
 		assert((carry & 1) == carry);
 	}
 	for (; carry && i < m; ++i) {
 		carry += x[i];
-		x[i] = carry & MASK;
-		carry >>= SHIFT;
+		x[i] = carry & PyLong_MASK;
+		carry >>= PyLong_SHIFT;
 		assert((carry & 1) == carry);
 	}
 	return carry;
@@ -1338,14 +1338,14 @@ v_isub(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n)
 	assert(m >= n);
 	for (i = 0; i < n; ++i) {
 		borrow = x[i] - y[i] - borrow;
-		x[i] = borrow & MASK;
-		borrow >>= SHIFT;
+		x[i] = borrow & PyLong_MASK;
+		borrow >>= PyLong_SHIFT;
 		borrow &= 1;	/* keep only 1 sign bit */
 	}
 	for (; borrow && i < m; ++i) {
 		borrow = x[i] - borrow;
-		x[i] = borrow & MASK;
-		borrow >>= SHIFT;
+		x[i] = borrow & PyLong_MASK;
+		borrow >>= PyLong_SHIFT;
 		borrow &= 1;
 	}
 	return borrow;
@@ -1364,7 +1364,7 @@ mul1(PyLongObject *a, wdigit n)
 static PyLongObject *
 muladd1(PyLongObject *a, wdigit n, wdigit extra)
 {
-	Py_ssize_t size_a = ABS(a->ob_size);
+	Py_ssize_t size_a = ABS(Py_Size(a));
 	PyLongObject *z = _PyLong_New(size_a+1);
 	twodigits carry = extra;
 	Py_ssize_t i;
@@ -1373,8 +1373,8 @@ muladd1(PyLongObject *a, wdigit n, wdigit extra)
 		return NULL;
 	for (i = 0; i < size_a; ++i) {
 		carry += (twodigits)a->ob_digit[i] * n;
-		z->ob_digit[i] = (digit) (carry & MASK);
-		carry >>= SHIFT;
+		z->ob_digit[i] = (digit) (carry & PyLong_MASK);
+		carry >>= PyLong_SHIFT;
 	}
 	z->ob_digit[i] = (digit) carry;
 	return long_normalize(z);
@@ -1391,12 +1391,12 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
 {
 	twodigits rem = 0;
 
-	assert(n > 0 && n <= MASK);
+	assert(n > 0 && n <= PyLong_MASK);
 	pin += size;
 	pout += size;
 	while (--size >= 0) {
 		digit hi;
-		rem = (rem << SHIFT) + *--pin;
+		rem = (rem << PyLong_SHIFT) + *--pin;
 		*--pout = hi = (digit)(rem / n);
 		rem -= hi * n;
 	}
@@ -1410,10 +1410,10 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
 static PyLongObject *
 divrem1(PyLongObject *a, digit n, digit *prem)
 {
-	const Py_ssize_t size = ABS(a->ob_size);
+	const Py_ssize_t size = ABS(Py_Size(a));
 	PyLongObject *z;
 
-	assert(n > 0 && n <= MASK);
+	assert(n > 0 && n <= PyLong_MASK);
 	z = _PyLong_New(size);
 	if (z == NULL)
 		return NULL;
@@ -1441,7 +1441,7 @@ _PyLong_Format(PyObject *aa, int base)
 		return NULL;
 	}
 	assert(base >= 2 && base <= 36);
-	size_a = ABS(a->ob_size);
+	size_a = ABS(Py_Size(a));
 
 	/* Compute a rough upper bound for the length of the string */
 	i = base;
@@ -1451,9 +1451,9 @@ _PyLong_Format(PyObject *aa, int base)
 		i >>= 1;
 	}
 	i = 5;
-	j = size_a*SHIFT + bits-1;
+	j = size_a*PyLong_SHIFT + bits-1;
 	sz = i + j / bits;
-	if (j / SHIFT < size_a || sz < i) {
+	if (j / PyLong_SHIFT < size_a || sz < i) {
 		PyErr_SetString(PyExc_OverflowError,
 				"int is too large to format");
 		return NULL;
@@ -1463,10 +1463,10 @@ _PyLong_Format(PyObject *aa, int base)
 		return NULL;
 	p = PyUnicode_AS_UNICODE(str) + sz;
 	*p = '\0';
-	if (a->ob_size < 0)
+	if (Py_Size(a) < 0)
 		sign = '-';
 
-	if (a->ob_size == 0) {
+	if (Py_Size(a) == 0) {
 		*--p = '0';
 	}
 	else if ((base & (base - 1)) == 0) {
@@ -1480,7 +1480,7 @@ _PyLong_Format(PyObject *aa, int base)
 
 		for (i = 0; i < size_a; ++i) {
 			accum |= (twodigits)a->ob_digit[i] << accumbits;
-			accumbits += SHIFT;
+			accumbits += PyLong_SHIFT;
 			assert(accumbits >= basebits);
 			do {
 				char cdigit = (char)(accum & (base - 1));
@@ -1505,7 +1505,7 @@ _PyLong_Format(PyObject *aa, int base)
 		int power = 1;
 		for (;;) {
 			unsigned long newpow = powbase * (unsigned long)base;
-			if (newpow >> SHIFT)  /* doesn't fit in a digit */
+			if (newpow >> PyLong_SHIFT)  /* doesn't fit in a digit */
 				break;
 			powbase = (digit)newpow;
 			++power;
@@ -1589,7 +1589,7 @@ _PyLong_Format(PyObject *aa, int base)
  * 'a' and 'A' map to 10, ..., 'z' and 'Z' map to 35.
  * All other indices map to 37.
  * Note that when converting a base B string, a char c is a legitimate
- * base B digit iff _PyLong_DigitValue[Py_CHARMASK(c)] < B.
+ * base B digit iff _PyLong_DigitValue[Py_CHARPyLong_MASK(c)] < B.
  */
 int _PyLong_DigitValue[256] = {
 	37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
@@ -1637,14 +1637,14 @@ long_from_binary_base(char **str, int base)
 	while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base)
 		++p;
 	*str = p;
-	/* n <- # of Python digits needed, = ceiling(n/SHIFT). */
-	n = (p - start) * bits_per_char + SHIFT - 1;
+	/* n <- # of Python digits needed, = ceiling(n/PyLong_SHIFT). */
+	n = (p - start) * bits_per_char + PyLong_SHIFT - 1;
 	if (n / bits_per_char < p - start) {
 		PyErr_SetString(PyExc_ValueError,
 				"int string too large to convert");
 		return NULL;
 	}
-	n = n / SHIFT;
+	n = n / PyLong_SHIFT;
 	z = _PyLong_New(n);
 	if (z == NULL)
 		return NULL;
@@ -1659,16 +1659,16 @@ long_from_binary_base(char **str, int base)
 		assert(k >= 0 && k < base);
 		accum |= (twodigits)(k << bits_in_accum);
 		bits_in_accum += bits_per_char;
-		if (bits_in_accum >= SHIFT) {
-			*pdigit++ = (digit)(accum & MASK);
+		if (bits_in_accum >= PyLong_SHIFT) {
+			*pdigit++ = (digit)(accum & PyLong_MASK);
 			assert(pdigit - z->ob_digit <= (int)n);
-			accum >>= SHIFT;
-			bits_in_accum -= SHIFT;
-			assert(bits_in_accum < SHIFT);
+			accum >>= PyLong_SHIFT;
+			bits_in_accum -= PyLong_SHIFT;
+			assert(bits_in_accum < PyLong_SHIFT);
 		}
 	}
 	if (bits_in_accum) {
-		assert(bits_in_accum <= SHIFT);
+		assert(bits_in_accum <= PyLong_SHIFT);
 		*pdigit++ = (digit)accum;
 		assert(pdigit - z->ob_digit <= (int)n);
 	}
@@ -1829,10 +1829,10 @@ digit beyond the first.
 			int i = 1;
 
 			log_base_BASE[base] = log((double)base) /
-						log((double)BASE);
+						log((double)PyLong_BASE);
 			for (;;) {
 				twodigits next = convmax * base;
-				if (next > BASE)
+				if (next > PyLong_BASE)
 					break;
 				convmax = next;
 				++i;
@@ -1859,7 +1859,7 @@ digit beyond the first.
 		z = _PyLong_New(size_z);
 		if (z == NULL)
 			return NULL;
-		z->ob_size = 0;
+		Py_Size(z) = 0;
 
 		/* `convwidth` consecutive input digits are treated as a single
 		 * digit in base `convmultmax`.
@@ -1874,7 +1874,7 @@ digit beyond the first.
 			for (i = 1; i < convwidth && str != scan; ++i, ++str) {
 				c = (twodigits)(c *  base +
 					_PyLong_DigitValue[Py_CHARMASK(*str)]);
-				assert(c < BASE);
+				assert(c < PyLong_BASE);
 			}
 
 			convmult = convmultmax;
@@ -1889,23 +1889,23 @@ digit beyond the first.
 
 			/* Multiply z by convmult, and add c. */
 			pz = z->ob_digit;
-			pzstop = pz + z->ob_size;
+			pzstop = pz + Py_Size(z);
 			for (; pz < pzstop; ++pz) {
 				c += (twodigits)*pz * convmult;
-				*pz = (digit)(c & MASK);
-				c >>= SHIFT;
+				*pz = (digit)(c & PyLong_MASK);
+				c >>= PyLong_SHIFT;
 			}
 			/* carry off the current end? */
 			if (c) {
-				assert(c < BASE);
-				if (z->ob_size < size_z) {
+				assert(c < PyLong_BASE);
+				if (Py_Size(z) < size_z) {
 					*pz = (digit)c;
-					++z->ob_size;
+					++Py_Size(z);
 				}
 				else {
 					PyLongObject *tmp;
 					/* Extremely rare.  Get more space. */
-					assert(z->ob_size == size_z);
+					assert(Py_Size(z) == size_z);
 					tmp = _PyLong_New(size_z + 1);
 					if (tmp == NULL) {
 						Py_DECREF(z);
@@ -1928,7 +1928,7 @@ digit beyond the first.
 		/* reset the base to 0, else the exception message
 		   doesn't make too much sense */
 		base = 0;
-		if (z->ob_size != 0)
+		if (Py_Size(z) != 0)
 			goto onError;
 		/* there might still be other problems, therefore base
 		   remains zero here for the same reason */
@@ -1936,7 +1936,7 @@ digit beyond the first.
 	if (str == start)
 		goto onError;
 	if (sign < 0)
-		z->ob_size = -(z->ob_size);
+		Py_Size(z) = -(Py_Size(z));
 	if (*str == 'L' || *str == 'l')
 		str++;
 	while (*str && isspace(Py_CHARMASK(*str)))
@@ -1995,7 +1995,7 @@ static int
 long_divrem(PyLongObject *a, PyLongObject *b,
 	    PyLongObject **pdiv, PyLongObject **prem)
 {
-	Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
+	Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
 	PyLongObject *z;
 
 	if (size_b == 0) {
@@ -2034,9 +2034,9 @@ long_divrem(PyLongObject *a, PyLongObject *b,
 	   The quotient z has the sign of a*b;
 	   the remainder r has the sign of a,
 	   so a = b*z + r. */
-	if ((a->ob_size < 0) != (b->ob_size < 0))
+	if ((Py_Size(a) < 0) != (Py_Size(b) < 0))
 		NEGATE(z);
-	if (a->ob_size < 0 && (*prem)->ob_size != 0)
+	if (Py_Size(a) < 0 && Py_Size(*prem) != 0)
 		NEGATE(*prem);
 	*pdiv = z;
 	return 0;
@@ -2047,8 +2047,8 @@ long_divrem(PyLongObject *a, PyLongObject *b,
 static PyLongObject *
 x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 {
-	Py_ssize_t size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size);
-	digit d = (digit) ((twodigits)BASE / (w1->ob_digit[size_w-1] + 1));
+	Py_ssize_t size_v = ABS(Py_Size(v1)), size_w = ABS(Py_Size(w1));
+	digit d = (digit) ((twodigits)PyLong_BASE / (w1->ob_digit[size_w-1] + 1));
 	PyLongObject *v = mul1(v1, d);
 	PyLongObject *w = mul1(w1, d);
 	PyLongObject *a;
@@ -2061,10 +2061,10 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 	}
 
 	assert(size_v >= size_w && size_w > 1); /* Assert checks by div() */
-	assert(v->ob_refcnt == 1); /* Since v will be used as accumulator! */
-	assert(size_w == ABS(w->ob_size)); /* That's how d was calculated */
+	assert(Py_Refcnt(v) == 1); /* Since v will be used as accumulator! */
+	assert(size_w == ABS(Py_Size(w))); /* That's how d was calculated */
 
-	size_v = ABS(v->ob_size);
+	size_v = ABS(Py_Size(v));
 	k = size_v - size_w;
 	a = _PyLong_New(k + 1);
 
@@ -2080,28 +2080,28 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 			break;
 		})
 		if (vj == w->ob_digit[size_w-1])
-			q = MASK;
+			q = PyLong_MASK;
 		else
-			q = (((twodigits)vj << SHIFT) + v->ob_digit[j-1]) /
+			q = (((twodigits)vj << PyLong_SHIFT) + v->ob_digit[j-1]) /
 				w->ob_digit[size_w-1];
 
 		while (w->ob_digit[size_w-2]*q >
 				((
-					((twodigits)vj << SHIFT)
+					((twodigits)vj << PyLong_SHIFT)
 					+ v->ob_digit[j-1]
 					- q*w->ob_digit[size_w-1]
-								) << SHIFT)
+								) << PyLong_SHIFT)
 				+ v->ob_digit[j-2])
 			--q;
 
 		for (i = 0; i < size_w && i+k < size_v; ++i) {
 			twodigits z = w->ob_digit[i] * q;
-			digit zz = (digit) (z >> SHIFT);
+			digit zz = (digit) (z >> PyLong_SHIFT);
 			carry += v->ob_digit[i+k] - z
-				+ ((twodigits)zz << SHIFT);
-			v->ob_digit[i+k] = (digit)(carry & MASK);
+				+ ((twodigits)zz << PyLong_SHIFT);
+			v->ob_digit[i+k] = (digit)(carry & PyLong_MASK);
 			carry = Py_ARITHMETIC_RIGHT_SHIFT(BASE_TWODIGITS_TYPE,
-							  carry, SHIFT);
+							  carry, PyLong_SHIFT);
 			carry -= zz;
 		}
 
@@ -2118,10 +2118,10 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 			carry = 0;
 			for (i = 0; i < size_w && i+k < size_v; ++i) {
 				carry += v->ob_digit[i+k] + w->ob_digit[i];
-				v->ob_digit[i+k] = (digit)(carry & MASK);
+				v->ob_digit[i+k] = (digit)(carry & PyLong_MASK);
 				carry = Py_ARITHMETIC_RIGHT_SHIFT(
 						BASE_TWODIGITS_TYPE,
-						carry, SHIFT);
+						carry, PyLong_SHIFT);
 			}
 		}
 	} /* for j, k */
@@ -2147,7 +2147,7 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 static void
 long_dealloc(PyObject *v)
 {
-	v->ob_type->tp_free(v);
+	Py_Type(v)->tp_free(v);
 }
 
 static PyObject *
@@ -2161,21 +2161,21 @@ long_compare(PyLongObject *a, PyLongObject *b)
 {
 	Py_ssize_t sign;
 
-	if (a->ob_size != b->ob_size) {
-		if (ABS(a->ob_size) == 0 && ABS(b->ob_size) == 0)
+	if (Py_Size(a) != Py_Size(b)) {
+		if (ABS(Py_Size(a)) == 0 && ABS(Py_Size(b)) == 0)
 			sign = 0;
 		else
-			sign = a->ob_size - b->ob_size;
+			sign = Py_Size(a) - Py_Size(b);
 	}
 	else {
-		Py_ssize_t i = ABS(a->ob_size);
+		Py_ssize_t i = ABS(Py_Size(a));
 		while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
 			;
 		if (i < 0)
 			sign = 0;
 		else {
 			sign = (int)a->ob_digit[i] - (int)b->ob_digit[i];
-			if (a->ob_size < 0)
+			if (Py_Size(a) < 0)
 				sign = -sign;
 		}
 	}
@@ -2204,7 +2204,7 @@ long_hash(PyLongObject *v)
 	/* This is designed so that Python ints and longs with the
 	   same value hash to the same value, otherwise comparisons
 	   of mapping keys will turn out weird */
-	i = v->ob_size;
+	i = Py_Size(v);
 	switch(i) {
 	case -1: return v->ob_digit[0]==1 ? -2 : -v->ob_digit[0];
 	case 0: return 0;
@@ -2216,13 +2216,13 @@ long_hash(PyLongObject *v)
 		sign = -1;
 		i = -(i);
 	}
-#define LONG_BIT_SHIFT	(8*sizeof(long) - SHIFT)
+#define LONG_BIT_PyLong_SHIFT	(8*sizeof(long) - PyLong_SHIFT)
 	while (--i >= 0) {
 		/* Force a native long #-bits (32 or 64) circular shift */
-		x = ((x << SHIFT) & ~MASK) | ((x >> LONG_BIT_SHIFT) & MASK);
+		x = ((x << PyLong_SHIFT) & ~PyLong_MASK) | ((x >> LONG_BIT_PyLong_SHIFT) & PyLong_MASK);
 		x += v->ob_digit[i];
 	}
-#undef LONG_BIT_SHIFT
+#undef LONG_BIT_PyLong_SHIFT
 	x = x * sign;
 	if (x == -1)
 		x = -2;
@@ -2235,7 +2235,7 @@ long_hash(PyLongObject *v)
 static PyLongObject *
 x_add(PyLongObject *a, PyLongObject *b)
 {
-	Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
+	Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
 	PyLongObject *z;
 	int i;
 	digit carry = 0;
@@ -2252,13 +2252,13 @@ x_add(PyLongObject *a, PyLongObject *b)
 		return NULL;
 	for (i = 0; i < size_b; ++i) {
 		carry += a->ob_digit[i] + b->ob_digit[i];
-		z->ob_digit[i] = carry & MASK;
-		carry >>= SHIFT;
+		z->ob_digit[i] = carry & PyLong_MASK;
+		carry >>= PyLong_SHIFT;
 	}
 	for (; i < size_a; ++i) {
 		carry += a->ob_digit[i];
-		z->ob_digit[i] = carry & MASK;
-		carry >>= SHIFT;
+		z->ob_digit[i] = carry & PyLong_MASK;
+		carry >>= PyLong_SHIFT;
 	}
 	z->ob_digit[i] = carry;
 	return long_normalize(z);
@@ -2269,7 +2269,7 @@ x_add(PyLongObject *a, PyLongObject *b)
 static PyLongObject *
 x_sub(PyLongObject *a, PyLongObject *b)
 {
-	Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
+	Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
 	PyLongObject *z;
 	Py_ssize_t i;
 	int sign = 1;
@@ -2301,16 +2301,16 @@ x_sub(PyLongObject *a, PyLongObject *b)
 		return NULL;
 	for (i = 0; i < size_b; ++i) {
 		/* The following assumes unsigned arithmetic
-		   works module 2**N for some N>SHIFT. */
+		   works module 2**N for some N>PyLong_SHIFT. */
 		borrow = a->ob_digit[i] - b->ob_digit[i] - borrow;
-		z->ob_digit[i] = borrow & MASK;
-		borrow >>= SHIFT;
+		z->ob_digit[i] = borrow & PyLong_MASK;
+		borrow >>= PyLong_SHIFT;
 		borrow &= 1; /* Keep only one sign bit */
 	}
 	for (; i < size_a; ++i) {
 		borrow = a->ob_digit[i] - borrow;
-		z->ob_digit[i] = borrow & MASK;
-		borrow >>= SHIFT;
+		z->ob_digit[i] = borrow & PyLong_MASK;
+		borrow >>= PyLong_SHIFT;
 		borrow &= 1; /* Keep only one sign bit */
 	}
 	assert(borrow == 0);
@@ -2326,24 +2326,24 @@ long_add(PyLongObject *v, PyLongObject *w)
 
 	CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b);
 
-	if (ABS(a->ob_size) <= 1 && ABS(b->ob_size) <= 1) {
+	if (ABS(Py_Size(a)) <= 1 && ABS(Py_Size(b)) <= 1) {
 		PyObject *result = PyInt_FromLong(MEDIUM_VALUE(a) +
 						  MEDIUM_VALUE(b));
 		Py_DECREF(a);
 		Py_DECREF(b);
 		return result;
 	}
-	if (a->ob_size < 0) {
-		if (b->ob_size < 0) {
+	if (Py_Size(a) < 0) {
+		if (Py_Size(b) < 0) {
 			z = x_add(a, b);
-			if (z != NULL && z->ob_size != 0)
-				z->ob_size = -(z->ob_size);
+			if (z != NULL && Py_Size(z) != 0)
+				Py_Size(z) = -(Py_Size(z));
 		}
 		else
 			z = x_sub(b, a);
 	}
 	else {
-		if (b->ob_size < 0)
+		if (Py_Size(b) < 0)
 			z = x_sub(a, b);
 		else
 			z = x_add(a, b);
@@ -2360,23 +2360,23 @@ long_sub(PyLongObject *v, PyLongObject *w)
 
 	CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b);
 
-	if (ABS(a->ob_size) <= 1 && ABS(b->ob_size) <= 1) {
+	if (ABS(Py_Size(a)) <= 1 && ABS(Py_Size(b)) <= 1) {
 		PyObject* r;
 		r = PyLong_FromLong(MEDIUM_VALUE(a)-MEDIUM_VALUE(b));
 		Py_DECREF(a);
 		Py_DECREF(b);
 		return r;
 	}
-	if (a->ob_size < 0) {
-		if (b->ob_size < 0)
+	if (Py_Size(a) < 0) {
+		if (Py_Size(b) < 0)
 			z = x_sub(a, b);
 		else
 			z = x_add(a, b);
-		if (z != NULL && z->ob_size != 0)
-			z->ob_size = -(z->ob_size);
+		if (z != NULL && Py_Size(z) != 0)
+			Py_Size(z) = -(Py_Size(z));
 	}
 	else {
-		if (b->ob_size < 0)
+		if (Py_Size(b) < 0)
 			z = x_add(a, b);
 		else
 			z = x_sub(a, b);
@@ -2393,15 +2393,15 @@ static PyLongObject *
 x_mul(PyLongObject *a, PyLongObject *b)
 {
 	PyLongObject *z;
-	Py_ssize_t size_a = ABS(a->ob_size);
-	Py_ssize_t size_b = ABS(b->ob_size);
+	Py_ssize_t size_a = ABS(Py_Size(a));
+	Py_ssize_t size_b = ABS(Py_Size(b));
 	Py_ssize_t i;
 
      	z = _PyLong_New(size_a + size_b);
 	if (z == NULL)
 		return NULL;
 
-	memset(z->ob_digit, 0, z->ob_size * sizeof(digit));
+	memset(z->ob_digit, 0, Py_Size(z) * sizeof(digit));
 	if (a == b) {
 		/* Efficient squaring per HAC, Algorithm 14.16:
 		 * http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
@@ -2422,9 +2422,9 @@ x_mul(PyLongObject *a, PyLongObject *b)
 			})
 
 			carry = *pz + f * f;
-			*pz++ = (digit)(carry & MASK);
-			carry >>= SHIFT;
-			assert(carry <= MASK);
+			*pz++ = (digit)(carry & PyLong_MASK);
+			carry >>= PyLong_SHIFT;
+			assert(carry <= PyLong_MASK);
 
 			/* Now f is added in twice in each column of the
 			 * pyramid it appears.  Same as adding f<<1 once.
@@ -2432,18 +2432,18 @@ x_mul(PyLongObject *a, PyLongObject *b)
 			f <<= 1;
 			while (pa < paend) {
 				carry += *pz + *pa++ * f;
-				*pz++ = (digit)(carry & MASK);
-				carry >>= SHIFT;
-				assert(carry <= (MASK << 1));
+				*pz++ = (digit)(carry & PyLong_MASK);
+				carry >>= PyLong_SHIFT;
+				assert(carry <= (PyLong_MASK << 1));
 			}
 			if (carry) {
 				carry += *pz;
-				*pz++ = (digit)(carry & MASK);
-				carry >>= SHIFT;
+				*pz++ = (digit)(carry & PyLong_MASK);
+				carry >>= PyLong_SHIFT;
 			}
 			if (carry)
-				*pz += (digit)(carry & MASK);
-			assert((carry >> SHIFT) == 0);
+				*pz += (digit)(carry & PyLong_MASK);
+			assert((carry >> PyLong_SHIFT) == 0);
 		}
 	}
 	else {	/* a is not the same as b -- gradeschool long mult */
@@ -2461,13 +2461,13 @@ x_mul(PyLongObject *a, PyLongObject *b)
 
 			while (pb < pbend) {
 				carry += *pz + *pb++ * f;
-				*pz++ = (digit)(carry & MASK);
-				carry >>= SHIFT;
-				assert(carry <= MASK);
+				*pz++ = (digit)(carry & PyLong_MASK);
+				carry >>= PyLong_SHIFT;
+				assert(carry <= PyLong_MASK);
 			}
 			if (carry)
-				*pz += (digit)(carry & MASK);
-			assert((carry >> SHIFT) == 0);
+				*pz += (digit)(carry & PyLong_MASK);
+			assert((carry >> PyLong_SHIFT) == 0);
 		}
 	}
 	return long_normalize(z);
@@ -2485,7 +2485,7 @@ kmul_split(PyLongObject *n, Py_ssize_t size, PyLongObject **high, PyLongObject *
 {
 	PyLongObject *hi, *lo;
 	Py_ssize_t size_lo, size_hi;
-	const Py_ssize_t size_n = ABS(n->ob_size);
+	const Py_ssize_t size_n = ABS(Py_Size(n));
 
 	size_lo = MIN(size_n, size);
 	size_hi = size_n - size_lo;
@@ -2514,8 +2514,8 @@ static PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b);
 static PyLongObject *
 k_mul(PyLongObject *a, PyLongObject *b)
 {
-	Py_ssize_t asize = ABS(a->ob_size);
-	Py_ssize_t bsize = ABS(b->ob_size);
+	Py_ssize_t asize = ABS(Py_Size(a));
+	Py_ssize_t bsize = ABS(Py_Size(b));
 	PyLongObject *ah = NULL;
 	PyLongObject *al = NULL;
 	PyLongObject *bh = NULL;
@@ -2567,7 +2567,7 @@ k_mul(PyLongObject *a, PyLongObject *b)
 	/* Split a & b into hi & lo pieces. */
 	shift = bsize >> 1;
 	if (kmul_split(a, shift, &ah, &al) < 0) goto fail;
-	assert(ah->ob_size > 0);	/* the split isn't degenerate */
+	assert(Py_Size(ah) > 0);	/* the split isn't degenerate */
 
 	if (a == b) {
 		bh = ah;
@@ -2598,20 +2598,20 @@ k_mul(PyLongObject *a, PyLongObject *b)
 	if (ret == NULL) goto fail;
 #ifdef Py_DEBUG
 	/* Fill with trash, to catch reference to uninitialized digits. */
-	memset(ret->ob_digit, 0xDF, ret->ob_size * sizeof(digit));
+	memset(ret->ob_digit, 0xDF, Py_Size(ret) * sizeof(digit));
 #endif
 
 	/* 2. t1 <- ah*bh, and copy into high digits of result. */
 	if ((t1 = k_mul(ah, bh)) == NULL) goto fail;
-	assert(t1->ob_size >= 0);
-	assert(2*shift + t1->ob_size <= ret->ob_size);
+	assert(Py_Size(t1) >= 0);
+	assert(2*shift + Py_Size(t1) <= Py_Size(ret));
 	memcpy(ret->ob_digit + 2*shift, t1->ob_digit,
-	       t1->ob_size * sizeof(digit));
+	       Py_Size(t1) * sizeof(digit));
 
 	/* Zero-out the digits higher than the ah*bh copy. */
-	i = ret->ob_size - 2*shift - t1->ob_size;
+	i = Py_Size(ret) - 2*shift - Py_Size(t1);
 	if (i)
-		memset(ret->ob_digit + 2*shift + t1->ob_size, 0,
+		memset(ret->ob_digit + 2*shift + Py_Size(t1), 0,
 		       i * sizeof(digit));
 
 	/* 3. t2 <- al*bl, and copy into the low digits. */
@@ -2619,23 +2619,23 @@ k_mul(PyLongObject *a, PyLongObject *b)
 		Py_DECREF(t1);
 		goto fail;
 	}
-	assert(t2->ob_size >= 0);
-	assert(t2->ob_size <= 2*shift); /* no overlap with high digits */
-	memcpy(ret->ob_digit, t2->ob_digit, t2->ob_size * sizeof(digit));
+	assert(Py_Size(t2) >= 0);
+	assert(Py_Size(t2) <= 2*shift); /* no overlap with high digits */
+	memcpy(ret->ob_digit, t2->ob_digit, Py_Size(t2) * sizeof(digit));
 
 	/* Zero out remaining digits. */
-	i = 2*shift - t2->ob_size;	/* number of uninitialized digits */
+	i = 2*shift - Py_Size(t2);	/* number of uninitialized digits */
 	if (i)
-		memset(ret->ob_digit + t2->ob_size, 0, i * sizeof(digit));
+		memset(ret->ob_digit + Py_Size(t2), 0, i * sizeof(digit));
 
 	/* 4 & 5. Subtract ah*bh (t1) and al*bl (t2).  We do al*bl first
 	 * because it's fresher in cache.
 	 */
-	i = ret->ob_size - shift;  /* # digits after shift */
-	(void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, t2->ob_size);
+	i = Py_Size(ret) - shift;  /* # digits after shift */
+	(void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_Size(t2));
 	Py_DECREF(t2);
 
-	(void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, t1->ob_size);
+	(void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_Size(t1));
 	Py_DECREF(t1);
 
 	/* 6. t3 <- (ah+al)(bh+bl), and add into result. */
@@ -2660,12 +2660,12 @@ k_mul(PyLongObject *a, PyLongObject *b)
 	Py_DECREF(t1);
 	Py_DECREF(t2);
 	if (t3 == NULL) goto fail;
-	assert(t3->ob_size >= 0);
+	assert(Py_Size(t3) >= 0);
 
 	/* Add t3.  It's not obvious why we can't run out of room here.
 	 * See the (*) comment after this function.
 	 */
-	(void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, t3->ob_size);
+	(void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_Size(t3));
 	Py_DECREF(t3);
 
 	return long_normalize(ret);
@@ -2713,7 +2713,7 @@ the question reduces to whether asize digits is enough to hold
 (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits.  If asize < bsize,
 then we're asking whether asize digits >= f(bsize/2) digits + 2 bits.  By #4,
 asize is at least f(bsize/2)+1 digits, so this in turn reduces to whether 1
-digit is enough to hold 2 bits.  This is so since SHIFT=15 >= 2.  If
+digit is enough to hold 2 bits.  This is so since PyLong_SHIFT=15 >= 2.  If
 asize == bsize, then we're asking whether bsize digits is enough to hold
 c(bsize/2) digits + 2 bits, or equivalently (by #1) whether f(bsize/2) digits
 is enough to hold 2 bits.  This is so if bsize >= 2, which holds because
@@ -2735,8 +2735,8 @@ ah*bh and al*bl too.
 static PyLongObject *
 k_lopsided_mul(PyLongObject *a, PyLongObject *b)
 {
-	const Py_ssize_t asize = ABS(a->ob_size);
-	Py_ssize_t bsize = ABS(b->ob_size);
+	const Py_ssize_t asize = ABS(Py_Size(a));
+	Py_ssize_t bsize = ABS(Py_Size(b));
 	Py_ssize_t nbdone;	/* # of b digits already multiplied */
 	PyLongObject *ret;
 	PyLongObject *bslice = NULL;
@@ -2748,7 +2748,7 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b)
 	ret = _PyLong_New(asize + bsize);
 	if (ret == NULL)
 		return NULL;
-	memset(ret->ob_digit, 0, ret->ob_size * sizeof(digit));
+	memset(ret->ob_digit, 0, Py_Size(ret) * sizeof(digit));
 
 	/* Successive slices of b are copied into bslice. */
 	bslice = _PyLong_New(asize);
@@ -2763,14 +2763,14 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b)
 		/* Multiply the next slice of b by a. */
 		memcpy(bslice->ob_digit, b->ob_digit + nbdone,
 		       nbtouse * sizeof(digit));
-		bslice->ob_size = nbtouse;
+		Py_Size(bslice) = nbtouse;
 		product = k_mul(a, bslice);
 		if (product == NULL)
 			goto fail;
 
 		/* Add into result. */
-		(void)v_iadd(ret->ob_digit + nbdone, ret->ob_size - nbdone,
-			     product->ob_digit, product->ob_size);
+		(void)v_iadd(ret->ob_digit + nbdone, Py_Size(ret) - nbdone,
+			     product->ob_digit, Py_Size(product));
 		Py_DECREF(product);
 
 		bsize -= nbtouse;
@@ -2796,7 +2796,7 @@ long_mul(PyLongObject *v, PyLongObject *w)
 		return Py_NotImplemented;
 	}
 
-	if (ABS(v->ob_size) <= 1 && ABS(w->ob_size) <= 1) {
+	if (ABS(Py_Size(v)) <= 1 && ABS(Py_Size(w)) <= 1) {
 		PyObject *r;
 		r = PyLong_FromLong(MEDIUM_VALUE(v)*MEDIUM_VALUE(w));
 		Py_DECREF(a);
@@ -2806,7 +2806,7 @@ long_mul(PyLongObject *v, PyLongObject *w)
 
 	z = k_mul(a, b);
 	/* Negate if exactly one of the inputs is negative. */
-	if (((a->ob_size ^ b->ob_size) < 0) && z)
+	if (((Py_Size(a) ^ Py_Size(b)) < 0) && z)
 		NEGATE(z);
 	Py_DECREF(a);
 	Py_DECREF(b);
@@ -2842,8 +2842,8 @@ l_divmod(PyLongObject *v, PyLongObject *w,
 
 	if (long_divrem(v, w, &div, &mod) < 0)
 		return -1;
-	if ((mod->ob_size < 0 && w->ob_size > 0) ||
-	    (mod->ob_size > 0 && w->ob_size < 0)) {
+	if ((Py_Size(mod) < 0 && Py_Size(w) > 0) ||
+	    (Py_Size(mod) > 0 && Py_Size(w) < 0)) {
 		PyLongObject *temp;
 		PyLongObject *one;
 		temp = (PyLongObject *) long_add(mod, w);
@@ -2917,15 +2917,15 @@ long_true_divide(PyObject *v, PyObject *w)
 		return NULL;
 	}
 
-	/* True value is very close to ad/bd * 2**(SHIFT*(aexp-bexp)) */
+	/* True value is very close to ad/bd * 2**(PyLong_SHIFT*(aexp-bexp)) */
 	ad /= bd;	/* overflow/underflow impossible here */
 	aexp -= bexp;
-	if (aexp > INT_MAX / SHIFT)
+	if (aexp > INT_MAX / PyLong_SHIFT)
 		goto overflow;
-	else if (aexp < -(INT_MAX / SHIFT))
+	else if (aexp < -(INT_MAX / PyLong_SHIFT))
 		return PyFloat_FromDouble(0.0);	/* underflow to 0 */
 	errno = 0;
-	ad = ldexp(ad, aexp * SHIFT);
+	ad = ldexp(ad, aexp * PyLong_SHIFT);
 	if (Py_OVERFLOWED(ad)) /* ignore underflow to 0.0 */
 		goto overflow;
 	return PyFloat_FromDouble(ad);
@@ -3010,7 +3010,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		return Py_NotImplemented;
 	}
 
-	if (b->ob_size < 0) {  /* if exponent is negative */
+	if (Py_Size(b) < 0) {  /* if exponent is negative */
 		if (c) {
 			PyErr_SetString(PyExc_TypeError, "pow() 2nd argument "
 			    "cannot be negative when 3rd argument specified");
@@ -3029,7 +3029,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 	if (c) {
 		/* if modulus == 0:
 		       raise ValueError() */
-		if (c->ob_size == 0) {
+		if (Py_Size(c) == 0) {
 			PyErr_SetString(PyExc_ValueError,
 					"pow() 3rd argument cannot be 0");
 			goto Error;
@@ -3038,7 +3038,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		/* if modulus < 0:
 		       negativeOutput = True
 		       modulus = -modulus */
-		if (c->ob_size < 0) {
+		if (Py_Size(c) < 0) {
 			negativeOutput = 1;
 			temp = (PyLongObject *)_PyLong_Copy(c);
 			if (temp == NULL)
@@ -3051,7 +3051,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 
 		/* if modulus == 1:
 		       return 0 */
-		if ((c->ob_size == 1) && (c->ob_digit[0] == 1)) {
+		if ((Py_Size(c) == 1) && (c->ob_digit[0] == 1)) {
 			z = (PyLongObject *)PyLong_FromLong(0L);
 			goto Done;
 		}
@@ -3059,7 +3059,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		/* if base < 0:
 		       base = base % modulus
 		   Having the base positive just makes things easier. */
-		if (a->ob_size < 0) {
+		if (Py_Size(a) < 0) {
 			if (l_divmod(a, c, NULL, &temp) < 0)
 				goto Error;
 			Py_DECREF(a);
@@ -3100,13 +3100,13 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 	REDUCE(result)					\
 }
 
-	if (b->ob_size <= FIVEARY_CUTOFF) {
+	if (Py_Size(b) <= FIVEARY_CUTOFF) {
 		/* Left-to-right binary exponentiation (HAC Algorithm 14.79) */
 		/* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf    */
-		for (i = b->ob_size - 1; i >= 0; --i) {
+		for (i = Py_Size(b) - 1; i >= 0; --i) {
 			digit bi = b->ob_digit[i];
 
-			for (j = 1 << (SHIFT-1); j != 0; j >>= 1) {
+			for (j = 1 << (PyLong_SHIFT-1); j != 0; j >>= 1) {
 				MULT(z, z, z)
 				if (bi & j)
 					MULT(z, a, z)
@@ -3120,10 +3120,10 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		for (i = 1; i < 32; ++i)
 			MULT(table[i-1], a, table[i])
 
-		for (i = b->ob_size - 1; i >= 0; --i) {
+		for (i = Py_Size(b) - 1; i >= 0; --i) {
 			const digit bi = b->ob_digit[i];
 
-			for (j = SHIFT - 5; j >= 0; j -= 5) {
+			for (j = PyLong_SHIFT - 5; j >= 0; j -= 5) {
 				const int index = (bi >> j) & 0x1f;
 				for (k = 0; k < 5; ++k)
 					MULT(z, z, z)
@@ -3133,7 +3133,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		}
 	}
 
-	if (negativeOutput && (z->ob_size != 0)) {
+	if (negativeOutput && (Py_Size(z) != 0)) {
 		temp = (PyLongObject *)long_sub(z, c);
 		if (temp == NULL)
 			goto Error;
@@ -3150,7 +3150,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
  	}
 	/* fall through */
  Done:
-	if (b->ob_size > FIVEARY_CUTOFF) {
+	if (Py_Size(b) > FIVEARY_CUTOFF) {
 		for (i = 0; i < 32; ++i)
 			Py_XDECREF(table[i]);
 	}
@@ -3167,7 +3167,7 @@ long_invert(PyLongObject *v)
 	/* Implement ~x as -(x+1) */
 	PyLongObject *x;
 	PyLongObject *w;
-	if (ABS(v->ob_size) <=1)
+	if (ABS(Py_Size(v)) <=1)
 		return PyLong_FromLong(-(MEDIUM_VALUE(v)+1));
 	w = (PyLongObject *)PyLong_FromLong(1L);
 	if (w == NULL)
@@ -3176,7 +3176,7 @@ long_invert(PyLongObject *v)
 	Py_DECREF(w);
 	if (x == NULL)
 		return NULL;
-	x->ob_size = -(x->ob_size);
+	Py_Size(x) = -(Py_Size(x));
 	return (PyObject *)x;
 }
 
@@ -3195,18 +3195,18 @@ static PyObject *
 long_neg(PyLongObject *v)
 {
 	PyLongObject *z;
-	if (ABS(v->ob_size) <= 1)
+	if (ABS(Py_Size(v)) <= 1)
 		return PyLong_FromLong(-MEDIUM_VALUE(v));
 	z = (PyLongObject *)_PyLong_Copy(v);
 	if (z != NULL)
-		z->ob_size = -(v->ob_size);
+		Py_Size(z) = -(Py_Size(v));
 	return (PyObject *)z;
 }
 
 static PyObject *
 long_abs(PyLongObject *v)
 {
-	if (v->ob_size < 0)
+	if (Py_Size(v) < 0)
 		return long_neg(v);
 	else
 		return long_pos(v);
@@ -3215,7 +3215,7 @@ long_abs(PyLongObject *v)
 static int
 long_bool(PyLongObject *v)
 {
-	return ABS(v->ob_size) != 0;
+	return ABS(Py_Size(v)) != 0;
 }
 
 static PyObject *
@@ -3229,7 +3229,7 @@ long_rshift(PyLongObject *v, PyLongObject *w)
 
 	CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b);
 
-	if (a->ob_size < 0) {
+	if (Py_Size(a) < 0) {
 		/* Right shifting negative numbers is harder */
 		PyLongObject *a1, *a2;
 		a1 = (PyLongObject *) long_invert(a);
@@ -3252,23 +3252,23 @@ long_rshift(PyLongObject *v, PyLongObject *w)
 					"negative shift count");
 			goto rshift_error;
 		}
-		wordshift = shiftby / SHIFT;
-		newsize = ABS(a->ob_size) - wordshift;
+		wordshift = shiftby / PyLong_SHIFT;
+		newsize = ABS(Py_Size(a)) - wordshift;
 		if (newsize <= 0) {
 			z = _PyLong_New(0);
 			Py_DECREF(a);
 			Py_DECREF(b);
 			return (PyObject *)z;
 		}
-		loshift = shiftby % SHIFT;
-		hishift = SHIFT - loshift;
+		loshift = shiftby % PyLong_SHIFT;
+		hishift = PyLong_SHIFT - loshift;
 		lomask = ((digit)1 << hishift) - 1;
-		himask = MASK ^ lomask;
+		himask = PyLong_MASK ^ lomask;
 		z = _PyLong_New(newsize);
 		if (z == NULL)
 			goto rshift_error;
-		if (a->ob_size < 0)
-			z->ob_size = -(z->ob_size);
+		if (Py_Size(a) < 0)
+			Py_Size(z) = -(Py_Size(z));
 		for (i = 0, j = wordshift; i < newsize; i++, j++) {
 			z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask;
 			if (i+1 < newsize)
@@ -3308,26 +3308,26 @@ long_lshift(PyObject *v, PyObject *w)
 				"outrageous left shift count");
 		goto lshift_error;
 	}
-	/* wordshift, remshift = divmod(shiftby, SHIFT) */
-	wordshift = (int)shiftby / SHIFT;
-	remshift  = (int)shiftby - wordshift * SHIFT;
+	/* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */
+	wordshift = (int)shiftby / PyLong_SHIFT;
+	remshift  = (int)shiftby - wordshift * PyLong_SHIFT;
 
-	oldsize = ABS(a->ob_size);
+	oldsize = ABS(Py_Size(a));
 	newsize = oldsize + wordshift;
 	if (remshift)
 		++newsize;
 	z = _PyLong_New(newsize);
 	if (z == NULL)
 		goto lshift_error;
-	if (a->ob_size < 0)
+	if (Py_Size(a) < 0)
 		NEGATE(z);
 	for (i = 0; i < wordshift; i++)
 		z->ob_digit[i] = 0;
 	accum = 0;
 	for (i = wordshift, j = 0; j < oldsize; i++, j++) {
 		accum |= (twodigits)a->ob_digit[j] << remshift;
-		z->ob_digit[i] = (digit)(accum & MASK);
-		accum >>= SHIFT;
+		z->ob_digit[i] = (digit)(accum & PyLong_MASK);
+		accum >>= PyLong_SHIFT;
 	}
 	if (remshift)
 		z->ob_digit[newsize-1] = (digit)accum;
@@ -3348,7 +3348,7 @@ long_bitwise(PyLongObject *a,
 	     int op,  /* '&', '|', '^' */
 	     PyLongObject *b)
 {
-	digit maska, maskb; /* 0 or MASK */
+	digit maska, maskb; /* 0 or PyLong_MASK */
 	int negz;
 	Py_ssize_t size_a, size_b, size_z;
 	PyLongObject *z;
@@ -3356,23 +3356,23 @@ long_bitwise(PyLongObject *a,
 	digit diga, digb;
 	PyObject *v;
 
-	if (a->ob_size < 0) {
+	if (Py_Size(a) < 0) {
 		a = (PyLongObject *) long_invert(a);
 		if (a == NULL)
 			return NULL;
-		maska = MASK;
+		maska = PyLong_MASK;
 	}
 	else {
 		Py_INCREF(a);
 		maska = 0;
 	}
-	if (b->ob_size < 0) {
+	if (Py_Size(b) < 0) {
 		b = (PyLongObject *) long_invert(b);
 		if (b == NULL) {
 			Py_DECREF(a);
 			return NULL;
 		}
-		maskb = MASK;
+		maskb = PyLong_MASK;
 	}
 	else {
 		Py_INCREF(b);
@@ -3383,23 +3383,23 @@ long_bitwise(PyLongObject *a,
 	switch (op) {
 	case '^':
 		if (maska != maskb) {
-			maska ^= MASK;
+			maska ^= PyLong_MASK;
 			negz = -1;
 		}
 		break;
 	case '&':
 		if (maska && maskb) {
 			op = '|';
-			maska ^= MASK;
-			maskb ^= MASK;
+			maska ^= PyLong_MASK;
+			maskb ^= PyLong_MASK;
 			negz = -1;
 		}
 		break;
 	case '|':
 		if (maska || maskb) {
 			op = '&';
-			maska ^= MASK;
-			maskb ^= MASK;
+			maska ^= PyLong_MASK;
+			maskb ^= PyLong_MASK;
 			negz = -1;
 		}
 		break;
@@ -3415,8 +3415,8 @@ long_bitwise(PyLongObject *a,
 	   whose length should be ignored.
 	*/
 
-	size_a = a->ob_size;
-	size_b = b->ob_size;
+	size_a = Py_Size(a);
+	size_b = Py_Size(b);
 	size_z = op == '&'
 		? (maska
 		   ? size_b
@@ -3585,7 +3585,7 @@ long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 	if (tmp == NULL)
 		return NULL;
 	assert(PyLong_CheckExact(tmp));
-	n = tmp->ob_size;
+	n = Py_Size(tmp);
 	if (n < 0)
 		n = -n;
 	newobj = (PyLongObject *)type->tp_alloc(type, n);
@@ -3594,7 +3594,7 @@ long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		return NULL;
 	}
 	assert(PyLong_Check(newobj));
-	newobj->ob_size = tmp->ob_size;
+	Py_Size(newobj) = Py_Size(tmp);
 	for (i = 0; i < n; i++)
 		newobj->ob_digit[i] = tmp->ob_digit[i];
 	Py_DECREF(tmp);
@@ -3662,8 +3662,7 @@ static PyNumberMethods long_as_number = {
 };
 
 PyTypeObject PyLong_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"int",					/* tp_name */
 	/* See _PyLong_New for why this isn't
 	   sizeof(PyLongObject) - sizeof(digit) */
@@ -3715,12 +3714,12 @@ _PyLong_Init(void)
 	PyLongObject *v = small_ints;
 	for (ival = -NSMALLNEGINTS; ival < 0; ival++, v++) {
 		PyObject_INIT(v, &PyLong_Type);
-		v->ob_size = -1;
+		Py_Size(v) = -1;
 		v->ob_digit[0] = -ival;
 	}
 	for (; ival < NSMALLPOSINTS; ival++, v++) {
 		PyObject_INIT(v, &PyLong_Type);
-		v->ob_size = ival ? 1 : 0;
+		Py_Size(v) = ival ? 1 : 0;
 		v->ob_digit[0] = ival;
 	}
 #endif