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. ................
author: Martin v. Löwis <martin@v.loewis.de> 2007-07-21 17:22:18 (GMT)
committer: Martin v. Löwis <martin@v.loewis.de> 2007-07-21 17:22:18 (GMT)
commit: 9f2e346911988cda95fec7c901e8d10d34fa9563 (patch)
tree: 1632c78fb8e18b2f789102451bedd15996bff6c5 /Objects
parent: b972a78e17beeb997d809d87f2e422e6622efd52 (diff)
download: cpython-9f2e346911988cda95fec7c901e8d10d34fa9563.zip
cpython-9f2e346911988cda95fec7c901e8d10d34fa9563.tar.gz
cpython-9f2e346911988cda95fec7c901e8d10d34fa9563.tar.bz2
33 files changed, 844 insertions, 916 deletions
diff --git a/Objects/boolobject.c b/Objects/boolobject.c
index b0170f6..00d8515 100644
--- a/Objects/boolobject.c
+++ b/Objects/boolobject.c
@@ -143,8 +143,7 @@ static PyNumberMethods bool_as_number = {
 /* The type object for bool.  Note that this cannot be subclassed! */
 
 PyTypeObject PyBool_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"bool",
 	sizeof(struct _longobject),
 	0,
@@ -188,11 +187,11 @@ PyTypeObject PyBool_Type = {
 
 /* Named Zero for link-level compatibility */
 struct _longobject _Py_FalseStruct = {
-	PyObject_HEAD_INIT(&PyBool_Type)
-	0, { 0 }
+	PyVarObject_HEAD_INIT(&PyBool_Type, 0)
+	{ 0 }
 };
 
 struct _longobject _Py_TrueStruct = {
-	PyObject_HEAD_INIT(&PyBool_Type)
-	1, { 1 }
+	PyVarObject_HEAD_INIT(&PyBool_Type, 1)
+	{ 1 }
 };
diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c
index 4b38aa2..64b11a9 100644
--- a/Objects/bufferobject.c
+++ b/Objects/bufferobject.c
@@ -710,8 +710,7 @@ static PyBufferProcs buffer_as_buffer = {
 };
 
 PyTypeObject PyBuffer_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"buffer",
 	sizeof(PyBufferObject),
 	0,
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
index ad5f4fe..31db95f 100644
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -25,7 +25,7 @@ PyBytes_Init(void)
     if (nullbytes == NULL)
         return 0;
     nullbytes->ob_bytes = NULL;
-    nullbytes->ob_size = nullbytes->ob_alloc = 0;
+    Py_Size(nullbytes) = nullbytes->ob_alloc = 0;
     return 1;
 }
 
@@ -51,7 +51,7 @@ _getbytevalue(PyObject* arg, int *value)
 Py_ssize_t
 _getbuffer(PyObject *obj, void **ptr)
 {
-    PyBufferProcs *buffer = obj->ob_type->tp_as_buffer;
+    PyBufferProcs *buffer = Py_Type(obj)->tp_as_buffer;
 
     if (buffer == NULL ||
         PyUnicode_Check(obj) ||
@@ -142,7 +142,7 @@ PyBytes_Resize(PyObject *self, Py_ssize_t size)
     }
     else if (size < alloc) {
         /* Within allocated size; quick exit */
-        ((PyBytesObject *)self)->ob_size = size;
+        Py_Size(self) = size;
 	((PyBytesObject *)self)->ob_bytes[size] = '\0'; /* Trailing null byte */
         return 0;
     }
@@ -162,7 +162,7 @@ PyBytes_Resize(PyObject *self, Py_ssize_t size)
     }
 
     ((PyBytesObject *)self)->ob_bytes = sval;
-    ((PyBytesObject *)self)->ob_size = size;
+    Py_Size(self) = size;
     ((PyBytesObject *)self)->ob_alloc = alloc;
     ((PyBytesObject *)self)->ob_bytes[size] = '\0'; /* Trailing null byte */
 
@@ -180,7 +180,7 @@ PyBytes_Concat(PyObject *a, PyObject *b)
     bsize = _getbuffer(b, &bptr);
     if (asize < 0 || bsize < 0) {
         PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
-                     a->ob_type->tp_name, b->ob_type->tp_name);
+                     Py_Type(a)->tp_name, Py_Type(b)->tp_name);
         return NULL;
     }
 
@@ -201,7 +201,7 @@ PyBytes_Concat(PyObject *a, PyObject *b)
 static Py_ssize_t
 bytes_length(PyBytesObject *self)
 {
-    return self->ob_size;
+    return Py_Size(self);
 }
 
 static PyObject *
@@ -222,16 +222,16 @@ bytes_iconcat(PyBytesObject *self, PyObject *other)
     osize = _getbuffer(other, &optr);
     if (osize < 0) {
         PyErr_Format(PyExc_TypeError,
-                     "can't concat bytes to %.100s", other->ob_type->tp_name);
+                     "can't concat bytes to %.100s", Py_Type(other)->tp_name);
         return NULL;
     }
 
-    mysize = self->ob_size;
+    mysize = Py_Size(self);
     size = mysize + osize;
     if (size < 0)
         return PyErr_NoMemory();
     if (size < self->ob_alloc) {
-        self->ob_size = size;
+        Py_Size(self) = size;
 	self->ob_bytes[self->ob_size] = '\0'; /* Trailing null byte */
     }
     else if (PyBytes_Resize((PyObject *)self, size) < 0)
@@ -250,7 +250,7 @@ bytes_repeat(PyBytesObject *self, Py_ssize_t count)
 
     if (count < 0)
         count = 0;
-    mysize = self->ob_size;
+    mysize = Py_Size(self);
     size = mysize * count;
     if (count != 0 && size / count != mysize)
         return PyErr_NoMemory();
@@ -275,12 +275,12 @@ bytes_irepeat(PyBytesObject *self, Py_ssize_t count)
 
     if (count < 0)
         count = 0;
-    mysize = self->ob_size;
+    mysize = Py_Size(self);
     size = mysize * count;
     if (count != 0 && size / count != mysize)
         return PyErr_NoMemory();
     if (size < self->ob_alloc) {
-        self->ob_size = size;
+        Py_Size(self) = size;
 	self->ob_bytes[self->ob_size] = '\0'; /* Trailing null byte */
     }
     else if (PyBytes_Resize((PyObject *)self, size) < 0)
@@ -303,15 +303,15 @@ bytes_substring(PyBytesObject *self, PyBytesObject *other)
 {
     Py_ssize_t i;
 
-    if (other->ob_size == 1) {
+    if (Py_Size(other) == 1) {
         return memchr(self->ob_bytes, other->ob_bytes[0],
-                      self->ob_size) != NULL;
+                      Py_Size(self)) != NULL;
     }
-    if (other->ob_size == 0)
+    if (Py_Size(other) == 0)
         return 1; /* Edge case */
-    for (i = 0; i + other->ob_size <= self->ob_size; i++) {
+    for (i = 0; i + Py_Size(other) <= Py_Size(self); i++) {
         /* XXX Yeah, yeah, lots of optimizations possible... */
-        if (memcmp(self->ob_bytes + i, other->ob_bytes, other->ob_size) == 0)
+        if (memcmp(self->ob_bytes + i, other->ob_bytes, Py_Size(other)) == 0)
             return 1;
     }
     return 0;
@@ -333,15 +333,15 @@ bytes_contains(PyBytesObject *self, PyObject *value)
         return -1;
     }
 
-    return memchr(self->ob_bytes, ival, self->ob_size) != NULL;
+    return memchr(self->ob_bytes, ival, Py_Size(self)) != NULL;
 }
 
 static PyObject *
 bytes_getitem(PyBytesObject *self, Py_ssize_t i)
 {
     if (i < 0)
-        i += self->ob_size;
-    if (i < 0 || i >= self->ob_size) {
+        i += Py_Size(self);
+    if (i < 0 || i >= Py_Size(self)) {
         PyErr_SetString(PyExc_IndexError, "bytes index out of range");
         return NULL;
     }
@@ -360,7 +360,7 @@ bytes_subscript(PyBytesObject *self, PyObject *item)
         if (i < 0)
             i += PyBytes_GET_SIZE(self);
 
-        if (i < 0 || i >= self->ob_size) {
+        if (i < 0 || i >= Py_Size(self)) {
             PyErr_SetString(PyExc_IndexError, "bytes index out of range");
             return NULL;
         }
@@ -430,7 +430,7 @@ bytes_setslice(PyBytesObject *self, Py_ssize_t lo, Py_ssize_t hi,
         if (needed < 0) {
             PyErr_Format(PyExc_TypeError,
                          "can't set bytes slice from %.100s",
-                         values->ob_type->tp_name);
+                         Py_Type(values)->tp_name);
             return -1;
         }
     }
@@ -439,8 +439,8 @@ bytes_setslice(PyBytesObject *self, Py_ssize_t lo, Py_ssize_t hi,
         lo = 0;
     if (hi < lo)
         hi = lo;
-    if (hi > self->ob_size)
-        hi = self->ob_size;
+    if (hi > Py_Size(self))
+        hi = Py_Size(self);
 
     avail = hi - lo;
     if (avail < 0)
@@ -455,10 +455,10 @@ bytes_setslice(PyBytesObject *self, Py_ssize_t lo, Py_ssize_t hi,
               0   lo      new_hi              new_size
             */
             memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,
-                    self->ob_size - hi);
+                    Py_Size(self) - hi);
         }
         if (PyBytes_Resize((PyObject *)self,
-                           self->ob_size + needed - avail) < 0)
+                           Py_Size(self) + needed - avail) < 0)
             return -1;
         if (avail < needed) {
             /*
@@ -468,7 +468,7 @@ bytes_setslice(PyBytesObject *self, Py_ssize_t lo, Py_ssize_t hi,
               0   lo            new_hi              new_size
              */
             memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,
-                    self->ob_size - lo - needed);
+                    Py_Size(self) - lo - needed);
         }
     }
 
@@ -484,9 +484,9 @@ bytes_setitem(PyBytesObject *self, Py_ssize_t i, PyObject *value)
     Py_ssize_t ival;
 
     if (i < 0)
-        i += self->ob_size;
+        i += Py_Size(self);
 
-    if (i < 0 || i >= self->ob_size) {
+    if (i < 0 || i >= Py_Size(self)) {
         PyErr_SetString(PyExc_IndexError, "bytes index out of range");
         return -1;
     }
@@ -522,7 +522,7 @@ bytes_ass_subscript(PyBytesObject *self, PyObject *item, PyObject *values)
         if (i < 0)
             i += PyBytes_GET_SIZE(self);
 
-        if (i < 0 || i >= self->ob_size) {
+        if (i < 0 || i >= Py_Size(self)) {
             PyErr_SetString(PyExc_IndexError, "bytes index out of range");
             return -1;
         }
@@ -576,7 +576,7 @@ bytes_ass_subscript(PyBytesObject *self, PyObject *item, PyObject *values)
     else {
         assert(PyBytes_Check(values));
         bytes = ((PyBytesObject *)values)->ob_bytes;
-        needed = ((PyBytesObject *)values)->ob_size;
+        needed = Py_Size(values);
     }
     /* Make sure b[5:2] = ... inserts before 5, not before 2. */
     if ((step < 0 && start < stop) ||
@@ -592,10 +592,10 @@ bytes_ass_subscript(PyBytesObject *self, PyObject *item, PyObject *values)
                   0   lo      new_hi              new_size
                 */
                 memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,
-                        self->ob_size - stop);
+                        Py_Size(self) - stop);
             }
             if (PyBytes_Resize((PyObject *)self,
-                               self->ob_size + needed - slicelen) < 0)
+                               Py_Size(self) + needed - slicelen) < 0)
                 return -1;
             if (slicelen < needed) {
                 /*
@@ -605,7 +605,7 @@ bytes_ass_subscript(PyBytesObject *self, PyObject *item, PyObject *values)
                   0   lo            new_hi              new_size
                  */
                 memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,
-                        self->ob_size - start - needed);
+                        Py_Size(self) - start - needed);
             }
         }
 
@@ -676,7 +676,7 @@ bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds)
     PyObject *it;
     PyObject *(*iternext)(PyObject *);
 
-    if (self->ob_size != 0) {
+    if (Py_Size(self) != 0) {
         /* Empty previous contents (yes, do this first of all!) */
         if (PyBytes_Resize((PyObject *)self, 0) < 0)
             return -1;
@@ -708,7 +708,7 @@ bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds)
         if (!PyBytes_Check(encoded) && !PyString_Check(encoded)) {
             PyErr_Format(PyExc_TypeError,
                 "encoder did not return a str8 or bytes object (type=%.400s)",
-                encoded->ob_type->tp_name);
+                Py_Type(encoded)->tp_name);
             Py_DECREF(encoded);
             return -1;
         }
@@ -761,7 +761,7 @@ bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds)
     it = PyObject_GetIter(arg);
     if (it == NULL)
         return -1;
-    iternext = *it->ob_type->tp_iternext;
+    iternext = *Py_Type(it)->tp_iternext;
 
     /* Run the iterator to exhaustion */
     for (;;) {
@@ -793,11 +793,11 @@ bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds)
         }
 
         /* Append the byte */
-        if (self->ob_size < self->ob_alloc)
-            self->ob_size++;
-        else if (PyBytes_Resize((PyObject *)self, self->ob_size+1) < 0)
+        if (Py_Size(self) < self->ob_alloc)
+            Py_Size(self)++;
+        else if (PyBytes_Resize((PyObject *)self, Py_Size(self)+1) < 0)
             goto error;
-        self->ob_bytes[self->ob_size-1] = value;
+        self->ob_bytes[Py_Size(self)-1] = value;
     }
 
     /* Clean up and return success */
@@ -818,7 +818,7 @@ bytes_repr(PyBytesObject *self)
     static const char *hexdigits = "0123456789abcdef";
     size_t newsize = 3 + 4 * self->ob_size;
     PyObject *v;
-    if (newsize > PY_SSIZE_T_MAX || newsize / 4 != self->ob_size) {
+    if (newsize > PY_SSIZE_T_MAX || newsize / 4 != Py_Size(self)) {
         PyErr_SetString(PyExc_OverflowError,
             "bytes object is too large to make repr");
         return NULL;
@@ -836,7 +836,7 @@ bytes_repr(PyBytesObject *self)
         p = PyUnicode_AS_UNICODE(v);
         *p++ = 'b';
         *p++ = quote;
-        for (i = 0; i < self->ob_size; i++) {
+        for (i = 0; i < Py_Size(self); i++) {
             /* There's at least enough room for a hex escape
                and a closing quote. */
             assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);
@@ -874,7 +874,7 @@ bytes_repr(PyBytesObject *self)
 static PyObject *
 bytes_str(PyBytesObject *self)
 {
-    return PyString_FromStringAndSize(self->ob_bytes, self->ob_size);
+    return PyString_FromStringAndSize(self->ob_bytes, Py_Size(self));
 }
 
 static PyObject *
@@ -941,7 +941,7 @@ bytes_dealloc(PyBytesObject *self)
     if (self->ob_bytes != 0) {
         PyMem_Free(self->ob_bytes);
     }
-    self->ob_type->tp_free((PyObject *)self);
+    Py_Type(self)->tp_free((PyObject *)self);
 }
 
 static Py_ssize_t
@@ -956,14 +956,14 @@ bytes_getbuffer(PyBytesObject *self, Py_ssize_t index, const void **ptr)
         *ptr = "";
     else
         *ptr = self->ob_bytes;
-    return self->ob_size;
+    return Py_Size(self);
 }
 
 static Py_ssize_t
 bytes_getsegcount(PyStringObject *self, Py_ssize_t *lenp)
 {
     if (lenp)
-        *lenp = self->ob_size;
+        *lenp = Py_Size(self);
     return 1;
 }
 
@@ -2043,7 +2043,7 @@ bytes_replace(PyBytesObject *self, PyObject *args)
     count++; }
 
 /* Always force the list to the expected size. */
-#define FIX_PREALLOC_SIZE(list) ((PyListObject *)list)->ob_size = count
+#define FIX_PREALLOC_SIZE(list) Py_Size(list) = count
 
 
 Py_LOCAL_INLINE(PyObject *)
@@ -2307,7 +2307,7 @@ end of the bytes.");
 static PyObject *
 bytes_extend(PyBytesObject *self, PyObject *arg)
 {
-    if (bytes_setslice(self, self->ob_size, self->ob_size, arg) == -1)
+    if (bytes_setslice(self, Py_Size(self), Py_Size(self), arg) == -1)
         return NULL;
     Py_RETURN_NONE;
 }
@@ -2321,7 +2321,7 @@ static PyObject *
 bytes_reverse(PyBytesObject *self, PyObject *unused)
 {
     char swap, *head, *tail;
-    Py_ssize_t i, j, n = self->ob_size;
+    Py_ssize_t i, j, n = Py_Size(self);
 
     j = n / 2;
     head = self->ob_bytes;
@@ -2343,7 +2343,7 @@ static PyObject *
 bytes_insert(PyBytesObject *self, PyObject *args)
 {
     int value;
-    Py_ssize_t where, n = self->ob_size;
+    Py_ssize_t where, n = Py_Size(self);
 
     if (!PyArg_ParseTuple(args, "ni:insert", &where, &value))
         return NULL;
@@ -2382,7 +2382,7 @@ static PyObject *
 bytes_append(PyBytesObject *self, PyObject *arg)
 {
     int value;
-    Py_ssize_t n = self->ob_size;
+    Py_ssize_t n = Py_Size(self);
 
     if (! _getbytevalue(arg, &value))
         return NULL;
@@ -2408,7 +2408,7 @@ static PyObject *
 bytes_pop(PyBytesObject *self, PyObject *args)
 {
     int value;
-    Py_ssize_t where = -1, n = self->ob_size;
+    Py_ssize_t where = -1, n = Py_Size(self);
 
     if (!PyArg_ParseTuple(args, "|n:pop", &where))
         return NULL;
@@ -2419,8 +2419,8 @@ bytes_pop(PyBytesObject *self, PyObject *args)
         return NULL;
     }
     if (where < 0)
-        where += self->ob_size;
-    if (where < 0 || where >= self->ob_size) {
+        where += Py_Size(self);
+    if (where < 0 || where >= Py_Size(self)) {
         PyErr_SetString(PyExc_IndexError, "pop index out of range");
         return NULL;
     }
@@ -2441,7 +2441,7 @@ static PyObject *
 bytes_remove(PyBytesObject *self, PyObject *arg)
 {
     int value;
-    Py_ssize_t where, n = self->ob_size;
+    Py_ssize_t where, n = Py_Size(self);
 
     if (! _getbytevalue(arg, &value))
         return NULL;
@@ -2498,9 +2498,9 @@ bytes_strip(PyBytesObject *self, PyObject *arg)
         return NULL;
     }
     myptr = self->ob_bytes;
-    mysize = self->ob_size;
+    mysize = Py_Size(self);
     argptr = ((PyBytesObject *)arg)->ob_bytes;
-    argsize = ((PyBytesObject *)arg)->ob_size;
+    argsize = Py_Size(arg);
     left = lstrip_helper(myptr, mysize, argptr, argsize);
     right = rstrip_helper(myptr, mysize, argptr, argsize);
     return PyBytes_FromStringAndSize(self->ob_bytes + left, right - left);
@@ -2520,9 +2520,9 @@ bytes_lstrip(PyBytesObject *self, PyObject *arg)
         return NULL;
     }
     myptr = self->ob_bytes;
-    mysize = self->ob_size;
+    mysize = Py_Size(self);
     argptr = ((PyBytesObject *)arg)->ob_bytes;
-    argsize = ((PyBytesObject *)arg)->ob_size;
+    argsize = Py_Size(arg);
     left = lstrip_helper(myptr, mysize, argptr, argsize);
     right = mysize;
     return PyBytes_FromStringAndSize(self->ob_bytes + left, right - left);
@@ -2542,9 +2542,9 @@ bytes_rstrip(PyBytesObject *self, PyObject *arg)
         return NULL;
     }
     myptr = self->ob_bytes;
-    mysize = self->ob_size;
+    mysize = Py_Size(self);
     argptr = ((PyBytesObject *)arg)->ob_bytes;
-    argsize = ((PyBytesObject *)arg)->ob_size;
+    argsize = Py_Size(arg);
     left = 0;
     right = rstrip_helper(myptr, mysize, argptr, argsize);
     return PyBytes_FromStringAndSize(self->ob_bytes + left, right - left);
@@ -2616,7 +2616,7 @@ bytes_join(PyBytesObject *self, PyObject *it)
                          "can only join an iterable of bytes "
                          "(item %ld has type '%.100s')",
                          /* XXX %ld isn't right on Win64 */
-                         (long)i, obj->ob_type->tp_name);
+                         (long)i, Py_Type(obj)->tp_name);
             goto error;
         }
         if (i > 0)
@@ -2725,7 +2725,7 @@ static PyObject *
 bytes_reduce(PyBytesObject *self)
 {
     return Py_BuildValue("(O(s#s))",
-                         self->ob_type,
+                         Py_Type(self),
                          self->ob_bytes == NULL ? "" : self->ob_bytes,
                          self->ob_size,
                          "latin-1");
@@ -2799,8 +2799,7 @@ PyDoc_STRVAR(bytes_doc,
 If an argument is given it must be an iterable yielding ints in range(256).");
 
 PyTypeObject PyBytes_Type = {
-    PyObject_HEAD_INIT(&PyType_Type)
-    0,
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "bytes",
     sizeof(PyBytesObject),
     0,
diff --git a/Objects/cellobject.c b/Objects/cellobject.c
index 1a19c6a..6794ff3 100644
--- a/Objects/cellobject.c
+++ b/Objects/cellobject.c
@@ -87,8 +87,7 @@ static PyGetSetDef cell_getsetlist[] = {
 };
 
 PyTypeObject PyCell_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"cell",
 	sizeof(PyCellObject),
 	0,
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 9c9c49e..2db898a 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -426,8 +426,7 @@ method_descr_get(PyObject *meth, PyObject *obj, PyObject *cls)
 }
 
 PyTypeObject PyMethod_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"method",
 	sizeof(PyMethodObject),
 	0,
diff --git a/Objects/cobject.c b/Objects/cobject.c
index b2cae9a..a1ee686 100644
--- a/Objects/cobject.c
+++ b/Objects/cobject.c
@@ -135,8 +135,7 @@ extension modules, so that extension modules can use the Python import\n\
 mechanism to link to one another.");
 
 PyTypeObject PyCObject_Type = {
-    PyObject_HEAD_INIT(&PyType_Type)
-    0,				/*ob_size*/
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "PyCObject",		/*tp_name*/
     sizeof(PyCObject),		/*tp_basicsize*/
     0,				/*tp_itemsize*/
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
index c735193..0a7c141 100644
--- a/Objects/codeobject.c
+++ b/Objects/codeobject.c
@@ -390,8 +390,7 @@ code_hash(PyCodeObject *co)
 /* XXX code objects need to participate in GC? */
 
 PyTypeObject PyCode_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"code",
 	sizeof(PyCodeObject),
 	0,
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 4580ef2..69dd502 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -1040,8 +1040,7 @@ static PyNumberMethods complex_as_number = {
 };
 
 PyTypeObject PyComplex_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"complex",
 	sizeof(PyComplexObject),
 	0,
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index e75fc80..a1a2c51 100644
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -384,8 +384,7 @@ descr_traverse(PyObject *self, visitproc visit, void *arg)
 }
 
 static PyTypeObject PyMethodDescr_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"method_descriptor",
 	sizeof(PyMethodDescrObject),
 	0,
@@ -423,8 +422,7 @@ static PyTypeObject PyMethodDescr_Type = {
 
 /* This is for METH_CLASS in C, not for "f = classmethod(f)" in Python! */
 static PyTypeObject PyClassMethodDescr_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"classmethod_descriptor",
 	sizeof(PyMethodDescrObject),
 	0,
@@ -461,8 +459,7 @@ static PyTypeObject PyClassMethodDescr_Type = {
 };
 
 static PyTypeObject PyMemberDescr_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"member_descriptor",
 	sizeof(PyMemberDescrObject),
 	0,
@@ -499,8 +496,7 @@ static PyTypeObject PyMemberDescr_Type = {
 };
 
 static PyTypeObject PyGetSetDescr_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"getset_descriptor",
 	sizeof(PyGetSetDescrObject),
 	0,
@@ -537,8 +533,7 @@ static PyTypeObject PyGetSetDescr_Type = {
 };
 
 PyTypeObject PyWrapperDescr_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"wrapper_descriptor",
 	sizeof(PyWrapperDescrObject),
 	0,
@@ -816,8 +811,7 @@ proxy_richcompare(proxyobject *v, PyObject *w, int op)
 }
 
 static PyTypeObject proxytype = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dictproxy",				/* tp_name */
 	sizeof(proxyobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -998,8 +992,7 @@ wrapper_traverse(PyObject *self, visitproc visit, void *arg)
 }
 
 static PyTypeObject wrappertype = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"method-wrapper",			/* tp_name */
 	sizeof(wrapperobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -1229,8 +1222,7 @@ property_traverse(PyObject *self, visitproc visit, void *arg)
 }
 
 PyTypeObject PyProperty_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"property",				/* tp_name */
 	sizeof(propertyobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 639c3c5..95afdc0 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -204,7 +204,7 @@ PyDict_New(void)
 	if (num_free_dicts) {
 		mp = free_dicts[--num_free_dicts];
 		assert (mp != NULL);
-		assert (mp->ob_type == &PyDict_Type);
+		assert (Py_Type(mp) == &PyDict_Type);
 		_Py_NewReference((PyObject *)mp);
 		if (mp->ma_fill) {
 			EMPTY_TO_MINSIZE(mp);
@@ -879,10 +879,10 @@ dict_dealloc(register dictobject *mp)
 	}
 	if (mp->ma_table != mp->ma_smalltable)
 		PyMem_DEL(mp->ma_table);
-	if (num_free_dicts < MAXFREEDICTS && mp->ob_type == &PyDict_Type)
+	if (num_free_dicts < MAXFREEDICTS && Py_Type(mp) == &PyDict_Type)
 		free_dicts[num_free_dicts++] = mp;
 	else
-		mp->ob_type->tp_free((PyObject *)mp);
+		Py_Type(mp)->tp_free((PyObject *)mp);
 	Py_TRASHCAN_SAFE_END(mp)
 }
 
@@ -1041,7 +1041,7 @@ dict_subscript(dictobject *mp, register PyObject *key)
 			if (missing_str == NULL)
 				missing_str =
 				  PyUnicode_InternFromString("__missing__");
-			missing = _PyType_Lookup(mp->ob_type, missing_str);
+			missing = _PyType_Lookup(Py_Type(mp), missing_str);
 			if (missing != NULL)
 				return PyObject_CallFunctionObjArgs(missing,
 					(PyObject *)mp, key, NULL);
@@ -2024,8 +2024,7 @@ PyDoc_STRVAR(dictionary_doc,
 "    in the keyword argument list.  For example:  dict(one=1, two=2)");
 
 PyTypeObject PyDict_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dict",
 	sizeof(dictobject),
 	0,
@@ -2209,8 +2208,7 @@ fail:
 }
 
 PyTypeObject PyDictIterKey_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dictionary-keyiterator",		/* tp_name */
 	sizeof(dictiterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -2282,8 +2280,7 @@ fail:
 }
 
 PyTypeObject PyDictIterValue_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dictionary-valueiterator",		/* tp_name */
 	sizeof(dictiterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -2369,8 +2366,7 @@ fail:
 }
 
 PyTypeObject PyDictIterItem_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dictionary-itemiterator",		/* tp_name */
 	sizeof(dictiterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -2574,8 +2570,7 @@ static PyMethodDef dictkeys_methods[] = {
 };
 
 PyTypeObject PyDictKeys_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dict_keys",				/* tp_name */
 	sizeof(dictviewobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -2659,8 +2654,7 @@ static PyMethodDef dictitems_methods[] = {
 };
 
 PyTypeObject PyDictItems_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dict_items",				/* tp_name */
 	sizeof(dictviewobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -2725,8 +2719,7 @@ static PyMethodDef dictvalues_methods[] = {
 };
 
 PyTypeObject PyDictValues_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"dict_values",				/* tp_name */
 	sizeof(dictviewobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/enumobject.c b/Objects/enumobject.c
index a456c9d..6997fdc 100644
--- a/Objects/enumobject.c
+++ b/Objects/enumobject.c
@@ -43,7 +43,7 @@ enum_dealloc(enumobject *en)
 	PyObject_GC_UnTrack(en);
 	Py_XDECREF(en->en_sit);
 	Py_XDECREF(en->en_result);
-	en->ob_type->tp_free(en);
+	Py_Type(en)->tp_free(en);
 }
 
 static int
@@ -68,7 +68,7 @@ enum_next(enumobject *en)
 		return NULL;         
 	}
 
-	next_item = (*it->ob_type->tp_iternext)(it);
+	next_item = (*Py_Type(it)->tp_iternext)(it);
 	if (next_item == NULL)
 		return NULL;
 
@@ -105,8 +105,7 @@ PyDoc_STRVAR(enum_doc,
 "for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...");
 
 PyTypeObject PyEnum_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,                              /* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"enumerate",                    /* tp_name */
 	sizeof(enumobject),             /* tp_basicsize */
 	0,                              /* tp_itemsize */
@@ -195,7 +194,7 @@ reversed_dealloc(reversedobject *ro)
 {
 	PyObject_GC_UnTrack(ro);
 	Py_XDECREF(ro->seq);
-	ro->ob_type->tp_free(ro);
+	Py_Type(ro)->tp_free(ro);
 }
 
 static int
@@ -253,8 +252,7 @@ static PyMethodDef reversediter_methods[] = {
 };
 
 PyTypeObject PyReversed_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,                              /* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"reversed",                     /* tp_name */
 	sizeof(reversedobject),         /* tp_basicsize */
 	0,                              /* tp_itemsize */
diff --git a/Objects/exceptions.c b/Objects/exceptions.c
index a401806..2d096a7 100644
--- a/Objects/exceptions.c
+++ b/Objects/exceptions.c
@@ -41,7 +41,7 @@ BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 static int
 BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
 {
-    if (!_PyArg_NoKeywords(self->ob_type->tp_name, kwds))
+    if (!_PyArg_NoKeywords(Py_Type(self)->tp_name, kwds))
         return -1;
 
     Py_DECREF(self->args);
@@ -64,7 +64,7 @@ BaseException_dealloc(PyBaseExceptionObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     BaseException_clear(self);
-    self->ob_type->tp_free((PyObject *)self);
+    Py_Type(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -94,7 +94,7 @@ BaseException_repr(PyBaseExceptionObject *self)
     char *name;
     char *dot;
 
-    name = (char *)self->ob_type->tp_name;
+    name = (char *)Py_Type(self)->tp_name;
     dot = strrchr(name, '.');
     if (dot != NULL) name = dot+1;
 
@@ -106,9 +106,9 @@ static PyObject *
 BaseException_reduce(PyBaseExceptionObject *self)
 {
     if (self->args && self->dict)
-        return PyTuple_Pack(3, self->ob_type, self->args, self->dict);
+        return PyTuple_Pack(3, Py_Type(self), self->args, self->dict);
     else
-        return PyTuple_Pack(2, self->ob_type, self->args);
+        return PyTuple_Pack(2, Py_Type(self), self->args);
 }
 
 /*
@@ -207,8 +207,7 @@ static PyGetSetDef BaseException_getset[] = {
 
 
 static PyTypeObject _PyExc_BaseException = {
-    PyObject_HEAD_INIT(NULL)
-    0,                          /*ob_size*/
+    PyVarObject_HEAD_INIT(NULL, 0)
     "BaseException", /*tp_name*/
     sizeof(PyBaseExceptionObject), /*tp_basicsize*/
     0,                          /*tp_itemsize*/
@@ -258,8 +257,7 @@ PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;
  */
 #define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \
 static PyTypeObject _PyExc_ ## EXCNAME = { \
-    PyObject_HEAD_INIT(NULL) \
-    0, \
+    PyVarObject_HEAD_INIT(NULL, 0) \
     # EXCNAME, \
     sizeof(PyBaseExceptionObject), \
     0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \
@@ -274,8 +272,7 @@ PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
 
 #define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \
 static PyTypeObject _PyExc_ ## EXCNAME = { \
-    PyObject_HEAD_INIT(NULL) \
-    0, \
+    PyVarObject_HEAD_INIT(NULL, 0) \
     # EXCNAME, \
     sizeof(Py ## EXCSTORE ## Object), \
     0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
@@ -290,8 +287,7 @@ PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
 
 #define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDEALLOC, EXCMETHODS, EXCMEMBERS, EXCSTR, EXCDOC) \
 static PyTypeObject _PyExc_ ## EXCNAME = { \
-    PyObject_HEAD_INIT(NULL) \
-    0, \
+    PyVarObject_HEAD_INIT(NULL, 0) \
     # EXCNAME, \
     sizeof(Py ## EXCSTORE ## Object), 0, \
     (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
@@ -369,7 +365,7 @@ SystemExit_dealloc(PySystemExitObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     SystemExit_clear(self);
-    self->ob_type->tp_free((PyObject *)self);
+    Py_Type(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -474,7 +470,7 @@ EnvironmentError_dealloc(PyEnvironmentErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     EnvironmentError_clear(self);
-    self->ob_type->tp_free((PyObject *)self);
+    Py_Type(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -540,9 +536,9 @@ EnvironmentError_reduce(PyEnvironmentErrorObject *self)
         Py_INCREF(args);
 
     if (self->dict)
-        res = PyTuple_Pack(3, self->ob_type, args, self->dict);
+        res = PyTuple_Pack(3, Py_Type(self), args, self->dict);
     else
-        res = PyTuple_Pack(2, self->ob_type, args);
+        res = PyTuple_Pack(2, Py_Type(self), args);
     Py_DECREF(args);
     return res;
 }
@@ -595,7 +591,7 @@ WindowsError_dealloc(PyWindowsErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     WindowsError_clear(self);
-    self->ob_type->tp_free((PyObject *)self);
+    Py_Type(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -793,7 +789,7 @@ SyntaxError_dealloc(PySyntaxErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     SyntaxError_clear(self);
-    self->ob_type->tp_free((PyObject *)self);
+    Py_Type(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -1244,7 +1240,7 @@ UnicodeError_dealloc(PyUnicodeErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     UnicodeError_clear(self);
-    self->ob_type->tp_free((PyObject *)self);
+    Py_Type(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -1316,8 +1312,7 @@ UnicodeEncodeError_str(PyObject *self)
 }
 
 static PyTypeObject _PyExc_UnicodeEncodeError = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "UnicodeEncodeError",
     sizeof(PyUnicodeErrorObject), 0,
     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -1378,8 +1373,7 @@ UnicodeDecodeError_str(PyObject *self)
 }
 
 static PyTypeObject _PyExc_UnicodeDecodeError = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "UnicodeDecodeError",
     sizeof(PyUnicodeErrorObject), 0,
     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -1465,8 +1459,7 @@ UnicodeTranslateError_str(PyObject *self)
 }
 
 static PyTypeObject _PyExc_UnicodeTranslateError = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "UnicodeTranslateError",
     sizeof(PyUnicodeErrorObject), 0,
     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 4d5d19e..f2f53ba 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -41,8 +41,8 @@ fill_free_list(void)
 	p = &((PyFloatBlock *)p)->objects[0];
 	q = p + N_FLOATOBJECTS;
 	while (--q > p)
-		q->ob_type = (struct _typeobject *)(q-1);
-	q->ob_type = NULL;
+		Py_Type(q) = (struct _typeobject *)(q-1);
+	Py_Type(q) = NULL;
 	return p + N_FLOATOBJECTS - 1;
 }
 
@@ -56,7 +56,7 @@ PyFloat_FromDouble(double fval)
 	}
 	/* Inline PyObject_New */
 	op = free_list;
-	free_list = (PyFloatObject *)op->ob_type;
+	free_list = (PyFloatObject *)Py_Type(op);
 	PyObject_INIT(op, &PyFloat_Type);
 	op->ob_fval = fval;
 	return (PyObject *) op;
@@ -156,11 +156,11 @@ static void
 float_dealloc(PyFloatObject *op)
 {
 	if (PyFloat_CheckExact(op)) {
-		op->ob_type = (struct _typeobject *)free_list;
+		Py_Type(op) = (struct _typeobject *)free_list;
 		free_list = op;
 	}
 	else
-		op->ob_type->tp_free((PyObject *)op);
+		Py_Type(op)->tp_free((PyObject *)op);
 }
 
 double
@@ -178,7 +178,7 @@ PyFloat_AsDouble(PyObject *op)
 		return -1;
 	}
 
-	if ((nb = op->ob_type->tp_as_number) == NULL || nb->nb_float == NULL) {
+	if ((nb = Py_Type(op)->tp_as_number) == NULL || nb->nb_float == NULL) {
 		PyErr_SetString(PyExc_TypeError, "a float is required");
 		return -1;
 	}
@@ -880,7 +880,7 @@ float_getformat(PyTypeObject *v, PyObject* arg)
 	if (!PyString_Check(arg)) {
 		PyErr_Format(PyExc_TypeError,
 	     "__getformat__() argument must be string, not %.500s",
-			     arg->ob_type->tp_name);
+			     Py_Type(arg)->tp_name);
 		return NULL;
 	}
 	s = PyString_AS_STRING(arg);
@@ -1044,8 +1044,7 @@ static PyNumberMethods float_as_number = {
 };
 
 PyTypeObject PyFloat_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"float",
 	sizeof(PyFloatObject),
 	0,
@@ -1156,7 +1155,7 @@ PyFloat_Fini(void)
 		for (i = 0, p = &list->objects[0];
 		     i < N_FLOATOBJECTS;
 		     i++, p++) {
-			if (PyFloat_CheckExact(p) && p->ob_refcnt != 0)
+			if (PyFloat_CheckExact(p) && Py_Refcnt(p) != 0)
 				frem++;
 		}
 		next = list->next;
@@ -1167,8 +1166,8 @@ PyFloat_Fini(void)
 			     i < N_FLOATOBJECTS;
 			     i++, p++) {
 				if (!PyFloat_CheckExact(p) ||
-				    p->ob_refcnt == 0) {
-					p->ob_type = (struct _typeobject *)
+				    Py_Refcnt(p) == 0) {
+					Py_Type(p) = (struct _typeobject *)
 						free_list;
 					free_list = p;
 				}
@@ -1200,7 +1199,7 @@ PyFloat_Fini(void)
 			     i < N_FLOATOBJECTS;
 			     i++, p++) {
 				if (PyFloat_CheckExact(p) &&
-				    p->ob_refcnt != 0) {
+				    Py_Refcnt(p) != 0) {
 					char buf[100];
 					format_float(buf, sizeof(buf), p, PREC_STR);
 					/* XXX(twouters) cast refcount to
@@ -1209,7 +1208,7 @@ PyFloat_Fini(void)
 					 */
 					fprintf(stderr,
 			     "#   <float at %p, refcnt=%ld, val=%s>\n",
-						p, (long)p->ob_refcnt, buf);
+						p, (long)Py_Refcnt(p), buf);
 				}
 			}
 			list = list->next;
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index bb27f1c..a878577 100644
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -503,8 +503,7 @@ frame_clear(PyFrameObject *f)
 
 
 PyTypeObject PyFrame_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"frame",
 	sizeof(PyFrameObject),
 	sizeof(PyObject *),
@@ -617,7 +616,7 @@ PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
 		    --numfree;
 		    f = free_list;
 		    free_list = free_list->f_back;
-		    if (f->ob_size < extras) {
+		    if (Py_Size(f) < extras) {
 			    f = PyObject_GC_Resize(PyFrameObject, f, extras);
 			    if (f == NULL) {
 				    Py_DECREF(builtins);
diff --git a/Objects/funcobject.c b/Objects/funcobject.c
index 343e67c..d0ceccb 100644
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -655,8 +655,7 @@ func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
 }
 
 PyTypeObject PyFunction_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"function",
 	sizeof(PyFunctionObject),
 	0,
@@ -726,7 +725,7 @@ cm_dealloc(classmethod *cm)
 {
 	_PyObject_GC_UNTRACK((PyObject *)cm);
 	Py_XDECREF(cm->cm_callable);
-	cm->ob_type->tp_free((PyObject *)cm);
+	Py_Type(cm)->tp_free((PyObject *)cm);
 }
 
 static int
@@ -755,9 +754,9 @@ cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 		return NULL;
 	}
 	if (type == NULL)
-		type = (PyObject *)(obj->ob_type);
+		type = (PyObject *)(Py_Type(obj));
  	return PyMethod_New(cm->cm_callable,
-			    type, (PyObject *)(type->ob_type));
+			    type, (PyObject *)(Py_Type(type)));
 }
 
 static int
@@ -803,8 +802,7 @@ Class methods are different than C++ or Java static methods.\n\
 If you want those, see the staticmethod builtin.");
 
 PyTypeObject PyClassMethod_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"classmethod",
 	sizeof(classmethod),
 	0,
@@ -884,7 +882,7 @@ sm_dealloc(staticmethod *sm)
 {
 	_PyObject_GC_UNTRACK((PyObject *)sm);
 	Py_XDECREF(sm->sm_callable);
-	sm->ob_type->tp_free((PyObject *)sm);
+	Py_Type(sm)->tp_free((PyObject *)sm);
 }
 
 static int
@@ -951,8 +949,7 @@ Static methods in Python are similar to those found in Java or C++.\n\
 For a more advanced concept, see the classmethod builtin.");
 
 PyTypeObject PyStaticMethod_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"staticmethod",
 	sizeof(staticmethod),
 	0,
diff --git a/Objects/genobject.c b/Objects/genobject.c
index bad485c..b0c8054 100644
--- a/Objects/genobject.c
+++ b/Objects/genobject.c
@@ -28,7 +28,7 @@ gen_dealloc(PyGenObject *gen)
 
 	if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) {
 		/* Generator is paused, so we need to close */
-		gen->ob_type->tp_del(self);
+		Py_Type(gen)->tp_del(self);
 		if (self->ob_refcnt > 0)
 			return;		/* resurrected.  :( */
 	}
@@ -295,8 +295,7 @@ static PyMethodDef gen_methods[] = {
 };
 
 PyTypeObject PyGen_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"generator",				/* tp_name */
 	sizeof(PyGenObject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/intobject.c b/Objects/intobject.c
index 14f98b9..9455f9e 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -57,8 +57,8 @@ fill_free_list(void)
 	p = &((PyIntBlock *)p)->objects[0];
 	q = p + N_INTOBJECTS;
 	while (--q > p)
-		q->ob_type = (struct _typeobject *)(q-1);
-	q->ob_type = NULL;
+		Py_Type(q) = (struct _typeobject *)(q-1);
+	Py_Type(q) = NULL;
 	return p + N_INTOBJECTS - 1;
 }
 
@@ -103,7 +103,7 @@ PyInt_FromLong(long ival)
 	}
 	/* Inline PyObject_New */
 	v = free_list;
-	free_list = (PyIntObject *)v->ob_type;
+	free_list = (PyIntObject *)Py_Type(v);
 	PyObject_INIT(v, &PyInt_Type);
 	v->ob_ival = ival;
 	return (PyObject *) v;
@@ -129,17 +129,17 @@ static void
 int_dealloc(PyIntObject *v)
 {
 	if (PyInt_CheckExact(v)) {
-		v->ob_type = (struct _typeobject *)free_list;
+		Py_Type(v) = (struct _typeobject *)free_list;
 		free_list = v;
 	}
 	else
-		v->ob_type->tp_free((PyObject *)v);
+		Py_Type(v)->tp_free((PyObject *)v);
 }
 
 static void
 int_free(PyIntObject *v)
 {
-	v->ob_type = (struct _typeobject *)free_list;
+	Py_Type(v) = (struct _typeobject *)free_list;
 	free_list = v;
 }
 
@@ -153,7 +153,7 @@ PyInt_AsLong(register PyObject *op)
 	if (op && PyInt_Check(op))
 		return PyInt_AS_LONG((PyIntObject*) op);
 
-	if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
+	if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
 	    nb->nb_int == NULL) {
 		PyErr_SetString(PyExc_TypeError, "an integer is required");
 		return -1;
@@ -208,7 +208,7 @@ PyInt_AsSsize_t(register PyObject *op)
 	return PyInt_AsLong(op);
 #else
 
-	if ((nb = op->ob_type->tp_as_number) == NULL ||
+	if ((nb = Py_Type(op)->tp_as_number) == NULL ||
 	    (nb->nb_int == NULL && nb->nb_long == 0)) {
 		PyErr_SetString(PyExc_TypeError, "an integer is required");
 		return -1;
@@ -257,7 +257,7 @@ PyInt_AsUnsignedLongMask(register PyObject *op)
 	if (op && PyLong_Check(op))
 		return PyLong_AsUnsignedLongMask(op);
 
-	if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
+	if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
 	    nb->nb_int == NULL) {
 		PyErr_SetString(PyExc_TypeError, "an integer is required");
 		return (unsigned long)-1;
@@ -302,7 +302,7 @@ PyInt_AsUnsignedLongLongMask(register PyObject *op)
 	if (op && PyLong_Check(op))
 		return PyLong_AsUnsignedLongLongMask(op);
 
-	if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
+	if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
 	    nb->nb_int == NULL) {
 		PyErr_SetString(PyExc_TypeError, "an integer is required");
 		return (unsigned PY_LONG_LONG)-1;
@@ -1062,8 +1062,7 @@ static PyNumberMethods int_as_number = {
 };
 
 PyTypeObject PyInt_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"int",
 	sizeof(PyIntObject),
 	0,
@@ -1116,7 +1115,7 @@ _PyInt_Init(void)
 			return 0;
 		/* PyObject_New is inlined */
 		v = free_list;
-		free_list = (PyIntObject *)v->ob_type;
+		free_list = (PyIntObject *)Py_Type(v);
 		PyObject_INIT(v, &PyInt_Type);
 		v->ob_ival = ival;
 		small_ints[ival + NSMALLNEGINTS] = v;
@@ -1169,7 +1168,7 @@ PyInt_Fini(void)
 			     ctr++, p++) {
 				if (!PyInt_CheckExact(p) ||
 				    p->ob_refcnt == 0) {
-					p->ob_type = (struct _typeobject *)
+					Py_Type(p) = (struct _typeobject *)
 						free_list;
 					free_list = p;
 				}
diff --git a/Objects/iterobject.c b/Objects/iterobject.c
index 6c12b74..32b9f94 100644
--- a/Objects/iterobject.c
+++ b/Objects/iterobject.c
@@ -94,8 +94,7 @@ static PyMethodDef seqiter_methods[] = {
 };
 
 PyTypeObject PySeqIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"iterator",				/* tp_name */
 	sizeof(seqiterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -199,8 +198,7 @@ calliter_iternext(calliterobject *it)
 }
 
 PyTypeObject PyCallIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"callable-iterator",			/* tp_name */
 	sizeof(calliterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -255,7 +253,7 @@ _PyZip_CreateIter(PyObject* args)
         
         assert(PyTuple_Check(args));
 
-	if (PyZipIter_Type.ob_type == NULL) {
+	if (Py_Type(&PyZipIter_Type) == NULL) {
 		if (PyType_Ready(&PyZipIter_Type) < 0)
 			return NULL;
 	}
@@ -370,8 +368,7 @@ zipiter_next(zipiterobject *zit)
 }
 
 static PyTypeObject PyZipIter_Type = {
-	PyObject_HEAD_INIT(0)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(0, 0)
 	"zipiterator",				/* tp_name */
 	sizeof(zipiterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 0180e89..4d4399c 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -34,7 +34,7 @@ list_resize(PyListObject *self, Py_ssize_t newsize)
 	*/
 	if (allocated >= newsize && newsize >= (allocated >> 1)) {
 		assert(self->ob_item != NULL || newsize == 0);
-		self->ob_size = newsize;
+		Py_Size(self) = newsize;
 		return 0;
 	}
 
@@ -58,7 +58,7 @@ list_resize(PyListObject *self, Py_ssize_t newsize)
 		return -1;
 	}
 	self->ob_item = items;
-	self->ob_size = newsize;
+	Py_Size(self) = newsize;
 	self->allocated = new_allocated;
 	return 0;
 }
@@ -114,7 +114,7 @@ PyList_New(Py_ssize_t size)
 		}
 		memset(op->ob_item, 0, nbytes);
 	}
-	op->ob_size = size;
+	Py_Size(op) = size;
 	op->allocated = size;
 	_PyObject_GC_TRACK(op);
 	return (PyObject *) op;
@@ -128,7 +128,7 @@ PyList_Size(PyObject *op)
 		return -1;
 	}
 	else
-		return ((PyListObject *)op) -> ob_size;
+		return Py_Size(op);
 }
 
 static PyObject *indexerr = NULL;
@@ -140,7 +140,7 @@ PyList_GetItem(PyObject *op, Py_ssize_t i)
 		PyErr_BadInternalCall();
 		return NULL;
 	}
-	if (i < 0 || i >= ((PyListObject *)op) -> ob_size) {
+	if (i < 0 || i >= Py_Size(op)) {
 		if (indexerr == NULL)
 			indexerr = PyString_FromString(
 				"list index out of range");
@@ -161,7 +161,7 @@ PyList_SetItem(register PyObject *op, register Py_ssize_t i,
 		PyErr_BadInternalCall();
 		return -1;
 	}
-	if (i < 0 || i >= ((PyListObject *)op) -> ob_size) {
+	if (i < 0 || i >= Py_Size(op)) {
 		Py_XDECREF(newitem);
 		PyErr_SetString(PyExc_IndexError,
 				"list assignment index out of range");
@@ -177,7 +177,7 @@ PyList_SetItem(register PyObject *op, register Py_ssize_t i,
 static int
 ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
 {
-	Py_ssize_t i, n = self->ob_size;
+	Py_ssize_t i, n = Py_Size(self);
 	PyObject **items;
 	if (v == NULL) {
 		PyErr_BadInternalCall();
@@ -259,7 +259,7 @@ list_dealloc(PyListObject *op)
 		   There's a simple test case where somehow this reduces
 		   thrashing when a *very* large list is created and
 		   immediately deleted. */
-		i = op->ob_size;
+		i = Py_Size(op);
 		while (--i >= 0) {
 			Py_XDECREF(op->ob_item[i]);
 		}
@@ -268,7 +268,7 @@ list_dealloc(PyListObject *op)
 	if (num_free_lists < MAXFREELISTS && PyList_CheckExact(op))
 		free_lists[num_free_lists++] = op;
 	else
-		op->ob_type->tp_free((PyObject *)op);
+		Py_Type(op)->tp_free((PyObject *)op);
 	Py_TRASHCAN_SAFE_END(op)
 }
 
@@ -286,7 +286,7 @@ list_print(PyListObject *op, FILE *fp, int flags)
 		return 0;
 	}
 	fprintf(fp, "[");
-	for (i = 0; i < op->ob_size; i++) {
+	for (i = 0; i < Py_Size(op); i++) {
 		if (i > 0)
 			fprintf(fp, ", ");
 		if (PyObject_Print(op->ob_item[i], fp, 0) != 0) {
@@ -311,7 +311,7 @@ list_repr(PyListObject *v)
 		return i > 0 ? PyUnicode_FromString("[...]") : NULL;
 	}
 
-	if (v->ob_size == 0) {
+	if (Py_Size(v) == 0) {
 		result = PyUnicode_FromString("[]");
 		goto Done;
 	}
@@ -322,7 +322,7 @@ list_repr(PyListObject *v)
 
 	/* Do repr() on each element.  Note that this may mutate the list,
 	   so must refetch the list size on each iteration. */
-	for (i = 0; i < v->ob_size; ++i) {
+	for (i = 0; i < Py_Size(v); ++i) {
 		int status;
 		s = PyObject_Repr(v->ob_item[i]);
 		if (s == NULL)
@@ -369,7 +369,7 @@ Done:
 static Py_ssize_t
 list_length(PyListObject *a)
 {
-	return a->ob_size;
+	return Py_Size(a);
 }
 
 static int
@@ -378,7 +378,7 @@ list_contains(PyListObject *a, PyObject *el)
 	Py_ssize_t i;
 	int cmp;
 
-	for (i = 0, cmp = 0 ; cmp == 0 && i < a->ob_size; ++i)
+	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(a); ++i)
 		cmp = PyObject_RichCompareBool(el, PyList_GET_ITEM(a, i),
 						   Py_EQ);
 	return cmp;
@@ -387,7 +387,7 @@ list_contains(PyListObject *a, PyObject *el)
 static PyObject *
 list_item(PyListObject *a, Py_ssize_t i)
 {
-	if (i < 0 || i >= a->ob_size) {
+	if (i < 0 || i >= Py_Size(a)) {
 		if (indexerr == NULL)
 			indexerr = PyString_FromString(
 				"list index out of range");
@@ -406,12 +406,12 @@ list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
 	Py_ssize_t i, len;
 	if (ilow < 0)
 		ilow = 0;
-	else if (ilow > a->ob_size)
-		ilow = a->ob_size;
+	else if (ilow > Py_Size(a))
+		ilow = Py_Size(a);
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > a->ob_size)
-		ihigh = a->ob_size;
+	else if (ihigh > Py_Size(a))
+		ihigh = Py_Size(a);
 	len = ihigh - ilow;
 	np = (PyListObject *) PyList_New(len);
 	if (np == NULL)
@@ -451,7 +451,7 @@ list_concat(PyListObject *a, PyObject *bb)
 		return NULL;
 	}
 #define b ((PyListObject *)bb)
-	size = a->ob_size + b->ob_size;
+	size = Py_Size(a) + Py_Size(b);
 	if (size < 0)
 		return PyErr_NoMemory();
 	np = (PyListObject *) PyList_New(size);
@@ -460,14 +460,14 @@ list_concat(PyListObject *a, PyObject *bb)
 	}
 	src = a->ob_item;
 	dest = np->ob_item;
-	for (i = 0; i < a->ob_size; i++) {
+	for (i = 0; i < Py_Size(a); i++) {
 		PyObject *v = src[i];
 		Py_INCREF(v);
 		dest[i] = v;
 	}
 	src = b->ob_item;
-	dest = np->ob_item + a->ob_size;
-	for (i = 0; i < b->ob_size; i++) {
+	dest = np->ob_item + Py_Size(a);
+	for (i = 0; i < Py_Size(b); i++) {
 		PyObject *v = src[i];
 		Py_INCREF(v);
 		dest[i] = v;
@@ -486,17 +486,17 @@ list_repeat(PyListObject *a, Py_ssize_t n)
 	PyObject *elem;
 	if (n < 0)
 		n = 0;
-	size = a->ob_size * n;
+	size = Py_Size(a) * n;
 	if (size == 0)
               return PyList_New(0);
-	if (n && size/n != a->ob_size)
+	if (n && size/n != Py_Size(a))
 		return PyErr_NoMemory();
 	np = (PyListObject *) PyList_New(size);
 	if (np == NULL)
 		return NULL;
 
 	items = np->ob_item;
-	if (a->ob_size == 1) {
+	if (Py_Size(a) == 1) {
 		elem = a->ob_item[0];
 		for (i = 0; i < n; i++) {
 			items[i] = elem;
@@ -507,7 +507,7 @@ list_repeat(PyListObject *a, Py_ssize_t n)
 	p = np->ob_item;
 	items = a->ob_item;
 	for (i = 0; i < n; i++) {
-		for (j = 0; j < a->ob_size; j++) {
+		for (j = 0; j < Py_Size(a); j++) {
 			*p = items[j];
 			Py_INCREF(*p);
 			p++;
@@ -524,8 +524,8 @@ list_clear(PyListObject *a)
 	if (item != NULL) {
 		/* Because XDECREF can recursively invoke operations on
 		   this list, we make it empty first. */
-		i = a->ob_size;
-		a->ob_size = 0;
+		i = Py_Size(a);
+		Py_Size(a) = 0;
 		a->ob_item = NULL;
 		a->allocated = 0;
 		while (--i >= 0) {
@@ -571,7 +571,7 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 	else {
 		if (a == b) {
 			/* Special case "a[i:j] = a" -- copy b first */
-			v = list_slice(b, 0, b->ob_size);
+			v = list_slice(b, 0, Py_Size(b));
 			if (v == NULL)
 				return result;
 			result = list_ass_slice(a, ilow, ihigh, v);
@@ -586,18 +586,18 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 	}
 	if (ilow < 0)
 		ilow = 0;
-	else if (ilow > a->ob_size)
-		ilow = a->ob_size;
+	else if (ilow > Py_Size(a))
+		ilow = Py_Size(a);
 
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > a->ob_size)
-		ihigh = a->ob_size;
+	else if (ihigh > Py_Size(a))
+		ihigh = Py_Size(a);
 
 	norig = ihigh - ilow;
 	assert(norig >= 0);
 	d = n - norig;
-	if (a->ob_size + d == 0) {
+	if (Py_Size(a) + d == 0) {
 		Py_XDECREF(v_as_SF);
 		return list_clear(a);
 	}
@@ -615,12 +615,12 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 
 	if (d < 0) { /* Delete -d items */
 		memmove(&item[ihigh+d], &item[ihigh],
-			(a->ob_size - ihigh)*sizeof(PyObject *));
-		list_resize(a, a->ob_size + d);
+			(Py_Size(a) - ihigh)*sizeof(PyObject *));
+		list_resize(a, Py_Size(a) + d);
 		item = a->ob_item;
 	}
 	else if (d > 0) { /* Insert d items */
-		k = a->ob_size;
+		k = Py_Size(a);
 		if (list_resize(a, k+d) < 0)
 			goto Error;
 		item = a->ob_item;
@@ -692,7 +692,7 @@ static int
 list_ass_item(PyListObject *a, Py_ssize_t i, PyObject *v)
 {
 	PyObject *old_value;
-	if (i < 0 || i >= a->ob_size) {
+	if (i < 0 || i >= Py_Size(a)) {
 		PyErr_SetString(PyExc_IndexError,
 				"list assignment index out of range");
 		return -1;
@@ -751,7 +751,7 @@ listextend(PyListObject *self, PyObject *b)
 			Py_DECREF(b);
 			Py_RETURN_NONE;
 		}
-		m = self->ob_size;
+		m = Py_Size(self);
 		if (list_resize(self, m + n) == -1) {
 			Py_DECREF(b);
 			return NULL;
@@ -789,14 +789,14 @@ listextend(PyListObject *self, PyObject *b)
 		PyErr_Clear();
 		n = 8;	/* arbitrary */
 	}
-	m = self->ob_size;
+	m = Py_Size(self);
 	mn = m + n;
 	if (mn >= m) {
 		/* Make room. */
 		if (list_resize(self, mn) == -1)
 			goto error;
 		/* Make the list sane again. */
-		self->ob_size = m;
+		Py_Size(self) = m;
 	}
 	/* Else m + n overflowed; on the chance that n lied, and there really
 	 * is enough room, ignore it.  If n was telling the truth, we'll
@@ -815,10 +815,10 @@ listextend(PyListObject *self, PyObject *b)
 			}
 			break;
 		}
-		if (self->ob_size < self->allocated) {
+		if (Py_Size(self) < self->allocated) {
 			/* steals ref */
-			PyList_SET_ITEM(self, self->ob_size, item);
-			++self->ob_size;
+			PyList_SET_ITEM(self, Py_Size(self), item);
+			++Py_Size(self);
 		}
 		else {
 			int status = app1(self, item);
@@ -829,8 +829,8 @@ listextend(PyListObject *self, PyObject *b)
 	}
 
 	/* Cut back result list if initial guess was too large. */
-	if (self->ob_size < self->allocated)
-		list_resize(self, self->ob_size);  /* shrinking can't fail */
+	if (Py_Size(self) < self->allocated)
+		list_resize(self, Py_Size(self));  /* shrinking can't fail */
 
 	Py_DECREF(it);
 	Py_RETURN_NONE;
@@ -869,20 +869,20 @@ listpop(PyListObject *self, PyObject *args)
 	if (!PyArg_ParseTuple(args, "|n:pop", &i))
 		return NULL;
 
-	if (self->ob_size == 0) {
+	if (Py_Size(self) == 0) {
 		/* Special-case most common failure cause */
 		PyErr_SetString(PyExc_IndexError, "pop from empty list");
 		return NULL;
 	}
 	if (i < 0)
-		i += self->ob_size;
-	if (i < 0 || i >= self->ob_size) {
+		i += Py_Size(self);
+	if (i < 0 || i >= Py_Size(self)) {
 		PyErr_SetString(PyExc_IndexError, "pop index out of range");
 		return NULL;
 	}
 	v = self->ob_item[i];
-	if (i == self->ob_size - 1) {
-		status = list_resize(self, self->ob_size - 1);
+	if (i == Py_Size(self) - 1) {
+		status = list_resize(self, Py_Size(self) - 1);
 		assert(status >= 0);
 		return v; /* and v now owns the reference the list had */
 	}
@@ -1812,8 +1812,7 @@ static void
 sortwrapper_dealloc(sortwrapperobject *);
 
 static PyTypeObject sortwrapper_type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"sortwrapper",				/* tp_name */
 	sizeof(sortwrapperobject),		/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -1929,8 +1928,7 @@ cmpwrapper_call(cmpwrapperobject *co, PyObject *args, PyObject *kwds)
 PyDoc_STRVAR(cmpwrapper_doc, "cmp() wrapper for sort with custom keys.");
 
 static PyTypeObject cmpwrapper_type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"cmpwrapper",				/* tp_name */
 	sizeof(cmpwrapperobject),		/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -2033,10 +2031,10 @@ listsort(PyListObject *self, PyObject *args, PyObject *kwds)
 	 * sorting (allowing mutations during sorting is a core-dump
 	 * factory, since ob_item may change).
 	 */
-	saved_ob_size = self->ob_size;
+	saved_ob_size = Py_Size(self);
 	saved_ob_item = self->ob_item;
 	saved_allocated = self->allocated;
-	self->ob_size = 0;
+	Py_Size(self) = 0;
 	self->ob_item = NULL;
 	self->allocated = -1; /* any operation will reset it to >= 0 */
 
@@ -2142,8 +2140,8 @@ fail:
 
 dsu_fail:
 	final_ob_item = self->ob_item;
-	i = self->ob_size;
-	self->ob_size = saved_ob_size;
+	i = Py_Size(self);
+	Py_Size(self) = saved_ob_size;
 	self->ob_item = saved_ob_item;
 	self->allocated = saved_allocated;
 	if (final_ob_item != NULL) {
@@ -2178,8 +2176,8 @@ PyList_Sort(PyObject *v)
 static PyObject *
 listreverse(PyListObject *self)
 {
-	if (self->ob_size > 1)
-		reverse_slice(self->ob_item, self->ob_item + self->ob_size);
+	if (Py_Size(self) > 1)
+		reverse_slice(self->ob_item, self->ob_item + Py_Size(self));
 	Py_RETURN_NONE;
 }
 
@@ -2192,8 +2190,8 @@ PyList_Reverse(PyObject *v)
 		PyErr_BadInternalCall();
 		return -1;
 	}
-	if (self->ob_size > 1)
-		reverse_slice(self->ob_item, self->ob_item + self->ob_size);
+	if (Py_Size(self) > 1)
+		reverse_slice(self->ob_item, self->ob_item + Py_Size(self));
 	return 0;
 }
 
@@ -2207,7 +2205,7 @@ PyList_AsTuple(PyObject *v)
 		PyErr_BadInternalCall();
 		return NULL;
 	}
-	n = ((PyListObject *)v)->ob_size;
+	n = Py_Size(v);
 	w = PyTuple_New(n);
 	if (w == NULL)
 		return NULL;
@@ -2225,7 +2223,7 @@ PyList_AsTuple(PyObject *v)
 static PyObject *
 listindex(PyListObject *self, PyObject *args)
 {
-	Py_ssize_t i, start=0, stop=self->ob_size;
+	Py_ssize_t i, start=0, stop=Py_Size(self);
 	PyObject *v;
 
 	if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
@@ -2233,16 +2231,16 @@ listindex(PyListObject *self, PyObject *args)
 	                            _PyEval_SliceIndex, &stop))
 		return NULL;
 	if (start < 0) {
-		start += self->ob_size;
+		start += Py_Size(self);
 		if (start < 0)
 			start = 0;
 	}
 	if (stop < 0) {
-		stop += self->ob_size;
+		stop += Py_Size(self);
 		if (stop < 0)
 			stop = 0;
 	}
-	for (i = start; i < stop && i < self->ob_size; i++) {
+	for (i = start; i < stop && i < Py_Size(self); i++) {
 		int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
 		if (cmp > 0)
 			return PyInt_FromSsize_t(i);
@@ -2259,7 +2257,7 @@ listcount(PyListObject *self, PyObject *v)
 	Py_ssize_t count = 0;
 	Py_ssize_t i;
 
-	for (i = 0; i < self->ob_size; i++) {
+	for (i = 0; i < Py_Size(self); i++) {
 		int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
 		if (cmp > 0)
 			count++;
@@ -2274,7 +2272,7 @@ listremove(PyListObject *self, PyObject *v)
 {
 	Py_ssize_t i;
 
-	for (i = 0; i < self->ob_size; i++) {
+	for (i = 0; i < Py_Size(self); i++) {
 		int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
 		if (cmp > 0) {
 			if (list_ass_slice(self, i, i+1,
@@ -2294,7 +2292,7 @@ list_traverse(PyListObject *o, visitproc visit, void *arg)
 {
 	Py_ssize_t i;
 
-	for (i = o->ob_size; --i >= 0; )
+	for (i = Py_Size(o); --i >= 0; )
 		Py_VISIT(o->ob_item[i]);
 	return 0;
 }
@@ -2313,7 +2311,7 @@ list_richcompare(PyObject *v, PyObject *w, int op)
 	vl = (PyListObject *)v;
 	wl = (PyListObject *)w;
 
-	if (vl->ob_size != wl->ob_size && (op == Py_EQ || op == Py_NE)) {
+	if (Py_Size(vl) != Py_Size(wl) && (op == Py_EQ || op == Py_NE)) {
 		/* Shortcut: if the lengths differ, the lists differ */
 		PyObject *res;
 		if (op == Py_EQ)
@@ -2325,7 +2323,7 @@ list_richcompare(PyObject *v, PyObject *w, int op)
 	}
 
 	/* Search for the first index where items are different */
-	for (i = 0; i < vl->ob_size && i < wl->ob_size; i++) {
+	for (i = 0; i < Py_Size(vl) && i < Py_Size(wl); i++) {
 		int k = PyObject_RichCompareBool(vl->ob_item[i],
 						 wl->ob_item[i], Py_EQ);
 		if (k < 0)
@@ -2334,10 +2332,10 @@ list_richcompare(PyObject *v, PyObject *w, int op)
 			break;
 	}
 
-	if (i >= vl->ob_size || i >= wl->ob_size) {
+	if (i >= Py_Size(vl) || i >= Py_Size(wl)) {
 		/* No more items to compare -- compare sizes */
-		Py_ssize_t vs = vl->ob_size;
-		Py_ssize_t ws = wl->ob_size;
+		Py_ssize_t vs = Py_Size(vl);
+		Py_ssize_t ws = Py_Size(wl);
 		int cmp;
 		PyObject *res;
 		switch (op) {
@@ -2381,8 +2379,8 @@ list_init(PyListObject *self, PyObject *args, PyObject *kw)
 		return -1;
 
 	/* Verify list invariants established by PyType_GenericAlloc() */
-	assert(0 <= self->ob_size);
-	assert(self->ob_size <= self->allocated || self->allocated == -1);
+	assert(0 <= Py_Size(self));
+	assert(Py_Size(self) <= self->allocated || self->allocated == -1);
 	assert(self->ob_item != NULL ||
 	       self->allocated == 0 || self->allocated == -1);
 
@@ -2478,7 +2476,7 @@ list_subscript(PyListObject* self, PyObject* item)
 		PyObject* it;
 		PyObject **src, **dest;
 
-		if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
+		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
 				 &start, &stop, &step, &slicelength) < 0) {
 			return NULL;
 		}
@@ -2524,7 +2522,7 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
 	else if (PySlice_Check(item)) {
 		Py_ssize_t start, stop, step, slicelength;
 
-		if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
+		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
 				 &start, &stop, &step, &slicelength) < 0) {
 			return -1;
 		}
@@ -2563,8 +2561,8 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
 
 				garbage[i] = PyList_GET_ITEM(self, cur);
 
-				if (cur + step >= self->ob_size) {
-					lim = self->ob_size - cur - 1;
+				if (cur + step >= Py_Size(self)) {
+					lim = Py_Size(self) - cur - 1;
 				}
 
 				memmove(self->ob_item + cur - i,
@@ -2573,13 +2571,13 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
 			}
 
 			for (cur = start + slicelength*step + 1;
-			     cur < self->ob_size; cur++) {
+			     cur < Py_Size(self); cur++) {
 				PyList_SET_ITEM(self, cur - slicelength,
 						PyList_GET_ITEM(self, cur));
 			}
 
-			self->ob_size -= slicelength;
-			list_resize(self, self->ob_size);
+			Py_Size(self) -= slicelength;
+			list_resize(self, Py_Size(self));
 
 			for (i = 0; i < slicelength; i++) {
 				Py_DECREF(garbage[i]);
@@ -2662,8 +2660,7 @@ static PyMappingMethods list_as_mapping = {
 };
 
 PyTypeObject PyList_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"list",
 	sizeof(PyListObject),
 	0,
@@ -2728,8 +2725,7 @@ static PyMethodDef listiter_methods[] = {
 };
 
 PyTypeObject PyListIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"listiterator",				/* tp_name */
 	sizeof(listiterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -2851,8 +2847,7 @@ static PySequenceMethods listreviter_as_sequence = {
 };
 
 PyTypeObject PyListRevIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"listreverseiterator",			/* tp_name */
 	sizeof(listreviterobject),		/* tp_basicsize */
 	0,					/* tp_itemsize */
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
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index 2d1c688..f47037b 100644
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -241,8 +241,7 @@ meth_hash(PyCFunctionObject *a)
 
 
 PyTypeObject PyCFunction_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"builtin_function_or_method",
 	sizeof(PyCFunctionObject),
 	0,
diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c
index 7c5e47f..6f7294a 100644
--- a/Objects/moduleobject.c
+++ b/Objects/moduleobject.c
@@ -181,7 +181,7 @@ module_dealloc(PyModuleObject *m)
 		_PyModule_Clear((PyObject *)m);
 		Py_DECREF(m->md_dict);
 	}
-	m->ob_type->tp_free((PyObject *)m);
+	Py_Type(m)->tp_free((PyObject *)m);
 }
 
 static PyObject *
@@ -220,8 +220,7 @@ Create a module object.\n\
 The name must be a string; the optional doc argument can have any type.");
 
 PyTypeObject PyModule_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"module",				/* tp_name */
 	sizeof(PyModuleObject),			/* tp_size */
 	0,					/* tp_itemsize */
diff --git a/Objects/object.c b/Objects/object.c
index 3583bca..a725022 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -214,7 +214,7 @@ PyObject_Init(PyObject *op, PyTypeObject *tp)
 	if (op == NULL)
 		return PyErr_NoMemory();
 	/* Any changes should be reflected in PyObject_INIT (objimpl.h) */
-	op->ob_type = tp;
+	Py_Type(op) = tp;
 	_Py_NewReference(op);
 	return op;
 }
@@ -226,7 +226,7 @@ PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)
 		return (PyVarObject *) PyErr_NoMemory();
 	/* Any changes should be reflected in PyObject_INIT_VAR */
 	op->ob_size = size;
-	op->ob_type = tp;
+	Py_Type(op) = tp;
 	_Py_NewReference((PyObject *)op);
 	return op;
 }
@@ -279,7 +279,7 @@ internal_print(PyObject *op, FILE *fp, int flags, int nesting)
 			   universally available */
 			fprintf(fp, "<refcnt %ld at %p>",
 				(long)op->ob_refcnt, op);
-		else if (op->ob_type->tp_print == NULL) {
+		else if (Py_Type(op)->tp_print == NULL) {
 			PyObject *s;
 			if (flags & Py_PRINT_RAW)
 				s = PyObject_Str(op);
@@ -294,7 +294,7 @@ internal_print(PyObject *op, FILE *fp, int flags, int nesting)
 			Py_XDECREF(s);
 		}
 		else
-			ret = (*op->ob_type->tp_print)(op, fp, flags);
+			ret = (*Py_Type(op)->tp_print)(op, fp, flags);
 	}
 	if (ret == 0) {
 		if (ferror(fp)) {
@@ -334,7 +334,7 @@ _PyObject_Dump(PyObject* op)
 			"type    : %s\n"
 			"refcount: %ld\n"
 			"address : %p\n",
-			op->ob_type==NULL ? "NULL" : op->ob_type->tp_name,
+			Py_Type(op)==NULL ? "NULL" : Py_Type(op)->tp_name,
 			(long)op->ob_refcnt,
 			op);
 	}
@@ -354,7 +354,7 @@ PyObject_Repr(PyObject *v)
 #endif
 	if (v == NULL)
 		return PyUnicode_FromString("<NULL>");
-	else if (v->ob_type->tp_repr == NULL)
+	else if (Py_Type(v)->tp_repr == NULL)
 		return PyUnicode_FromFormat("<%s object at %p>", v->ob_type->tp_name, v);
 	else {
 		ress = (*v->ob_type->tp_repr)(v);
@@ -408,16 +408,16 @@ _PyObject_Str(PyObject *v)
 		Py_INCREF(v);
 		return v;
 	}
-	if (v->ob_type->tp_str == NULL)
+	if (Py_Type(v)->tp_str == NULL)
 		return PyObject_Repr(v);
 
-	res = (*v->ob_type->tp_str)(v);
+	res = (*Py_Type(v)->tp_str)(v);
 	if (res == NULL)
 		return NULL;
 	if (!(PyString_Check(res) || PyUnicode_Check(res))) {
 		PyErr_Format(PyExc_TypeError,
 			     "__str__ returned non-string (type %.200s)",
-			     res->ob_type->tp_name);
+			     Py_Type(res)->tp_name);
 		Py_DECREF(res);
 		return NULL;
 	}
@@ -486,8 +486,8 @@ PyObject_Unicode(PyObject *v)
 			res = v;
 		}
 		else {
-			if (v->ob_type->tp_str != NULL)
-				res = (*v->ob_type->tp_str)(v);
+			if (Py_Type(v)->tp_str != NULL)
+				res = (*Py_Type(v)->tp_str)(v);
 			else
 				res = PyObject_Repr(v);
 		}
@@ -849,8 +849,8 @@ PyObject_GetAttrString(PyObject *v, const char *name)
 {
 	PyObject *w, *res;
 
-	if (v->ob_type->tp_getattr != NULL)
-		return (*v->ob_type->tp_getattr)(v, (char*)name);
+	if (Py_Type(v)->tp_getattr != NULL)
+		return (*Py_Type(v)->tp_getattr)(v, (char*)name);
 	w = PyUnicode_InternFromString(name);
 	if (w == NULL)
 		return NULL;
@@ -877,8 +877,8 @@ PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
 	PyObject *s;
 	int res;
 
-	if (v->ob_type->tp_setattr != NULL)
-		return (*v->ob_type->tp_setattr)(v, (char*)name, w);
+	if (Py_Type(v)->tp_setattr != NULL)
+		return (*Py_Type(v)->tp_setattr)(v, (char*)name, w);
 	s = PyUnicode_InternFromString(name);
 	if (s == NULL)
 		return -1;
@@ -890,9 +890,9 @@ PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
 PyObject *
 PyObject_GetAttr(PyObject *v, PyObject *name)
 {
-	PyTypeObject *tp = v->ob_type;
+	PyTypeObject *tp = Py_Type(v);
 
-	if (!PyUnicode_Check(name)) {
+ 	if (!PyUnicode_Check(name)) {
 		PyErr_Format(PyExc_TypeError,
 			     "attribute name must be string, not '%.200s'",
 			     name->ob_type->tp_name);
@@ -923,7 +923,7 @@ PyObject_HasAttr(PyObject *v, PyObject *name)
 int
 PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
 {
-	PyTypeObject *tp = v->ob_type;
+	PyTypeObject *tp = Py_Type(v);
 	int err;
 
 	if (!PyUnicode_Check(name)) {
@@ -970,7 +970,7 @@ PyObject **
 _PyObject_GetDictPtr(PyObject *obj)
 {
 	Py_ssize_t dictoffset;
-	PyTypeObject *tp = obj->ob_type;
+	PyTypeObject *tp = Py_Type(obj);
 
 	dictoffset = tp->tp_dictoffset;
 	if (dictoffset == 0)
@@ -1003,7 +1003,7 @@ PyObject_SelfIter(PyObject *obj)
 PyObject *
 PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 {
-	PyTypeObject *tp = obj->ob_type;
+	PyTypeObject *tp = Py_Type(obj);
 	PyObject *descr = NULL;
 	PyObject *res = NULL;
 	descrgetfunc f;
@@ -1087,7 +1087,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 	}
 
 	if (f != NULL) {
-		res = f(descr, obj, (PyObject *)obj->ob_type);
+		res = f(descr, obj, (PyObject *)Py_Type(obj));
 		Py_DECREF(descr);
 		goto done;
 	}
@@ -1109,7 +1109,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 int
 PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
 {
-	PyTypeObject *tp = obj->ob_type;
+	PyTypeObject *tp = Py_Type(obj);
 	PyObject *descr;
 	descrsetfunc f;
 	PyObject **dictptr;
@@ -1309,7 +1309,7 @@ _dir_locals(void)
 	if (!PyList_Check(names)) {
 		PyErr_Format(PyExc_TypeError,
 			"dir(): expected keys() of locals to be a list, "
-			"not '%.200s'", names->ob_type->tp_name);
+			"not '%.200s'", Py_Type(names)->tp_name);
 		Py_DECREF(names);
 		return NULL;
 	}
@@ -1437,7 +1437,7 @@ _dir_object(PyObject *obj)
 		if (!PyList_Check(result)) {
 			PyErr_Format(PyExc_TypeError,
 				     "__dir__() must return a list, not %.200s",
-				     result->ob_type->tp_name);
+				     Py_Type(result)->tp_name);
 			Py_DECREF(result);
 			result = NULL;
 		}
@@ -1499,8 +1499,7 @@ none_dealloc(PyObject* ignore)
 
 
 static PyTypeObject PyNone_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"NoneType",
 	0,
 	0,
@@ -1517,7 +1516,8 @@ static PyTypeObject PyNone_Type = {
 };
 
 PyObject _Py_NoneStruct = {
-	PyObject_HEAD_INIT(&PyNone_Type)
+  _PyObject_EXTRA_INIT
+  1, &PyNone_Type
 };
 
 /* NotImplemented is an object that can be used to signal that an
@@ -1530,8 +1530,7 @@ NotImplemented_repr(PyObject *op)
 }
 
 static PyTypeObject PyNotImplemented_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"NotImplementedType",
 	0,
 	0,
@@ -1548,7 +1547,8 @@ static PyTypeObject PyNotImplemented_Type = {
 };
 
 PyObject _Py_NotImplementedStruct = {
-	PyObject_HEAD_INIT(&PyNotImplemented_Type)
+	_PyObject_EXTRA_INIT
+	1, &PyNotImplemented_Type
 };
 
 void
@@ -1625,7 +1625,7 @@ _Py_ForgetReference(register PyObject *op)
 void
 _Py_Dealloc(PyObject *op)
 {
-	destructor dealloc = op->ob_type->tp_dealloc;
+	destructor dealloc = Py_Type(op)->tp_dealloc;
 	_Py_ForgetReference(op);
 	(*dealloc)(op);
 }
@@ -1656,7 +1656,7 @@ _Py_PrintReferenceAddresses(FILE *fp)
 	fprintf(fp, "Remaining object addresses:\n");
 	for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
 		fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] %s\n", op,
-			op->ob_refcnt, op->ob_type->tp_name);
+			op->ob_refcnt, Py_Type(op)->tp_name);
 }
 
 PyObject *
@@ -1674,7 +1674,7 @@ _Py_GetObjects(PyObject *self, PyObject *args)
 		return NULL;
 	for (i = 0; (n == 0 || i < n) && op != &refchain; i++) {
 		while (op == self || op == args || op == res || op == t ||
-		       (t != NULL && op->ob_type != (PyTypeObject *) t)) {
+		       (t != NULL && Py_Type(op) != (PyTypeObject *) t)) {
 			op = op->_ob_next;
 			if (op == &refchain)
 				return res;
@@ -1817,7 +1817,7 @@ _PyTrash_destroy_chain(void)
 {
 	while (_PyTrash_delete_later) {
 		PyObject *op = _PyTrash_delete_later;
-		destructor dealloc = op->ob_type->tp_dealloc;
+		destructor dealloc = Py_Type(op)->tp_dealloc;
 
 		_PyTrash_delete_later =
 			(PyObject*) _Py_AS_GC(op)->gc.gc_prev;
diff --git a/Objects/obmalloc.c b/Objects/obmalloc.c
index 840570e..2f2b35e 100644
--- a/Objects/obmalloc.c
+++ b/Objects/obmalloc.c
@@ -675,8 +675,8 @@ extremely desirable that it be this fast.
 /* This is only useful when running memory debuggers such as
  * Purify or Valgrind.  Uncomment to use.
  *
-#define Py_USING_MEMORY_DEBUGGER
  */
+#define Py_USING_MEMORY_DEBUGGER
 
 #ifdef Py_USING_MEMORY_DEBUGGER
 
diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c
index 8cefe67..3a08ccd 100644
--- a/Objects/rangeobject.c
+++ b/Objects/rangeobject.c
@@ -272,8 +272,7 @@ static PyMethodDef range_methods[] = {
 };
 
 PyTypeObject PyRange_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,			/* Number of items for varobject */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"range",		/* Name of this type */
 	sizeof(rangeobject),	/* Basic object size */
 	0,			/* Item size for varobject */
@@ -368,8 +367,7 @@ static PyMethodDef rangeiter_methods[] = {
 };
 
 PyTypeObject Pyrangeiter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,                                      /* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"rangeiterator",                        /* tp_name */
 	sizeof(rangeiterobject),                /* tp_basicsize */
 	0,                                      /* tp_itemsize */
@@ -520,8 +518,7 @@ longrangeiter_next(longrangeiterobject *r)
 }
 
 static PyTypeObject Pylongrangeiter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,                                      /* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"rangeiterator",                        /* tp_name */
 	sizeof(longrangeiterobject),            /* tp_basicsize */
 	0,                                      /* tp_itemsize */
diff --git a/Objects/setobject.c b/Objects/setobject.c
index 8d4291b..cc60488 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -3,7 +3,7 @@
    Written and maintained by Raymond D. Hettinger <python@rcn.com>
    Derived from Lib/sets.py and Objects/dictobject.c.
 
-   Copyright (c) 2003-6 Python Software Foundation.
+   Copyright (c) 2003-2007 Python Software Foundation.
    All rights reserved.
 */
 
@@ -561,7 +561,7 @@ set_dealloc(PySetObject *so)
 	if (num_free_sets < MAXFREESETS && PyAnySet_CheckExact(so))
 		free_sets[num_free_sets++] = so;
 	else 
-		so->ob_type->tp_free(so);
+		Py_Type(so)->tp_free(so);
 	Py_TRASHCAN_SAFE_END(so)
 }
 
@@ -578,21 +578,21 @@ set_tp_print(PySetObject *so, FILE *fp, int flags)
 	if (status != 0) {
 		if (status < 0)
 			return status;
-		fprintf(fp, "%s(...)", so->ob_type->tp_name);
+		fprintf(fp, "%s(...)", Py_Type(so)->tp_name);
 		return 0;
 	}        
 
 	if (!so->used) {
 		Py_ReprLeave((PyObject*)so);
-		fprintf(fp, "%s()", so->ob_type->tp_name);
+		fprintf(fp, "%s()", Py_Type(so)->tp_name);
 		return 0;
 	}
 
-	if (so->ob_type == &PySet_Type) {
+	if (Py_Type(so) == &PySet_Type) {
 		literalform = 1;
 		fprintf(fp, "{");
 	} else
-		fprintf(fp, "%s([", so->ob_type->tp_name);
+		fprintf(fp, "%s([", Py_Type(so)->tp_name);
 	while (set_next(so, &pos, &entry)) {
 		fputs(emit, fp);
 		emit = separator;
@@ -892,8 +892,7 @@ fail:
 }
 
 static PyTypeObject PySetIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"setiterator",				/* tp_name */
 	sizeof(setiterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -1019,7 +1018,7 @@ make_new_set(PyTypeObject *type, PyObject *iterable)
 	    (type == &PySet_Type  ||  type == &PyFrozenSet_Type)) {
 		so = free_sets[--num_free_sets];
 		assert (so != NULL && PyAnySet_CheckExact(so));
-		so->ob_type = type;
+		Py_Type(so) = type;
 		_Py_NewReference((PyObject *)so);
 		EMPTY_TO_MINSIZE(so);
 		PyObject_GC_Track(so);
@@ -1145,8 +1144,8 @@ set_swap_bodies(PySetObject *a, PySetObject *b)
 		memcpy(b->smalltable, tab, sizeof(tab));
 	}
 
-	if (PyType_IsSubtype(a->ob_type, &PyFrozenSet_Type)  &&
-	    PyType_IsSubtype(b->ob_type, &PyFrozenSet_Type)) {
+	if (PyType_IsSubtype(Py_Type(a), &PyFrozenSet_Type)  &&
+	    PyType_IsSubtype(Py_Type(b), &PyFrozenSet_Type)) {
 		h = a->hash;     a->hash = b->hash;  b->hash = h;
 	} else {
 		a->hash = -1;
@@ -1157,7 +1156,7 @@ set_swap_bodies(PySetObject *a, PySetObject *b)
 static PyObject *
 set_copy(PySetObject *so)
 {
-	return make_new_set(so->ob_type, (PyObject *)so);
+	return make_new_set(Py_Type(so), (PyObject *)so);
 }
 
 static PyObject *
@@ -1235,7 +1234,7 @@ set_intersection(PySetObject *so, PyObject *other)
 	if ((PyObject *)so == other)
 		return set_copy(so);
 
-	result = (PySetObject *)make_new_set(so->ob_type, NULL);
+	result = (PySetObject *)make_new_set(Py_Type(so), NULL);
 	if (result == NULL)
 		return NULL;
 
@@ -1422,7 +1421,7 @@ set_difference(PySetObject *so, PyObject *other)
 		return NULL;
 	}
 	
-	result = make_new_set(so->ob_type, NULL);
+	result = make_new_set(Py_Type(so), NULL);
 	if (result == NULL)
 		return NULL;
 
@@ -1523,7 +1522,7 @@ set_symmetric_difference_update(PySetObject *so, PyObject *other)
 		Py_INCREF(other);
 		otherset = (PySetObject *)other;
 	} else {
-		otherset = (PySetObject *)make_new_set(so->ob_type, other);
+		otherset = (PySetObject *)make_new_set(Py_Type(so), other);
 		if (otherset == NULL)
 			return NULL;
 	}
@@ -1554,7 +1553,7 @@ set_symmetric_difference(PySetObject *so, PyObject *other)
 	PyObject *rv;
 	PySetObject *otherset;
 
-	otherset = (PySetObject *)make_new_set(so->ob_type, other);
+	otherset = (PySetObject *)make_new_set(Py_Type(so), other);
 	if (otherset == NULL)
 		return NULL;
 	rv = set_symmetric_difference_update(otherset, (PyObject *)so);
@@ -1821,7 +1820,7 @@ set_reduce(PySetObject *so)
 		dict = Py_None;
 		Py_INCREF(dict);
 	}
-	result = PyTuple_Pack(3, so->ob_type, args, dict);
+	result = PyTuple_Pack(3, Py_Type(so), args, dict);
 done:
 	Py_XDECREF(args);
 	Py_XDECREF(keys);
@@ -1838,7 +1837,7 @@ set_init(PySetObject *self, PyObject *args, PyObject *kwds)
 
 	if (!PyAnySet_Check(self))
 		return -1;
-	if (!PyArg_UnpackTuple(args, self->ob_type->tp_name, 0, 1, &iterable))
+	if (!PyArg_UnpackTuple(args, Py_Type(self)->tp_name, 0, 1, &iterable))
 		return -1;
 	set_clear_internal(self);
 	self->hash = -1;
@@ -1952,8 +1951,7 @@ PyDoc_STRVAR(set_doc,
 Build an unordered collection of unique elements.");
 
 PyTypeObject PySet_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,				/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"set",				/* tp_name */
 	sizeof(PySetObject),		/* tp_basicsize */
 	0,				/* tp_itemsize */
@@ -2046,8 +2044,7 @@ PyDoc_STRVAR(frozenset_doc,
 Build an immutable unordered collection of unique elements.");
 
 PyTypeObject PyFrozenSet_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,				/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"frozenset",			/* tp_name */
 	sizeof(PySetObject),		/* tp_basicsize */
 	0,				/* tp_itemsize */
@@ -2128,7 +2125,7 @@ PySet_Size(PyObject *anyset)
 int
 PySet_Clear(PyObject *set)
 {
-	if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return -1;
 	}
@@ -2148,7 +2145,7 @@ PySet_Contains(PyObject *anyset, PyObject *key)
 int
 PySet_Discard(PyObject *set, PyObject *key)
 {
-	if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return -1;
 	}
@@ -2158,7 +2155,7 @@ PySet_Discard(PyObject *set, PyObject *key)
 int
 PySet_Add(PyObject *set, PyObject *key)
 {
-	if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return -1;
 	}
@@ -2199,7 +2196,7 @@ _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, long *hash)
 PyObject *
 PySet_Pop(PyObject *set)
 {
-	if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return NULL;
 	}
@@ -2209,7 +2206,7 @@ PySet_Pop(PyObject *set)
 int
 _PySet_Update(PyObject *set, PyObject *iterable)
 {
-	if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return -1;
 	}
diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
index a30edef..498172d 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -23,8 +23,7 @@ ellipsis_repr(PyObject *op)
 }
 
 static PyTypeObject PyEllipsis_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,				/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"ellipsis",			/* tp_name */
 	0,				/* tp_basicsize */
 	0,				/* tp_itemsize */
@@ -47,7 +46,8 @@ static PyTypeObject PyEllipsis_Type = {
 };
 
 PyObject _Py_EllipsisObject = {
-	PyObject_HEAD_INIT(&PyEllipsis_Type)
+	_PyObject_EXTRA_INIT
+	1, &PyEllipsis_Type
 };
 
 
@@ -266,7 +266,7 @@ handling of normal slices.");
 static PyObject *
 slice_reduce(PySliceObject* self)
 {
-	return Py_BuildValue("O(OOO)", self->ob_type, self->start, self->stop, self->step);
+	return Py_BuildValue("O(OOO)", Py_Type(self), self->start, self->stop, self->step);
 }
 
 PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
@@ -338,8 +338,7 @@ slice_hash(PySliceObject *v)
 }
 
 PyTypeObject PySlice_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,			/* Number of items for varobject */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"slice",		/* Name of this type */
 	sizeof(PySliceObject),	/* Basic object size */
 	0,			/* Item size for varobject */
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index 4e343b2..6156b2f 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -414,7 +414,7 @@ PyObject *PyString_AsDecodedString(PyObject *str,
     if (!PyString_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return a string object (type=%.400s)",
-                     v->ob_type->tp_name);
+                     Py_Type(v)->tp_name);
         Py_DECREF(v);
         goto onError;
     }
@@ -487,7 +487,7 @@ PyObject *PyString_AsEncodedString(PyObject *str,
     if (!PyString_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "encoder did not return a string object (type=%.400s)",
-                     v->ob_type->tp_name);
+                     Py_Type(v)->tp_name);
         Py_DECREF(v);
         goto onError;
     }
@@ -507,7 +507,7 @@ string_dealloc(PyObject *op)
 
 		case SSTATE_INTERNED_MORTAL:
 			/* revive dead object temporarily for DelItem */
-			op->ob_refcnt = 3;
+			Py_Refcnt(op) = 3;
 			if (PyDict_DelItem(interned, op) != 0)
 				Py_FatalError(
 					"deletion of interned string failed");
@@ -519,7 +519,7 @@ string_dealloc(PyObject *op)
 		default:
 			Py_FatalError("Inconsistent interned string state.");
 	}
-	op->ob_type->tp_free(op);
+	Py_Type(op)->tp_free(op);
 }
 
 /* Unescape a backslash-escaped string. If unicode is non-zero,
@@ -693,7 +693,7 @@ PyString_Size(register PyObject *op)
 	}
 	if (!PyString_Check(op))
 		return string_getsize(op);
-	return ((PyStringObject *)op) -> ob_size;
+	return Py_Size(op);
 }
 
 /*const*/ char *
@@ -729,7 +729,7 @@ PyString_AsStringAndSize(register PyObject *obj,
 		{
 			PyErr_Format(PyExc_TypeError,
 				     "expected string, "
-				     "%.200s found", obj->ob_type->tp_name);
+				     "%.200s found", Py_Type(obj)->tp_name);
 			return -1;
 		}
 	}
@@ -784,7 +784,7 @@ string_print(PyStringObject *op, FILE *fp, int flags)
 	}
 	if (flags & Py_PRINT_RAW) {
 		char *data = op->ob_sval;
-		Py_ssize_t size = op->ob_size;
+		Py_ssize_t size = Py_Size(op);
 		while (size > INT_MAX) {
 			/* Very long strings cannot be written atomically.
 			 * But don't write exactly INT_MAX bytes at a time
@@ -805,12 +805,12 @@ string_print(PyStringObject *op, FILE *fp, int flags)
 
 	/* figure out which quote to use; single is preferred */
 	quote = '\'';
-	if (memchr(op->ob_sval, '\'', op->ob_size) &&
-	    !memchr(op->ob_sval, '"', op->ob_size))
+	if (memchr(op->ob_sval, '\'', Py_Size(op)) &&
+	    !memchr(op->ob_sval, '"', Py_Size(op)))
 		quote = '"';
 
 	fputc(quote, fp);
-	for (i = 0; i < op->ob_size; i++) {
+	for (i = 0; i < Py_Size(op); i++) {
 		c = op->ob_sval[i];
 		if (c == quote || c == '\\')
 			fprintf(fp, "\\%c", c);
@@ -837,7 +837,7 @@ PyString_Repr(PyObject *obj, int smartquotes)
 	Py_ssize_t length = PyString_GET_SIZE(op);
 	size_t newsize = 3 + 4 * op->ob_size;
 	PyObject *v;
-	if (newsize > PY_SSIZE_T_MAX || newsize / 4 != op->ob_size) {
+	if (newsize > PY_SSIZE_T_MAX || newsize / 4 != Py_Size(op)) {
 		PyErr_SetString(PyExc_OverflowError,
 			"string is too large to make repr");
 	}
@@ -869,7 +869,7 @@ PyString_Repr(PyObject *obj, int smartquotes)
 		}
 
 		*p++ = 's', *p++ = quote;
-		for (i = 0; i < op->ob_size; i++) {
+		for (i = 0; i < Py_Size(op); i++) {
 			/* There's at least enough room for a hex escape
 			   and a closing quote. */
 			assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);
@@ -919,14 +919,14 @@ string_str(PyObject *s)
 	else {
 		/* Subtype -- return genuine string with the same value. */
 		PyStringObject *t = (PyStringObject *) s;
-		return PyString_FromStringAndSize(t->ob_sval, t->ob_size);
+		return PyString_FromStringAndSize(t->ob_sval, Py_Size(t));
 	}
 }
 
 static Py_ssize_t
 string_length(PyStringObject *a)
 {
-	return a->ob_size;
+	return Py_Size(a);
 }
 
 static PyObject *
@@ -941,21 +941,21 @@ string_concat(register PyStringObject *a, register PyObject *bb)
 			return PyBytes_Concat((PyObject *)a, bb);
 		PyErr_Format(PyExc_TypeError,
 			     "cannot concatenate 'str8' and '%.200s' objects",
-			     bb->ob_type->tp_name);
+			     Py_Type(bb)->tp_name);
 		return NULL;
 	}
 #define b ((PyStringObject *)bb)
 	/* Optimize cases with empty left or right operand */
-	if ((a->ob_size == 0 || b->ob_size == 0) &&
+	if ((Py_Size(a) == 0 || Py_Size(b) == 0) &&
 	    PyString_CheckExact(a) && PyString_CheckExact(b)) {
-		if (a->ob_size == 0) {
+		if (Py_Size(a) == 0) {
 			Py_INCREF(bb);
 			return bb;
 		}
 		Py_INCREF(a);
 		return (PyObject *)a;
 	}
-	size = a->ob_size + b->ob_size;
+	size = Py_Size(a) + Py_Size(b);
 	if (size < 0) {
 		PyErr_SetString(PyExc_OverflowError,
 				"strings are too large to concat");
@@ -969,8 +969,8 @@ string_concat(register PyStringObject *a, register PyObject *bb)
 	PyObject_INIT_VAR(op, &PyString_Type, size);
 	op->ob_shash = -1;
 	op->ob_sstate = SSTATE_NOT_INTERNED;
-	Py_MEMCPY(op->ob_sval, a->ob_sval, a->ob_size);
-	Py_MEMCPY(op->ob_sval + a->ob_size, b->ob_sval, b->ob_size);
+	Py_MEMCPY(op->ob_sval, a->ob_sval, Py_Size(a));
+	Py_MEMCPY(op->ob_sval + Py_Size(a), b->ob_sval, Py_Size(b));
 	op->ob_sval[size] = '\0';
 	return (PyObject *) op;
 #undef b
@@ -989,13 +989,13 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n)
 	/* watch out for overflows:  the size can overflow int,
 	 * and the # of bytes needed can overflow size_t
 	 */
-	size = a->ob_size * n;
-	if (n && size / n != a->ob_size) {
+	size = Py_Size(a) * n;
+	if (n && size / n != Py_Size(a)) {
 		PyErr_SetString(PyExc_OverflowError,
 			"repeated string is too long");
 		return NULL;
 	}
-	if (size == a->ob_size && PyString_CheckExact(a)) {
+	if (size == Py_Size(a) && PyString_CheckExact(a)) {
 		Py_INCREF(a);
 		return (PyObject *)a;
 	}
@@ -1013,14 +1013,14 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n)
 	op->ob_shash = -1;
 	op->ob_sstate = SSTATE_NOT_INTERNED;
 	op->ob_sval[size] = '\0';
-	if (a->ob_size == 1 && n > 0) {
+	if (Py_Size(a) == 1 && n > 0) {
 		memset(op->ob_sval, a->ob_sval[0] , n);
 		return (PyObject *) op;
 	}
 	i = 0;
 	if (i < size) {
-		Py_MEMCPY(op->ob_sval, a->ob_sval, a->ob_size);
-		i = a->ob_size;
+		Py_MEMCPY(op->ob_sval, a->ob_sval, Py_Size(a));
+		i = Py_Size(a);
 	}
 	while (i < size) {
 		j = (i <= size-i)  ?  i  :  size-i;
@@ -1041,9 +1041,9 @@ string_slice(register PyStringObject *a, register Py_ssize_t i,
 		i = 0;
 	if (j < 0)
 		j = 0; /* Avoid signed/unsigned bug in next line */
-	if (j > a->ob_size)
-		j = a->ob_size;
-	if (i == 0 && j == a->ob_size && PyString_CheckExact(a)) {
+	if (j > Py_Size(a))
+		j = Py_Size(a);
+	if (i == 0 && j == Py_Size(a) && PyString_CheckExact(a)) {
 		/* It's the same as a */
 		Py_INCREF(a);
 		return (PyObject *)a;
@@ -1062,7 +1062,7 @@ string_contains(PyObject *str_obj, PyObject *sub_obj)
 		if (!PyString_Check(sub_obj)) {
 			PyErr_Format(PyExc_TypeError,
 			    "'in <string>' requires string as left operand, "
-			    "not %.200s", sub_obj->ob_type->tp_name);
+			    "not %.200s", Py_Type(sub_obj)->tp_name);
 			return -1;
 		}
 	}
@@ -1075,7 +1075,7 @@ string_item(PyStringObject *a, register Py_ssize_t i)
 {
 	char pchar;
 	PyObject *v;
-	if (i < 0 || i >= a->ob_size) {
+	if (i < 0 || i >= Py_Size(a)) {
 		PyErr_SetString(PyExc_IndexError, "string index out of range");
 		return NULL;
 	}
@@ -1118,16 +1118,16 @@ string_richcompare(PyStringObject *a, PyStringObject *b, int op)
 	if (op == Py_EQ) {
 		/* Supporting Py_NE here as well does not save
 		   much time, since Py_NE is rarely used.  */
-		if (a->ob_size == b->ob_size
+		if (Py_Size(a) == Py_Size(b)
 		    && (a->ob_sval[0] == b->ob_sval[0]
-			&& memcmp(a->ob_sval, b->ob_sval, a->ob_size) == 0)) {
+			&& memcmp(a->ob_sval, b->ob_sval, Py_Size(a)) == 0)) {
 			result = Py_True;
 		} else {
 			result = Py_False;
 		}
 		goto out;
 	}
-	len_a = a->ob_size; len_b = b->ob_size;
+	len_a = Py_Size(a); len_b = Py_Size(b);
 	min_len = (len_a < len_b) ? len_a : len_b;
 	if (min_len > 0) {
 		c = Py_CHARMASK(*a->ob_sval) - Py_CHARMASK(*b->ob_sval);
@@ -1159,9 +1159,9 @@ _PyString_Eq(PyObject *o1, PyObject *o2)
 {
 	PyStringObject *a = (PyStringObject*) o1;
 	PyStringObject *b = (PyStringObject*) o2;
-        return a->ob_size == b->ob_size
+        return Py_Size(a) == Py_Size(b)
           && *a->ob_sval == *b->ob_sval
-          && memcmp(a->ob_sval, b->ob_sval, a->ob_size) == 0;
+          && memcmp(a->ob_sval, b->ob_sval, Py_Size(a)) == 0;
 }
 
 static long
@@ -1173,12 +1173,12 @@ string_hash(PyStringObject *a)
 
 	if (a->ob_shash != -1)
 		return a->ob_shash;
-	len = a->ob_size;
+	len = Py_Size(a);
 	p = (unsigned char *) a->ob_sval;
 	x = *p << 7;
 	while (--len >= 0)
 		x = (1000003*x) ^ *p++;
-	x ^= a->ob_size;
+	x ^= Py_Size(a);
 	if (x == -1)
 		x = -2;
 	a->ob_shash = x;
@@ -1231,7 +1231,7 @@ string_subscript(PyStringObject* self, PyObject* item)
 	else {
 		PyErr_Format(PyExc_TypeError,
 			     "string indices must be integers, not %.200s",
-			     item->ob_type->tp_name);
+			     Py_Type(item)->tp_name);
 		return NULL;
 	}
 }
@@ -1245,7 +1245,7 @@ string_buffer_getreadbuf(PyStringObject *self, Py_ssize_t index, const void **pt
 		return -1;
 	}
 	*ptr = (void *)self->ob_sval;
-	return self->ob_size;
+	return Py_Size(self);
 }
 
 static Py_ssize_t
@@ -1260,7 +1260,7 @@ static Py_ssize_t
 string_buffer_getsegcount(PyStringObject *self, Py_ssize_t *lenp)
 {
 	if ( lenp )
-		*lenp = self->ob_size;
+		*lenp = Py_Size(self);
 	return 1;
 }
 
@@ -1273,7 +1273,7 @@ string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **pt
 		return -1;
 	}
 	*ptr = self->ob_sval;
-	return self->ob_size;
+	return Py_Size(self);
 }
 
 static PySequenceMethods string_as_sequence = {
@@ -1362,7 +1362,7 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
 	count++; }
 
 /* Always force the list to the expected size. */
-#define FIX_PREALLOC_SIZE(list) ((PyListObject *)list)->ob_size = count
+#define FIX_PREALLOC_SIZE(list) Py_Size(list) = count
 
 #define SKIP_SPACE(s, i, len)    { while (i<len &&  isspace(Py_CHARMASK(s[i]))) i++; }
 #define SKIP_NONSPACE(s, i, len) { while (i<len && !isspace(Py_CHARMASK(s[i]))) i++; }
@@ -1767,7 +1767,7 @@ string_join(PyStringObject *self, PyObject *orig)
 			PyErr_Format(PyExc_TypeError,
 				     "sequence item %zd: expected string,"
 				     " %.80s found",
-				     i, item->ob_type->tp_name);
+				     i, Py_Type(item)->tp_name);
 			Py_DECREF(seq);
 			return NULL;
 		}
@@ -3207,7 +3207,7 @@ string_encode(PyStringObject *self, PyObject *args)
         PyErr_Format(PyExc_TypeError,
                      "[str8] encoder did not return a bytes object "
                      "(type=%.400s)",
-                     v->ob_type->tp_name);
+                     Py_Type(v)->tp_name);
         Py_DECREF(v);
         return NULL;
     }
@@ -3244,7 +3244,7 @@ string_decode(PyStringObject *self, PyObject *args)
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return a string/unicode object "
                      "(type=%.400s)",
-                     v->ob_type->tp_name);
+                     Py_Type(v)->tp_name);
         Py_DECREF(v);
         return NULL;
     }
@@ -3802,7 +3802,7 @@ string_splitlines(PyStringObject *self, PyObject *args)
 static PyObject *
 string_getnewargs(PyStringObject *v)
 {
-	return Py_BuildValue("(s#)", v->ob_sval, v->ob_size);
+	return Py_BuildValue("(s#)", v->ob_sval, Py_Size(v));
 }
 
 
@@ -3928,8 +3928,7 @@ static PyNumberMethods string_as_number = {
 
 
 PyTypeObject PyBaseString_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"basestring",
 	0,
 	0,
@@ -3979,8 +3978,7 @@ If the argument is a string, the return value is the same object.");
 static PyObject *str_iter(PyObject *seq);
 
 PyTypeObject PyString_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"str8",
 	sizeof(PyStringObject),
 	sizeof(char),
@@ -4066,7 +4064,7 @@ _PyString_Resize(PyObject **pv, Py_ssize_t newsize)
 	register PyObject *v;
 	register PyStringObject *sv;
 	v = *pv;
-	if (!PyString_Check(v) || v->ob_refcnt != 1 || newsize < 0 ||
+	if (!PyString_Check(v) || Py_Refcnt(v) != 1 || newsize < 0 ||
 	    PyString_CHECK_INTERNED(v)) {
 		*pv = 0;
 		Py_DECREF(v);
@@ -4085,7 +4083,7 @@ _PyString_Resize(PyObject **pv, Py_ssize_t newsize)
 	}
 	_Py_NewReference(*pv);
 	sv = (PyStringObject *) *pv;
-	sv->ob_size = newsize;
+	Py_Size(sv) = newsize;
 	sv->ob_sval[newsize] = '\0';
 	sv->ob_shash = -1;	/* invalidate cached hash value */
 	return 0;
@@ -4133,7 +4131,7 @@ formatfloat(char *buf, size_t buflen, int flags,
 	x = PyFloat_AsDouble(v);
 	if (x == -1.0 && PyErr_Occurred()) {
 		PyErr_Format(PyExc_TypeError, "float argument required, "
-			     "not %.200s", v->ob_type->tp_name);
+			     "not %.200s", Py_Type(v)->tp_name);
 		return -1;
 	}
 	if (prec < 0)
@@ -4215,7 +4213,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 	switch (type) {
 	case 'd':
 	case 'u':
-		result = val->ob_type->tp_str(val);
+		result = Py_Type(val)->tp_str(val);
 		break;
 	case 'o':
 		numnondigits = 2;
@@ -4239,7 +4237,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 	}
 
 	/* To modify the string in-place, there can only be one reference. */
-	if (result->ob_refcnt != 1) {
+	if (Py_Refcnt(result) != 1) {
 		PyErr_BadInternalCall();
 		return NULL;
 	}
@@ -4323,7 +4321,7 @@ formatint(char *buf, size_t buflen, int flags,
 	x = PyInt_AsLong(v);
 	if (x == -1 && PyErr_Occurred()) {
 		PyErr_Format(PyExc_TypeError, "int argument required, not %.200s",
-			     v->ob_type->tp_name);
+			     Py_Type(v)->tp_name);
 		return -1;
 	}
 	if (x < 0 && type == 'u') {
@@ -4439,7 +4437,7 @@ PyString_Format(PyObject *format, PyObject *args)
 		arglen = -1;
 		argidx = -2;
 	}
-	if (args->ob_type->tp_as_mapping && !PyTuple_Check(args) &&
+	if (Py_Type(args)->tp_as_mapping && !PyTuple_Check(args) &&
 	    !PyObject_TypeCheck(args, &PyBaseString_Type))
 		dict = args;
 	while (--fmtcnt >= 0) {
@@ -4901,7 +4899,7 @@ PyString_InternInPlace(PyObject **p)
 	}
 	/* The two references in interned are not counted by refcnt.
 	   The string deallocator will take care of this */
-	s->ob_refcnt -= 2;
+	Py_Refcnt(s) -= 2;
 	PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
 }
 
@@ -4968,12 +4966,12 @@ void _Py_ReleaseInternedStrings(void)
 			/* XXX Shouldn't happen */
 			break;
 		case SSTATE_INTERNED_IMMORTAL:
-			s->ob_refcnt += 1;
-			immortal_size += s->ob_size;
+			Py_Refcnt(s) += 1;
+			immortal_size += Py_Size(s);
 			break;
 		case SSTATE_INTERNED_MORTAL:
-			s->ob_refcnt += 2;
-			mortal_size += s->ob_size;
+			Py_Refcnt(s) += 2;
+			mortal_size += Py_Size(s);
 			break;
 		default:
 			Py_FatalError("Inconsistent interned string state.");
@@ -5057,8 +5055,7 @@ static PyMethodDef striter_methods[] = {
 };
 
 PyTypeObject PyStringIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"striterator",				/* tp_name */
 	sizeof(striterobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/structseq.c b/Objects/structseq.c
index 7ac2a1f..5e57f1f 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -13,17 +13,17 @@ static char unnamed_fields_key[] = "n_unnamed_fields";
    They are only allowed for indices < n_visible_fields. */
 char *PyStructSequence_UnnamedField = "unnamed field";
 
-#define VISIBLE_SIZE(op) ((op)->ob_size)
+#define VISIBLE_SIZE(op) Py_Size(op)
 #define VISIBLE_SIZE_TP(tp) PyInt_AsLong( \
                       PyDict_GetItemString((tp)->tp_dict, visible_length_key))
 
 #define REAL_SIZE_TP(tp) PyInt_AsLong( \
                       PyDict_GetItemString((tp)->tp_dict, real_length_key))
-#define REAL_SIZE(op) REAL_SIZE_TP((op)->ob_type)
+#define REAL_SIZE(op) REAL_SIZE_TP(Py_Type(op))
 
 #define UNNAMED_FIELDS_TP(tp) PyInt_AsLong( \
                       PyDict_GetItemString((tp)->tp_dict, unnamed_fields_key))
-#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP((op)->ob_type)
+#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_Type(op))
 
 
 PyObject *
@@ -32,7 +32,7 @@ PyStructSequence_New(PyTypeObject *type)
 	PyStructSequence *obj;
        
 	obj = PyObject_New(PyStructSequence, type);
-	obj->ob_size = VISIBLE_SIZE_TP(type);
+	Py_Size(obj) = VISIBLE_SIZE_TP(type);
 
 	return (PyObject*) obj;
 }
@@ -274,12 +274,12 @@ structseq_reduce(PyStructSequence* self)
 	}
 	
 	for (; i < n_fields; i++) {
-		char *n = self->ob_type->tp_members[i-n_unnamed_fields].name;
+		char *n = Py_Type(self)->tp_members[i-n_unnamed_fields].name;
 		PyDict_SetItemString(dict, n,
 				     self->ob_item[i]);
 	}
 
-	result = Py_BuildValue("(O(OO))", self->ob_type, tup, dict);
+	result = Py_BuildValue("(O(OO))", Py_Type(self), tup, dict);
 
 	Py_DECREF(tup);
 	Py_DECREF(dict);
@@ -305,8 +305,7 @@ static PyMethodDef structseq_methods[] = {
 };
 
 static PyTypeObject _struct_sequence_template = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	NULL,	                     		/* tp_name */
         0,		                        /* tp_basicsize */
 	0,	                      		/* tp_itemsize */
@@ -356,7 +355,7 @@ PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc)
 #ifdef Py_TRACE_REFS
 	/* if the type object was chained, unchain it first
 	   before overwriting its storage */
-	if (type->_ob_next) {
+	if (type->ob_base.ob_base._ob_next) {
 		_Py_ForgetReference((PyObject*)type);
 	}
 #endif
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index fb5c246..6e30c81 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -49,8 +49,8 @@ PyTuple_New(register Py_ssize_t size)
 #endif
 		/* Inline PyObject_InitVar */
 #ifdef Py_TRACE_REFS
-		op->ob_size = size;
-		op->ob_type = &PyTuple_Type;
+		Py_Size(op) = size;
+		Py_Type(op) = &PyTuple_Type;
 #endif
 		_Py_NewReference((PyObject *)op);
 	}
@@ -90,7 +90,7 @@ PyTuple_Size(register PyObject *op)
 		return -1;
 	}
 	else
-		return ((PyTupleObject *)op)->ob_size;
+		return Py_Size(op);
 }
 
 PyObject *
@@ -100,7 +100,7 @@ PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
 		PyErr_BadInternalCall();
 		return NULL;
 	}
-	if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
+	if (i < 0 || i >= Py_Size(op)) {
 		PyErr_SetString(PyExc_IndexError, "tuple index out of range");
 		return NULL;
 	}
@@ -117,7 +117,7 @@ PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem)
 		PyErr_BadInternalCall();
 		return -1;
 	}
-	if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
+	if (i < 0 || i >= Py_Size(op)) {
 		Py_XDECREF(newitem);
 		PyErr_SetString(PyExc_IndexError,
 				"tuple assignment index out of range");
@@ -160,7 +160,7 @@ static void
 tupledealloc(register PyTupleObject *op)
 {
 	register Py_ssize_t i;
-	register Py_ssize_t len =  op->ob_size;
+	register Py_ssize_t len =  Py_Size(op);
 	PyObject_GC_UnTrack(op);
 	Py_TRASHCAN_SAFE_BEGIN(op)
 	if (len > 0) {
@@ -170,7 +170,7 @@ tupledealloc(register PyTupleObject *op)
 #if MAXSAVESIZE > 0
 		if (len < MAXSAVESIZE &&
 		    num_free_tuples[len] < MAXSAVEDTUPLES &&
-		    op->ob_type == &PyTuple_Type)
+		    Py_Type(op) == &PyTuple_Type)
 		{
 			op->ob_item[0] = (PyObject *) free_tuples[len];
 			num_free_tuples[len]++;
@@ -179,7 +179,7 @@ tupledealloc(register PyTupleObject *op)
 		}
 #endif
 	}
-	op->ob_type->tp_free((PyObject *)op);
+	Py_Type(op)->tp_free((PyObject *)op);
 done:
 	Py_TRASHCAN_SAFE_END(op)
 }
@@ -189,13 +189,13 @@ tupleprint(PyTupleObject *op, FILE *fp, int flags)
 {
 	Py_ssize_t i;
 	fprintf(fp, "(");
-	for (i = 0; i < op->ob_size; i++) {
+	for (i = 0; i < Py_Size(op); i++) {
 		if (i > 0)
 			fprintf(fp, ", ");
 		if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
 			return -1;
 	}
-	if (op->ob_size == 1)
+	if (Py_Size(op) == 1)
 		fprintf(fp, ",");
 	fprintf(fp, ")");
 	return 0;
@@ -208,7 +208,7 @@ tuplerepr(PyTupleObject *v)
 	PyObject *s, *temp;
 	PyObject *pieces, *result = NULL;
 
-	n = v->ob_size;
+	n = Py_Size(v);
 	if (n == 0)
 		return PyUnicode_FromString("()");
 
@@ -268,7 +268,7 @@ static long
 tuplehash(PyTupleObject *v)
 {
 	register long x, y;
-	register Py_ssize_t len = v->ob_size;
+	register Py_ssize_t len = Py_Size(v);
 	register PyObject **p;
 	long mult = 1000003L;
 	x = 0x345678L;
@@ -290,7 +290,7 @@ tuplehash(PyTupleObject *v)
 static Py_ssize_t
 tuplelength(PyTupleObject *a)
 {
-	return a->ob_size;
+	return Py_Size(a);
 }
 
 static int
@@ -299,7 +299,7 @@ tuplecontains(PyTupleObject *a, PyObject *el)
 	Py_ssize_t i;
 	int cmp;
 
-	for (i = 0, cmp = 0 ; cmp == 0 && i < a->ob_size; ++i)
+	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(a); ++i)
 		cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
 						   Py_EQ);
 	return cmp;
@@ -308,7 +308,7 @@ tuplecontains(PyTupleObject *a, PyObject *el)
 static PyObject *
 tupleitem(register PyTupleObject *a, register Py_ssize_t i)
 {
-	if (i < 0 || i >= a->ob_size) {
+	if (i < 0 || i >= Py_Size(a)) {
 		PyErr_SetString(PyExc_IndexError, "tuple index out of range");
 		return NULL;
 	}
@@ -326,11 +326,11 @@ tupleslice(register PyTupleObject *a, register Py_ssize_t ilow,
 	Py_ssize_t len;
 	if (ilow < 0)
 		ilow = 0;
-	if (ihigh > a->ob_size)
-		ihigh = a->ob_size;
+	if (ihigh > Py_Size(a))
+		ihigh = Py_Size(a);
 	if (ihigh < ilow)
 		ihigh = ilow;
-	if (ilow == 0 && ihigh == a->ob_size && PyTuple_CheckExact(a)) {
+	if (ilow == 0 && ihigh == Py_Size(a) && PyTuple_CheckExact(a)) {
 		Py_INCREF(a);
 		return (PyObject *)a;
 	}
@@ -368,11 +368,11 @@ tupleconcat(register PyTupleObject *a, register PyObject *bb)
 	if (!PyTuple_Check(bb)) {
 		PyErr_Format(PyExc_TypeError,
        		     "can only concatenate tuple (not \"%.200s\") to tuple",
-			     bb->ob_type->tp_name);
+			     Py_Type(bb)->tp_name);
 		return NULL;
 	}
 #define b ((PyTupleObject *)bb)
-	size = a->ob_size + b->ob_size;
+	size = Py_Size(a) + Py_Size(b);
 	if (size < 0)
 		return PyErr_NoMemory();
 	np = (PyTupleObject *) PyTuple_New(size);
@@ -381,14 +381,14 @@ tupleconcat(register PyTupleObject *a, register PyObject *bb)
 	}
 	src = a->ob_item;
 	dest = np->ob_item;
-	for (i = 0; i < a->ob_size; i++) {
+	for (i = 0; i < Py_Size(a); i++) {
 		PyObject *v = src[i];
 		Py_INCREF(v);
 		dest[i] = v;
 	}
 	src = b->ob_item;
-	dest = np->ob_item + a->ob_size;
-	for (i = 0; i < b->ob_size; i++) {
+	dest = np->ob_item + Py_Size(a);
+	for (i = 0; i < Py_Size(b); i++) {
 		PyObject *v = src[i];
 		Py_INCREF(v);
 		dest[i] = v;
@@ -406,18 +406,18 @@ tuplerepeat(PyTupleObject *a, Py_ssize_t n)
 	PyObject **p, **items;
 	if (n < 0)
 		n = 0;
-	if (a->ob_size == 0 || n == 1) {
+	if (Py_Size(a) == 0 || n == 1) {
 		if (PyTuple_CheckExact(a)) {
 			/* Since tuples are immutable, we can return a shared
 			   copy in this case */
 			Py_INCREF(a);
 			return (PyObject *)a;
 		}
-		if (a->ob_size == 0)
+		if (Py_Size(a) == 0)
 			return PyTuple_New(0);
 	}
-	size = a->ob_size * n;
-	if (size/a->ob_size != n)
+	size = Py_Size(a) * n;
+	if (size/Py_Size(a) != n)
 		return PyErr_NoMemory();
 	np = (PyTupleObject *) PyTuple_New(size);
 	if (np == NULL)
@@ -425,7 +425,7 @@ tuplerepeat(PyTupleObject *a, Py_ssize_t n)
 	p = np->ob_item;
 	items = a->ob_item;
 	for (i = 0; i < n; i++) {
-		for (j = 0; j < a->ob_size; j++) {
+		for (j = 0; j < Py_Size(a); j++) {
 			*p = items[j];
 			Py_INCREF(*p);
 			p++;
@@ -439,7 +439,7 @@ tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
 {
 	Py_ssize_t i;
 
-	for (i = o->ob_size; --i >= 0; )
+	for (i = Py_Size(o); --i >= 0; )
 		Py_VISIT(o->ob_item[i]);
 	return 0;
 }
@@ -459,8 +459,8 @@ tuplerichcompare(PyObject *v, PyObject *w, int op)
 	vt = (PyTupleObject *)v;
 	wt = (PyTupleObject *)w;
 
-	vlen = vt->ob_size;
-	wlen = wt->ob_size;
+	vlen = Py_Size(vt);
+	wlen = Py_Size(wt);
 
 	/* Note:  the corresponding code for lists has an "early out" test
 	 * here when op is EQ or NE and the lengths differ.  That pays there,
@@ -622,7 +622,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
 	else {
 		PyErr_Format(PyExc_TypeError, 
 			     "tuple indices must be integers, not %.200s",
-			     item->ob_type->tp_name);
+			     Py_Type(item)->tp_name);
 		return NULL;
 	}
 }
@@ -630,7 +630,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
 static PyObject *
 tuple_getnewargs(PyTupleObject *v)
 {
-	return Py_BuildValue("(N)", tupleslice(v, 0, v->ob_size));
+	return Py_BuildValue("(N)", tupleslice(v, 0, Py_Size(v)));
 	
 }
 
@@ -648,8 +648,7 @@ static PyMappingMethods tuple_as_mapping = {
 static PyObject *tuple_iter(PyObject *seq);
 
 PyTypeObject PyTuple_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"tuple",
 	sizeof(PyTupleObject) - sizeof(PyObject *),
 	sizeof(PyObject *),
@@ -707,14 +706,14 @@ _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
 	Py_ssize_t oldsize;
 
 	v = (PyTupleObject *) *pv;
-	if (v == NULL || v->ob_type != &PyTuple_Type ||
-	    (v->ob_size != 0 && v->ob_refcnt != 1)) {
+	if (v == NULL || Py_Type(v) != &PyTuple_Type ||
+	    (Py_Size(v) != 0 && Py_Refcnt(v) != 1)) {
 		*pv = 0;
 		Py_XDECREF(v);
 		PyErr_BadInternalCall();
 		return -1;
 	}
-	oldsize = v->ob_size;
+	oldsize = Py_Size(v);
 	if (oldsize == newsize)
 		return 0;
 
@@ -838,8 +837,7 @@ static PyMethodDef tupleiter_methods[] = {
 };
 
 PyTypeObject PyTupleIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"tupleiterator",			/* tp_name */
 	sizeof(tupleiterobject),		/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 891be61..3ad5efc 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -63,7 +63,7 @@ type_set_name(PyTypeObject *type, PyObject *value, void *context)
 	if (!PyString_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "can only assign string to %s.__name__, not '%s'",
-			     type->tp_name, value->ob_type->tp_name);
+			     type->tp_name, Py_Type(value)->tp_name);
 		return -1;
 	}
 	if (strlen(PyString_AS_STRING(value))
@@ -209,7 +209,7 @@ type_set_bases(PyTypeObject *type, PyObject *value, void *context)
 	if (!PyTuple_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 		     "can only assign tuple to %s.__bases__, not %s",
-			     type->tp_name, value->ob_type->tp_name);
+			     type->tp_name, Py_Type(value)->tp_name);
 		return -1;
 	}
 	if (PyTuple_GET_SIZE(value) == 0) {
@@ -224,7 +224,7 @@ type_set_bases(PyTypeObject *type, PyObject *value, void *context)
 			PyErr_Format(
 				PyExc_TypeError,
 	"%s.__bases__ must be tuple of old- or new-style classes, not '%s'",
-				type->tp_name, ob->ob_type->tp_name);
+				type->tp_name, Py_Type(ob)->tp_name);
 			return -1;
 		}
 		if (PyType_Check(ob)) {
@@ -349,8 +349,8 @@ type_get_doc(PyTypeObject *type, void *context)
 		result = Py_None;
 		Py_INCREF(result);
 	}
-	else if (result->ob_type->tp_descr_get) {
-		result = result->ob_type->tp_descr_get(result, NULL,
+	else if (Py_Type(result)->tp_descr_get) {
+		result = Py_Type(result)->tp_descr_get(result, NULL,
 						       (PyObject *)type);
 	}
 	else {
@@ -423,9 +423,9 @@ type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
 			return obj;
 		/* If the returned object is not an instance of type,
 		   it won't be initialized. */
-		if (!PyType_IsSubtype(obj->ob_type, type))
+		if (!PyType_IsSubtype(Py_Type(obj), type))
 			return obj;
-		type = obj->ob_type;
+		type = Py_Type(obj);
 		if (type->tp_init != NULL &&
 		    type->tp_init(obj, args, kwds) < 0) {
 			Py_DECREF(obj);
@@ -479,7 +479,7 @@ traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg)
 	Py_ssize_t i, n;
 	PyMemberDef *mp;
 
-	n = type->ob_size;
+	n = Py_Size(type);
 	mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
 	for (i = 0; i < n; i++, mp++) {
 		if (mp->type == T_OBJECT_EX) {
@@ -503,10 +503,10 @@ subtype_traverse(PyObject *self, visitproc visit, void *arg)
 
 	/* Find the nearest base with a different tp_traverse,
 	   and traverse slots while we're at it */
-	type = self->ob_type;
+	type = Py_Type(self);
 	base = type;
 	while ((basetraverse = base->tp_traverse) == subtype_traverse) {
-		if (base->ob_size) {
+		if (Py_Size(base)) {
 			int err = traverse_slots(base, self, visit, arg);
 			if (err)
 				return err;
@@ -538,7 +538,7 @@ clear_slots(PyTypeObject *type, PyObject *self)
 	Py_ssize_t i, n;
 	PyMemberDef *mp;
 
-	n = type->ob_size;
+	n = Py_Size(type);
 	mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
 	for (i = 0; i < n; i++, mp++) {
 		if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) {
@@ -560,10 +560,10 @@ subtype_clear(PyObject *self)
 
 	/* Find the nearest base with a different tp_clear
 	   and clear slots while we're at it */
-	type = self->ob_type;
+	type = Py_Type(self);
 	base = type;
 	while ((baseclear = base->tp_clear) == subtype_clear) {
-		if (base->ob_size)
+		if (Py_Size(base))
 			clear_slots(base, self);
 		base = base->tp_base;
 		assert(base);
@@ -584,7 +584,7 @@ subtype_dealloc(PyObject *self)
 	destructor basedealloc;
 
 	/* Extract the type; we expect it to be a heap type */
-	type = self->ob_type;
+	type = Py_Type(self);
 	assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
 
 	/* Test whether the type has GC exactly once */
@@ -606,7 +606,7 @@ subtype_dealloc(PyObject *self)
 		/* Find the nearest base with a different tp_dealloc */
 		base = type;
 		while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
-			assert(base->ob_size == 0);
+			assert(Py_Size(base) == 0);
 			base = base->tp_base;
 			assert(base);
 		}
@@ -674,7 +674,7 @@ subtype_dealloc(PyObject *self)
 	/*  Clear slots up to the nearest base with a different tp_dealloc */
 	base = type;
 	while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
-		if (base->ob_size)
+		if (Py_Size(base))
 			clear_slots(base, self);
 		base = base->tp_base;
 		assert(base);
@@ -865,13 +865,13 @@ lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj)
 		if (*attrobj == NULL)
 			return NULL;
 	}
-	res = _PyType_Lookup(self->ob_type, *attrobj);
+	res = _PyType_Lookup(Py_Type(self), *attrobj);
 	if (res != NULL) {
 		descrgetfunc f;
-		if ((f = res->ob_type->tp_descr_get) == NULL)
+		if ((f = Py_Type(res)->tp_descr_get) == NULL)
 			Py_INCREF(res);
 		else
-			res = f(res, self, (PyObject *)(self->ob_type));
+			res = f(res, self, (PyObject *)(Py_Type(self)));
 	}
 	return res;
 }
@@ -1244,7 +1244,7 @@ mro_internal(PyTypeObject *type)
 	PyObject *mro, *result, *tuple;
 	int checkit = 0;
 
-	if (type->ob_type == &PyType_Type) {
+	if (Py_Type(type) == &PyType_Type) {
 		result = mro_implementation(type);
 	}
 	else {
@@ -1277,7 +1277,7 @@ mro_internal(PyTypeObject *type)
 			if (!PyType_Check(cls)) {
 				PyErr_Format(PyExc_TypeError,
 			     "mro() returned a non-class ('%.500s')",
-					     cls->ob_type->tp_name);
+					     Py_Type(cls)->tp_name);
 				Py_DECREF(tuple);
 				return -1;
 			}
@@ -1433,7 +1433,7 @@ raise_dict_descr_error(PyObject *obj)
 {
 	PyErr_Format(PyExc_TypeError,
 		     "this __dict__ descriptor does not support "
-		     "'%.200s' objects", obj->ob_type->tp_name);
+		     "'%.200s' objects", Py_Type(obj)->tp_name);
 }
 
 static PyObject *
@@ -1443,7 +1443,7 @@ subtype_dict(PyObject *obj, void *context)
 	PyObject *dict;
 	PyTypeObject *base;
 
-	base = get_builtin_base_with_dict(obj->ob_type);
+	base = get_builtin_base_with_dict(Py_Type(obj));
 	if (base != NULL) {
 		descrgetfunc func;
 		PyObject *descr = get_dict_descriptor(base);
@@ -1451,12 +1451,12 @@ subtype_dict(PyObject *obj, void *context)
 			raise_dict_descr_error(obj);
 			return NULL;
 		}
-		func = descr->ob_type->tp_descr_get;
+		func = Py_Type(descr)->tp_descr_get;
 		if (func == NULL) {
 			raise_dict_descr_error(obj);
 			return NULL;
 		}
-		return func(descr, obj, (PyObject *)(obj->ob_type));
+		return func(descr, obj, (PyObject *)(Py_Type(obj)));
 	}
 
 	dictptr = _PyObject_GetDictPtr(obj);
@@ -1479,7 +1479,7 @@ subtype_setdict(PyObject *obj, PyObject *value, void *context)
 	PyObject *dict;
 	PyTypeObject *base;
 
-	base = get_builtin_base_with_dict(obj->ob_type);
+	base = get_builtin_base_with_dict(Py_Type(obj));
 	if (base != NULL) {
 		descrsetfunc func;
 		PyObject *descr = get_dict_descriptor(base);
@@ -1487,7 +1487,7 @@ subtype_setdict(PyObject *obj, PyObject *value, void *context)
 			raise_dict_descr_error(obj);
 			return -1;
 		}
-		func = descr->ob_type->tp_descr_set;
+		func = Py_Type(descr)->tp_descr_set;
 		if (func == NULL) {
 			raise_dict_descr_error(obj);
 			return -1;
@@ -1504,7 +1504,7 @@ subtype_setdict(PyObject *obj, PyObject *value, void *context)
 	if (value != NULL && !PyDict_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "__dict__ must be set to a dictionary, "
-			     "not a '%.200s'", value->ob_type->tp_name);
+			     "not a '%.200s'", Py_Type(value)->tp_name);
 		return -1;
 	}
 	dict = *dictptr;
@@ -1520,16 +1520,16 @@ subtype_getweakref(PyObject *obj, void *context)
 	PyObject **weaklistptr;
 	PyObject *result;
 
-	if (obj->ob_type->tp_weaklistoffset == 0) {
+	if (Py_Type(obj)->tp_weaklistoffset == 0) {
 		PyErr_SetString(PyExc_AttributeError,
 				"This object has no __weakref__");
 		return NULL;
 	}
-	assert(obj->ob_type->tp_weaklistoffset > 0);
-	assert(obj->ob_type->tp_weaklistoffset + sizeof(PyObject *) <=
-	       (size_t)(obj->ob_type->tp_basicsize));
+	assert(Py_Type(obj)->tp_weaklistoffset > 0);
+	assert(Py_Type(obj)->tp_weaklistoffset + sizeof(PyObject *) <=
+	       (size_t)(Py_Type(obj)->tp_basicsize));
 	weaklistptr = (PyObject **)
-		((char *)obj + obj->ob_type->tp_weaklistoffset);
+		((char *)obj + Py_Type(obj)->tp_weaklistoffset);
 	if (*weaklistptr == NULL)
 		result = Py_None;
 	else
@@ -1569,7 +1569,7 @@ valid_identifier(PyObject *s)
 	if (!PyUnicode_Check(s)) {
 		PyErr_Format(PyExc_TypeError,
 			     "__slots__ items must be strings, not '%.200s'",
-			     s->ob_type->tp_name);
+			     Py_Type(s)->tp_name);
 		return 0;
 	}
 	p = PyUnicode_AS_UNICODE(s);
@@ -1643,8 +1643,8 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 
 		if (PyType_CheckExact(metatype) && nargs == 1 && nkwds == 0) {
 			PyObject *x = PyTuple_GET_ITEM(args, 0);
-			Py_INCREF(x->ob_type);
-			return (PyObject *) x->ob_type;
+			Py_INCREF(Py_Type(x));
+			return (PyObject *) Py_Type(x);
 		}
 
 		/* SF bug 475327 -- if that didn't trigger, we need 3
@@ -1672,7 +1672,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 	winner = metatype;
 	for (i = 0; i < nbases; i++) {
 		tmp = PyTuple_GET_ITEM(bases, i);
-		tmptype = tmp->ob_type;
+		tmptype = Py_Type(tmp);
 		if (PyType_IsSubtype(winner, tmptype))
 			continue;
 		if (PyType_IsSubtype(tmptype, winner)) {
@@ -2056,7 +2056,7 @@ _PyType_Lookup(PyTypeObject *type, PyObject *name)
 static PyObject *
 type_getattro(PyTypeObject *type, PyObject *name)
 {
-	PyTypeObject *metatype = type->ob_type;
+	PyTypeObject *metatype = Py_Type(type);
 	PyObject *meta_attribute, *attribute;
 	descrgetfunc meta_get;
 
@@ -2073,7 +2073,7 @@ type_getattro(PyTypeObject *type, PyObject *name)
 	meta_attribute = _PyType_Lookup(metatype, name);
 
 	if (meta_attribute != NULL) {
-		meta_get = meta_attribute->ob_type->tp_descr_get;
+		meta_get = Py_Type(meta_attribute)->tp_descr_get;
 
 		if (meta_get != NULL && PyDescr_IsData(meta_attribute)) {
 			/* Data descriptors implement tp_descr_set to intercept
@@ -2091,7 +2091,7 @@ type_getattro(PyTypeObject *type, PyObject *name)
 	attribute = _PyType_Lookup(type, name);
 	if (attribute != NULL) {
 		/* Implement descriptor functionality, if any */
-		descrgetfunc local_get = attribute->ob_type->tp_descr_get;
+		descrgetfunc local_get = Py_Type(attribute)->tp_descr_get;
 
 		Py_XDECREF(meta_attribute);
 
@@ -2169,7 +2169,7 @@ type_dealloc(PyTypeObject *type)
 	PyObject_Free((char *)type->tp_doc);
 	Py_XDECREF(et->ht_name);
 	Py_XDECREF(et->ht_slots);
-	type->ob_type->tp_free((PyObject *)type);
+	Py_Type(type)->tp_free((PyObject *)type);
 }
 
 static PyObject *
@@ -2277,8 +2277,7 @@ type_is_gc(PyTypeObject *type)
 }
 
 PyTypeObject PyType_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"type",					/* tp_name */
 	sizeof(PyHeapTypeObject),		/* tp_basicsize */
 	sizeof(PyMemberDef),			/* tp_itemsize */
@@ -2380,7 +2379,7 @@ object_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
 	int err = 0;
 	if (excess_args(args, kwds)) {
-		PyTypeObject *type = self->ob_type;
+		PyTypeObject *type = Py_Type(self);
 		if (type->tp_init != object_init &&
 		    type->tp_new != object_new)
 		{
@@ -2427,7 +2426,7 @@ object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 static void
 object_dealloc(PyObject *self)
 {
-	self->ob_type->tp_free(self);
+	Py_Type(self)->tp_free(self);
 }
 
 static PyObject *
@@ -2436,7 +2435,7 @@ object_repr(PyObject *self)
 	PyTypeObject *type;
 	PyObject *mod, *name, *rtn;
 
-	type = self->ob_type;
+	type = Py_Type(self);
 	mod = type_module(type, NULL);
 	if (mod == NULL)
 		PyErr_Clear();
@@ -2462,7 +2461,7 @@ object_str(PyObject *self)
 {
 	unaryfunc f;
 
-	f = self->ob_type->tp_repr;
+	f = Py_Type(self)->tp_repr;
 	if (f == NULL)
 		f = object_repr;
 	return f(self);
@@ -2511,8 +2510,8 @@ object_richcompare(PyObject *self, PyObject *other, int op)
 static PyObject *
 object_get_class(PyObject *self, void *closure)
 {
-	Py_INCREF(self->ob_type);
-	return (PyObject *)(self->ob_type);
+	Py_INCREF(Py_Type(self));
+	return (PyObject *)(Py_Type(self));
 }
 
 static int
@@ -2597,7 +2596,7 @@ compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, char* attr)
 static int
 object_set_class(PyObject *self, PyObject *value, void *closure)
 {
-	PyTypeObject *oldto = self->ob_type;
+	PyTypeObject *oldto = Py_Type(self);
 	PyTypeObject *newto;
 
 	if (value == NULL) {
@@ -2608,7 +2607,7 @@ object_set_class(PyObject *self, PyObject *value, void *closure)
 	if (!PyType_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 		  "__class__ must be set to new-style class, not '%s' object",
-		  value->ob_type->tp_name);
+		  Py_Type(value)->tp_name);
 		return -1;
 	}
 	newto = (PyTypeObject *)value;
@@ -2621,7 +2620,7 @@ object_set_class(PyObject *self, PyObject *value, void *closure)
 	}
 	if (compatible_for_assignment(newto, oldto, "__class__")) {
 		Py_INCREF(newto);
-		self->ob_type = newto;
+		Py_Type(self) = newto;
 		Py_DECREF(oldto);
 		return 0;
 	}
@@ -2717,7 +2716,7 @@ reduce_2(PyObject *obj)
 		if (args != NULL && !PyTuple_Check(args)) {
 			PyErr_Format(PyExc_TypeError,
 				"__getnewargs__ should return a tuple, "
-				"not '%.200s'", args->ob_type->tp_name);
+				"not '%.200s'", Py_Type(args)->tp_name);
 			goto end;
 		}
 	}
@@ -2933,8 +2932,7 @@ static PyMethodDef object_methods[] = {
 
 
 PyTypeObject PyBaseObject_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"object",				/* tp_name */
 	sizeof(PyObject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
@@ -3360,8 +3358,8 @@ PyType_Ready(PyTypeObject *type)
 	   NULL when type is &PyBaseObject_Type, and we know its ob_type is
 	   not NULL (it's initialized to &PyType_Type).	 But coverity doesn't
 	   know that. */
-	if (type->ob_type == NULL && base != NULL)
-		type->ob_type = base->ob_type;
+	if (Py_Type(type) == NULL && base != NULL)
+		Py_Type(type) = Py_Type(base);
 
 	/* Initialize tp_bases */
 	bases = type->tp_bases;
@@ -3630,7 +3628,7 @@ wrap_binaryfunc_r(PyObject *self, PyObject *args, void *wrapped)
 	if (!check_num_args(args, 1))
 		return NULL;
 	other = PyTuple_GET_ITEM(args, 0);
-	if (!PyType_IsSubtype(other->ob_type, self->ob_type)) {
+	if (!PyType_IsSubtype(Py_Type(other), Py_Type(self))) {
 		Py_INCREF(Py_NotImplemented);
 		return Py_NotImplemented;
 	}
@@ -3699,7 +3697,7 @@ getindex(PyObject *self, PyObject *arg)
 	if (i == -1 && PyErr_Occurred())
 		return -1;
 	if (i < 0) {
-		PySequenceMethods *sq = self->ob_type->tp_as_sequence;
+		PySequenceMethods *sq = Py_Type(self)->tp_as_sequence;
 		if (sq && sq->sq_length) {
 			Py_ssize_t n = (*sq->sq_length)(self);
 			if (n < 0)
@@ -3875,14 +3873,14 @@ wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
 	if (!check_num_args(args, 1))
 		return NULL;
 	other = PyTuple_GET_ITEM(args, 0);
-	if (other->ob_type->tp_compare != func &&
-	    !PyType_IsSubtype(other->ob_type, self->ob_type)) {
+	if (Py_Type(other)->tp_compare != func &&
+	    !PyType_IsSubtype(Py_Type(other), Py_Type(self))) {
 		PyErr_Format(
 			PyExc_TypeError,
 			"%s.__cmp__(x,y) requires y to be a '%s', not a '%s'",
-			self->ob_type->tp_name,
-			self->ob_type->tp_name,
-			other->ob_type->tp_name);
+			Py_Type(self)->tp_name,
+			Py_Type(self)->tp_name,
+			Py_Type(other)->tp_name);
 		return NULL;
 	}
 	res = (*func)(self, other);
@@ -3896,7 +3894,7 @@ wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
 static int
 hackcheck(PyObject *self, setattrofunc func, char *what)
 {
-	PyTypeObject *type = self->ob_type;
+	PyTypeObject *type = Py_Type(self);
 	while (type && type->tp_flags & Py_TPFLAGS_HEAPTYPE)
 		type = type->tp_base;
 	/* If type is NULL now, this is a really weird type.
@@ -4096,7 +4094,7 @@ tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds)
 		PyErr_Format(PyExc_TypeError,
 			     "%s.__new__(X): X is not a type object (%s)",
 			     type->tp_name,
-			     arg0->ob_type->tp_name);
+			     Py_Type(arg0)->tp_name);
 		return NULL;
 	}
 	subtype = (PyTypeObject *)arg0;
@@ -4187,14 +4185,14 @@ method_is_overloaded(PyObject *left, PyObject *right, char *name)
 	PyObject *a, *b;
 	int ok;
 
-	b = PyObject_GetAttrString((PyObject *)(right->ob_type), name);
+	b = PyObject_GetAttrString((PyObject *)(Py_Type(right)), name);
 	if (b == NULL) {
 		PyErr_Clear();
 		/* If right doesn't have it, it's not overloaded */
 		return 0;
 	}
 
-	a = PyObject_GetAttrString((PyObject *)(left->ob_type), name);
+	a = PyObject_GetAttrString((PyObject *)(Py_Type(left)), name);
 	if (a == NULL) {
 		PyErr_Clear();
 		Py_DECREF(b);
@@ -4219,14 +4217,14 @@ static PyObject * \
 FUNCNAME(PyObject *self, PyObject *other) \
 { \
 	static PyObject *cache_str, *rcache_str; \
-	int do_other = self->ob_type != other->ob_type && \
-	    other->ob_type->tp_as_number != NULL && \
-	    other->ob_type->tp_as_number->SLOTNAME == TESTFUNC; \
-	if (self->ob_type->tp_as_number != NULL && \
-	    self->ob_type->tp_as_number->SLOTNAME == TESTFUNC) { \
+	int do_other = Py_Type(self) != Py_Type(other) && \
+	    Py_Type(other)->tp_as_number != NULL && \
+	    Py_Type(other)->tp_as_number->SLOTNAME == TESTFUNC; \
+	if (Py_Type(self)->tp_as_number != NULL && \
+	    Py_Type(self)->tp_as_number->SLOTNAME == TESTFUNC) { \
 		PyObject *r; \
 		if (do_other && \
-		    PyType_IsSubtype(other->ob_type, self->ob_type) && \
+		    PyType_IsSubtype(Py_Type(other), Py_Type(self)) && \
 		    method_is_overloaded(self, other, ROPSTR)) { \
 			r = call_maybe( \
 				other, ROPSTR, &rcache_str, "(O)", self); \
@@ -4238,7 +4236,7 @@ FUNCNAME(PyObject *self, PyObject *other) \
 		r = call_maybe( \
 			self, OPSTR, &cache_str, "(O)", other); \
 		if (r != Py_NotImplemented || \
-		    other->ob_type == self->ob_type) \
+		    Py_Type(other) == Py_Type(self)) \
 			return r; \
 		Py_DECREF(r); \
 	} \
@@ -4296,12 +4294,12 @@ slot_sq_item(PyObject *self, Py_ssize_t i)
 		if (getitem_str == NULL)
 			return NULL;
 	}
-	func = _PyType_Lookup(self->ob_type, getitem_str);
+	func = _PyType_Lookup(Py_Type(self), getitem_str);
 	if (func != NULL) {
-		if ((f = func->ob_type->tp_descr_get) == NULL)
+		if ((f = Py_Type(func)->tp_descr_get) == NULL)
 			Py_INCREF(func);
 		else {
-			func = f(func, self, (PyObject *)(self->ob_type));
+			func = f(func, self, (PyObject *)(Py_Type(self)));
 			if (func == NULL) {
 				return NULL;
 			}
@@ -4439,8 +4437,8 @@ slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus)
 	/* Three-arg power doesn't use __rpow__.  But ternary_op
 	   can call this when the second argument's type uses
 	   slot_nb_power, so check before calling self.__pow__. */
-	if (self->ob_type->tp_as_number != NULL &&
-	    self->ob_type->tp_as_number->nb_power == slot_nb_power) {
+	if (Py_Type(self)->tp_as_number != NULL &&
+	    Py_Type(self)->tp_as_number->nb_power == slot_nb_power) {
 		return call_method(self, "__pow__", &pow_str,
 				   "(OO)", other, modulus);
 	}
@@ -4485,7 +4483,7 @@ slot_nb_bool(PyObject *self)
 				PyErr_Format(PyExc_TypeError,
 					 "__bool__ should return "
 					 "bool, returned %s",
-					 temp->ob_type->tp_name);
+					 Py_Type(temp)->tp_name);
 				result = -1;
 			}
 			Py_DECREF(temp);
@@ -4576,12 +4574,12 @@ _PyObject_SlotCompare(PyObject *self, PyObject *other)
 {
 	int c;
 
-	if (self->ob_type->tp_compare == _PyObject_SlotCompare) {
+	if (Py_Type(self)->tp_compare == _PyObject_SlotCompare) {
 		c = half_compare(self, other);
 		if (c <= 1)
 			return c;
 	}
-	if (other->ob_type->tp_compare == _PyObject_SlotCompare) {
+	if (Py_Type(other)->tp_compare == _PyObject_SlotCompare) {
 		c = half_compare(other, self);
 		if (c < -1)
 			return -2;
@@ -4606,7 +4604,7 @@ slot_tp_repr(PyObject *self)
 	}
 	PyErr_Clear();
 	return PyUnicode_FromFormat("<%s object at %p>",
-				   self->ob_type->tp_name, self);
+				   Py_Type(self)->tp_name, self);
 }
 
 static PyObject *
@@ -4649,7 +4647,7 @@ slot_tp_hash(PyObject *self)
 
 	if (func == NULL) {
 		PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
-			     self->ob_type->tp_name);
+			     Py_Type(self)->tp_name);
 		return -1;
         }
 
@@ -4714,7 +4712,7 @@ slot_tp_getattro(PyObject *self, PyObject *name)
 static PyObject *
 slot_tp_getattr_hook(PyObject *self, PyObject *name)
 {
-	PyTypeObject *tp = self->ob_type;
+	PyTypeObject *tp = Py_Type(self);
 	PyObject *getattr, *getattribute, *res;
 	static PyObject *getattribute_str = NULL;
 	static PyObject *getattr_str = NULL;
@@ -4738,7 +4736,7 @@ slot_tp_getattr_hook(PyObject *self, PyObject *name)
 	}
 	getattribute = _PyType_Lookup(tp, getattribute_str);
 	if (getattribute == NULL ||
-	    (getattribute->ob_type == &PyWrapperDescr_Type &&
+	    (Py_Type(getattribute) == &PyWrapperDescr_Type &&
 	     ((PyWrapperDescrObject *)getattribute)->d_wrapped ==
 	     (void *)PyObject_GenericGetAttr))
 		res = PyObject_GenericGetAttr(self, name);
@@ -4797,13 +4795,13 @@ slot_tp_richcompare(PyObject *self, PyObject *other, int op)
 {
 	PyObject *res;
 
-	if (self->ob_type->tp_richcompare == slot_tp_richcompare) {
+	if (Py_Type(self)->tp_richcompare == slot_tp_richcompare) {
 		res = half_richcompare(self, other, op);
 		if (res != Py_NotImplemented)
 			return res;
 		Py_DECREF(res);
 	}
-	if (other->ob_type->tp_richcompare == slot_tp_richcompare) {
+	if (Py_Type(other)->tp_richcompare == slot_tp_richcompare) {
 		res = half_richcompare(other, self, _Py_SwappedOp[op]);
 		if (res != Py_NotImplemented) {
 			return res;
@@ -4836,7 +4834,7 @@ slot_tp_iter(PyObject *self)
 	if (func == NULL) {
 		PyErr_Format(PyExc_TypeError,
 			     "'%.200s' object is not iterable",
-			     self->ob_type->tp_name);
+			     Py_Type(self)->tp_name);
 		return NULL;
 	}
 	Py_DECREF(func);
@@ -4853,7 +4851,7 @@ slot_tp_iternext(PyObject *self)
 static PyObject *
 slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 {
-	PyTypeObject *tp = self->ob_type;
+	PyTypeObject *tp = Py_Type(self);
 	PyObject *get;
 	static PyObject *get_str = NULL;
 
@@ -4911,7 +4909,7 @@ slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
 	if (res != Py_None) {
 		PyErr_Format(PyExc_TypeError,
 			     "__init__() should return None, not '%.200s'",
-			     res->ob_type->tp_name);
+			     Py_Type(res)->tp_name);
 		Py_DECREF(res);
 		return -1;
 	}
@@ -4996,7 +4994,7 @@ slot_tp_del(PyObject *self)
 		_Py_NewReference(self);
 		self->ob_refcnt = refcnt;
 	}
-	assert(!PyType_IS_GC(self->ob_type) ||
+	assert(!PyType_IS_GC(Py_Type(self)) ||
 	       _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
 	/* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
 	 * we need to undo that. */
@@ -5008,8 +5006,8 @@ slot_tp_del(PyObject *self)
 	 * undone.
 	 */
 #ifdef COUNT_ALLOCS
-	--self->ob_type->tp_frees;
-	--self->ob_type->tp_allocs;
+	--Py_Type(self)->tp_frees;
+	--Py_Type(self)->tp_allocs;
 #endif
 }
 
@@ -5359,7 +5357,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
 		descr = _PyType_Lookup(type, p->name_strobj);
 		if (descr == NULL)
 			continue;
-		if (descr->ob_type == &PyWrapperDescr_Type) {
+		if (Py_Type(descr) == &PyWrapperDescr_Type) {
 			void **tptr = resolve_slotdups(type, p->name_strobj);
 			if (tptr == NULL || tptr == ptr)
 				generic = p->function;
@@ -5374,7 +5372,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
 					use_generic = 1;
 			}
 		}
-		else if (descr->ob_type == &PyCFunction_Type &&
+		else if (Py_Type(descr) == &PyCFunction_Type &&
 			 PyCFunction_GET_FUNCTION(descr) ==
 			 (PyCFunction)tp_new_wrapper &&
 			 strcmp(p->name, "__new__") == 0)
@@ -5645,7 +5643,7 @@ super_dealloc(PyObject *self)
 	Py_XDECREF(su->obj);
 	Py_XDECREF(su->type);
 	Py_XDECREF(su->obj_type);
-	self->ob_type->tp_free(self);
+	Py_Type(self)->tp_free(self);
 }
 
 static PyObject *
@@ -5708,7 +5706,7 @@ super_getattro(PyObject *self, PyObject *name)
 			res = PyDict_GetItem(dict, name);
 			if (res != NULL) {
 				Py_INCREF(res);
-				f = res->ob_type->tp_descr_get;
+				f = Py_Type(res)->tp_descr_get;
 				if (f != NULL) {
 					tmp = f(res,
 						/* Only pass 'obj' param if
@@ -5744,7 +5742,7 @@ supercheck(PyTypeObject *type, PyObject *obj)
 	     the normal case; the return value is obj.__class__.
 
 	   But... when obj is an instance, we want to allow for the case where
-	   obj->ob_type is not a subclass of type, but obj.__class__ is!
+	   Py_Type(obj) is not a subclass of type, but obj.__class__ is!
 	   This will allow using super() with a proxy for obj.
 	*/
 
@@ -5755,9 +5753,9 @@ supercheck(PyTypeObject *type, PyObject *obj)
 	}
 
 	/* Normal case */
-	if (PyType_IsSubtype(obj->ob_type, type)) {
-		Py_INCREF(obj->ob_type);
-		return obj->ob_type;
+	if (PyType_IsSubtype(Py_Type(obj), type)) {
+		Py_INCREF(Py_Type(obj));
+		return Py_Type(obj);
 	}
 	else {
 		/* Try the slow way */
@@ -5774,7 +5772,7 @@ supercheck(PyTypeObject *type, PyObject *obj)
 
 		if (class_attr != NULL &&
 		    PyType_Check(class_attr) &&
-		    (PyTypeObject *)class_attr != obj->ob_type)
+		    (PyTypeObject *)class_attr != Py_Type(obj))
 		{
 			int ok = PyType_IsSubtype(
 				(PyTypeObject *)class_attr, type);
@@ -5805,10 +5803,10 @@ super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 		Py_INCREF(self);
 		return self;
 	}
-	if (su->ob_type != &PySuper_Type)
+	if (Py_Type(su) != &PySuper_Type)
 		/* If su is an instance of a (strict) subclass of super,
 		   call its type */
-		return PyObject_CallFunctionObjArgs((PyObject *)su->ob_type,
+		return PyObject_CallFunctionObjArgs((PyObject *)Py_Type(su),
 						    su->type, obj, NULL);
 	else {
 		/* Inline the common case */
@@ -5890,7 +5888,7 @@ super_init(PyObject *self, PyObject *args, PyObject *kwds)
 				if (!PyType_Check(type)) {
 				    PyErr_Format(PyExc_SystemError,
 				      "super(): __class__ is not a type (%s)",
-				      type->ob_type->tp_name);
+				      Py_Type(type)->tp_name);
 				    return -1;
 				}
 				break;
@@ -5946,8 +5944,7 @@ super_traverse(PyObject *self, visitproc visit, void *arg)
 }
 
 PyTypeObject PySuper_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"super",				/* tp_name */
 	sizeof(superobject),			/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 1399d19..bf031bb 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -338,7 +338,7 @@ void unicode_dealloc(register PyUnicodeObject *unicode)
     else {
 	PyMem_DEL(unicode->str);
 	Py_XDECREF(unicode->defenc);
-	unicode->ob_type->tp_free((PyObject *)unicode);
+	Py_Type(unicode)->tp_free((PyObject *)unicode);
     }
 }
 
@@ -352,7 +352,7 @@ int PyUnicode_Resize(PyObject **unicode, Py_ssize_t length)
 	return -1;
     }
     v = (PyUnicodeObject *)*unicode;
-    if (v == NULL || !PyUnicode_Check(v) || v->ob_refcnt != 1 || length < 0) {
+    if (v == NULL || !PyUnicode_Check(v) || Py_Refcnt(v) != 1 || length < 0) {
 	PyErr_BadInternalCall();
 	return -1;
     }
@@ -1004,7 +1004,7 @@ PyObject *PyUnicode_FromEncodedObject(register PyObject *obj,
 	PyErr_Format(PyExc_TypeError,
 			 "coercing to Unicode: need string or buffer, "
 			 "%.80s found",
-		     obj->ob_type->tp_name);
+		     Py_Type(obj)->tp_name);
 	goto onError;
     }
 
@@ -1054,7 +1054,7 @@ PyObject *PyUnicode_Decode(const char *s,
     if (!PyUnicode_Check(unicode)) {
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return an unicode object (type=%.400s)",
-                     unicode->ob_type->tp_name);
+                     Py_Type(unicode)->tp_name);
         Py_DECREF(unicode);
         goto onError;
     }
@@ -3722,8 +3722,7 @@ encoding_map_dealloc(PyObject* o)
 }
 
 static PyTypeObject EncodingMapType = {
-	PyObject_HEAD_INIT(NULL)
-        0,                      /*ob_size*/
+	PyVarObject_HEAD_INIT(NULL, 0)
         "EncodingMap",          /*tp_name*/
         sizeof(struct encoding_map),   /*tp_basicsize*/
         0,                      /*tp_itemsize*/
@@ -3984,7 +3983,7 @@ charmapencode_result charmapencode_output(Py_UNICODE c, PyObject *mapping,
     char *outstart;
     Py_ssize_t outsize = PyBytes_GET_SIZE(outobj);
 
-    if (mapping->ob_type == &EncodingMapType) {
+    if (Py_Type(mapping) == &EncodingMapType) {
         int res = encoding_map_lookup(c, mapping);
 	Py_ssize_t requiredsize = *outpos+1;
         if (res == -1)
@@ -4056,7 +4055,7 @@ int charmap_encoding_error(
     /* find all unencodable characters */
     while (collendpos < size) {
         PyObject *rep;
-        if (mapping->ob_type == &EncodingMapType) {
+        if (Py_Type(mapping) == &EncodingMapType) {
 	    int res = encoding_map_lookup(p[collendpos], mapping);
 	    if (res != -1)
 		break;
@@ -5114,7 +5113,7 @@ PyUnicode_Join(PyObject *separator, PyObject *seq)
 	    PyErr_Format(PyExc_TypeError,
 			 "sequence item %zd: expected string or Unicode,"
 			 " %.80s found",
-			 i, item->ob_type->tp_name);
+			 i, Py_Type(item)->tp_name);
 	    goto onError;
 	}
 	item = PyUnicode_FromObject(item);
@@ -6155,7 +6154,7 @@ unicode_encode(PyUnicodeObject *self, PyObject *args)
         PyErr_Format(PyExc_TypeError,
                      "encoder did not return a bytes object "
                      "(type=%.400s)",
-                     v->ob_type->tp_name);
+                     Py_Type(v)->tp_name);
         Py_DECREF(v);
         return NULL;
     }
@@ -6191,7 +6190,7 @@ unicode_decode(PyUnicodeObject *self, PyObject *args)
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return a string/unicode object "
                      "(type=%.400s)",
-                     v->ob_type->tp_name);
+                     Py_Type(v)->tp_name);
         Py_DECREF(v);
         return NULL;
     }
@@ -8134,7 +8133,7 @@ PyObject *PyUnicode_Format(PyObject *format,
 	arglen = -1;
 	argidx = -2;
     }
-    if (args->ob_type->tp_as_mapping && !PyTuple_Check(args) &&
+    if (Py_Type(args)->tp_as_mapping && !PyTuple_Check(args) &&
         !PyObject_TypeCheck(args, &PyBaseString_Type))
 	dict = args;
 
@@ -8604,8 +8603,7 @@ errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.");
 static PyObject *unicode_iter(PyObject *seq);
 
 PyTypeObject PyUnicode_Type = {
-    PyObject_HEAD_INIT(&PyType_Type)
-    0, 					/* ob_size */
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "str", 				/* tp_name */
     sizeof(PyUnicodeObject), 		/* tp_size */
     0, 					/* tp_itemsize */
@@ -8902,8 +8900,7 @@ static PyMethodDef unicodeiter_methods[] = {
 };
 
 PyTypeObject PyUnicodeIter_Type = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,					/* ob_size */
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"unicodeiterator",			/* tp_name */
 	sizeof(unicodeiterobject),		/* tp_basicsize */
 	0,					/* tp_itemsize */
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index d30b90f..6dc7d08 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -105,7 +105,7 @@ weakref_dealloc(PyObject *self)
 {
     PyObject_GC_UnTrack(self);
     clear_weakref((PyWeakReference *) self);
-    self->ob_type->tp_free(self);
+    Py_Type(self)->tp_free(self);
 }
 
 
@@ -172,7 +172,7 @@ weakref_repr(PyWeakReference *self)
 		      name ? "<weakref at %p; to '%.50s' at %p (%s)>"
 		           : "<weakref at %p; to '%.50s' at %p>",
 		      self,
-		      PyWeakref_GET_OBJECT(self)->ob_type->tp_name,
+		      Py_Type(PyWeakref_GET_OBJECT(self))->tp_name,
 		      PyWeakref_GET_OBJECT(self),
 		      name);
 	Py_XDECREF(nameobj);
@@ -276,10 +276,10 @@ weakref___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         PyWeakReference *ref, *proxy;
         PyWeakReference **list;
 
-        if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) {
+        if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
             PyErr_Format(PyExc_TypeError,
                          "cannot create weak reference to '%s' object",
-                         ob->ob_type->tp_name);
+                         Py_Type(ob)->tp_name);
             return NULL;
         }
         if (callback == Py_None)
@@ -334,8 +334,7 @@ weakref___init__(PyObject *self, PyObject *args, PyObject *kwargs)
 
 PyTypeObject
 _PyWeakref_RefType = {
-    PyObject_HEAD_INIT(&PyType_Type)
-    0,
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "weakref",
     sizeof(PyWeakReference),
     0,
@@ -449,7 +448,7 @@ proxy_repr(PyWeakReference *proxy)
     char buf[160];
     PyOS_snprintf(buf, sizeof(buf),
 		  "<weakproxy at %p to %.100s at %p>", proxy,
-		  PyWeakref_GET_OBJECT(proxy)->ob_type->tp_name,
+		  Py_Type(PyWeakref_GET_OBJECT(proxy))->tp_name,
 		  PyWeakref_GET_OBJECT(proxy));
     return PyUnicode_FromString(buf);
 }
@@ -644,8 +643,7 @@ static PyMappingMethods proxy_as_mapping = {
 
 PyTypeObject
 _PyWeakref_ProxyType = {
-    PyObject_HEAD_INIT(&PyType_Type)
-    0,
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "weakproxy",
     sizeof(PyWeakReference),
     0,
@@ -678,8 +676,7 @@ _PyWeakref_ProxyType = {
 
 PyTypeObject
 _PyWeakref_CallableProxyType = {
-    PyObject_HEAD_INIT(&PyType_Type)
-    0,
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "weakcallableproxy",
     sizeof(PyWeakReference),
     0,
@@ -718,10 +715,10 @@ PyWeakref_NewRef(PyObject *ob, PyObject *callback)
     PyWeakReference **list;
     PyWeakReference *ref, *proxy;
 
-    if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) {
+    if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
         PyErr_Format(PyExc_TypeError,
 		     "cannot create weak reference to '%s' object",
-                     ob->ob_type->tp_name);
+                     Py_Type(ob)->tp_name);
         return NULL;
     }
     list = GET_WEAKREFS_LISTPTR(ob);
@@ -777,10 +774,10 @@ PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
     PyWeakReference **list;
     PyWeakReference *ref, *proxy;
 
-    if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) {
+    if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
         PyErr_Format(PyExc_TypeError,
 		     "cannot create weak reference to '%s' object",
-                     ob->ob_type->tp_name);
+                     Py_Type(ob)->tp_name);
         return NULL;
     }
     list = GET_WEAKREFS_LISTPTR(ob);
@@ -803,9 +800,9 @@ PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
             PyWeakReference *prev;
 
             if (PyCallable_Check(ob))
-                result->ob_type = &_PyWeakref_CallableProxyType;
+                Py_Type(result) = &_PyWeakref_CallableProxyType;
             else
-                result->ob_type = &_PyWeakref_ProxyType;
+                Py_Type(result) = &_PyWeakref_ProxyType;
             get_basic_refs(*list, &ref, &proxy);
             if (callback == NULL) {
                 if (proxy != NULL) {
@@ -870,7 +867,7 @@ PyObject_ClearWeakRefs(PyObject *object)
     PyWeakReference **list;
 
     if (object == NULL
-        || !PyType_SUPPORTS_WEAKREFS(object->ob_type)
+        || !PyType_SUPPORTS_WEAKREFS(Py_Type(object))
         || object->ob_refcnt != 0) {
         PyErr_BadInternalCall();
         return;
author	Martin v. Löwis <martin@v.loewis.de>	2007-07-21 17:22:18 (GMT)
committer	Martin v. Löwis <martin@v.loewis.de>	2007-07-21 17:22:18 (GMT)
commit	9f2e346911988cda95fec7c901e8d10d34fa9563 (patch)
tree	1632c78fb8e18b2f789102451bedd15996bff6c5 /Objects
parent	b972a78e17beeb997d809d87f2e422e6622efd52 (diff)
download	cpython-9f2e346911988cda95fec7c901e8d10d34fa9563.zip cpython-9f2e346911988cda95fec7c901e8d10d34fa9563.tar.gz cpython-9f2e346911988cda95fec7c901e8d10d34fa9563.tar.bz2