#1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT.

144 files changed, 1306 insertions, 1153 deletions

diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst
index f21ff72..e5a8d22 100644
--- a/Doc/whatsnew/2.6.rst
+++ b/Doc/whatsnew/2.6.rst
@@ -72,8 +72,6 @@ new feature.
 Python 3.0
 ================
 
-.. % XXX add general comment about Python 3.0 features in 2.6
-
 The development cycle for Python 2.6 also saw the release of the first
 alphas of Python 3.0, and the development of 3.0 has influenced 
 a number of features in 2.6.
@@ -95,7 +93,9 @@ are:
 A new command-line switch, :option:`-3`, enables warnings
 about features that will be removed in Python 3.0.  You can run code
 with this switch to see how much work will be necessary to port
-code to 3.0.
+code to 3.0.  The value of this switch is available 
+to Python code as the boolean variable ``sys.py3kwarning``,
+and to C extension code as :cdata:`Py_Py3kWarningFlag`.
 
 .. seealso::
 
@@ -103,6 +103,62 @@ code to 3.0.
    Python 3.0 and various features that have been accepted, rejected,
    or are still under consideration.
 
+
+Development Changes
+==================================================
+
+While 2.6 was being developed, the Python development process 
+underwent two significant changes: the developer group 
+switched from SourceForge's issue tracker to a customized 
+Roundup installation, and the documentation was converted from
+LaTeX to reStructured Text.
+
+
+New Issue Tracker: Roundup
+--------------------------------------------------
+
+XXX write this.
+
+
+New Documentation Format: ReStructured Text
+--------------------------------------------------
+
+Python's documentation had been written using LaTeX since the
+project's inception around 1989.  At that time, most documentation was
+printed out for later study, not viewed online. LaTeX was widely used
+because it provided attractive printed output while 
+remaining straightforward to write, once the basic rules 
+of the markup have been learned.
+
+LaTeX is still used today for writing technical publications destined
+for printing, but the landscape for programming tools has shifted.  We
+no longer print out reams of documentation; instead, we browse through
+it online and HTML is the most important format to support.
+Unfortunately, converting LaTeX to HTML is fairly complicated, and
+Fred L. Drake Jr., the Python documentation editor for many years,
+spent a lot of time wrestling the conversion process into shape.
+Occasionally people would suggest converting the documentation into 
+SGML or, later, XML, but performing a good conversion is a major task 
+and no one pursued the task to completion.
+
+During the 2.6 development cycle, Georg Brandl put a substantial 
+effort into building a new toolchain called Sphinx 
+for processing the documentation.
+The input format is reStructured Text, 
+a markup commonly used in the Python community that supports
+custom extensions  and directives.   Sphinx concentrates 
+on its HTML output, producing attractively styled 
+and modern HTML. (XXX finish this -- mention new search feature)
+
+.. seealso::
+
+   `Docutils <http://docutils.sf.net>`__: The fundamental
+   reStructured Text parser and toolset.
+
+   `Documenting Python <XXX>`__: Describes how to write for 
+   Python's documentation.
+
+
 PEP 343: The 'with' statement
 =============================
 
@@ -352,6 +408,24 @@ bound to a variable, and calls ``object.close`` at the end of the block. ::
 
 .. % ======================================================================
 
+.. _pep-0366:
+
+PEP 366: Explicit Relative Imports From a Main Module
+============================================================
+
+Python's :option:`-m` switch allows running a module as a script.
+When you ran a module that was located inside a package, relative
+imports didn't work correctly.
+
+The fix in Python 2.6 adds a :attr:`__package__` attribute to modules.
+When present, relative imports will be relative to the value of this
+attribute instead of the :attr:`__name__` attribute.  PEP 302-style
+importers can then set :attr:`__package__`.  The :mod:`runpy` module
+that implements the :option:`-m` switch now does this, so relative imports
+can now be used in scripts running from inside a package.
+
+.. % ======================================================================
+
 .. _pep-3110:
 
 PEP 3110: Exception-Handling Changes
@@ -414,7 +488,7 @@ XXX
    :pep:`3119` - Introducing Abstract Base Classes
       PEP written by Guido van Rossum and Talin.
       Implemented by XXX.
-      Backported to 2.6 by Benjamin Aranguren (with Alex Martelli).
+      Backported to 2.6 by Benjamin Aranguren, with Alex Martelli.
 
 Other Language Changes
 ======================
@@ -443,6 +517,25 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
 
   .. % Revision 57619
 
+* Properties now have two attributes, 
+  :attr:`setter` and :attr:`deleter`, that are useful shortcuts for
+  adding a setter or deleter function to an existing property.  
+  You would use them like this::
+
+    class C(object):
+	@property                                                              
+	def x(self): 
+	    return self._x                                            
+
+	@x.setter                                                              
+	def x(self, value): 
+	    self._x = value                                    
+
+	@x.deleter                                                             
+	def x(self): 
+	    del self._x             
+
+
 * C functions and methods that use 
   :cfunc:`PyComplex_AsCComplex` will now accept arguments that 
   have a :meth:`__complex__` method.  In particular, the functions in the 
@@ -452,11 +545,26 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
 
   .. % Patch #1675423
 
+  A numerical nicety: when creating a complex number from two floats
+  on systems that support signed zeros (-0 and +0), the 
+  :func:`complex()` constructor will now preserve the sign 
+  of the zero.
+
+  .. % Patch 1507
+
 * Changes to the :class:`Exception` interface
   as dictated by :pep:`352` continue to be made.  For 2.6, 
   the :attr:`message` attribute is being deprecated in favor of the
   :attr:`args` attribute.
 
+* The :exc:`GeneratorExit` exception now subclasses 
+  :exc:`BaseException` instead of :exc:`Exception`.  This means 
+  that an exception handler that does ``except Exception:``
+  will not inadvertently catch :exc:`GeneratorExit`. 
+  (Contributed by Chad Austin.)
+
+  .. % Patch #1537
+
 * The :func:`compile` built-in function now accepts keyword arguments
   as well as positional parameters.  (Contributed by Thomas Wouters.)
 
@@ -653,6 +761,20 @@ complete list of changes, or look through the CVS logs for all the details.
 
   .. % Patch #1490190
 
+* The :mod:`new` module has been removed from Python 3.0.
+  Importing it therefore
+  triggers a warning message when Python is running in 3.0-warning
+  mode.
+
+* New functions in the :mod:`os` module include 
+  ``fchmod(fd, mode)``,   ``fchown(fd, uid, gid)``,  
+  and ``lchmod(path, mode)``, on operating systems that support these
+  functions. :func:`fchmod` and :func:`fchown` let you change the mode
+  and ownership of an opened file, and :func:`lchmod` changes the mode
+  of a symlink.
+
+  (Contributed by Georg Brandl and Christian Heimes.)
+
 * The :func:`os.walk` function now has a ``followlinks`` parameter. If
   set to True, it will follow symlinks pointing to directories and
   visit the directory's contents.  For backward compatibility, the
@@ -703,6 +825,15 @@ complete list of changes, or look through the CVS logs for all the details.
   changed and :const:`UF_APPEND` to indicate that data can only be appended to the
   file.  (Contributed by M. Levinson.)
 
+* The :mod:`random` module's :class:`Random` objects can
+  now be pickled on a 32-bit system and unpickled on a 64-bit
+  system, and vice versa.  Unfortunately, this change also means
+  that Python 2.6's :class:`Random` objects can't be unpickled correctly
+  on earlier versions of Python.
+  (Contributed by Shawn Ligocki.)
+
+  .. % Issue 1727780
+
 * The :mod:`rgbimg` module has been removed.
 
 * The :mod:`sets` module has been deprecated; it's better to 
@@ -725,6 +856,17 @@ complete list of changes, or look through the CVS logs for all the details.
 
   .. % Patch #957003
 
+* A new variable in the :mod:`sys` module,
+  :attr:`float_info`, is a dictionary 
+  containing information about the platform's floating-point support
+  derived from the :file:`float.h` file.  Key/value pairs 
+  in this dictionary include 
+  ``"mant_dig"`` (number of digits in the mantissa), ``"epsilon"``
+  (smallest difference between 1.0 and the next largest value
+  representable), and several others.  (Contributed by Christian Heimes.)
+
+  .. % Patch 1534
+
 * The :mod:`tarfile` module now supports POSIX.1-2001 (pax) and
   POSIX.1-1988 (ustar) format tarfiles, in addition to the GNU tar
   format that was already supported.  The default format 
@@ -883,6 +1025,17 @@ Changes to Python's build process and to the C API include:
 
   .. % Patch 1551895
 
+* Several functions return information about the platform's 
+  floating-point support.  :cfunc:`PyFloat_GetMax` returns
+  the maximum representable floating point value,
+  and :cfunc:`PyFloat_GetMin` returns the minimum 
+  positive value.  :cfunc:`PyFloat_GetInfo` returns a dictionary 
+  containing more information from the :file:`float.h` file, such as
+  ``"mant_dig"`` (number of digits in the mantissa), ``"epsilon"``
+  (smallest difference between 1.0 and the next largest value
+  representable), and several others.
+
+  .. % Issue 1534
 
 .. % ======================================================================
 
diff --git a/Include/abstract.h b/Include/abstract.h
index e344fba..468afe9 100644
--- a/Include/abstract.h
+++ b/Include/abstract.h
@@ -1070,7 +1070,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
        */
 
 #define PySequence_ITEM(o, i)\
-	( Py_Type(o)->tp_as_sequence->sq_item(o, i) )
+	( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
        /* Assume tp_as_sequence and sq_item exist and that i does not
 	  need to be corrected for a negative index
        */     
diff --git a/Include/boolobject.h b/Include/boolobject.h
index 33f8112..7cc2f1f 100644
--- a/Include/boolobject.h
+++ b/Include/boolobject.h
@@ -9,7 +9,7 @@ extern "C" {
 
 PyAPI_DATA(PyTypeObject) PyBool_Type;
 
-#define PyBool_Check(x) (Py_Type(x) == &PyBool_Type)
+#define PyBool_Check(x) (Py_TYPE(x) == &PyBool_Type)
 
 /* Py_False and Py_True are the only two bools in existence.
 Don't forget to apply Py_INCREF() when returning either!!! */
diff --git a/Include/bytesobject.h b/Include/bytesobject.h
index e9c319c..49d1d38 100644
--- a/Include/bytesobject.h
+++ b/Include/bytesobject.h
@@ -33,7 +33,7 @@ PyAPI_DATA(PyTypeObject) PyBytesIter_Type;
 
 /* Type check macros */
 #define PyBytes_Check(self) PyObject_TypeCheck(self, &PyBytes_Type)
-#define PyBytes_CheckExact(self) (Py_Type(self) == &PyBytes_Type)
+#define PyBytes_CheckExact(self) (Py_TYPE(self) == &PyBytes_Type)
 
 /* Direct API functions */
 PyAPI_FUNC(PyObject *) PyBytes_FromObject(PyObject *);
@@ -45,7 +45,7 @@ PyAPI_FUNC(int) PyBytes_Resize(PyObject *, Py_ssize_t);
 
 /* Macros, trading safety for speed */
 #define PyBytes_AS_STRING(self) (assert(PyBytes_Check(self)),((PyBytesObject *)(self))->ob_bytes)
-#define PyBytes_GET_SIZE(self)  (assert(PyBytes_Check(self)),Py_Size(self))
+#define PyBytes_GET_SIZE(self)  (assert(PyBytes_Check(self)),Py_SIZE(self))
 
 #ifdef __cplusplus
 }
diff --git a/Include/cStringIO.h b/Include/cStringIO.h
index 50f8cbe..d22b9eb 100644
--- a/Include/cStringIO.h
+++ b/Include/cStringIO.h
@@ -60,9 +60,9 @@ static struct PycStringIO_CAPI {
 
 /* These can be used to test if you have one */
 #define PycStringIO_InputCheck(O) \
-  (Py_Type(O)==PycStringIO->InputType)
+  (Py_TYPE(O)==PycStringIO->InputType)
 #define PycStringIO_OutputCheck(O) \
-  (Py_Type(O)==PycStringIO->OutputType)
+  (Py_TYPE(O)==PycStringIO->OutputType)
 
 #ifdef __cplusplus
 }
diff --git a/Include/cellobject.h b/Include/cellobject.h
index 1036420..c927ee5 100644
--- a/Include/cellobject.h
+++ b/Include/cellobject.h
@@ -13,7 +13,7 @@ typedef struct {
 
 PyAPI_DATA(PyTypeObject) PyCell_Type;
 
-#define PyCell_Check(op) (Py_Type(op) == &PyCell_Type)
+#define PyCell_Check(op) (Py_TYPE(op) == &PyCell_Type)
 
 PyAPI_FUNC(PyObject *) PyCell_New(PyObject *);
 PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *);
diff --git a/Include/cobject.h b/Include/cobject.h
index 0e0ed1b..499dfad 100644
--- a/Include/cobject.h
+++ b/Include/cobject.h
@@ -16,7 +16,7 @@ extern "C" {
 
 PyAPI_DATA(PyTypeObject) PyCObject_Type;
 
-#define PyCObject_Check(op) (Py_Type(op) == &PyCObject_Type)
+#define PyCObject_Check(op) (Py_TYPE(op) == &PyCObject_Type)
 
 /* Create a PyCObject from a pointer to a C object and an optional
    destructor function.  If the second argument is non-null, then it
diff --git a/Include/code.h b/Include/code.h
index 3f3df49..56d6cb5 100644
--- a/Include/code.h
+++ b/Include/code.h
@@ -59,7 +59,7 @@ typedef struct {
 
 PyAPI_DATA(PyTypeObject) PyCode_Type;
 
-#define PyCode_Check(op) (Py_Type(op) == &PyCode_Type)
+#define PyCode_Check(op) (Py_TYPE(op) == &PyCode_Type)
 #define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars))
 
 /* Public interface */
@@ -72,7 +72,7 @@ PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int);
 
 /* for internal use only */
 #define _PyCode_GETCODEPTR(co, pp) \
-	((*Py_Type((co)->co_code)->tp_as_buffer->bf_getreadbuffer) \
+	((*Py_TYPE((co)->co_code)->tp_as_buffer->bf_getreadbuffer) \
 	 ((co)->co_code, 0, (void **)(pp)))
 
 typedef struct _addr_pair {
diff --git a/Include/complexobject.h b/Include/complexobject.h
index 3e1cda5..b036444 100644
--- a/Include/complexobject.h
+++ b/Include/complexobject.h
@@ -43,7 +43,7 @@ typedef struct {
 PyAPI_DATA(PyTypeObject) PyComplex_Type;
 
 #define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type)
-#define PyComplex_CheckExact(op) (Py_Type(op) == &PyComplex_Type)
+#define PyComplex_CheckExact(op) (Py_TYPE(op) == &PyComplex_Type)
 
 PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex);
 PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag);
diff --git a/Include/datetime.h b/Include/datetime.h
index 43e3093..0d310b4 100644
--- a/Include/datetime.h
+++ b/Include/datetime.h
@@ -166,19 +166,19 @@ typedef struct {
 
 /* Macros for type checking when building the Python core. */
 #define PyDate_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateType)
-#define PyDate_CheckExact(op) (Py_Type(op) == &PyDateTime_DateType)
+#define PyDate_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateType)
 
 #define PyDateTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateTimeType)
-#define PyDateTime_CheckExact(op) (Py_Type(op) == &PyDateTime_DateTimeType)
+#define PyDateTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateTimeType)
 
 #define PyTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_TimeType)
-#define PyTime_CheckExact(op) (Py_Type(op) == &PyDateTime_TimeType)
+#define PyTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TimeType)
 
 #define PyDelta_Check(op) PyObject_TypeCheck(op, &PyDateTime_DeltaType)
-#define PyDelta_CheckExact(op) (Py_Type(op) == &PyDateTime_DeltaType)
+#define PyDelta_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DeltaType)
 
 #define PyTZInfo_Check(op) PyObject_TypeCheck(op, &PyDateTime_TZInfoType)
-#define PyTZInfo_CheckExact(op) (Py_Type(op) == &PyDateTime_TZInfoType)
+#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TZInfoType)
 
 #else
 
@@ -198,19 +198,19 @@ static PyDateTime_CAPI *PyDateTimeAPI;
 
 /* Macros for type checking when not building the Python core. */
 #define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType)
-#define PyDate_CheckExact(op) (Py_Type(op) == PyDateTimeAPI->DateType)
+#define PyDate_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateType)
 
 #define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType)
-#define PyDateTime_CheckExact(op) (Py_Type(op) == PyDateTimeAPI->DateTimeType)
+#define PyDateTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateTimeType)
 
 #define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType)
-#define PyTime_CheckExact(op) (Py_Type(op) == PyDateTimeAPI->TimeType)
+#define PyTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TimeType)
 
 #define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType)
-#define PyDelta_CheckExact(op) (Py_Type(op) == PyDateTimeAPI->DeltaType)
+#define PyDelta_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DeltaType)
 
 #define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType)
-#define PyTZInfo_CheckExact(op) (Py_Type(op) == PyDateTimeAPI->TZInfoType)
+#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TZInfoType)
 
 /* Macros for accessing constructors in a simplified fashion. */
 #define PyDate_FromDate(year, month, day) \
diff --git a/Include/descrobject.h b/Include/descrobject.h
index badfa5b..f06b421 100644
--- a/Include/descrobject.h
+++ b/Include/descrobject.h
@@ -82,7 +82,7 @@ PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
 					       struct PyGetSetDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
 						struct wrapperbase *, void *);
-#define PyDescr_IsData(d) (Py_Type(d)->tp_descr_set != NULL)
+#define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)
 
 PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *);
 PyAPI_FUNC(PyObject *) PyWrapper_New(PyObject *, PyObject *);
diff --git a/Include/dictobject.h b/Include/dictobject.h
index afc55af..76fc75b 100644
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -97,11 +97,11 @@ PyAPI_DATA(PyTypeObject) PyDictItems_Type;
 PyAPI_DATA(PyTypeObject) PyDictValues_Type;
 
 #define PyDict_Check(op) \
-                 PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_DICT_SUBCLASS)
-#define PyDict_CheckExact(op) (Py_Type(op) == &PyDict_Type)
-#define PyDictKeys_Check(op) (Py_Type(op) == &PyDictKeys_Type)
-#define PyDictItems_Check(op) (Py_Type(op) == &PyDictItems_Type)
-#define PyDictValues_Check(op) (Py_Type(op) == &PyDictValues_Type)
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
+#define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type)
+#define PyDictKeys_Check(op) (Py_TYPE(op) == &PyDictKeys_Type)
+#define PyDictItems_Check(op) (Py_TYPE(op) == &PyDictItems_Type)
+#define PyDictValues_Check(op) (Py_TYPE(op) == &PyDictValues_Type)
 /* This excludes Values, since they are not sets. */
 # define PyDictViewSet_Check(op) \
 	(PyDictKeys_Check(op) || PyDictItems_Check(op))
diff --git a/Include/floatobject.h b/Include/floatobject.h
index b9c79c7..f18933b 100644
--- a/Include/floatobject.h
+++ b/Include/floatobject.h
@@ -19,7 +19,7 @@ typedef struct {
 PyAPI_DATA(PyTypeObject) PyFloat_Type;
 
 #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)
-#define PyFloat_CheckExact(op) (Py_Type(op) == &PyFloat_Type)
+#define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type)
 
 PyAPI_FUNC(double) PyFloat_GetMax(void);
 PyAPI_FUNC(double) PyFloat_GetMin(void);
diff --git a/Include/frameobject.h b/Include/frameobject.h
index 0dc4d06..05877f9 100644
--- a/Include/frameobject.h
+++ b/Include/frameobject.h
@@ -51,7 +51,7 @@ typedef struct _frame {
 
 PyAPI_DATA(PyTypeObject) PyFrame_Type;
 
-#define PyFrame_Check(op) (Py_Type(op) == &PyFrame_Type)
+#define PyFrame_Check(op) (Py_TYPE(op) == &PyFrame_Type)
 
 PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
                                        PyObject *, PyObject *);
diff --git a/Include/funcobject.h b/Include/funcobject.h
index 798b257..058c6bf 100644
--- a/Include/funcobject.h
+++ b/Include/funcobject.h
@@ -41,7 +41,7 @@ typedef struct {
 
 PyAPI_DATA(PyTypeObject) PyFunction_Type;
 
-#define PyFunction_Check(op) (Py_Type(op) == &PyFunction_Type)
+#define PyFunction_Check(op) (Py_TYPE(op) == &PyFunction_Type)
 
 PyAPI_FUNC(PyObject *) PyFunction_New(PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) PyFunction_GetCode(PyObject *);
diff --git a/Include/genobject.h b/Include/genobject.h
index f9d9b16..11c6823 100644
--- a/Include/genobject.h
+++ b/Include/genobject.h
@@ -26,7 +26,7 @@ typedef struct {
 PyAPI_DATA(PyTypeObject) PyGen_Type;
 
 #define PyGen_Check(op) PyObject_TypeCheck(op, &PyGen_Type)
-#define PyGen_CheckExact(op) (Py_Type(op) == &PyGen_Type)
+#define PyGen_CheckExact(op) (Py_TYPE(op) == &PyGen_Type)
 
 PyAPI_FUNC(PyObject *) PyGen_New(struct _frame *);
 PyAPI_FUNC(int) PyGen_NeedsFinalizing(PyGenObject *);
diff --git a/Include/iterobject.h b/Include/iterobject.h
index ba1b482..851cd7b 100644
--- a/Include/iterobject.h
+++ b/Include/iterobject.h
@@ -10,12 +10,12 @@ PyAPI_DATA(PyTypeObject) PyCallIter_Type;
 PyAPI_DATA(PyTypeObject) PyZipIter_Type;
 PyAPI_DATA(PyTypeObject) PyCmpWrapper_Type;
 
-#define PySeqIter_Check(op) (Py_Type(op) == &PySeqIter_Type)
+#define PySeqIter_Check(op) (Py_TYPE(op) == &PySeqIter_Type)
 
 PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *);
 
 
-#define PyCallIter_Check(op) (Py_Type(op) == &PyCallIter_Type)
+#define PyCallIter_Check(op) (Py_TYPE(op) == &PyCallIter_Type)
 
 PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *);
 
diff --git a/Include/listobject.h b/Include/listobject.h
index d395889..755fbbe 100644
--- a/Include/listobject.h
+++ b/Include/listobject.h
@@ -44,8 +44,8 @@ PyAPI_DATA(PyTypeObject) PyListRevIter_Type;
 PyAPI_DATA(PyTypeObject) PySortWrapper_Type;
 
 #define PyList_Check(op) \
-		PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_LIST_SUBCLASS)
-#define PyList_CheckExact(op) (Py_Type(op) == &PyList_Type)
+		PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS)
+#define PyList_CheckExact(op) (Py_TYPE(op) == &PyList_Type)
 
 PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size);
 PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *);
@@ -63,7 +63,7 @@ PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *);
 /* Macro, trading safety for speed */
 #define PyList_GET_ITEM(op, i) (((PyListObject *)(op))->ob_item[i])
 #define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v))
-#define PyList_GET_SIZE(op)    Py_Size(op)
+#define PyList_GET_SIZE(op)    Py_SIZE(op)
 
 #ifdef __cplusplus
 }
diff --git a/Include/longobject.h b/Include/longobject.h
index d48552c..18d0c55 100644
--- a/Include/longobject.h
+++ b/Include/longobject.h
@@ -12,8 +12,8 @@ typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */
 PyAPI_DATA(PyTypeObject) PyLong_Type;
 
 #define PyLong_Check(op) \
-		PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_LONG_SUBCLASS)
-#define PyLong_CheckExact(op) (Py_Type(op) == &PyLong_Type)
+		PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS)
+#define PyLong_CheckExact(op) (Py_TYPE(op) == &PyLong_Type)
 
 PyAPI_FUNC(PyObject *) PyLong_FromLong(long);
 PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLong(unsigned long);
diff --git a/Include/memoryobject.h b/Include/memoryobject.h
index 8709da5..ad2e8e7 100644
--- a/Include/memoryobject.h
+++ b/Include/memoryobject.h
@@ -16,7 +16,7 @@ typedef struct {
 
 PyAPI_DATA(PyTypeObject) PyMemoryView_Type;
 
-#define PyMemory_Check(op) (Py_Type(op) == &PyMemoryView_Type)
+#define PyMemory_Check(op) (Py_TYPE(op) == &PyMemoryView_Type)
 #define PyMemoryView(op) (((PyMemoryViewObject *)(op))->view)
 
 #define Py_END_OF_MEMORY	(-1)
diff --git a/Include/methodobject.h b/Include/methodobject.h
index 0068120..48e780e 100644
--- a/Include/methodobject.h
+++ b/Include/methodobject.h
@@ -13,7 +13,7 @@ extern "C" {
 
 PyAPI_DATA(PyTypeObject) PyCFunction_Type;
 
-#define PyCFunction_Check(op) (Py_Type(op) == &PyCFunction_Type)
+#define PyCFunction_Check(op) (Py_TYPE(op) == &PyCFunction_Type)
 
 typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
 typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,
diff --git a/Include/moduleobject.h b/Include/moduleobject.h
index f50c729..d643ce2 100644
--- a/Include/moduleobject.h
+++ b/Include/moduleobject.h
@@ -10,7 +10,7 @@ extern "C" {
 PyAPI_DATA(PyTypeObject) PyModule_Type;
 
 #define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type)
-#define PyModule_CheckExact(op) (Py_Type(op) == &PyModule_Type)
+#define PyModule_CheckExact(op) (Py_TYPE(op) == &PyModule_Type)
 
 PyAPI_FUNC(PyObject *) PyModule_New(const char *);
 PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *);
diff --git a/Include/object.h b/Include/object.h
index 942f801..d008c50 100644
--- a/Include/object.h
+++ b/Include/object.h
@@ -109,9 +109,9 @@ typedef struct {
 	Py_ssize_t ob_size; /* Number of items in variable part */
 } PyVarObject;
 
-#define Py_Refcnt(ob)		(((PyObject*)(ob))->ob_refcnt)
-#define Py_Type(ob)		(((PyObject*)(ob))->ob_type)
-#define Py_Size(ob)		(((PyVarObject*)(ob))->ob_size)
+#define Py_REFCNT(ob)		(((PyObject*)(ob))->ob_refcnt)
+#define Py_TYPE(ob)		(((PyObject*)(ob))->ob_type)
+#define Py_SIZE(ob)		(((PyVarObject*)(ob))->ob_size)
 
 /*
 Type objects contain a string containing the type name (to help somewhat
@@ -404,21 +404,21 @@ typedef struct _heaptypeobject {
 
 /* access macro to the members which are floating "behind" the object */
 #define PyHeapType_GET_MEMBERS(etype) \
-    ((PyMemberDef *)(((char *)etype) + Py_Type(etype)->tp_basicsize))
+    ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize))
 
 
 /* Generic type check */
 PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
 #define PyObject_TypeCheck(ob, tp) \
-	(Py_Type(ob) == (tp) || PyType_IsSubtype(Py_Type(ob), (tp)))
+	(Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))
 
 PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */
 PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */
 PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */
 
 #define PyType_Check(op) \
-	PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_TYPE_SUBCLASS)
-#define PyType_CheckExact(op) (Py_Type(op) == &PyType_Type)
+	PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
+#define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type)
 
 PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);
 PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
@@ -612,9 +612,9 @@ PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);
 #ifdef COUNT_ALLOCS
 PyAPI_FUNC(void) inc_count(PyTypeObject *);
 PyAPI_FUNC(void) dec_count(PyTypeObject *);
-#define _Py_INC_TPALLOCS(OP)	inc_count(Py_Type(OP))
-#define _Py_INC_TPFREES(OP)	dec_count(Py_Type(OP))
-#define _Py_DEC_TPFREES(OP)	Py_Type(OP)->tp_frees--
+#define _Py_INC_TPALLOCS(OP)	inc_count(Py_TYPE(OP))
+#define _Py_INC_TPFREES(OP)	dec_count(Py_TYPE(OP))
+#define _Py_DEC_TPFREES(OP)	Py_TYPE(OP)->tp_frees--
 #define _Py_COUNT_ALLOCS_COMMA	,
 #else
 #define _Py_INC_TPALLOCS(OP)
@@ -639,13 +639,13 @@ PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *, int force);
 #define _Py_NewReference(op) (				\
 	_Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA	\
 	_Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA		\
-	Py_Refcnt(op) = 1)
+	Py_REFCNT(op) = 1)
 
 #define _Py_ForgetReference(op) _Py_INC_TPFREES(op)
 
 #define _Py_Dealloc(op) (				\
 	_Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA	\
-	(*Py_Type(op)->tp_dealloc)((PyObject *)(op)))
+	(*Py_TYPE(op)->tp_dealloc)((PyObject *)(op)))
 #endif /* !Py_TRACE_REFS */
 
 #define Py_INCREF(op) (				\
diff --git a/Include/objimpl.h b/Include/objimpl.h
index 3f867e3..20d9c24 100644
--- a/Include/objimpl.h
+++ b/Include/objimpl.h
@@ -151,9 +151,9 @@ PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
 /* Macros trading binary compatibility for speed. See also pymem.h.
    Note that these macros expect non-NULL object pointers.*/
 #define PyObject_INIT(op, typeobj) \
-	( Py_Type(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
+	( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
 #define PyObject_INIT_VAR(op, typeobj, size) \
-	( Py_Size(op) = (size), PyObject_INIT((op), (typeobj)) )
+	( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) )
 
 #define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
 
@@ -228,8 +228,8 @@ PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void);
 #define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
 
 /* Test if an object has a GC head */
-#define PyObject_IS_GC(o) (PyType_IS_GC(Py_Type(o)) && \
-	(Py_Type(o)->tp_is_gc == NULL || Py_Type(o)->tp_is_gc(o)))
+#define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) && \
+	(Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
 
 PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);
 #define PyObject_GC_Resize(type, op, n) \
@@ -323,7 +323,7 @@ PyAPI_FUNC(void) PyObject_GC_Del(void *);
 #define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0)
 
 #define PyObject_GET_WEAKREFS_LISTPTR(o) \
-	((PyObject **) (((char *) (o)) + Py_Type(o)->tp_weaklistoffset))
+	((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset))
 
 #ifdef __cplusplus
 }
diff --git a/Include/py_curses.h b/Include/py_curses.h
index 23d9d16..3cb23cc 100644
--- a/Include/py_curses.h
+++ b/Include/py_curses.h
@@ -73,7 +73,7 @@ typedef struct {
 	WINDOW *win;
 } PyCursesWindowObject;
 
-#define PyCursesWindow_Check(v)	 (Py_Type(v) == &PyCursesWindow_Type)
+#define PyCursesWindow_Check(v)	 (Py_TYPE(v) == &PyCursesWindow_Type)
 
 #ifdef CURSES_MODULE
 /* This section is used when compiling _cursesmodule.c */
diff --git a/Include/rangeobject.h b/Include/rangeobject.h
index 2746454..7e4dc28 100644
--- a/Include/rangeobject.h
+++ b/Include/rangeobject.h
@@ -19,7 +19,7 @@ PyAPI_DATA(PyTypeObject) PyRange_Type;
 PyAPI_DATA(PyTypeObject) PyRangeIter_Type;
 PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type;
 
-#define PyRange_Check(op) (Py_Type(op) == &PyRange_Type)
+#define PyRange_Check(op) (Py_TYPE(op) == &PyRange_Type)
 
 #ifdef __cplusplus
 }
diff --git a/Include/setobject.h b/Include/setobject.h
index 5b97fcb..5b7fb7e 100644
--- a/Include/setobject.h
+++ b/Include/setobject.h
@@ -67,13 +67,13 @@ PyAPI_DATA(PyTypeObject) PySetIter_Type;
  *     hash is -1
  */
 
-#define PyFrozenSet_CheckExact(ob) (Py_Type(ob) == &PyFrozenSet_Type)
+#define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_CheckExact(ob) \
-	(Py_Type(ob) == &PySet_Type || Py_Type(ob) == &PyFrozenSet_Type)
+	(Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_Check(ob) \
-	(Py_Type(ob) == &PySet_Type || Py_Type(ob) == &PyFrozenSet_Type || \
-	  PyType_IsSubtype(Py_Type(ob), &PySet_Type) || \
-	  PyType_IsSubtype(Py_Type(ob), &PyFrozenSet_Type))
+	(Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
+	  PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
+	  PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
 
 PyAPI_FUNC(PyObject *) PySet_New(PyObject *);
 PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *);
diff --git a/Include/sliceobject.h b/Include/sliceobject.h
index 21bc025..dfc30c7 100644
--- a/Include/sliceobject.h
+++ b/Include/sliceobject.h
@@ -26,7 +26,7 @@ typedef struct {
 
 PyAPI_DATA(PyTypeObject) PySlice_Type;
 
-#define PySlice_Check(op) (Py_Type(op) == &PySlice_Type)
+#define PySlice_Check(op) (Py_TYPE(op) == &PySlice_Type)
 
 PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop,
                                   PyObject* step);
diff --git a/Include/stringobject.h b/Include/stringobject.h
index 6a63576..c1a5114 100644
--- a/Include/stringobject.h
+++ b/Include/stringobject.h
@@ -43,8 +43,8 @@ PyAPI_DATA(PyTypeObject) PyString_Type;
 PyAPI_DATA(PyTypeObject) PyStringIter_Type;
 
 #define PyString_Check(op) \
-                 PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_STRING_SUBCLASS)
-#define PyString_CheckExact(op) (Py_Type(op) == &PyString_Type)
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_STRING_SUBCLASS)
+#define PyString_CheckExact(op) (Py_TYPE(op) == &PyString_Type)
 
 PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, Py_ssize_t);
 PyAPI_FUNC(PyObject *) PyString_FromString(const char *);
@@ -68,7 +68,7 @@ PyAPI_FUNC(PyObject *) PyString_DecodeEscape(const char *, Py_ssize_t,
 /* Macro, trading safety for speed */
 #define PyString_AS_STRING(op) (assert(PyString_Check(op)), \
                                 (((PyStringObject *)(op))->ob_sval))
-#define PyString_GET_SIZE(op)  (assert(PyString_Check(op)),Py_Size(op))
+#define PyString_GET_SIZE(op)  (assert(PyString_Check(op)),Py_SIZE(op))
 
 /* _PyString_Join(sep, x) is like sep.join(x).  sep must be PyStringObject*,
    x must be an iterable object. */
diff --git a/Include/symtable.h b/Include/symtable.h
index 12efd7f..8c1dc41 100644
--- a/Include/symtable.h
+++ b/Include/symtable.h
@@ -53,7 +53,7 @@ typedef struct _symtable_entry {
 
 PyAPI_DATA(PyTypeObject) PySTEntry_Type;
 
-#define PySTEntry_Check(op) (Py_Type(op) == &PySTEntry_Type)
+#define PySTEntry_Check(op) (Py_TYPE(op) == &PySTEntry_Type)
 
 PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *);
 
diff --git a/Include/traceback.h b/Include/traceback.h
index 4c7b8cc..0b3bfae 100644
--- a/Include/traceback.h
+++ b/Include/traceback.h
@@ -22,7 +22,7 @@ PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *);
 
 /* Reveal traceback type so we can typecheck traceback objects */
 PyAPI_DATA(PyTypeObject) PyTraceBack_Type;
-#define PyTraceBack_Check(v) (Py_Type(v) == &PyTraceBack_Type)
+#define PyTraceBack_Check(v) (Py_TYPE(v) == &PyTraceBack_Type)
 
 #ifdef __cplusplus
 }
diff --git a/Include/tupleobject.h b/Include/tupleobject.h
index 7e9cdb5..018ef2f 100644
--- a/Include/tupleobject.h
+++ b/Include/tupleobject.h
@@ -35,8 +35,8 @@ PyAPI_DATA(PyTypeObject) PyTuple_Type;
 PyAPI_DATA(PyTypeObject) PyTupleIter_Type;
 
 #define PyTuple_Check(op) \
-                 PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_TUPLE_SUBCLASS)
-#define PyTuple_CheckExact(op) (Py_Type(op) == &PyTuple_Type)
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS)
+#define PyTuple_CheckExact(op) (Py_TYPE(op) == &PyTuple_Type)
 
 PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size);
 PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *);
@@ -48,7 +48,7 @@ PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...);
 
 /* Macro, trading safety for speed */
 #define PyTuple_GET_ITEM(op, i) (((PyTupleObject *)(op))->ob_item[i])
-#define PyTuple_GET_SIZE(op)    Py_Size(op)
+#define PyTuple_GET_SIZE(op)    Py_SIZE(op)
 
 /* Macro, *only* to be used to fill in brand new tuples */
 #define PyTuple_SET_ITEM(op, i, v) (((PyTupleObject *)(op))->ob_item[i] = v)
diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h
index 4e94f76..8a4e6a2 100644
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -424,8 +424,8 @@ PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type;
 #define SSTATE_INTERNED_IMMORTAL 2
 
 #define PyUnicode_Check(op) \
-                 PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_UNICODE_SUBCLASS)
-#define PyUnicode_CheckExact(op) (Py_Type(op) == &PyUnicode_Type)
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS)
+#define PyUnicode_CheckExact(op) (Py_TYPE(op) == &PyUnicode_Type)
 
 /* Fast access macros */
 #define PyUnicode_GET_SIZE(op) \
diff --git a/Include/weakrefobject.h b/Include/weakrefobject.h
index e58c352..f15c9d9c 100644
--- a/Include/weakrefobject.h
+++ b/Include/weakrefobject.h
@@ -44,10 +44,10 @@ PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType;
 
 #define PyWeakref_CheckRef(op) PyObject_TypeCheck(op, &_PyWeakref_RefType)
 #define PyWeakref_CheckRefExact(op) \
-        (Py_Type(op) == &_PyWeakref_RefType)
+        (Py_TYPE(op) == &_PyWeakref_RefType)
 #define PyWeakref_CheckProxy(op) \
-        ((Py_Type(op) == &_PyWeakref_ProxyType) || \
-         (Py_Type(op) == &_PyWeakref_CallableProxyType))
+        ((Py_TYPE(op) == &_PyWeakref_ProxyType) || \
+         (Py_TYPE(op) == &_PyWeakref_CallableProxyType))
 
 /* This macro calls PyWeakref_CheckRef() last since that can involve a
    function call; this makes it more likely that the function call
diff --git a/Mac/Modules/MacOS.c b/Mac/Modules/MacOS.c
index 350975b..7ba1dd6 100644
--- a/Mac/Modules/MacOS.c
+++ b/Mac/Modules/MacOS.c
@@ -609,7 +609,7 @@ initMacOS(void)
 	MacOS_Error = PyMac_GetOSErrException();
 	if (MacOS_Error == NULL || PyDict_SetItemString(d, "Error", MacOS_Error) != 0)
 		return;
-	Py_Type(&Rftype) = &PyType_Type;
+	Py_TYPE(&Rftype) = &PyType_Type;
 	Py_INCREF(&Rftype);
 	if (PyDict_SetItemString(d, "ResourceForkType", (PyObject *)&Rftype) != 0)
 		return;
diff --git a/Mac/Modules/ae/_AEmodule.c b/Mac/Modules/ae/_AEmodule.c
index 37c0b7c..9a4de36 100644
--- a/Mac/Modules/ae/_AEmodule.c
+++ b/Mac/Modules/ae/_AEmodule.c
@@ -47,7 +47,7 @@ static PyObject *AE_Error;
 
 PyTypeObject AEDesc_Type;
 
-#define AEDesc_Check(x) (Py_Type(x) == &AEDesc_Type || PyObject_TypeCheck((x), &AEDesc_Type))
+#define AEDesc_Check(x) (Py_TYPE(x) == &AEDesc_Type || PyObject_TypeCheck((x), &AEDesc_Type))
 
 typedef struct AEDescObject {
 	PyObject_HEAD
@@ -79,7 +79,7 @@ int AEDesc_Convert(PyObject *v, AEDesc *p_itself)
 static void AEDesc_dealloc(AEDescObject *self)
 {
 	if (self->ob_owned) AEDisposeDesc(&self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *AEDesc_AECoerceDesc(AEDescObject *_self, PyObject *_args)
@@ -1440,7 +1440,7 @@ void init_AE(void)
 	if (AE_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", AE_Error) != 0)
 		return;
-	Py_Type(&AEDesc_Type) = &PyType_Type;
+	Py_TYPE(&AEDesc_Type) = &PyType_Type;
 	if (PyType_Ready(&AEDesc_Type) < 0) return;
 	Py_INCREF(&AEDesc_Type);
 	PyModule_AddObject(m, "AEDesc", (PyObject *)&AEDesc_Type);
diff --git a/Mac/Modules/app/_Appmodule.c b/Mac/Modules/app/_Appmodule.c
index 6e0a38b..782df63 100644
--- a/Mac/Modules/app/_Appmodule.c
+++ b/Mac/Modules/app/_Appmodule.c
@@ -30,7 +30,7 @@ static PyObject *App_Error;
 
 PyTypeObject ThemeDrawingState_Type;
 
-#define ThemeDrawingStateObj_Check(x) (Py_Type(x) == &ThemeDrawingState_Type || PyObject_TypeCheck((x), &ThemeDrawingState_Type))
+#define ThemeDrawingStateObj_Check(x) (Py_TYPE(x) == &ThemeDrawingState_Type || PyObject_TypeCheck((x), &ThemeDrawingState_Type))
 
 typedef struct ThemeDrawingStateObject {
 	PyObject_HEAD
@@ -60,7 +60,7 @@ int ThemeDrawingStateObj_Convert(PyObject *v, ThemeDrawingState *p_itself)
 static void ThemeDrawingStateObj_dealloc(ThemeDrawingStateObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *ThemeDrawingStateObj_SetThemeDrawingState(ThemeDrawingStateObject *_self, PyObject *_args)
@@ -1807,7 +1807,7 @@ void init_App(void)
 	if (App_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", App_Error) != 0)
 		return;
-	Py_Type(&ThemeDrawingState_Type) = &PyType_Type;
+	Py_TYPE(&ThemeDrawingState_Type) = &PyType_Type;
 	if (PyType_Ready(&ThemeDrawingState_Type) < 0) return;
 	Py_INCREF(&ThemeDrawingState_Type);
 	PyModule_AddObject(m, "ThemeDrawingState", (PyObject *)&ThemeDrawingState_Type);
diff --git a/Mac/Modules/carbonevt/_CarbonEvtmodule.c b/Mac/Modules/carbonevt/_CarbonEvtmodule.c
index 725dae3..df7284b 100755
--- a/Mac/Modules/carbonevt/_CarbonEvtmodule.c
+++ b/Mac/Modules/carbonevt/_CarbonEvtmodule.c
@@ -151,7 +151,7 @@ int EventRef_Convert(PyObject *v, EventRef *p_itself)
 static void EventRef_dealloc(EventRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventRef_RetainEvent(EventRefObject *_self, PyObject *_args)
@@ -495,7 +495,7 @@ int EventQueueRef_Convert(PyObject *v, EventQueueRef *p_itself)
 static void EventQueueRef_dealloc(EventQueueRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventQueueRef_PostEventToQueue(EventQueueRefObject *_self, PyObject *_args)
@@ -715,7 +715,7 @@ int EventLoopRef_Convert(PyObject *v, EventLoopRef *p_itself)
 static void EventLoopRef_dealloc(EventLoopRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject *_args)
@@ -844,7 +844,7 @@ int EventLoopTimerRef_Convert(PyObject *v, EventLoopTimerRef *p_itself)
 static void EventLoopTimerRef_dealloc(EventLoopTimerRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventLoopTimerRef_RemoveEventLoopTimer(EventLoopTimerRefObject *_self, PyObject *_args)
@@ -996,7 +996,7 @@ static void EventHandlerRef_dealloc(EventHandlerRefObject *self)
 		RemoveEventHandler(self->ob_itself);
 		Py_DECREF(self->ob_callback);
 	}
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject *_self, PyObject *_args)
@@ -1183,7 +1183,7 @@ int EventHandlerCallRef_Convert(PyObject *v, EventHandlerCallRef *p_itself)
 static void EventHandlerCallRef_dealloc(EventHandlerCallRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObject *_self, PyObject *_args)
@@ -1315,7 +1315,7 @@ int EventTargetRef_Convert(PyObject *v, EventTargetRef *p_itself)
 static void EventTargetRef_dealloc(EventTargetRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventTargetRef_InstallStandardEventHandler(EventTargetRefObject *_self, PyObject *_args)
@@ -1469,7 +1469,7 @@ int EventHotKeyRef_Convert(PyObject *v, EventHotKeyRef *p_itself)
 static void EventHotKeyRef_dealloc(EventHotKeyRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_self, PyObject *_args)
@@ -2152,56 +2152,56 @@ void init_CarbonEvt(void)
 	if (CarbonEvents_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", CarbonEvents_Error) != 0)
 		return;
-	Py_Type(&EventRef_Type) = &PyType_Type;
+	Py_TYPE(&EventRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventRef_Type) < 0) return;
 	Py_INCREF(&EventRef_Type);
 	PyModule_AddObject(m, "EventRef", (PyObject *)&EventRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&EventRef_Type);
 	PyModule_AddObject(m, "EventRefType", (PyObject *)&EventRef_Type);
-	Py_Type(&EventQueueRef_Type) = &PyType_Type;
+	Py_TYPE(&EventQueueRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventQueueRef_Type) < 0) return;
 	Py_INCREF(&EventQueueRef_Type);
 	PyModule_AddObject(m, "EventQueueRef", (PyObject *)&EventQueueRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&EventQueueRef_Type);
 	PyModule_AddObject(m, "EventQueueRefType", (PyObject *)&EventQueueRef_Type);
-	Py_Type(&EventLoopRef_Type) = &PyType_Type;
+	Py_TYPE(&EventLoopRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventLoopRef_Type) < 0) return;
 	Py_INCREF(&EventLoopRef_Type);
 	PyModule_AddObject(m, "EventLoopRef", (PyObject *)&EventLoopRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&EventLoopRef_Type);
 	PyModule_AddObject(m, "EventLoopRefType", (PyObject *)&EventLoopRef_Type);
-	Py_Type(&EventLoopTimerRef_Type) = &PyType_Type;
+	Py_TYPE(&EventLoopTimerRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventLoopTimerRef_Type) < 0) return;
 	Py_INCREF(&EventLoopTimerRef_Type);
 	PyModule_AddObject(m, "EventLoopTimerRef", (PyObject *)&EventLoopTimerRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&EventLoopTimerRef_Type);
 	PyModule_AddObject(m, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type);
-	Py_Type(&EventHandlerRef_Type) = &PyType_Type;
+	Py_TYPE(&EventHandlerRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventHandlerRef_Type) < 0) return;
 	Py_INCREF(&EventHandlerRef_Type);
 	PyModule_AddObject(m, "EventHandlerRef", (PyObject *)&EventHandlerRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&EventHandlerRef_Type);
 	PyModule_AddObject(m, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type);
-	Py_Type(&EventHandlerCallRef_Type) = &PyType_Type;
+	Py_TYPE(&EventHandlerCallRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventHandlerCallRef_Type) < 0) return;
 	Py_INCREF(&EventHandlerCallRef_Type);
 	PyModule_AddObject(m, "EventHandlerCallRef", (PyObject *)&EventHandlerCallRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&EventHandlerCallRef_Type);
 	PyModule_AddObject(m, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type);
-	Py_Type(&EventTargetRef_Type) = &PyType_Type;
+	Py_TYPE(&EventTargetRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventTargetRef_Type) < 0) return;
 	Py_INCREF(&EventTargetRef_Type);
 	PyModule_AddObject(m, "EventTargetRef", (PyObject *)&EventTargetRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&EventTargetRef_Type);
 	PyModule_AddObject(m, "EventTargetRefType", (PyObject *)&EventTargetRef_Type);
-	Py_Type(&EventHotKeyRef_Type) = &PyType_Type;
+	Py_TYPE(&EventHotKeyRef_Type) = &PyType_Type;
 	if (PyType_Ready(&EventHotKeyRef_Type) < 0) return;
 	Py_INCREF(&EventHotKeyRef_Type);
 	PyModule_AddObject(m, "EventHotKeyRef", (PyObject *)&EventHotKeyRef_Type);
diff --git a/Mac/Modules/cf/_CFmodule.c b/Mac/Modules/cf/_CFmodule.c
index 691a636..473e649 100644
--- a/Mac/Modules/cf/_CFmodule.c
+++ b/Mac/Modules/cf/_CFmodule.c
@@ -116,7 +116,7 @@ static PyObject *CF_Error;
 
 PyTypeObject CFTypeRef_Type;
 
-#define CFTypeRefObj_Check(x) (Py_Type(x) == &CFTypeRef_Type || PyObject_TypeCheck((x), &CFTypeRef_Type))
+#define CFTypeRefObj_Check(x) (Py_TYPE(x) == &CFTypeRef_Type || PyObject_TypeCheck((x), &CFTypeRef_Type))
 
 typedef struct CFTypeRefObject {
 	PyObject_HEAD
@@ -161,7 +161,7 @@ static void CFTypeRefObj_dealloc(CFTypeRefObject *self)
 		self->ob_freeit((CFTypeRef)self->ob_itself);
 		self->ob_itself = NULL;
 	}
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args)
@@ -477,7 +477,7 @@ PyTypeObject CFTypeRef_Type = {
 
 PyTypeObject CFArrayRef_Type;
 
-#define CFArrayRefObj_Check(x) (Py_Type(x) == &CFArrayRef_Type || PyObject_TypeCheck((x), &CFArrayRef_Type))
+#define CFArrayRefObj_Check(x) (Py_TYPE(x) == &CFArrayRef_Type || PyObject_TypeCheck((x), &CFArrayRef_Type))
 
 typedef struct CFArrayRefObject {
 	PyObject_HEAD
@@ -687,7 +687,7 @@ PyTypeObject CFArrayRef_Type = {
 
 PyTypeObject CFMutableArrayRef_Type;
 
-#define CFMutableArrayRefObj_Check(x) (Py_Type(x) == &CFMutableArrayRef_Type || PyObject_TypeCheck((x), &CFMutableArrayRef_Type))
+#define CFMutableArrayRefObj_Check(x) (Py_TYPE(x) == &CFMutableArrayRef_Type || PyObject_TypeCheck((x), &CFMutableArrayRef_Type))
 
 typedef struct CFMutableArrayRefObject {
 	PyObject_HEAD
@@ -926,7 +926,7 @@ PyTypeObject CFMutableArrayRef_Type = {
 
 PyTypeObject CFDictionaryRef_Type;
 
-#define CFDictionaryRefObj_Check(x) (Py_Type(x) == &CFDictionaryRef_Type || PyObject_TypeCheck((x), &CFDictionaryRef_Type))
+#define CFDictionaryRefObj_Check(x) (Py_TYPE(x) == &CFDictionaryRef_Type || PyObject_TypeCheck((x), &CFDictionaryRef_Type))
 
 typedef struct CFDictionaryRefObject {
 	PyObject_HEAD
@@ -1118,7 +1118,7 @@ PyTypeObject CFDictionaryRef_Type = {
 
 PyTypeObject CFMutableDictionaryRef_Type;
 
-#define CFMutableDictionaryRefObj_Check(x) (Py_Type(x) == &CFMutableDictionaryRef_Type || PyObject_TypeCheck((x), &CFMutableDictionaryRef_Type))
+#define CFMutableDictionaryRefObj_Check(x) (Py_TYPE(x) == &CFMutableDictionaryRef_Type || PyObject_TypeCheck((x), &CFMutableDictionaryRef_Type))
 
 typedef struct CFMutableDictionaryRefObject {
 	PyObject_HEAD
@@ -1294,7 +1294,7 @@ PyTypeObject CFMutableDictionaryRef_Type = {
 
 PyTypeObject CFDataRef_Type;
 
-#define CFDataRefObj_Check(x) (Py_Type(x) == &CFDataRef_Type || PyObject_TypeCheck((x), &CFDataRef_Type))
+#define CFDataRefObj_Check(x) (Py_TYPE(x) == &CFDataRef_Type || PyObject_TypeCheck((x), &CFDataRef_Type))
 
 typedef struct CFDataRefObject {
 	PyObject_HEAD
@@ -1524,7 +1524,7 @@ PyTypeObject CFDataRef_Type = {
 
 PyTypeObject CFMutableDataRef_Type;
 
-#define CFMutableDataRefObj_Check(x) (Py_Type(x) == &CFMutableDataRef_Type || PyObject_TypeCheck((x), &CFMutableDataRef_Type))
+#define CFMutableDataRefObj_Check(x) (Py_TYPE(x) == &CFMutableDataRef_Type || PyObject_TypeCheck((x), &CFMutableDataRef_Type))
 
 typedef struct CFMutableDataRefObject {
 	PyObject_HEAD
@@ -1788,7 +1788,7 @@ PyTypeObject CFMutableDataRef_Type = {
 
 PyTypeObject CFStringRef_Type;
 
-#define CFStringRefObj_Check(x) (Py_Type(x) == &CFStringRef_Type || PyObject_TypeCheck((x), &CFStringRef_Type))
+#define CFStringRefObj_Check(x) (Py_TYPE(x) == &CFStringRef_Type || PyObject_TypeCheck((x), &CFStringRef_Type))
 
 typedef struct CFStringRefObject {
 	PyObject_HEAD
@@ -2530,7 +2530,7 @@ PyTypeObject CFStringRef_Type = {
 
 PyTypeObject CFMutableStringRef_Type;
 
-#define CFMutableStringRefObj_Check(x) (Py_Type(x) == &CFMutableStringRef_Type || PyObject_TypeCheck((x), &CFMutableStringRef_Type))
+#define CFMutableStringRefObj_Check(x) (Py_TYPE(x) == &CFMutableStringRef_Type || PyObject_TypeCheck((x), &CFMutableStringRef_Type))
 
 typedef struct CFMutableStringRefObject {
 	PyObject_HEAD
@@ -2917,7 +2917,7 @@ PyTypeObject CFMutableStringRef_Type = {
 
 PyTypeObject CFURLRef_Type;
 
-#define CFURLRefObj_Check(x) (Py_Type(x) == &CFURLRef_Type || PyObject_TypeCheck((x), &CFURLRef_Type))
+#define CFURLRefObj_Check(x) (Py_TYPE(x) == &CFURLRef_Type || PyObject_TypeCheck((x), &CFURLRef_Type))
 
 typedef struct CFURLRefObject {
 	PyObject_HEAD
@@ -4890,14 +4890,14 @@ void init_CF(void)
 	if (CF_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", CF_Error) != 0)
 		return;
-	Py_Type(&CFTypeRef_Type) = &PyType_Type;
+	Py_TYPE(&CFTypeRef_Type) = &PyType_Type;
 	if (PyType_Ready(&CFTypeRef_Type) < 0) return;
 	Py_INCREF(&CFTypeRef_Type);
 	PyModule_AddObject(m, "CFTypeRef", (PyObject *)&CFTypeRef_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&CFTypeRef_Type);
 	PyModule_AddObject(m, "CFTypeRefType", (PyObject *)&CFTypeRef_Type);
-	Py_Type(&CFArrayRef_Type) = &PyType_Type;
+	Py_TYPE(&CFArrayRef_Type) = &PyType_Type;
 	CFArrayRef_Type.tp_base = &CFTypeRef_Type;
 	if (PyType_Ready(&CFArrayRef_Type) < 0) return;
 	Py_INCREF(&CFArrayRef_Type);
@@ -4905,7 +4905,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFArrayRef_Type);
 	PyModule_AddObject(m, "CFArrayRefType", (PyObject *)&CFArrayRef_Type);
-	Py_Type(&CFMutableArrayRef_Type) = &PyType_Type;
+	Py_TYPE(&CFMutableArrayRef_Type) = &PyType_Type;
 	CFMutableArrayRef_Type.tp_base = &CFArrayRef_Type;
 	if (PyType_Ready(&CFMutableArrayRef_Type) < 0) return;
 	Py_INCREF(&CFMutableArrayRef_Type);
@@ -4913,7 +4913,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFMutableArrayRef_Type);
 	PyModule_AddObject(m, "CFMutableArrayRefType", (PyObject *)&CFMutableArrayRef_Type);
-	Py_Type(&CFDictionaryRef_Type) = &PyType_Type;
+	Py_TYPE(&CFDictionaryRef_Type) = &PyType_Type;
 	CFDictionaryRef_Type.tp_base = &CFTypeRef_Type;
 	if (PyType_Ready(&CFDictionaryRef_Type) < 0) return;
 	Py_INCREF(&CFDictionaryRef_Type);
@@ -4921,7 +4921,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFDictionaryRef_Type);
 	PyModule_AddObject(m, "CFDictionaryRefType", (PyObject *)&CFDictionaryRef_Type);
-	Py_Type(&CFMutableDictionaryRef_Type) = &PyType_Type;
+	Py_TYPE(&CFMutableDictionaryRef_Type) = &PyType_Type;
 	CFMutableDictionaryRef_Type.tp_base = &CFDictionaryRef_Type;
 	if (PyType_Ready(&CFMutableDictionaryRef_Type) < 0) return;
 	Py_INCREF(&CFMutableDictionaryRef_Type);
@@ -4929,7 +4929,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFMutableDictionaryRef_Type);
 	PyModule_AddObject(m, "CFMutableDictionaryRefType", (PyObject *)&CFMutableDictionaryRef_Type);
-	Py_Type(&CFDataRef_Type) = &PyType_Type;
+	Py_TYPE(&CFDataRef_Type) = &PyType_Type;
 	CFDataRef_Type.tp_base = &CFTypeRef_Type;
 	if (PyType_Ready(&CFDataRef_Type) < 0) return;
 	Py_INCREF(&CFDataRef_Type);
@@ -4937,7 +4937,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFDataRef_Type);
 	PyModule_AddObject(m, "CFDataRefType", (PyObject *)&CFDataRef_Type);
-	Py_Type(&CFMutableDataRef_Type) = &PyType_Type;
+	Py_TYPE(&CFMutableDataRef_Type) = &PyType_Type;
 	CFMutableDataRef_Type.tp_base = &CFDataRef_Type;
 	if (PyType_Ready(&CFMutableDataRef_Type) < 0) return;
 	Py_INCREF(&CFMutableDataRef_Type);
@@ -4945,7 +4945,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFMutableDataRef_Type);
 	PyModule_AddObject(m, "CFMutableDataRefType", (PyObject *)&CFMutableDataRef_Type);
-	Py_Type(&CFStringRef_Type) = &PyType_Type;
+	Py_TYPE(&CFStringRef_Type) = &PyType_Type;
 	CFStringRef_Type.tp_base = &CFTypeRef_Type;
 	if (PyType_Ready(&CFStringRef_Type) < 0) return;
 	Py_INCREF(&CFStringRef_Type);
@@ -4953,7 +4953,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFStringRef_Type);
 	PyModule_AddObject(m, "CFStringRefType", (PyObject *)&CFStringRef_Type);
-	Py_Type(&CFMutableStringRef_Type) = &PyType_Type;
+	Py_TYPE(&CFMutableStringRef_Type) = &PyType_Type;
 	CFMutableStringRef_Type.tp_base = &CFStringRef_Type;
 	if (PyType_Ready(&CFMutableStringRef_Type) < 0) return;
 	Py_INCREF(&CFMutableStringRef_Type);
@@ -4961,7 +4961,7 @@ void init_CF(void)
 	/* Backward-compatible name */
 	Py_INCREF(&CFMutableStringRef_Type);
 	PyModule_AddObject(m, "CFMutableStringRefType", (PyObject *)&CFMutableStringRef_Type);
-	Py_Type(&CFURLRef_Type) = &PyType_Type;
+	Py_TYPE(&CFURLRef_Type) = &PyType_Type;
 	CFURLRef_Type.tp_base = &CFTypeRef_Type;
 	if (PyType_Ready(&CFURLRef_Type) < 0) return;
 	Py_INCREF(&CFURLRef_Type);
diff --git a/Mac/Modules/cg/_CGmodule.c b/Mac/Modules/cg/_CGmodule.c
index bcfe7b0..67c6bad 100755
--- a/Mac/Modules/cg/_CGmodule.c
+++ b/Mac/Modules/cg/_CGmodule.c
@@ -95,7 +95,7 @@ static PyObject *CG_Error;
 
 PyTypeObject CGContextRef_Type;
 
-#define CGContextRefObj_Check(x) (Py_Type(x) == &CGContextRef_Type || PyObject_TypeCheck((x), &CGContextRef_Type))
+#define CGContextRefObj_Check(x) (Py_TYPE(x) == &CGContextRef_Type || PyObject_TypeCheck((x), &CGContextRef_Type))
 
 typedef struct CGContextRefObject {
 	PyObject_HEAD
@@ -125,7 +125,7 @@ int CGContextRefObj_Convert(PyObject *v, CGContextRef *p_itself)
 static void CGContextRefObj_dealloc(CGContextRefObject *self)
 {
 	CGContextRelease(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *CGContextRefObj_CGContextSaveGState(CGContextRefObject *_self, PyObject *_args)
@@ -1294,7 +1294,7 @@ void init_CG(void)
 	if (CG_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", CG_Error) != 0)
 		return;
-	Py_Type(&CGContextRef_Type) = &PyType_Type;
+	Py_TYPE(&CGContextRef_Type) = &PyType_Type;
 	if (PyType_Ready(&CGContextRef_Type) < 0) return;
 	Py_INCREF(&CGContextRef_Type);
 	PyModule_AddObject(m, "CGContextRef", (PyObject *)&CGContextRef_Type);
diff --git a/Mac/Modules/cm/_Cmmodule.c b/Mac/Modules/cm/_Cmmodule.c
index 9c74482..c445981 100644
--- a/Mac/Modules/cm/_Cmmodule.c
+++ b/Mac/Modules/cm/_Cmmodule.c
@@ -60,7 +60,7 @@ static PyObject *Cm_Error;
 
 PyTypeObject ComponentInstance_Type;
 
-#define CmpInstObj_Check(x) (Py_Type(x) == &ComponentInstance_Type || PyObject_TypeCheck((x), &ComponentInstance_Type))
+#define CmpInstObj_Check(x) (Py_TYPE(x) == &ComponentInstance_Type || PyObject_TypeCheck((x), &ComponentInstance_Type))
 
 typedef struct ComponentInstanceObject {
 	PyObject_HEAD
@@ -94,7 +94,7 @@ int CmpInstObj_Convert(PyObject *v, ComponentInstance *p_itself)
 static void CmpInstObj_dealloc(ComponentInstanceObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *CmpInstObj_CloseComponent(ComponentInstanceObject *_self, PyObject *_args)
@@ -326,7 +326,7 @@ PyTypeObject ComponentInstance_Type = {
 
 PyTypeObject Component_Type;
 
-#define CmpObj_Check(x) (Py_Type(x) == &Component_Type || PyObject_TypeCheck((x), &Component_Type))
+#define CmpObj_Check(x) (Py_TYPE(x) == &Component_Type || PyObject_TypeCheck((x), &Component_Type))
 
 typedef struct ComponentObject {
 	PyObject_HEAD
@@ -365,7 +365,7 @@ int CmpObj_Convert(PyObject *v, Component *p_itself)
 static void CmpObj_dealloc(ComponentObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *CmpObj_UnregisterComponent(ComponentObject *_self, PyObject *_args)
@@ -925,14 +925,14 @@ void init_Cm(void)
 	if (Cm_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Cm_Error) != 0)
 		return;
-	Py_Type(&ComponentInstance_Type) = &PyType_Type;
+	Py_TYPE(&ComponentInstance_Type) = &PyType_Type;
 	if (PyType_Ready(&ComponentInstance_Type) < 0) return;
 	Py_INCREF(&ComponentInstance_Type);
 	PyModule_AddObject(m, "ComponentInstance", (PyObject *)&ComponentInstance_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&ComponentInstance_Type);
 	PyModule_AddObject(m, "ComponentInstanceType", (PyObject *)&ComponentInstance_Type);
-	Py_Type(&Component_Type) = &PyType_Type;
+	Py_TYPE(&Component_Type) = &PyType_Type;
 	if (PyType_Ready(&Component_Type) < 0) return;
 	Py_INCREF(&Component_Type);
 	PyModule_AddObject(m, "Component", (PyObject *)&Component_Type);
diff --git a/Mac/Modules/ctl/_Ctlmodule.c b/Mac/Modules/ctl/_Ctlmodule.c
index f872b82..38ca1d1 100644
--- a/Mac/Modules/ctl/_Ctlmodule.c
+++ b/Mac/Modules/ctl/_Ctlmodule.c
@@ -135,7 +135,7 @@ static PyObject *Ctl_Error;
 
 PyTypeObject Control_Type;
 
-#define CtlObj_Check(x) (Py_Type(x) == &Control_Type || PyObject_TypeCheck((x), &Control_Type))
+#define CtlObj_Check(x) (Py_TYPE(x) == &Control_Type || PyObject_TypeCheck((x), &Control_Type))
 
 typedef struct ControlObject {
 	PyObject_HEAD
@@ -170,7 +170,7 @@ static void CtlObj_dealloc(ControlObject *self)
 {
 	Py_XDECREF(self->ob_callbackdict);
 	if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *CtlObj_HiliteControl(ControlObject *_self, PyObject *_args)
@@ -5790,7 +5790,7 @@ void init_Ctl(void)
 	if (Ctl_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Ctl_Error) != 0)
 		return;
-	Py_Type(&Control_Type) = &PyType_Type;
+	Py_TYPE(&Control_Type) = &PyType_Type;
 	if (PyType_Ready(&Control_Type) < 0) return;
 	Py_INCREF(&Control_Type);
 	PyModule_AddObject(m, "Control", (PyObject *)&Control_Type);
diff --git a/Mac/Modules/dlg/_Dlgmodule.c b/Mac/Modules/dlg/_Dlgmodule.c
index 1a56325..866b357 100644
--- a/Mac/Modules/dlg/_Dlgmodule.c
+++ b/Mac/Modules/dlg/_Dlgmodule.c
@@ -129,7 +129,7 @@ static PyObject *Dlg_Error;
 
 PyTypeObject Dialog_Type;
 
-#define DlgObj_Check(x) (Py_Type(x) == &Dialog_Type || PyObject_TypeCheck((x), &Dialog_Type))
+#define DlgObj_Check(x) (Py_TYPE(x) == &Dialog_Type || PyObject_TypeCheck((x), &Dialog_Type))
 
 typedef struct DialogObject {
 	PyObject_HEAD
@@ -164,7 +164,7 @@ int DlgObj_Convert(PyObject *v, DialogPtr *p_itself)
 static void DlgObj_dealloc(DialogObject *self)
 {
 	DisposeDialog(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *DlgObj_DrawDialog(DialogObject *_self, PyObject *_args)
@@ -1582,7 +1582,7 @@ void init_Dlg(void)
 	if (Dlg_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Dlg_Error) != 0)
 		return;
-	Py_Type(&Dialog_Type) = &PyType_Type;
+	Py_TYPE(&Dialog_Type) = &PyType_Type;
 	if (PyType_Ready(&Dialog_Type) < 0) return;
 	Py_INCREF(&Dialog_Type);
 	PyModule_AddObject(m, "Dialog", (PyObject *)&Dialog_Type);
diff --git a/Mac/Modules/drag/_Dragmodule.c b/Mac/Modules/drag/_Dragmodule.c
index 5c03703..ce2c034 100644
--- a/Mac/Modules/drag/_Dragmodule.c
+++ b/Mac/Modules/drag/_Dragmodule.c
@@ -40,7 +40,7 @@ static PyObject *Drag_Error;
 
 PyTypeObject DragObj_Type;
 
-#define DragObj_Check(x) (Py_Type(x) == &DragObj_Type || PyObject_TypeCheck((x), &DragObj_Type))
+#define DragObj_Check(x) (Py_TYPE(x) == &DragObj_Type || PyObject_TypeCheck((x), &DragObj_Type))
 
 typedef struct DragObjObject {
 	PyObject_HEAD
@@ -76,7 +76,7 @@ int DragObj_Convert(PyObject *v, DragRef *p_itself)
 static void DragObj_dealloc(DragObjObject *self)
 {
 	Py_XDECREF(self->sendproc);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *DragObj_DisposeDrag(DragObjObject *_self, PyObject *_args)
@@ -1125,7 +1125,7 @@ void init_Drag(void)
 	if (Drag_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Drag_Error) != 0)
 		return;
-	Py_Type(&DragObj_Type) = &PyType_Type;
+	Py_TYPE(&DragObj_Type) = &PyType_Type;
 	if (PyType_Ready(&DragObj_Type) < 0) return;
 	Py_INCREF(&DragObj_Type);
 	PyModule_AddObject(m, "DragObj", (PyObject *)&DragObj_Type);
diff --git a/Mac/Modules/file/_Filemodule.c b/Mac/Modules/file/_Filemodule.c
index ffc16d5..4125dba 100644
--- a/Mac/Modules/file/_Filemodule.c
+++ b/Mac/Modules/file/_Filemodule.c
@@ -143,7 +143,7 @@ static PyObject *File_Error;
 
 static PyTypeObject FSCatalogInfo_Type;
 
-#define FSCatalogInfo_Check(x) (Py_Type(x) == &FSCatalogInfo_Type || PyObject_TypeCheck((x), &FSCatalogInfo_Type))
+#define FSCatalogInfo_Check(x) (Py_TYPE(x) == &FSCatalogInfo_Type || PyObject_TypeCheck((x), &FSCatalogInfo_Type))
 
 typedef struct FSCatalogInfoObject {
 	PyObject_HEAD
@@ -174,7 +174,7 @@ static int FSCatalogInfo_Convert(PyObject *v, FSCatalogInfo *p_itself)
 static void FSCatalogInfo_dealloc(FSCatalogInfoObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyMethodDef FSCatalogInfo_methods[] = {
@@ -502,7 +502,7 @@ static PyTypeObject FSCatalogInfo_Type = {
 
 static PyTypeObject FInfo_Type;
 
-#define FInfo_Check(x) (Py_Type(x) == &FInfo_Type || PyObject_TypeCheck((x), &FInfo_Type))
+#define FInfo_Check(x) (Py_TYPE(x) == &FInfo_Type || PyObject_TypeCheck((x), &FInfo_Type))
 
 typedef struct FInfoObject {
 	PyObject_HEAD
@@ -533,7 +533,7 @@ static int FInfo_Convert(PyObject *v, FInfo *p_itself)
 static void FInfo_dealloc(FInfoObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyMethodDef FInfo_methods[] = {
@@ -687,7 +687,7 @@ static PyTypeObject FInfo_Type = {
 
 static PyTypeObject Alias_Type;
 
-#define Alias_Check(x) (Py_Type(x) == &Alias_Type || PyObject_TypeCheck((x), &Alias_Type))
+#define Alias_Check(x) (Py_TYPE(x) == &Alias_Type || PyObject_TypeCheck((x), &Alias_Type))
 
 typedef struct AliasObject {
 	PyObject_HEAD
@@ -724,7 +724,7 @@ static void Alias_dealloc(AliasObject *self)
 		self->ob_freeit(self->ob_itself);
 	}
 	self->ob_itself = NULL;
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *Alias_ResolveAlias(AliasObject *_self, PyObject *_args)
@@ -1053,7 +1053,7 @@ static PyObject *FSSpec_New(FSSpec *itself)
 static void FSSpec_dealloc(FSSpecObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *FSSpec_FSpOpenDF(FSSpecObject *_self, PyObject *_args)
@@ -1386,7 +1386,7 @@ static PyObject * FSSpec_repr(FSSpecObject *self)
 {
 	char buf[512];
 	PyOS_snprintf(buf, sizeof(buf), "%s((%d, %ld, '%.*s'))",
-	        Py_Type(self)->tp_name,
+	        Py_TYPE(self)->tp_name,
 	        self->ob_itself.vRefNum,
 	        self->ob_itself.parID,
 	        self->ob_itself.name[0], self->ob_itself.name+1);
@@ -1511,7 +1511,7 @@ static PyObject *FSRef_New(FSRef *itself)
 static void FSRef_dealloc(FSRefObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *FSRef_FSMakeFSRefUnicode(FSRefObject *_self, PyObject *_args)
@@ -3246,35 +3246,35 @@ void init_File(void)
 	if (File_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", File_Error) != 0)
 		return;
-	Py_Type(&FSCatalogInfo_Type) = &PyType_Type;
+	Py_TYPE(&FSCatalogInfo_Type) = &PyType_Type;
 	if (PyType_Ready(&FSCatalogInfo_Type) < 0) return;
 	Py_INCREF(&FSCatalogInfo_Type);
 	PyModule_AddObject(m, "FSCatalogInfo", (PyObject *)&FSCatalogInfo_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&FSCatalogInfo_Type);
 	PyModule_AddObject(m, "FSCatalogInfoType", (PyObject *)&FSCatalogInfo_Type);
-	Py_Type(&FInfo_Type) = &PyType_Type;
+	Py_TYPE(&FInfo_Type) = &PyType_Type;
 	if (PyType_Ready(&FInfo_Type) < 0) return;
 	Py_INCREF(&FInfo_Type);
 	PyModule_AddObject(m, "FInfo", (PyObject *)&FInfo_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&FInfo_Type);
 	PyModule_AddObject(m, "FInfoType", (PyObject *)&FInfo_Type);
-	Py_Type(&Alias_Type) = &PyType_Type;
+	Py_TYPE(&Alias_Type) = &PyType_Type;
 	if (PyType_Ready(&Alias_Type) < 0) return;
 	Py_INCREF(&Alias_Type);
 	PyModule_AddObject(m, "Alias", (PyObject *)&Alias_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&Alias_Type);
 	PyModule_AddObject(m, "AliasType", (PyObject *)&Alias_Type);
-	Py_Type(&FSSpec_Type) = &PyType_Type;
+	Py_TYPE(&FSSpec_Type) = &PyType_Type;
 	if (PyType_Ready(&FSSpec_Type) < 0) return;
 	Py_INCREF(&FSSpec_Type);
 	PyModule_AddObject(m, "FSSpec", (PyObject *)&FSSpec_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&FSSpec_Type);
 	PyModule_AddObject(m, "FSSpecType", (PyObject *)&FSSpec_Type);
-	Py_Type(&FSRef_Type) = &PyType_Type;
+	Py_TYPE(&FSRef_Type) = &PyType_Type;
 	if (PyType_Ready(&FSRef_Type) < 0) return;
 	Py_INCREF(&FSRef_Type);
 	PyModule_AddObject(m, "FSRef", (PyObject *)&FSRef_Type);
diff --git a/Mac/Modules/ibcarbon/_IBCarbon.c b/Mac/Modules/ibcarbon/_IBCarbon.c
index 72b17b3..91f694b 100644
--- a/Mac/Modules/ibcarbon/_IBCarbon.c
+++ b/Mac/Modules/ibcarbon/_IBCarbon.c
@@ -19,7 +19,7 @@ static PyObject *IBCarbon_Error;
 
 PyTypeObject IBNibRef_Type;
 
-#define IBNibRefObj_Check(x) (Py_Type(x) == &IBNibRef_Type || PyObject_TypeCheck((x), &IBNibRef_Type))
+#define IBNibRefObj_Check(x) (Py_TYPE(x) == &IBNibRef_Type || PyObject_TypeCheck((x), &IBNibRef_Type))
 
 typedef struct IBNibRefObject {
 	PyObject_HEAD
@@ -49,7 +49,7 @@ int IBNibRefObj_Convert(PyObject *v, IBNibRef *p_itself)
 static void IBNibRefObj_dealloc(IBNibRefObject *self)
 {
 	DisposeNibReference(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *IBNibRefObj_CreateWindowFromNib(IBNibRefObject *_self, PyObject *_args)
@@ -248,7 +248,7 @@ void init_IBCarbon(void)
 	if (IBCarbon_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", IBCarbon_Error) != 0)
 		return;
-	Py_Type(&IBNibRef_Type) = &PyType_Type;
+	Py_TYPE(&IBNibRef_Type) = &PyType_Type;
 	if (PyType_Ready(&IBNibRef_Type) < 0) return;
 	Py_INCREF(&IBNibRef_Type);
 	PyModule_AddObject(m, "IBNibRef", (PyObject *)&IBNibRef_Type);
diff --git a/Mac/Modules/list/_Listmodule.c b/Mac/Modules/list/_Listmodule.c
index aa13490..504ceff 100644
--- a/Mac/Modules/list/_Listmodule.c
+++ b/Mac/Modules/list/_Listmodule.c
@@ -37,7 +37,7 @@ static PyObject *List_Error;
 
 PyTypeObject List_Type;
 
-#define ListObj_Check(x) (Py_Type(x) == &List_Type || PyObject_TypeCheck((x), &List_Type))
+#define ListObj_Check(x) (Py_TYPE(x) == &List_Type || PyObject_TypeCheck((x), &List_Type))
 
 typedef struct ListObject {
 	PyObject_HEAD
@@ -79,7 +79,7 @@ static void ListObj_dealloc(ListObject *self)
 	self->ob_ldef_func = NULL;
 	SetListRefCon(self->ob_itself, (long)0);
 	if (self->ob_must_be_disposed && self->ob_itself) LDispose(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *ListObj_LAddColumn(ListObject *_self, PyObject *_args)
@@ -1116,7 +1116,7 @@ void init_List(void)
 	if (List_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", List_Error) != 0)
 		return;
-	Py_Type(&List_Type) = &PyType_Type;
+	Py_TYPE(&List_Type) = &PyType_Type;
 	if (PyType_Ready(&List_Type) < 0) return;
 	Py_INCREF(&List_Type);
 	PyModule_AddObject(m, "List", (PyObject *)&List_Type);
diff --git a/Mac/Modules/menu/_Menumodule.c b/Mac/Modules/menu/_Menumodule.c
index 3e0dfd8..85dde5a 100644
--- a/Mac/Modules/menu/_Menumodule.c
+++ b/Mac/Modules/menu/_Menumodule.c
@@ -57,7 +57,7 @@ static PyObject *Menu_Error;
 
 PyTypeObject Menu_Type;
 
-#define MenuObj_Check(x) (Py_Type(x) == &Menu_Type || PyObject_TypeCheck((x), &Menu_Type))
+#define MenuObj_Check(x) (Py_TYPE(x) == &Menu_Type || PyObject_TypeCheck((x), &Menu_Type))
 
 typedef struct MenuObject {
 	PyObject_HEAD
@@ -87,7 +87,7 @@ int MenuObj_Convert(PyObject *v, MenuHandle *p_itself)
 static void MenuObj_dealloc(MenuObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *MenuObj_DisposeMenu(MenuObject *_self, PyObject *_args)
@@ -3455,7 +3455,7 @@ void init_Menu(void)
 	if (Menu_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Menu_Error) != 0)
 		return;
-	Py_Type(&Menu_Type) = &PyType_Type;
+	Py_TYPE(&Menu_Type) = &PyType_Type;
 	if (PyType_Ready(&Menu_Type) < 0) return;
 	Py_INCREF(&Menu_Type);
 	PyModule_AddObject(m, "Menu", (PyObject *)&Menu_Type);
diff --git a/Mac/Modules/mlte/_Mltemodule.c b/Mac/Modules/mlte/_Mltemodule.c
index 748139e..7a5ea38 100644
--- a/Mac/Modules/mlte/_Mltemodule.c
+++ b/Mac/Modules/mlte/_Mltemodule.c
@@ -69,7 +69,7 @@ static PyObject *Mlte_Error;
 
 PyTypeObject TXNObject_Type;
 
-#define TXNObj_Check(x) (Py_Type(x) == &TXNObject_Type || PyObject_TypeCheck((x), &TXNObject_Type))
+#define TXNObj_Check(x) (Py_TYPE(x) == &TXNObject_Type || PyObject_TypeCheck((x), &TXNObject_Type))
 
 typedef struct TXNObjectObject {
 	PyObject_HEAD
@@ -100,7 +100,7 @@ int TXNObj_Convert(PyObject *v, TXNObject *p_itself)
 static void TXNObj_dealloc(TXNObjectObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *TXNObj_TXNDeleteObject(TXNObjectObject *_self, PyObject *_args)
@@ -1304,7 +1304,7 @@ PyTypeObject TXNObject_Type = {
 
 PyTypeObject TXNFontMenuObject_Type;
 
-#define TXNFontMenuObj_Check(x) (Py_Type(x) == &TXNFontMenuObject_Type || PyObject_TypeCheck((x), &TXNFontMenuObject_Type))
+#define TXNFontMenuObj_Check(x) (Py_TYPE(x) == &TXNFontMenuObject_Type || PyObject_TypeCheck((x), &TXNFontMenuObject_Type))
 
 typedef struct TXNFontMenuObjectObject {
 	PyObject_HEAD
@@ -1335,7 +1335,7 @@ int TXNFontMenuObj_Convert(PyObject *v, TXNFontMenuObject *p_itself)
 static void TXNFontMenuObj_dealloc(TXNFontMenuObjectObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *TXNFontMenuObj_TXNGetFontMenuHandle(TXNFontMenuObjectObject *_self, PyObject *_args)
@@ -1659,14 +1659,14 @@ void init_Mlte(void)
 	if (Mlte_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Mlte_Error) != 0)
 		return;
-	Py_Type(&TXNObject_Type) = &PyType_Type;
+	Py_TYPE(&TXNObject_Type) = &PyType_Type;
 	if (PyType_Ready(&TXNObject_Type) < 0) return;
 	Py_INCREF(&TXNObject_Type);
 	PyModule_AddObject(m, "TXNObject", (PyObject *)&TXNObject_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&TXNObject_Type);
 	PyModule_AddObject(m, "TXNObjectType", (PyObject *)&TXNObject_Type);
-	Py_Type(&TXNFontMenuObject_Type) = &PyType_Type;
+	Py_TYPE(&TXNFontMenuObject_Type) = &PyType_Type;
 	if (PyType_Ready(&TXNFontMenuObject_Type) < 0) return;
 	Py_INCREF(&TXNFontMenuObject_Type);
 	PyModule_AddObject(m, "TXNFontMenuObject", (PyObject *)&TXNFontMenuObject_Type);
diff --git a/Mac/Modules/osa/_OSAmodule.c b/Mac/Modules/osa/_OSAmodule.c
index 6351e1c..2c29ff2 100644
--- a/Mac/Modules/osa/_OSAmodule.c
+++ b/Mac/Modules/osa/_OSAmodule.c
@@ -34,7 +34,7 @@ static PyObject *OSA_Error;
 
 PyTypeObject OSAComponentInstance_Type;
 
-#define OSAObj_Check(x) (Py_Type(x) == &OSAComponentInstance_Type || PyObject_TypeCheck((x), &OSAComponentInstance_Type))
+#define OSAObj_Check(x) (Py_TYPE(x) == &OSAComponentInstance_Type || PyObject_TypeCheck((x), &OSAComponentInstance_Type))
 
 typedef struct OSAComponentInstanceObject {
 	PyObject_HEAD
@@ -73,7 +73,7 @@ int OSAObj_Convert(PyObject *v, ComponentInstance *p_itself)
 static void OSAObj_dealloc(OSAComponentInstanceObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *OSAObj_OSALoad(OSAComponentInstanceObject *_self, PyObject *_args)
@@ -885,7 +885,7 @@ void init_OSA(void)
 	if (OSA_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", OSA_Error) != 0)
 		return;
-	Py_Type(&OSAComponentInstance_Type) = &PyType_Type;
+	Py_TYPE(&OSAComponentInstance_Type) = &PyType_Type;
 	if (PyType_Ready(&OSAComponentInstance_Type) < 0) return;
 	Py_INCREF(&OSAComponentInstance_Type);
 	PyModule_AddObject(m, "OSAComponentInstance", (PyObject *)&OSAComponentInstance_Type);
diff --git a/Mac/Modules/qd/_Qdmodule.c b/Mac/Modules/qd/_Qdmodule.c
index 715a4c5..ea7fa66 100644
--- a/Mac/Modules/qd/_Qdmodule.c
+++ b/Mac/Modules/qd/_Qdmodule.c
@@ -73,7 +73,7 @@ static PyObject *Qd_Error;
 
 PyTypeObject GrafPort_Type;
 
-#define GrafObj_Check(x) (Py_Type(x) == &GrafPort_Type || PyObject_TypeCheck((x), &GrafPort_Type))
+#define GrafObj_Check(x) (Py_TYPE(x) == &GrafPort_Type || PyObject_TypeCheck((x), &GrafPort_Type))
 
 typedef struct GrafPortObject {
 	PyObject_HEAD
@@ -125,7 +125,7 @@ int GrafObj_Convert(PyObject *v, GrafPtr *p_itself)
 static void GrafObj_dealloc(GrafPortObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *GrafObj_MacSetPort(GrafPortObject *_self, PyObject *_args)
@@ -1407,7 +1407,7 @@ PyTypeObject GrafPort_Type = {
 
 PyTypeObject BitMap_Type;
 
-#define BMObj_Check(x) (Py_Type(x) == &BitMap_Type || PyObject_TypeCheck((x), &BitMap_Type))
+#define BMObj_Check(x) (Py_TYPE(x) == &BitMap_Type || PyObject_TypeCheck((x), &BitMap_Type))
 
 typedef struct BitMapObject {
 	PyObject_HEAD
@@ -1443,7 +1443,7 @@ static void BMObj_dealloc(BitMapObject *self)
 {
 	Py_XDECREF(self->referred_object);
 	if (self->referred_bitmap) free(self->referred_bitmap);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *BMObj_getdata(BitMapObject *_self, PyObject *_args)
@@ -7122,14 +7122,14 @@ void init_Qd(void)
 	if (Qd_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Qd_Error) != 0)
 		return;
-	Py_Type(&GrafPort_Type) = &PyType_Type;
+	Py_TYPE(&GrafPort_Type) = &PyType_Type;
 	if (PyType_Ready(&GrafPort_Type) < 0) return;
 	Py_INCREF(&GrafPort_Type);
 	PyModule_AddObject(m, "GrafPort", (PyObject *)&GrafPort_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&GrafPort_Type);
 	PyModule_AddObject(m, "GrafPortType", (PyObject *)&GrafPort_Type);
-	Py_Type(&BitMap_Type) = &PyType_Type;
+	Py_TYPE(&BitMap_Type) = &PyType_Type;
 	if (PyType_Ready(&BitMap_Type) < 0) return;
 	Py_INCREF(&BitMap_Type);
 	PyModule_AddObject(m, "BitMap", (PyObject *)&BitMap_Type);
diff --git a/Mac/Modules/qdoffs/_Qdoffsmodule.c b/Mac/Modules/qdoffs/_Qdoffsmodule.c
index 6c9a003..be46765 100644
--- a/Mac/Modules/qdoffs/_Qdoffsmodule.c
+++ b/Mac/Modules/qdoffs/_Qdoffsmodule.c
@@ -34,7 +34,7 @@ static PyObject *Qdoffs_Error;
 
 PyTypeObject GWorld_Type;
 
-#define GWorldObj_Check(x) (Py_Type(x) == &GWorld_Type || PyObject_TypeCheck((x), &GWorld_Type))
+#define GWorldObj_Check(x) (Py_TYPE(x) == &GWorld_Type || PyObject_TypeCheck((x), &GWorld_Type))
 
 typedef struct GWorldObject {
 	PyObject_HEAD
@@ -65,7 +65,7 @@ int GWorldObj_Convert(PyObject *v, GWorldPtr *p_itself)
 static void GWorldObj_dealloc(GWorldObject *self)
 {
 	DisposeGWorld(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *GWorldObj_GetGWorldDevice(GWorldObject *_self, PyObject *_args)
@@ -700,7 +700,7 @@ void init_Qdoffs(void)
 	if (Qdoffs_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Qdoffs_Error) != 0)
 		return;
-	Py_Type(&GWorld_Type) = &PyType_Type;
+	Py_TYPE(&GWorld_Type) = &PyType_Type;
 	if (PyType_Ready(&GWorld_Type) < 0) return;
 	Py_INCREF(&GWorld_Type);
 	PyModule_AddObject(m, "GWorld", (PyObject *)&GWorld_Type);
diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c
index d105b32..f0dd6c5 100644
--- a/Mac/Modules/qt/_Qtmodule.c
+++ b/Mac/Modules/qt/_Qtmodule.c
@@ -97,7 +97,7 @@ static PyObject *Qt_Error;
 
 PyTypeObject IdleManager_Type;
 
-#define IdleManagerObj_Check(x) (Py_Type(x) == &IdleManager_Type || PyObject_TypeCheck((x), &IdleManager_Type))
+#define IdleManagerObj_Check(x) (Py_TYPE(x) == &IdleManager_Type || PyObject_TypeCheck((x), &IdleManager_Type))
 
 typedef struct IdleManagerObject {
 	PyObject_HEAD
@@ -136,7 +136,7 @@ int IdleManagerObj_Convert(PyObject *v, IdleManager *p_itself)
 static void IdleManagerObj_dealloc(IdleManagerObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyMethodDef IdleManagerObj_methods[] = {
@@ -220,7 +220,7 @@ PyTypeObject IdleManager_Type = {
 
 PyTypeObject MovieController_Type;
 
-#define MovieCtlObj_Check(x) (Py_Type(x) == &MovieController_Type || PyObject_TypeCheck((x), &MovieController_Type))
+#define MovieCtlObj_Check(x) (Py_TYPE(x) == &MovieController_Type || PyObject_TypeCheck((x), &MovieController_Type))
 
 typedef struct MovieControllerObject {
 	PyObject_HEAD
@@ -259,7 +259,7 @@ int MovieCtlObj_Convert(PyObject *v, MovieController *p_itself)
 static void MovieCtlObj_dealloc(MovieControllerObject *self)
 {
 	if (self->ob_itself) DisposeMovieController(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *MovieCtlObj_MCSetMovie(MovieControllerObject *_self, PyObject *_args)
@@ -1339,7 +1339,7 @@ PyTypeObject MovieController_Type = {
 
 PyTypeObject TimeBase_Type;
 
-#define TimeBaseObj_Check(x) (Py_Type(x) == &TimeBase_Type || PyObject_TypeCheck((x), &TimeBase_Type))
+#define TimeBaseObj_Check(x) (Py_TYPE(x) == &TimeBase_Type || PyObject_TypeCheck((x), &TimeBase_Type))
 
 typedef struct TimeBaseObject {
 	PyObject_HEAD
@@ -1378,7 +1378,7 @@ int TimeBaseObj_Convert(PyObject *v, TimeBase *p_itself)
 static void TimeBaseObj_dealloc(TimeBaseObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *TimeBaseObj_DisposeTimeBase(TimeBaseObject *_self, PyObject *_args)
@@ -1832,7 +1832,7 @@ PyTypeObject TimeBase_Type = {
 
 PyTypeObject UserData_Type;
 
-#define UserDataObj_Check(x) (Py_Type(x) == &UserData_Type || PyObject_TypeCheck((x), &UserData_Type))
+#define UserDataObj_Check(x) (Py_TYPE(x) == &UserData_Type || PyObject_TypeCheck((x), &UserData_Type))
 
 typedef struct UserDataObject {
 	PyObject_HEAD
@@ -1871,7 +1871,7 @@ int UserDataObj_Convert(PyObject *v, UserData *p_itself)
 static void UserDataObj_dealloc(UserDataObject *self)
 {
 	if (self->ob_itself) DisposeUserData(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *UserDataObj_GetUserData(UserDataObject *_self, PyObject *_args)
@@ -2202,7 +2202,7 @@ PyTypeObject UserData_Type = {
 
 PyTypeObject Media_Type;
 
-#define MediaObj_Check(x) (Py_Type(x) == &Media_Type || PyObject_TypeCheck((x), &Media_Type))
+#define MediaObj_Check(x) (Py_TYPE(x) == &Media_Type || PyObject_TypeCheck((x), &Media_Type))
 
 typedef struct MediaObject {
 	PyObject_HEAD
@@ -2241,7 +2241,7 @@ int MediaObj_Convert(PyObject *v, Media *p_itself)
 static void MediaObj_dealloc(MediaObject *self)
 {
 	if (self->ob_itself) DisposeTrackMedia(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *MediaObj_LoadMediaIntoRam(MediaObject *_self, PyObject *_args)
@@ -3443,7 +3443,7 @@ PyTypeObject Media_Type = {
 
 PyTypeObject Track_Type;
 
-#define TrackObj_Check(x) (Py_Type(x) == &Track_Type || PyObject_TypeCheck((x), &Track_Type))
+#define TrackObj_Check(x) (Py_TYPE(x) == &Track_Type || PyObject_TypeCheck((x), &Track_Type))
 
 typedef struct TrackObject {
 	PyObject_HEAD
@@ -3482,7 +3482,7 @@ int TrackObj_Convert(PyObject *v, Track *p_itself)
 static void TrackObj_dealloc(TrackObject *self)
 {
 	if (self->ob_itself) DisposeMovieTrack(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *TrackObj_LoadTrackIntoRam(TrackObject *_self, PyObject *_args)
@@ -4790,7 +4790,7 @@ PyTypeObject Track_Type = {
 
 PyTypeObject Movie_Type;
 
-#define MovieObj_Check(x) (Py_Type(x) == &Movie_Type || PyObject_TypeCheck((x), &Movie_Type))
+#define MovieObj_Check(x) (Py_TYPE(x) == &Movie_Type || PyObject_TypeCheck((x), &Movie_Type))
 
 typedef struct MovieObject {
 	PyObject_HEAD
@@ -4829,7 +4829,7 @@ int MovieObj_Convert(PyObject *v, Movie *p_itself)
 static void MovieObj_dealloc(MovieObject *self)
 {
 	if (self->ob_itself) DisposeMovie(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *MovieObj_MoviesTask(MovieObject *_self, PyObject *_args)
@@ -7342,7 +7342,7 @@ PyTypeObject Movie_Type = {
 
 PyTypeObject SGOutput_Type;
 
-#define SGOutputObj_Check(x) (Py_Type(x) == &SGOutput_Type || PyObject_TypeCheck((x), &SGOutput_Type))
+#define SGOutputObj_Check(x) (Py_TYPE(x) == &SGOutput_Type || PyObject_TypeCheck((x), &SGOutput_Type))
 
 typedef struct SGOutputObject {
 	PyObject_HEAD
@@ -7381,7 +7381,7 @@ int SGOutputObj_Convert(PyObject *v, SGOutput *p_itself)
 static void SGOutputObj_dealloc(SGOutputObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyMethodDef SGOutputObj_methods[] = {
@@ -28013,56 +28013,56 @@ void init_Qt(void)
 	if (Qt_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Qt_Error) != 0)
 		return;
-	Py_Type(&IdleManager_Type) = &PyType_Type;
+	Py_TYPE(&IdleManager_Type) = &PyType_Type;
 	if (PyType_Ready(&IdleManager_Type) < 0) return;
 	Py_INCREF(&IdleManager_Type);
 	PyModule_AddObject(m, "IdleManager", (PyObject *)&IdleManager_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&IdleManager_Type);
 	PyModule_AddObject(m, "IdleManagerType", (PyObject *)&IdleManager_Type);
-	Py_Type(&MovieController_Type) = &PyType_Type;
+	Py_TYPE(&MovieController_Type) = &PyType_Type;
 	if (PyType_Ready(&MovieController_Type) < 0) return;
 	Py_INCREF(&MovieController_Type);
 	PyModule_AddObject(m, "MovieController", (PyObject *)&MovieController_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&MovieController_Type);
 	PyModule_AddObject(m, "MovieControllerType", (PyObject *)&MovieController_Type);
-	Py_Type(&TimeBase_Type) = &PyType_Type;
+	Py_TYPE(&TimeBase_Type) = &PyType_Type;
 	if (PyType_Ready(&TimeBase_Type) < 0) return;
 	Py_INCREF(&TimeBase_Type);
 	PyModule_AddObject(m, "TimeBase", (PyObject *)&TimeBase_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&TimeBase_Type);
 	PyModule_AddObject(m, "TimeBaseType", (PyObject *)&TimeBase_Type);
-	Py_Type(&UserData_Type) = &PyType_Type;
+	Py_TYPE(&UserData_Type) = &PyType_Type;
 	if (PyType_Ready(&UserData_Type) < 0) return;
 	Py_INCREF(&UserData_Type);
 	PyModule_AddObject(m, "UserData", (PyObject *)&UserData_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&UserData_Type);
 	PyModule_AddObject(m, "UserDataType", (PyObject *)&UserData_Type);
-	Py_Type(&Media_Type) = &PyType_Type;
+	Py_TYPE(&Media_Type) = &PyType_Type;
 	if (PyType_Ready(&Media_Type) < 0) return;
 	Py_INCREF(&Media_Type);
 	PyModule_AddObject(m, "Media", (PyObject *)&Media_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&Media_Type);
 	PyModule_AddObject(m, "MediaType", (PyObject *)&Media_Type);
-	Py_Type(&Track_Type) = &PyType_Type;
+	Py_TYPE(&Track_Type) = &PyType_Type;
 	if (PyType_Ready(&Track_Type) < 0) return;
 	Py_INCREF(&Track_Type);
 	PyModule_AddObject(m, "Track", (PyObject *)&Track_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&Track_Type);
 	PyModule_AddObject(m, "TrackType", (PyObject *)&Track_Type);
-	Py_Type(&Movie_Type) = &PyType_Type;
+	Py_TYPE(&Movie_Type) = &PyType_Type;
 	if (PyType_Ready(&Movie_Type) < 0) return;
 	Py_INCREF(&Movie_Type);
 	PyModule_AddObject(m, "Movie", (PyObject *)&Movie_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&Movie_Type);
 	PyModule_AddObject(m, "MovieType", (PyObject *)&Movie_Type);
-	Py_Type(&SGOutput_Type) = &PyType_Type;
+	Py_TYPE(&SGOutput_Type) = &PyType_Type;
 	if (PyType_Ready(&SGOutput_Type) < 0) return;
 	Py_INCREF(&SGOutput_Type);
 	PyModule_AddObject(m, "SGOutput", (PyObject *)&SGOutput_Type);
diff --git a/Mac/Modules/res/_Resmodule.c b/Mac/Modules/res/_Resmodule.c
index ecb5cb3..80b5337 100644
--- a/Mac/Modules/res/_Resmodule.c
+++ b/Mac/Modules/res/_Resmodule.c
@@ -41,7 +41,7 @@ static PyObject *Res_Error;
 
 PyTypeObject Resource_Type;
 
-#define ResObj_Check(x) (Py_Type(x) == &Resource_Type || PyObject_TypeCheck((x), &Resource_Type))
+#define ResObj_Check(x) (Py_TYPE(x) == &Resource_Type || PyObject_TypeCheck((x), &Resource_Type))
 
 typedef struct ResourceObject {
 	PyObject_HEAD
@@ -89,7 +89,7 @@ static void ResObj_dealloc(ResourceObject *self)
 		self->ob_freeit(self->ob_itself);
 	}
 	self->ob_itself = NULL;
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *ResObj_HomeResFile(ResourceObject *_self, PyObject *_args)
@@ -1730,7 +1730,7 @@ void init_Res(void)
 	if (Res_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Res_Error) != 0)
 		return;
-	Py_Type(&Resource_Type) = &PyType_Type;
+	Py_TYPE(&Resource_Type) = &PyType_Type;
 	if (PyType_Ready(&Resource_Type) < 0) return;
 	Py_INCREF(&Resource_Type);
 	PyModule_AddObject(m, "Resource", (PyObject *)&Resource_Type);
diff --git a/Mac/Modules/scrap/_Scrapmodule.c b/Mac/Modules/scrap/_Scrapmodule.c
index ade5e57..bd27512 100644
--- a/Mac/Modules/scrap/_Scrapmodule.c
+++ b/Mac/Modules/scrap/_Scrapmodule.c
@@ -23,7 +23,7 @@ static PyObject *Scrap_Error;
 
 PyTypeObject Scrap_Type;
 
-#define ScrapObj_Check(x) (Py_Type(x) == &Scrap_Type || PyObject_TypeCheck((x), &Scrap_Type))
+#define ScrapObj_Check(x) (Py_TYPE(x) == &Scrap_Type || PyObject_TypeCheck((x), &Scrap_Type))
 
 typedef struct ScrapObject {
 	PyObject_HEAD
@@ -52,7 +52,7 @@ int ScrapObj_Convert(PyObject *v, ScrapRef *p_itself)
 static void ScrapObj_dealloc(ScrapObject *self)
 {
 	/* Cleanup of self->ob_itself goes here */
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *ScrapObj_GetScrapFlavorFlags(ScrapObject *_self, PyObject *_args)
@@ -346,7 +346,7 @@ void init_Scrap(void)
 	if (Scrap_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Scrap_Error) != 0)
 		return;
-	Py_Type(&Scrap_Type) = &PyType_Type;
+	Py_TYPE(&Scrap_Type) = &PyType_Type;
 	Py_INCREF(&Scrap_Type);
 	if (PyDict_SetItemString(d, "ScrapType", (PyObject *)&Scrap_Type) != 0)
 		Py_FatalError("can't initialize ScrapType");
diff --git a/Mac/Modules/snd/_Sndmodule.c b/Mac/Modules/snd/_Sndmodule.c
index 867c8f7..0e2e572 100644
--- a/Mac/Modules/snd/_Sndmodule.c
+++ b/Mac/Modules/snd/_Sndmodule.c
@@ -42,7 +42,7 @@ static PyObject *Snd_Error;
 
 static PyTypeObject SndChannel_Type;
 
-#define SndCh_Check(x) (Py_Type(x) == &SndChannel_Type || PyObject_TypeCheck((x), &SndChannel_Type))
+#define SndCh_Check(x) (Py_TYPE(x) == &SndChannel_Type || PyObject_TypeCheck((x), &SndChannel_Type))
 
 typedef struct SndChannelObject {
 	PyObject_HEAD
@@ -256,7 +256,7 @@ static PyTypeObject SndChannel_Type = {
 
 static PyTypeObject SPB_Type;
 
-#define SPBObj_Check(x) (Py_Type(x) == &SPB_Type || PyObject_TypeCheck((x), &SPB_Type))
+#define SPBObj_Check(x) (Py_TYPE(x) == &SPB_Type || PyObject_TypeCheck((x), &SPB_Type))
 
 typedef struct SPBObject {
 	PyObject_HEAD
@@ -1129,14 +1129,14 @@ void init_Snd(void)
 	if (Snd_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Snd_Error) != 0)
 		return;
-	Py_Type(&SndChannel_Type) = &PyType_Type;
+	Py_TYPE(&SndChannel_Type) = &PyType_Type;
 	if (PyType_Ready(&SndChannel_Type) < 0) return;
 	Py_INCREF(&SndChannel_Type);
 	PyModule_AddObject(m, "SndChannel", (PyObject *)&SndChannel_Type);
 	/* Backward-compatible name */
 	Py_INCREF(&SndChannel_Type);
 	PyModule_AddObject(m, "SndChannelType", (PyObject *)&SndChannel_Type);
-	Py_Type(&SPB_Type) = &PyType_Type;
+	Py_TYPE(&SPB_Type) = &PyType_Type;
 	if (PyType_Ready(&SPB_Type) < 0) return;
 	Py_INCREF(&SPB_Type);
 	PyModule_AddObject(m, "SPB", (PyObject *)&SPB_Type);
diff --git a/Mac/Modules/te/_TEmodule.c b/Mac/Modules/te/_TEmodule.c
index 893758c..2f73272 100644
--- a/Mac/Modules/te/_TEmodule.c
+++ b/Mac/Modules/te/_TEmodule.c
@@ -58,7 +58,7 @@ static PyObject *TE_Error;
 
 PyTypeObject TE_Type;
 
-#define TEObj_Check(x) (Py_Type(x) == &TE_Type || PyObject_TypeCheck((x), &TE_Type))
+#define TEObj_Check(x) (Py_TYPE(x) == &TE_Type || PyObject_TypeCheck((x), &TE_Type))
 
 typedef struct TEObject {
 	PyObject_HEAD
@@ -92,7 +92,7 @@ int TEObj_Convert(PyObject *v, TEHandle *p_itself)
 static void TEObj_dealloc(TEObject *self)
 {
 	TEDispose(self->ob_itself);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *TEObj_TESetText(TEObject *_self, PyObject *_args)
@@ -1317,7 +1317,7 @@ void init_TE(void)
 	if (TE_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", TE_Error) != 0)
 		return;
-	Py_Type(&TE_Type) = &PyType_Type;
+	Py_TYPE(&TE_Type) = &PyType_Type;
 	if (PyType_Ready(&TE_Type) < 0) return;
 	Py_INCREF(&TE_Type);
 	PyModule_AddObject(m, "TE", (PyObject *)&TE_Type);
diff --git a/Mac/Modules/win/_Winmodule.c b/Mac/Modules/win/_Winmodule.c
index 8a3cb2c..a079b89 100644
--- a/Mac/Modules/win/_Winmodule.c
+++ b/Mac/Modules/win/_Winmodule.c
@@ -45,7 +45,7 @@ static PyObject *Win_Error;
 
 PyTypeObject Window_Type;
 
-#define WinObj_Check(x) (Py_Type(x) == &Window_Type || PyObject_TypeCheck((x), &Window_Type))
+#define WinObj_Check(x) (Py_TYPE(x) == &Window_Type || PyObject_TypeCheck((x), &Window_Type))
 
 typedef struct WindowObject {
 	PyObject_HEAD
@@ -102,7 +102,7 @@ static void WinObj_dealloc(WindowObject *self)
 	}
 	self->ob_itself = NULL;
 	self->ob_freeit = NULL;
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *WinObj_GetWindowOwnerCount(WindowObject *_self, PyObject *_args)
@@ -3244,7 +3244,7 @@ void init_Win(void)
 	if (Win_Error == NULL ||
 	    PyDict_SetItemString(d, "Error", Win_Error) != 0)
 		return;
-	Py_Type(&Window_Type) = &PyType_Type;
+	Py_TYPE(&Window_Type) = &PyType_Type;
 	if (PyType_Ready(&Window_Type) < 0) return;
 	Py_INCREF(&Window_Type);
 	PyModule_AddObject(m, "Window", (PyObject *)&Window_Type);
diff --git a/Modules/_bsddb.c b/Modules/_bsddb.c
index 3452a61..fb71161 100644
--- a/Modules/_bsddb.c
+++ b/Modules/_bsddb.c
@@ -203,13 +203,13 @@ static PyObject* DBPermissionsError;    /* EPERM  */
 
 static PyTypeObject DB_Type, DBCursor_Type, DBEnv_Type, DBTxn_Type, DBLock_Type;
 
-#define DBObject_Check(v)           (Py_Type(v) == &DB_Type)
-#define DBCursorObject_Check(v)     (Py_Type(v) == &DBCursor_Type)
-#define DBEnvObject_Check(v)        (Py_Type(v) == &DBEnv_Type)
-#define DBTxnObject_Check(v)        (Py_Type(v) == &DBTxn_Type)
-#define DBLockObject_Check(v)       (Py_Type(v) == &DBLock_Type)
+#define DBObject_Check(v)           (Py_TYPE(v) == &DB_Type)
+#define DBCursorObject_Check(v)     (Py_TYPE(v) == &DBCursor_Type)
+#define DBEnvObject_Check(v)        (Py_TYPE(v) == &DBEnv_Type)
+#define DBTxnObject_Check(v)        (Py_TYPE(v) == &DBTxn_Type)
+#define DBLockObject_Check(v)       (Py_TYPE(v) == &DBLock_Type)
 #if (DBVER >= 43)
-#define DBSequenceObject_Check(v)   (Py_Type(v) == &DBSequence_Type)
+#define DBSequenceObject_Check(v)   (Py_TYPE(v) == &DBSequence_Type)
 #endif
 
 
@@ -461,7 +461,7 @@ make_key_dbt(DBObject* self, PyObject* keyobj, DBT* key, int* pflags,
     else {
         PyErr_Format(PyExc_TypeError,
                      "buffer or int object expected for key, %s found",
-                     Py_Type(keyobj)->tp_name);
+                     Py_TYPE(keyobj)->tp_name);
         return 0;
     }
 
@@ -611,7 +611,7 @@ static int makeDBError(int err)
 static void makeTypeError(char* expected, PyObject* found)
 {
     PyErr_Format(PyExc_TypeError, "Expected %s argument, %s found.",
-                 expected, Py_Type(found)->tp_name);
+                 expected, Py_TYPE(found)->tp_name);
 }
 
 
@@ -1176,7 +1176,7 @@ _db_associateCallback(DB* db, const DBT* priKey, const DBT* priData,
             Py_ssize_t size;
 
             CLEAR_DBT(*secKey);
-            size = Py_Size(result);
+            size = Py_SIZE(result);
             if (PyBytes_Check(result))
                 data = PyBytes_AS_STRING(result);
             else
@@ -5656,13 +5656,13 @@ PyMODINIT_FUNC init_bsddb(void)
 
     /* Initialize the type of the new type objects here; doing it here
        is required for portability to Windows without requiring C++. */
-    Py_Type(&DB_Type) = &PyType_Type;
-    Py_Type(&DBCursor_Type) = &PyType_Type;
-    Py_Type(&DBEnv_Type) = &PyType_Type;
-    Py_Type(&DBTxn_Type) = &PyType_Type;
-    Py_Type(&DBLock_Type) = &PyType_Type;
+    Py_TYPE(&DB_Type) = &PyType_Type;
+    Py_TYPE(&DBCursor_Type) = &PyType_Type;
+    Py_TYPE(&DBEnv_Type) = &PyType_Type;
+    Py_TYPE(&DBTxn_Type) = &PyType_Type;
+    Py_TYPE(&DBLock_Type) = &PyType_Type;
 #if (DBVER >= 43)    
-    Py_Type(&DBSequence_Type) = &PyType_Type;
+    Py_TYPE(&DBSequence_Type) = &PyType_Type;
 #endif    
 
 
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index 0d1df5f..493f314 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -583,7 +583,7 @@ deque_dealloc(dequeobject *deque)
 	}
 	deque->leftblock = NULL;
 	deque->rightblock = NULL;
-	Py_Type(deque)->tp_free(deque);
+	Py_TYPE(deque)->tp_free(deque);
 }
 
 static int
@@ -619,9 +619,9 @@ static PyObject *
 deque_copy(PyObject *deque)
 {
 	if (((dequeobject *)deque)->maxlen == -1)
-		return PyObject_CallFunction((PyObject *)(Py_Type(deque)), "O", deque, NULL);
+		return PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "O", deque, NULL);
 	else
-		return PyObject_CallFunction((PyObject *)(Py_Type(deque)), "Oi",
+		return PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi",
 			deque, ((dequeobject *)deque)->maxlen, NULL);
 }
 
@@ -642,14 +642,14 @@ deque_reduce(dequeobject *deque)
 	}
 	if (dict == NULL) {
 		if (deque->maxlen == -1)
-			result = Py_BuildValue("O(O)", Py_Type(deque), aslist);
+			result = Py_BuildValue("O(O)", Py_TYPE(deque), aslist);
 		else
-			result = Py_BuildValue("O(Oi)", Py_Type(deque), aslist, deque->maxlen);
+			result = Py_BuildValue("O(Oi)", Py_TYPE(deque), aslist, deque->maxlen);
 	} else {
 		if (deque->maxlen == -1)
-			result = Py_BuildValue("O(OO)O", Py_Type(deque), aslist, Py_None, dict);
+			result = Py_BuildValue("O(OO)O", Py_TYPE(deque), aslist, Py_None, dict);
 		else
-			result = Py_BuildValue("O(Oi)O", Py_Type(deque), aslist, deque->maxlen, dict);
+			result = Py_BuildValue("O(Oi)O", Py_TYPE(deque), aslist, deque->maxlen, dict);
 	}
 	Py_XDECREF(dict);
 	Py_DECREF(aslist);
@@ -921,7 +921,7 @@ static void
 dequeiter_dealloc(dequeiterobject *dio)
 {
 	Py_XDECREF(dio->deque);
-	Py_Type(dio)->tp_free(dio);
+	Py_TYPE(dio)->tp_free(dio);
 }
 
 static PyObject *
@@ -1129,7 +1129,7 @@ defdict_copy(defdictobject *dd)
 	   whose class constructor has the same signature.  Subclasses that
 	   define a different constructor signature must override copy().
 	*/
-	return PyObject_CallFunctionObjArgs((PyObject*)Py_Type(dd),
+	return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd),
 					    dd->default_factory, dd, NULL);
 }
 
@@ -1172,7 +1172,7 @@ defdict_reduce(defdictobject *dd)
 		Py_DECREF(args);
 		return NULL;
 	}
-	result = PyTuple_Pack(5, Py_Type(dd), args,
+	result = PyTuple_Pack(5, Py_TYPE(dd), args,
 			      Py_None, Py_None, items);
 	Py_DECREF(items);
 	Py_DECREF(args);
diff --git a/Modules/_csv.c b/Modules/_csv.c
index aee490c..9a72955 100644
--- a/Modules/_csv.c
+++ b/Modules/_csv.c
@@ -81,7 +81,7 @@ typedef struct {
 
 static PyTypeObject Reader_Type;
 
-#define ReaderObject_Check(v)   (Py_Type(v) == &Reader_Type)
+#define ReaderObject_Check(v)   (Py_TYPE(v) == &Reader_Type)
 
 typedef struct {
         PyObject_HEAD
@@ -284,7 +284,7 @@ static void
 Dialect_dealloc(DialectObj *self)
 {
         Py_XDECREF(self->lineterminator);
-        Py_Type(self)->tp_free((PyObject *)self);
+        Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static char *dialect_kws[] = {
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index dd4b754..5da7de0 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -328,7 +328,7 @@ CDataType_from_param(PyObject *type, PyObject *value)
 			Py_INCREF(value);
 			return value;
 		}
-		ob_name = (ob) ? Py_Type(ob)->tp_name : "???";
+		ob_name = (ob) ? Py_TYPE(ob)->tp_name : "???";
 		PyErr_Format(PyExc_TypeError,
 			     "expected %s instance instead of pointer to %s",
 			     ((PyTypeObject *)type)->tp_name, ob_name);
@@ -344,7 +344,7 @@ CDataType_from_param(PyObject *type, PyObject *value)
 	PyErr_Format(PyExc_TypeError,
 		     "expected %s instance instead of %s",
 		     ((PyTypeObject *)type)->tp_name,
-		     Py_Type(value)->tp_name);
+		     Py_TYPE(value)->tp_name);
 	return NULL;
 }
 
@@ -798,7 +798,7 @@ CharArray_set_value(CDataObject *self, PyObject *value)
 	} else if (!PyString_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "str/bytes expected instead of %s instance",
-			     Py_Type(value)->tp_name);
+			     Py_TYPE(value)->tp_name);
 		return -1;
 	} else
 		Py_INCREF(value);
@@ -858,7 +858,7 @@ WCharArray_set_value(CDataObject *self, PyObject *value)
 	} else if (!PyUnicode_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 				"unicode string expected instead of %s instance",
-				Py_Type(value)->tp_name);
+				Py_TYPE(value)->tp_name);
 		return -1;
 	} else
 		Py_INCREF(value);
@@ -2075,7 +2075,7 @@ static void
 CData_dealloc(PyObject *self)
 {
 	CData_clear((CDataObject *)self);
-	Py_Type(self)->tp_free(self);
+	Py_TYPE(self)->tp_free(self);
 }
 
 static PyMemberDef CData_members[] = {
@@ -2334,7 +2334,7 @@ _CData_set(CDataObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value,
 			PyErr_Format(PyExc_TypeError,
 				     "expected %s instance, got %s",
 				     ((PyTypeObject *)type)->tp_name,
-				     Py_Type(value)->tp_name);
+				     Py_TYPE(value)->tp_name);
 			return NULL;
 		}
 	}
@@ -2365,7 +2365,7 @@ _CData_set(CDataObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value,
 		if (p1->proto != p2->proto) {
 			PyErr_Format(PyExc_TypeError,
 				     "incompatible types, %s instance instead of %s instance",
-				     Py_Type(value)->tp_name,
+				     Py_TYPE(value)->tp_name,
 				     ((PyTypeObject *)type)->tp_name);
 			return NULL;
 		}
@@ -2384,7 +2384,7 @@ _CData_set(CDataObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value,
 	}
 	PyErr_Format(PyExc_TypeError,
 		     "incompatible types, %s instance instead of %s instance",
-		     Py_Type(value)->tp_name,
+		     Py_TYPE(value)->tp_name,
 		     ((PyTypeObject *)type)->tp_name);
 	return NULL;
 }
@@ -2645,7 +2645,7 @@ _check_outarg_type(PyObject *arg, Py_ssize_t index)
 		     Py_SAFE_DOWNCAST(index, Py_ssize_t, int),
 		     PyType_Check(arg) ?
 		     ((PyTypeObject *)arg)->tp_name :
-		     Py_Type(arg)->tp_name);
+		     Py_TYPE(arg)->tp_name);
 	return 0;
 }
 
@@ -3430,7 +3430,7 @@ static void
 CFuncPtr_dealloc(CFuncPtrObject *self)
 {
 	CFuncPtr_clear(self);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *
@@ -3440,11 +3440,11 @@ CFuncPtr_repr(CFuncPtrObject *self)
 	if (self->index)
 		return PyUnicode_FromFormat("<COM method offset %d: %s at %p>",
 					   self->index - 0x1000,
-					   Py_Type(self)->tp_name,
+					   Py_TYPE(self)->tp_name,
 					   self);
 #endif
 	return PyUnicode_FromFormat("<%s object at %p>",
-				   Py_Type(self)->tp_name,
+				   Py_TYPE(self)->tp_name,
 				   self);
 }
 
@@ -4078,7 +4078,7 @@ static PyGetSetDef Simple_getsets[] = {
 static PyObject *
 Simple_from_outparm(PyObject *self, PyObject *args)
 {
-	if (IsSimpleSubType((PyObject *)Py_Type(self))) {
+	if (IsSimpleSubType((PyObject *)Py_TYPE(self))) {
 		Py_INCREF(self);
 		return self;
 	}
@@ -4116,9 +4116,9 @@ Simple_repr(CDataObject *self)
 	PyObject *val, *name, *args, *result;
 	static PyObject *format;
 
-	if (Py_Type(self)->tp_base != &Simple_Type) {
+	if (Py_TYPE(self)->tp_base != &Simple_Type) {
 		return PyUnicode_FromFormat("<%s object at %p>",
-					   Py_Type(self)->tp_name, self);
+					   Py_TYPE(self)->tp_name, self);
 	}
 
 	if (format == NULL) {
@@ -4131,7 +4131,7 @@ Simple_repr(CDataObject *self)
 	if (val == NULL)
 		return NULL;
 
-	name = PyUnicode_FromString(Py_Type(self)->tp_name);
+	name = PyUnicode_FromString(Py_TYPE(self)->tp_name);
 	if (name == NULL) {
 		Py_DECREF(val);
 		return NULL;
@@ -4302,7 +4302,7 @@ Pointer_set_contents(CDataObject *self, PyObject *value, void *closure)
 		PyErr_Format(PyExc_TypeError,
 			     "expected %s instead of %s",
 			     ((PyTypeObject *)(stgdict->proto))->tp_name,
-			     Py_Type(value)->tp_name);
+			     Py_TYPE(value)->tp_name);
 		return -1;
 	}
 
@@ -4588,7 +4588,7 @@ comerror_init(PyObject *self, PyObject *args, PyObject *kwds)
     PyObject *a;
     int status;
 
-    if (!_PyArg_NoKeywords(Py_Type(self)->tp_name, kwds))
+    if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
         return -1;
 
     if (!PyArg_ParseTuple(args, "OOO:COMError", &hresult, &text, &details))
@@ -4703,7 +4703,7 @@ cast_check_pointertype(PyObject *arg)
 		     "cast() argument 2 must be a pointer type, not %s",
 		     PyType_Check(arg)
 		     ? ((PyTypeObject *)arg)->tp_name
-		     : Py_Type(arg)->tp_name);
+		     : Py_TYPE(arg)->tp_name);
 	return 0;
 }
 
@@ -4830,37 +4830,37 @@ init_ctypes(void)
 	if (PyType_Ready(&CData_Type) < 0)
 		return;
 
-	Py_Type(&Struct_Type) = &StructType_Type;
+	Py_TYPE(&Struct_Type) = &StructType_Type;
 	Struct_Type.tp_base = &CData_Type;
 	if (PyType_Ready(&Struct_Type) < 0)
 		return;
 	PyModule_AddObject(m, "Structure", (PyObject *)&Struct_Type);
 
-	Py_Type(&Union_Type) = &UnionType_Type;
+	Py_TYPE(&Union_Type) = &UnionType_Type;
 	Union_Type.tp_base = &CData_Type;
 	if (PyType_Ready(&Union_Type) < 0)
 		return;
 	PyModule_AddObject(m, "Union", (PyObject *)&Union_Type);
 
-	Py_Type(&Pointer_Type) = &PointerType_Type;
+	Py_TYPE(&Pointer_Type) = &PointerType_Type;
 	Pointer_Type.tp_base = &CData_Type;
 	if (PyType_Ready(&Pointer_Type) < 0)
 		return;
 	PyModule_AddObject(m, "_Pointer", (PyObject *)&Pointer_Type);
 
-	Py_Type(&Array_Type) = &ArrayType_Type;
+	Py_TYPE(&Array_Type) = &ArrayType_Type;
 	Array_Type.tp_base = &CData_Type;
 	if (PyType_Ready(&Array_Type) < 0)
 		return;
 	PyModule_AddObject(m, "Array", (PyObject *)&Array_Type);
 
-	Py_Type(&Simple_Type) = &SimpleType_Type;
+	Py_TYPE(&Simple_Type) = &SimpleType_Type;
 	Simple_Type.tp_base = &CData_Type;
 	if (PyType_Ready(&Simple_Type) < 0)
 		return;
 	PyModule_AddObject(m, "_SimpleCData", (PyObject *)&Simple_Type);
 
-	Py_Type(&CFuncPtr_Type) = &CFuncPtrType_Type;
+	Py_TYPE(&CFuncPtr_Type) = &CFuncPtrType_Type;
 	CFuncPtr_Type.tp_base = &CData_Type;
 	if (PyType_Ready(&CFuncPtr_Type) < 0)
 		return;
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index befb31b..8f6b957 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -1153,7 +1153,7 @@ call_commethod(PyObject *self, PyObject *args)
 	if (!CDataObject_Check(pcom) || (pcom->b_size != sizeof(void *))) {
 		PyErr_Format(PyExc_TypeError,
 			     "COM Pointer expected instead of %s instance",
-			     Py_Type(pcom)->tp_name);
+			     Py_TYPE(pcom)->tp_name);
 		return NULL;
 	}
 
@@ -1393,7 +1393,7 @@ byref(PyObject *self, PyObject *obj)
 	if (!CDataObject_Check(obj)) {
 		PyErr_Format(PyExc_TypeError,
 			     "byref() argument must be a ctypes instance, not '%s'",
-			     Py_Type(obj)->tp_name);
+			     Py_TYPE(obj)->tp_name);
 		return NULL;
 	}
 
diff --git a/Modules/_ctypes/cfield.c b/Modules/_ctypes/cfield.c
index a873642..e7a534e 100644
--- a/Modules/_ctypes/cfield.c
+++ b/Modules/_ctypes/cfield.c
@@ -1349,7 +1349,7 @@ s_set(void *ptr, PyObject *value, Py_ssize_t length)
 	data = PyString_AS_STRING(value);
 	if (!data)
 		return NULL;
-	size = strlen(data); /* XXX Why not Py_Size(value)? */
+	size = strlen(data); /* XXX Why not Py_SIZE(value)? */
 	if (size < length) {
 		/* This will copy the leading NUL character
 		 * if there is space for it.
diff --git a/Modules/_ctypes/stgdict.c b/Modules/_ctypes/stgdict.c
index d38380b..11a1a63 100644
--- a/Modules/_ctypes/stgdict.c
+++ b/Modules/_ctypes/stgdict.c
@@ -183,7 +183,7 @@ MakeFields(PyObject *type, CFieldObject *descr,
 			Py_DECREF(fieldlist);
 			return -1;
 		}
-		if (Py_Type(fdescr) != &CField_Type) {
+		if (Py_TYPE(fdescr) != &CField_Type) {
 			PyErr_SetString(PyExc_TypeError, "unexpected type");
 			Py_DECREF(fdescr);
 			Py_DECREF(fieldlist);
@@ -206,7 +206,7 @@ MakeFields(PyObject *type, CFieldObject *descr,
 			Py_DECREF(fieldlist);
 			return -1;
 		}
-		assert(Py_Type(new_descr) == &CField_Type);
+		assert(Py_TYPE(new_descr) == &CField_Type);
  		new_descr->size = fdescr->size;
  		new_descr->offset = fdescr->offset + offset;
  		new_descr->index = fdescr->index + index;
@@ -254,7 +254,7 @@ MakeAnonFields(PyObject *type)
 			Py_DECREF(anon_names);
 			return -1;
 		}
-		assert(Py_Type(descr) == &CField_Type);
+		assert(Py_TYPE(descr) == &CField_Type);
 		descr->anonymous = 1;
 
 		/* descr is in the field descriptor. */
diff --git a/Modules/_curses_panel.c b/Modules/_curses_panel.c
index e73d986..9bdd194 100644
--- a/Modules/_curses_panel.c
+++ b/Modules/_curses_panel.c
@@ -56,7 +56,7 @@ typedef struct {
 
 PyTypeObject PyCursesPanel_Type;
 
-#define PyCursesPanel_Check(v)	 (Py_Type(v) == &PyCursesPanel_Type)
+#define PyCursesPanel_Check(v)	 (Py_TYPE(v) == &PyCursesPanel_Type)
 
 /* Some helper functions. The problem is that there's always a window
    associated with a panel. To ensure that Python's GC doesn't pull
@@ -457,7 +457,7 @@ init_curses_panel(void)
     PyObject *m, *d, *v;
 
     /* Initialize object type */
-    Py_Type(&PyCursesPanel_Type) = &PyType_Type;
+    Py_TYPE(&PyCursesPanel_Type) = &PyType_Type;
 
     import_curses();
 
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index d1cd1551..ea98d08 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -2709,7 +2709,7 @@ init_curses(void)
 	static void *PyCurses_API[PyCurses_API_pointers];
 
 	/* Initialize object type */
-	Py_Type(&PyCursesWindow_Type) = &PyType_Type;
+	Py_TYPE(&PyCursesWindow_Type) = &PyType_Type;
 
 	/* Initialize the C API pointer array */
 	PyCurses_API[0] = (void *)&PyCursesWindow_Type;
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index 72c157d..97297b8 100644
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -248,7 +248,7 @@ typedef struct {
 
 static PyTypeObject Element_Type;
 
-#define Element_CheckExact(op) (Py_Type(op) == &Element_Type)
+#define Element_CheckExact(op) (Py_TYPE(op) == &Element_Type)
 
 /* -------------------------------------------------------------------- */
 /* element constructor and destructor */
@@ -1174,7 +1174,7 @@ element_setslice(PyObject* self_, Py_ssize_t start, Py_ssize_t end, PyObject* it
         /* FIXME: support arbitrary sequences? */
         PyErr_Format(
             PyExc_TypeError,
-            "expected list, not \"%.200s\"", Py_Type(item)->tp_name
+            "expected list, not \"%.200s\"", Py_TYPE(item)->tp_name
             );
         return -1;
     }
@@ -1407,7 +1407,7 @@ typedef struct {
 
 static PyTypeObject TreeBuilder_Type;
 
-#define TreeBuilder_CheckExact(op) (Py_Type(op) == &TreeBuilder_Type)
+#define TreeBuilder_CheckExact(op) (Py_TYPE(op) == &TreeBuilder_Type)
 
 /* -------------------------------------------------------------------- */
 /* constructor and destructor */
@@ -1574,7 +1574,7 @@ treebuilder_handle_data(TreeBuilderObject* self, PyObject* data)
         Py_INCREF(data); self->data = data;
     } else {
         /* more than one item; use a list to collect items */
-        if (PyString_CheckExact(self->data) && Py_Refcnt(self->data) == 1 &&
+        if (PyString_CheckExact(self->data) && Py_REFCNT(self->data) == 1 &&
             PyString_CheckExact(data) && PyString_GET_SIZE(data) == 1) {
             /* expat often generates single character data sections; handle
                the most common case by resizing the existing string... */
@@ -2550,9 +2550,9 @@ init_elementtree(void)
 #endif
 
     /* Patch object type */
-    Py_Type(&Element_Type) = Py_Type(&TreeBuilder_Type) = &PyType_Type;
+    Py_TYPE(&Element_Type) = Py_TYPE(&TreeBuilder_Type) = &PyType_Type;
 #if defined(USE_EXPAT)
-    Py_Type(&XMLParser_Type) = &PyType_Type;
+    Py_TYPE(&XMLParser_Type) = &PyType_Type;
 #endif
 
     m = Py_InitModule("_elementtree", _functions);
diff --git a/Modules/_fileio.c b/Modules/_fileio.c
index f3b20c9..7490ed6 100644
--- a/Modules/_fileio.c
+++ b/Modules/_fileio.c
@@ -304,7 +304,7 @@ fileio_dealloc(PyFileIOObject *self)
 		}
 	}
 
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *
diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
index 7564c3a..167f906 100644
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -81,7 +81,7 @@ partial_dealloc(partialobject *pto)
 	Py_XDECREF(pto->args);
 	Py_XDECREF(pto->kw);
 	Py_XDECREF(pto->dict);
-	Py_Type(pto)->tp_free(pto);
+	Py_TYPE(pto)->tp_free(pto);
 }
 
 static PyObject *
diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c
index 487240e..1791efe 100644
--- a/Modules/_hashopenssl.c
+++ b/Modules/_hashopenssl.c
@@ -510,7 +510,7 @@ init_hashlib(void)
      * but having some be unsupported.  Only init appropriate
      * constants. */
 
-    Py_Type(&EVPtype) = &PyType_Type;
+    Py_TYPE(&EVPtype) = &PyType_Type;
     if (PyType_Ready(&EVPtype) < 0)
         return;
 
diff --git a/Modules/_lsprof.c b/Modules/_lsprof.c
index 1707679..e0446ec 100644
--- a/Modules/_lsprof.c
+++ b/Modules/_lsprof.c
@@ -120,7 +120,7 @@ typedef struct {
 static PyTypeObject PyProfiler_Type;
 
 #define PyProfiler_Check(op) PyObject_TypeCheck(op, &PyProfiler_Type)
-#define PyProfiler_CheckExact(op) (Py_Type(op) == &PyProfiler_Type)
+#define PyProfiler_CheckExact(op) (Py_TYPE(op) == &PyProfiler_Type)
 
 /*** External Timers ***/
 
@@ -207,7 +207,7 @@ normalizeUserObj(PyObject *obj)
 		PyObject *self = fn->m_self;
 		PyObject *name = PyUnicode_FromString(fn->m_ml->ml_name);
 		if (name != NULL) {
-			PyObject *mo = _PyType_Lookup(Py_Type(self), name);
+			PyObject *mo = _PyType_Lookup(Py_TYPE(self), name);
 			Py_XINCREF(mo);
 			Py_DECREF(name);
 			if (mo != NULL) {
@@ -756,7 +756,7 @@ profiler_dealloc(ProfilerObject *op)
 	flush_unmatched(op);
 	clearEntries(op);
 	Py_XDECREF(op->externalTimer);
-	Py_Type(op)->tp_free(op);
+	Py_TYPE(op)->tp_free(op);
 }
 
 static int
diff --git a/Modules/_randommodule.c b/Modules/_randommodule.c
index c791909..957422c 100644
--- a/Modules/_randommodule.c
+++ b/Modules/_randommodule.c
@@ -84,7 +84,7 @@ typedef struct {
 
 static PyTypeObject Random_Type;
 
-#define RandomObject_Check(v)	   (Py_Type(v) == &Random_Type)
+#define RandomObject_Check(v)	   (Py_TYPE(v) == &Random_Type)
 
 
 /* Random methods */
@@ -405,7 +405,7 @@ random_jumpahead(RandomObject *self, PyObject *n)
 	if (!PyLong_Check(n)) {
 		PyErr_Format(PyExc_TypeError, "jumpahead requires an "
 			     "integer, not '%s'",
-			     Py_Type(n)->tp_name);
+			     Py_TYPE(n)->tp_name);
 		return NULL;
 	}
 
diff --git a/Modules/_sqlite/cache.c b/Modules/_sqlite/cache.c
index 2f50e6a..3cb540a 100644
--- a/Modules/_sqlite/cache.c
+++ b/Modules/_sqlite/cache.c
@@ -51,7 +51,7 @@ void pysqlite_node_dealloc(pysqlite_Node* self)
     Py_DECREF(self->key);
     Py_DECREF(self->data);
 
-    Py_Type(self)->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs)
@@ -109,7 +109,7 @@ void pysqlite_cache_dealloc(pysqlite_Cache* self)
     }
     Py_DECREF(self->mapping);
 
-    Py_Type(self)->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* args)
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index 92a3e51..9451881 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -205,7 +205,7 @@ void pysqlite_connection_dealloc(pysqlite_Connection* self)
     Py_XDECREF(self->collations);
     Py_XDECREF(self->statements);
 
-    Py_Type(self)->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c
index 334f94b..d723cdb 100644
--- a/Modules/_sqlite/cursor.c
+++ b/Modules/_sqlite/cursor.c
@@ -134,7 +134,7 @@ void pysqlite_cursor_dealloc(pysqlite_Cursor* self)
     Py_XDECREF(self->row_factory);
     Py_XDECREF(self->next_row);
 
-    Py_Type(self)->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 PyObject* _pysqlite_get_converter(PyObject* key)
diff --git a/Modules/_sqlite/prepare_protocol.c b/Modules/_sqlite/prepare_protocol.c
index c979610..c018c96 100644
--- a/Modules/_sqlite/prepare_protocol.c
+++ b/Modules/_sqlite/prepare_protocol.c
@@ -30,7 +30,7 @@ int pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol* self, PyObject* arg
 
 void pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol* self)
 {
-    Py_Type(self)->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 PyTypeObject pysqlite_PrepareProtocolType= {
@@ -78,6 +78,6 @@ PyTypeObject pysqlite_PrepareProtocolType= {
 extern int pysqlite_prepare_protocol_setup_types(void)
 {
     pysqlite_PrepareProtocolType.tp_new = PyType_GenericNew;
-    Py_Type(&pysqlite_PrepareProtocolType)= &PyType_Type;
+    Py_TYPE(&pysqlite_PrepareProtocolType)= &PyType_Type;
     return PyType_Ready(&pysqlite_PrepareProtocolType);
 }
diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c
index dfb6363..a851579 100644
--- a/Modules/_sqlite/row.c
+++ b/Modules/_sqlite/row.c
@@ -30,7 +30,7 @@ void pysqlite_row_dealloc(pysqlite_Row* self)
     Py_XDECREF(self->data);
     Py_XDECREF(self->description);
 
-    Py_Type(self)->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 int pysqlite_row_init(pysqlite_Row* self, PyObject* args, PyObject* kwargs)
diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c
index 126ba6f..d280a67 100644
--- a/Modules/_sqlite/statement.c
+++ b/Modules/_sqlite/statement.c
@@ -307,7 +307,7 @@ void pysqlite_statement_dealloc(pysqlite_Statement* self)
         PyObject_ClearWeakRefs((PyObject*)self);
     }
 
-    Py_Type(self)->tp_free((PyObject*)self);
+    Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 /*
diff --git a/Modules/_sre.c b/Modules/_sre.c
index 33f3759..19e7bdc 100644
--- a/Modules/_sre.c
+++ b/Modules/_sre.c
@@ -1685,7 +1685,7 @@ getstring(PyObject* string, Py_ssize_t* p_length, int* p_charsize)
 
     /* get pointer to string buffer */
     view.len = -1;
-    buffer = Py_Type(string)->tp_as_buffer;
+    buffer = Py_TYPE(string)->tp_as_buffer;
     if (!buffer || !buffer->bf_getbuffer || 
         (*buffer->bf_getbuffer)(string, &view, PyBUF_SIMPLE) < 0) {
             PyErr_SetString(PyExc_TypeError, "expected string or buffer");
diff --git a/Modules/_ssl.c b/Modules/_ssl.c
index 58b04a6..13d27cc 100644
--- a/Modules/_ssl.c
+++ b/Modules/_ssl.c
@@ -127,7 +127,7 @@ static int check_socket_and_wait_for_timeout(PySocketSockObject *s,
 static PyObject *PySSL_peercert(PySSLObject *self, PyObject *args);
 static PyObject *PySSL_cipher(PySSLObject *self);
 
-#define PySSLObject_Check(v)	(Py_Type(v) == &PySSL_Type)
+#define PySSLObject_Check(v)	(Py_TYPE(v) == &PySSL_Type)
 
 typedef enum {
 	SOCKET_IS_NONBLOCKING,
@@ -1451,7 +1451,7 @@ PySSL_RAND_egd(PyObject *self, PyObject *arg)
     if (!PyUnicode_Check(arg))
 	return PyErr_Format(PyExc_TypeError,
 			    "RAND_egd() expected string, found %s",
-			    Py_Type(arg)->tp_name);
+			    Py_TYPE(arg)->tp_name);
     bytes = RAND_egd(PyUnicode_AsString(arg));
     if (bytes == -1) {
 	PyErr_SetString(PySSLErrorObject,
@@ -1568,7 +1568,7 @@ init_ssl(void)
 {
 	PyObject *m, *d;
 
-	Py_Type(&PySSL_Type) = &PyType_Type;
+	Py_TYPE(&PySSL_Type) = &PyType_Type;
 
 	m = Py_InitModule3("_ssl", PySSL_methods, module_doc);
 	if (m == NULL)
diff --git a/Modules/_struct.c b/Modules/_struct.c
index dd92e0c..3c02bc9 100644
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -67,7 +67,7 @@ typedef struct {
 
 
 #define PyStruct_Check(op) PyObject_TypeCheck(op, &PyStructType)
-#define PyStruct_CheckExact(op) (Py_Type(op) == &PyStructType)
+#define PyStruct_CheckExact(op) (Py_TYPE(op) == &PyStructType)
 
 
 /* Exception */
@@ -126,7 +126,7 @@ get_pylong(PyObject *v)
 		Py_INCREF(v);
 		return v;
 	}
-	m = Py_Type(v)->tp_as_number;
+	m = Py_TYPE(v)->tp_as_number;
 	if (m != NULL && m->nb_long != NULL) {
 		v = m->nb_long(v);
 		if (v == NULL)
@@ -1485,7 +1485,7 @@ s_dealloc(PyStructObject *s)
 		PyMem_FREE(s->s_codes);
 	}
 	Py_XDECREF(s->s_format);
-	Py_Type(s)->tp_free((PyObject *)s);
+	Py_TYPE(s)->tp_free((PyObject *)s);
 }
 
 static PyObject *
@@ -1870,7 +1870,7 @@ init_struct(void)
 	if (m == NULL)
 		return;
 
-	Py_Type(&PyStructType) = &PyType_Type;
+	Py_TYPE(&PyStructType) = &PyType_Type;
 	if (PyType_Ready(&PyStructType) < 0)
 		return;
 
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index 7de5e0d..d89a513 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -1057,7 +1057,7 @@ init_testcapi(void)
 	if (m == NULL)
 		return;
 
-	Py_Type(&test_structmembersType)=&PyType_Type;
+	Py_TYPE(&test_structmembersType)=&PyType_Type;
 	Py_INCREF(&test_structmembersType);
 	PyModule_AddObject(m, "test_structmembersType", (PyObject *)&test_structmembersType);
 
diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index 2a341ab..bc54b7b 100644
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -262,12 +262,12 @@ typedef struct {
 	Tcl_ObjType *StringType;
 } TkappObject;
 
-#define Tkapp_Check(v) (Py_Type(v) == &Tkapp_Type)
+#define Tkapp_Check(v) (Py_TYPE(v) == &Tkapp_Type)
 #define Tkapp_Interp(v) (((TkappObject *) (v))->interp)
 #define Tkapp_Result(v) Tcl_GetStringResult(Tkapp_Interp(v))
 
 #define DEBUG_REFCNT(v) (printf("DEBUG: id=%p, refcnt=%i\n", \
-(void *) v, Py_Refcnt(v)))
+(void *) v, Py_REFCNT(v)))
 
 
 
@@ -3016,7 +3016,7 @@ init_tkinter(void)
 {
 	PyObject *m, *d;
 
-	Py_Type(&Tkapp_Type) = &PyType_Type;
+	Py_TYPE(&Tkapp_Type) = &PyType_Type;
 
 #ifdef WITH_THREAD
 	tcl_lock = PyThread_allocate_lock();
@@ -3044,10 +3044,10 @@ init_tkinter(void)
 
 	PyDict_SetItemString(d, "TkappType", (PyObject *)&Tkapp_Type);
 
-	Py_Type(&Tktt_Type) = &PyType_Type;
+	Py_TYPE(&Tktt_Type) = &PyType_Type;
 	PyDict_SetItemString(d, "TkttType", (PyObject *)&Tktt_Type);
 
-	Py_Type(&PyTclObject_Type) = &PyType_Type;
+	Py_TYPE(&PyTclObject_Type) = &PyType_Type;
 	PyDict_SetItemString(d, "Tcl_Obj", (PyObject *)&PyTclObject_Type);
 
 #ifdef TK_AQUA
diff --git a/Modules/_weakref.c b/Modules/_weakref.c
index f4ee3a3..b187a26 100644
--- a/Modules/_weakref.c
+++ b/Modules/_weakref.c
@@ -14,7 +14,7 @@ weakref_getweakrefcount(PyObject *self, PyObject *object)
 {
     PyObject *result = NULL;
 
-    if (PyType_SUPPORTS_WEAKREFS(Py_Type(object))) {
+    if (PyType_SUPPORTS_WEAKREFS(Py_TYPE(object))) {
         PyWeakReference **list = GET_WEAKREFS_LISTPTR(object);
 
         result = PyLong_FromSsize_t(_PyWeakref_GetWeakrefCount(*list));
@@ -35,7 +35,7 @@ weakref_getweakrefs(PyObject *self, PyObject *object)
 {
     PyObject *result = NULL;
 
-    if (PyType_SUPPORTS_WEAKREFS(Py_Type(object))) {
+    if (PyType_SUPPORTS_WEAKREFS(Py_TYPE(object))) {
         PyWeakReference **list = GET_WEAKREFS_LISTPTR(object);
         Py_ssize_t count = _PyWeakref_GetWeakrefCount(*list);
 
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index 86afc92..eb12625 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -41,7 +41,7 @@ typedef struct arrayobject {
 static PyTypeObject Arraytype;
 
 #define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
-#define array_CheckExact(op) (Py_Type(op) == &Arraytype)
+#define array_CheckExact(op) (Py_TYPE(op) == &Arraytype)
 
 static int
 array_resize(arrayobject *self, Py_ssize_t newsize)
@@ -55,9 +55,9 @@ array_resize(arrayobject *self, Py_ssize_t newsize)
 	*/
 
 	if (self->allocated >= newsize &&
-	    Py_Size(self) < newsize + 16 &&
+	    Py_SIZE(self) < newsize + 16 &&
 	    self->ob_item != NULL) {
-		Py_Size(self) = newsize;
+		Py_SIZE(self) = newsize;
 		return 0;
 	}
 
@@ -79,7 +79,7 @@ array_resize(arrayobject *self, Py_ssize_t newsize)
 	 * memory critical.
 	 */
 
-	_new_size = (newsize >> 4) + (Py_Size(self) < 8 ? 3 : 7) + newsize;
+	_new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
 	items = self->ob_item;
 	/* XXX The following multiplication and division does not optimize away 
 	   like it does for lists since the size is not known at compile time */
@@ -92,7 +92,7 @@ array_resize(arrayobject *self, Py_ssize_t newsize)
 		return -1;
 	}
 	self->ob_item = items;
-	Py_Size(self) = newsize;
+	Py_SIZE(self) = newsize;
 	self->allocated = _new_size;
 	return 0;
 }
@@ -421,7 +421,7 @@ newarrayobject(PyTypeObject *type, Py_ssize_t size, struct arraydescr *descr)
 	if (op == NULL) {
 		return NULL;
 	}
-	Py_Size(op) = size;
+	Py_SIZE(op) = size;
 	if (size <= 0) {
 		op->ob_item = NULL;
 	}
@@ -445,7 +445,7 @@ getarrayitem(PyObject *op, Py_ssize_t i)
 	register arrayobject *ap;
 	assert(array_Check(op));
 	ap = (arrayobject *)op;
-	assert(i>=0 && i<Py_Size(ap));
+	assert(i>=0 && i<Py_SIZE(ap));
 	return (*ap->ob_descr->getitem)(ap, i);
 }
 
@@ -453,7 +453,7 @@ static int
 ins1(arrayobject *self, Py_ssize_t where, PyObject *v)
 {
 	char *items;
-	Py_ssize_t n = Py_Size(self);
+	Py_ssize_t n = Py_SIZE(self);
 	if (v == NULL) {
 		PyErr_BadInternalCall();
 		return -1;
@@ -488,7 +488,7 @@ array_dealloc(arrayobject *op)
 		PyObject_ClearWeakRefs((PyObject *) op);
 	if (op->ob_item != NULL)
 		PyMem_DEL(op->ob_item);
-	Py_Type(op)->tp_free((PyObject *)op);
+	Py_TYPE(op)->tp_free((PyObject *)op);
 }
 
 static PyObject *
@@ -508,7 +508,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
 	va = (arrayobject *)v;
 	wa = (arrayobject *)w;
 
-	if (Py_Size(va) != Py_Size(wa) && (op == Py_EQ || op == Py_NE)) {
+	if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) {
 		/* Shortcut: if the lengths differ, the arrays differ */
 		if (op == Py_EQ)
 			res = Py_False;
@@ -520,7 +520,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
 
 	/* Search for the first index where items are different */
 	k = 1;
-	for (i = 0; i < Py_Size(va) && i < Py_Size(wa); i++) {
+	for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
 		vi = getarrayitem(v, i);
 		wi = getarrayitem(w, i);
 		if (vi == NULL || wi == NULL) {
@@ -539,8 +539,8 @@ array_richcompare(PyObject *v, PyObject *w, int op)
 
 	if (k) {
 		/* No more items to compare -- compare sizes */
-		Py_ssize_t vs = Py_Size(va);
-		Py_ssize_t ws = Py_Size(wa);
+		Py_ssize_t vs = Py_SIZE(va);
+		Py_ssize_t ws = Py_SIZE(wa);
 		int cmp;
 		switch (op) {
 		case Py_LT: cmp = vs <  ws; break;
@@ -580,13 +580,13 @@ array_richcompare(PyObject *v, PyObject *w, int op)
 static Py_ssize_t
 array_length(arrayobject *a)
 {
-	return Py_Size(a);
+	return Py_SIZE(a);
 }
 
 static PyObject *
 array_item(arrayobject *a, Py_ssize_t i)
 {
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		PyErr_SetString(PyExc_IndexError, "array index out of range");
 		return NULL;
 	}
@@ -599,14 +599,14 @@ array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
 	arrayobject *np;
 	if (ilow < 0)
 		ilow = 0;
-	else if (ilow > Py_Size(a))
-		ilow = Py_Size(a);
+	else if (ilow > Py_SIZE(a))
+		ilow = Py_SIZE(a);
 	if (ihigh < 0)
 		ihigh = 0;
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > Py_Size(a))
-		ihigh = Py_Size(a);
+	else if (ihigh > Py_SIZE(a))
+		ihigh = Py_SIZE(a);
 	np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
 	if (np == NULL)
 		return NULL;
@@ -618,7 +618,7 @@ array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
 static PyObject *
 array_copy(arrayobject *a, PyObject *unused)
 {
-	return array_slice(a, 0, Py_Size(a));
+	return array_slice(a, 0, Py_SIZE(a));
 }
 
 PyDoc_STRVAR(copy_doc,
@@ -634,7 +634,7 @@ array_concat(arrayobject *a, PyObject *bb)
 	if (!array_Check(bb)) {
 		PyErr_Format(PyExc_TypeError,
 		     "can only append array (not \"%.200s\") to array",
-			     Py_Type(bb)->tp_name);
+			     Py_TYPE(bb)->tp_name);
 		return NULL;
 	}
 #define b ((arrayobject *)bb)
@@ -642,14 +642,14 @@ array_concat(arrayobject *a, PyObject *bb)
 		PyErr_BadArgument();
 		return NULL;
 	}
-	size = Py_Size(a) + Py_Size(b);
+	size = Py_SIZE(a) + Py_SIZE(b);
 	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
 	if (np == NULL) {
 		return NULL;
 	}
-	memcpy(np->ob_item, a->ob_item, Py_Size(a)*a->ob_descr->itemsize);
-	memcpy(np->ob_item + Py_Size(a)*a->ob_descr->itemsize,
-	       b->ob_item, Py_Size(b)*b->ob_descr->itemsize);
+	memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
+	memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
+	       b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
 	return (PyObject *)np;
 #undef b
 }
@@ -664,12 +664,12 @@ array_repeat(arrayobject *a, Py_ssize_t n)
 	Py_ssize_t nbytes;
 	if (n < 0)
 		n = 0;
-	size = Py_Size(a) * n;
+	size = Py_SIZE(a) * n;
 	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
 	if (np == NULL)
 		return NULL;
 	p = np->ob_item;
-	nbytes = Py_Size(a) * a->ob_descr->itemsize;
+	nbytes = Py_SIZE(a) * a->ob_descr->itemsize;
 	for (i = 0; i < n; i++) {
 		memcpy(p, a->ob_item, nbytes);
 		p += nbytes;
@@ -687,7 +687,7 @@ array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 	if (v == NULL)
 		n = 0;
 	else if (array_Check(v)) {
-		n = Py_Size(b);
+		n = Py_SIZE(b);
 		if (a == b) {
 			/* Special case "a[i:j] = a" -- copy b first */
 			int ret;
@@ -706,44 +706,44 @@ array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 	else {
 		PyErr_Format(PyExc_TypeError,
 	     "can only assign array (not \"%.200s\") to array slice",
-			     Py_Type(v)->tp_name);
+			     Py_TYPE(v)->tp_name);
 		return -1;
 	}
 	if (ilow < 0)
 		ilow = 0;
-	else if (ilow > Py_Size(a))
-		ilow = Py_Size(a);
+	else if (ilow > Py_SIZE(a))
+		ilow = Py_SIZE(a);
 	if (ihigh < 0)
 		ihigh = 0;
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > Py_Size(a))
-		ihigh = Py_Size(a);
+	else if (ihigh > Py_SIZE(a))
+		ihigh = Py_SIZE(a);
 	item = a->ob_item;
 	d = n - (ihigh-ilow);
 	if (d < 0) { /* Delete -d items */
 		memmove(item + (ihigh+d)*a->ob_descr->itemsize,
 			item + ihigh*a->ob_descr->itemsize,
-			(Py_Size(a)-ihigh)*a->ob_descr->itemsize);
-		Py_Size(a) += d;
-		PyMem_RESIZE(item, char, Py_Size(a)*a->ob_descr->itemsize);
+			(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
+		Py_SIZE(a) += d;
+		PyMem_RESIZE(item, char, Py_SIZE(a)*a->ob_descr->itemsize);
 						/* Can't fail */
 		a->ob_item = item;
-		a->allocated = Py_Size(a);
+		a->allocated = Py_SIZE(a);
 	}
 	else if (d > 0) { /* Insert d items */
 		PyMem_RESIZE(item, char,
-			     (Py_Size(a) + d)*a->ob_descr->itemsize);
+			     (Py_SIZE(a) + d)*a->ob_descr->itemsize);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return -1;
 		}
 		memmove(item + (ihigh+d)*a->ob_descr->itemsize,
 			item + ihigh*a->ob_descr->itemsize,
-			(Py_Size(a)-ihigh)*a->ob_descr->itemsize);
+			(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
 		a->ob_item = item;
-		Py_Size(a) += d;
-		a->allocated = Py_Size(a);
+		Py_SIZE(a) += d;
+		a->allocated = Py_SIZE(a);
 	}
 	if (n > 0)
 		memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
@@ -755,7 +755,7 @@ array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 static int
 array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
 {
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		PyErr_SetString(PyExc_IndexError,
 			         "array assignment index out of range");
 		return -1;
@@ -782,7 +782,7 @@ array_iter_extend(arrayobject *self, PyObject *bb)
 		return -1;
 
 	while ((v = PyIter_Next(it)) != NULL) {
-		if (ins1(self, (int) Py_Size(self), v) != 0) {
+		if (ins1(self, (int) Py_SIZE(self), v) != 0) {
 			Py_DECREF(v);
 			Py_DECREF(it);
 			return -1;
@@ -808,16 +808,16 @@ array_do_extend(arrayobject *self, PyObject *bb)
 			     "can only extend with array of same kind");
 		return -1;
 	}
-	size = Py_Size(self) + Py_Size(b);
+	size = Py_SIZE(self) + Py_SIZE(b);
         PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
         if (self->ob_item == NULL) {
                 PyObject_Del(self);
                 PyErr_NoMemory();
 		return -1;
         }
-	memcpy(self->ob_item + Py_Size(self)*self->ob_descr->itemsize,
-               b->ob_item, Py_Size(b)*b->ob_descr->itemsize);
-	Py_Size(self) = size;
+	memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
+               b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
+	Py_SIZE(self) = size;
 	self->allocated = size;
 
 	return 0;
@@ -830,7 +830,7 @@ array_inplace_concat(arrayobject *self, PyObject *bb)
 	if (!array_Check(bb)) {
 		PyErr_Format(PyExc_TypeError,
 			"can only extend array with array (not \"%.200s\")",
-			Py_Type(bb)->tp_name);
+			Py_TYPE(bb)->tp_name);
 		return NULL;
 	}
 	if (array_do_extend(self, bb) == -1)
@@ -845,15 +845,15 @@ array_inplace_repeat(arrayobject *self, Py_ssize_t n)
 	char *items, *p;
 	Py_ssize_t size, i;
 
-	if (Py_Size(self) > 0) {
+	if (Py_SIZE(self) > 0) {
 		if (n < 0)
 			n = 0;
 		items = self->ob_item;
-		size = Py_Size(self) * self->ob_descr->itemsize;
+		size = Py_SIZE(self) * self->ob_descr->itemsize;
 		if (n == 0) {
 			PyMem_FREE(items);
 			self->ob_item = NULL;
-			Py_Size(self) = 0;
+			Py_SIZE(self) = 0;
 			self->allocated = 0;
 		}
 		else {
@@ -866,8 +866,8 @@ array_inplace_repeat(arrayobject *self, Py_ssize_t n)
 				memcpy(p, items, size);
 			}
 			self->ob_item = items;
-			Py_Size(self) *= n;
-			self->allocated = Py_Size(self);
+			Py_SIZE(self) *= n;
+			self->allocated = Py_SIZE(self);
 		}
 	}
 	Py_INCREF(self);
@@ -890,7 +890,7 @@ array_count(arrayobject *self, PyObject *v)
 	Py_ssize_t count = 0;
 	Py_ssize_t i;
 
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self, i);
 		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -912,7 +912,7 @@ array_index(arrayobject *self, PyObject *v)
 {
 	Py_ssize_t i;
 
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self, i);
 		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -937,7 +937,7 @@ array_contains(arrayobject *self, PyObject *v)
 	Py_ssize_t i;
 	int cmp;
 
-	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(self); i++) {
+	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self, i);
 		cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -950,7 +950,7 @@ array_remove(arrayobject *self, PyObject *v)
 {
 	int i;
 
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *selfi = getarrayitem((PyObject *)self,i);
 		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
 		Py_DECREF(selfi);
@@ -980,14 +980,14 @@ array_pop(arrayobject *self, PyObject *args)
 	PyObject *v;
 	if (!PyArg_ParseTuple(args, "|n:pop", &i))
 		return NULL;
-	if (Py_Size(self) == 0) {
+	if (Py_SIZE(self) == 0) {
 		/* Special-case most common failure cause */
 		PyErr_SetString(PyExc_IndexError, "pop from empty array");
 		return NULL;
 	}
 	if (i < 0)
-		i += Py_Size(self);
-	if (i < 0 || i >= Py_Size(self)) {
+		i += Py_SIZE(self);
+	if (i < 0 || i >= Py_SIZE(self)) {
 		PyErr_SetString(PyExc_IndexError, "pop index out of range");
 		return NULL;
 	}
@@ -1043,7 +1043,7 @@ array_buffer_info(arrayobject *self, PyObject *unused)
 		return NULL;
 
 	PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
-	PyTuple_SET_ITEM(retval, 1, PyLong_FromLong((long)(Py_Size(self))));
+	PyTuple_SET_ITEM(retval, 1, PyLong_FromLong((long)(Py_SIZE(self))));
 
 	return retval;
 }
@@ -1060,7 +1060,7 @@ the buffer length in bytes.");
 static PyObject *
 array_append(arrayobject *self, PyObject *v)
 {
-	return ins(self, (int) Py_Size(self), v);
+	return ins(self, (int) Py_SIZE(self), v);
 }
 
 PyDoc_STRVAR(append_doc,
@@ -1079,14 +1079,14 @@ array_byteswap(arrayobject *self, PyObject *unused)
 	case 1:
 		break;
 	case 2:
-		for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 2) {
+		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
 			char p0 = p[0];
 			p[0] = p[1];
 			p[1] = p0;
 		}
 		break;
 	case 4:
-		for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 4) {
+		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
 			char p0 = p[0];
 			char p1 = p[1];
 			p[0] = p[3];
@@ -1096,7 +1096,7 @@ array_byteswap(arrayobject *self, PyObject *unused)
 		}
 		break;
 	case 8:
-		for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 8) {
+		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
 			char p0 = p[0];
 			char p1 = p[1];
 			char p2 = p[2];
@@ -1137,16 +1137,16 @@ array_reduce(arrayobject *array)
 		dict = Py_None;
 		Py_INCREF(dict);
 	}
-	if (Py_Size(array) > 0) {
+	if (Py_SIZE(array) > 0) {
 		result = Py_BuildValue("O(cy#)O", 
-			Py_Type(array), 
+			Py_TYPE(array), 
 			array->ob_descr->typecode,
 			array->ob_item,
-			Py_Size(array) * array->ob_descr->itemsize,
+			Py_SIZE(array) * array->ob_descr->itemsize,
 			dict);
 	} else {
 		result = Py_BuildValue("O(c)O", 
-			Py_Type(array), 
+			Py_TYPE(array), 
 			array->ob_descr->typecode,
 			dict);
 	}
@@ -1165,9 +1165,9 @@ array_reverse(arrayobject *self, PyObject *unused)
 	char tmp[256];	/* 8 is probably enough -- but why skimp */
 	assert((size_t)itemsize <= sizeof(tmp));
 
-	if (Py_Size(self) > 1) {
+	if (Py_SIZE(self) > 1) {
 		for (p = self->ob_item,
-		     q = self->ob_item + (Py_Size(self) - 1)*itemsize;
+		     q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
 		     p < q;
 		     p += itemsize, q -= itemsize) {
 			/* memory areas guaranteed disjoint, so memcpy
@@ -1247,14 +1247,14 @@ array.  Also called as read.");
 static PyObject *
 array_tofile(arrayobject *self, PyObject *f)
 {
-	Py_ssize_t nbytes = Py_Size(self) * self->ob_descr->itemsize;
+	Py_ssize_t nbytes = Py_SIZE(self) * self->ob_descr->itemsize;
 	/* Write 64K blocks at a time */
 	/* XXX Make the block size settable */
 	int BLOCKSIZE = 64*1024;
 	Py_ssize_t nblocks = (nbytes + BLOCKSIZE - 1) / BLOCKSIZE;
 	Py_ssize_t i;
 
-        if (Py_Size(self) == 0)
+        if (Py_SIZE(self) == 0)
 		goto done;
 
 	for (i = 0; i < nblocks; i++) {
@@ -1299,23 +1299,23 @@ array_fromlist(arrayobject *self, PyObject *list)
 	if (n > 0) {
 		char *item = self->ob_item;
 		Py_ssize_t i;
-		PyMem_RESIZE(item, char, (Py_Size(self) + n) * itemsize);
+		PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return NULL;
 		}
 		self->ob_item = item;
-		Py_Size(self) += n;
-		self->allocated = Py_Size(self);
+		Py_SIZE(self) += n;
+		self->allocated = Py_SIZE(self);
 		for (i = 0; i < n; i++) {
 			PyObject *v = PyList_GetItem(list, i);
 			if ((*self->ob_descr->setitem)(self,
-					Py_Size(self) - n + i, v) != 0) {
-				Py_Size(self) -= n;
+					Py_SIZE(self) - n + i, v) != 0) {
+				Py_SIZE(self) -= n;
 				PyMem_RESIZE(item, char,
-					          Py_Size(self) * itemsize);
+					          Py_SIZE(self) * itemsize);
 				self->ob_item = item;
-				self->allocated = Py_Size(self);
+				self->allocated = Py_SIZE(self);
 				return NULL;
 			}
 		}
@@ -1332,12 +1332,12 @@ Append items to array from list.");
 static PyObject *
 array_tolist(arrayobject *self, PyObject *unused)
 {
-	PyObject *list = PyList_New(Py_Size(self));
+	PyObject *list = PyList_New(Py_SIZE(self));
 	Py_ssize_t i;
 
 	if (list == NULL)
 		return NULL;
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		PyObject *v = getarrayitem((PyObject *)self, i);
 		if (v == NULL) {
 			Py_DECREF(list);
@@ -1370,15 +1370,15 @@ array_fromstring(arrayobject *self, PyObject *args)
 	n = n / itemsize;
 	if (n > 0) {
 		char *item = self->ob_item;
-		PyMem_RESIZE(item, char, (Py_Size(self) + n) * itemsize);
+		PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return NULL;
 		}
 		self->ob_item = item;
-		Py_Size(self) += n;
-		self->allocated = Py_Size(self);
-		memcpy(item + (Py_Size(self) - n) * itemsize,
+		Py_SIZE(self) += n;
+		self->allocated = Py_SIZE(self);
+		memcpy(item + (Py_SIZE(self) - n) * itemsize,
 		       str, itemsize*n);
 	}
 	Py_INCREF(Py_None);
@@ -1396,7 +1396,7 @@ static PyObject *
 array_tostring(arrayobject *self, PyObject *unused)
 {
 	return PyString_FromStringAndSize(self->ob_item,
-                                         Py_Size(self) * self->ob_descr->itemsize);
+                                         Py_SIZE(self) * self->ob_descr->itemsize);
 }
 
 PyDoc_STRVAR(tostring_doc,
@@ -1425,15 +1425,15 @@ array_fromunicode(arrayobject *self, PyObject *args)
 	}
 	if (n > 0) {
 		Py_UNICODE *item = (Py_UNICODE *) self->ob_item;
-		PyMem_RESIZE(item, Py_UNICODE, Py_Size(self) + n);
+		PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
 		if (item == NULL) {
 			PyErr_NoMemory();
 			return NULL;
 		}
 		self->ob_item = (char *) item;
-		Py_Size(self) += n;
-		self->allocated = Py_Size(self);
-		memcpy(item + Py_Size(self) - n,
+		Py_SIZE(self) += n;
+		self->allocated = Py_SIZE(self);
+		memcpy(item + Py_SIZE(self) - n,
 		       ustr, n * sizeof(Py_UNICODE));
 	}
 
@@ -1460,7 +1460,7 @@ array_tounicode(arrayobject *self, PyObject *unused)
 		     "tounicode() may only be called on unicode type arrays");
 		return NULL;
 	}
-	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_Size(self));
+	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
 }
 
 PyDoc_STRVAR(tounicode_doc,
@@ -1553,7 +1553,7 @@ array_repr(arrayobject *a)
 	PyObject *s, *v = NULL;
 	Py_ssize_t len;
 
-	len = Py_Size(a);
+	len = Py_SIZE(a);
 	typecode = a->ob_descr->typecode;
 	if (len == 0) {
 		return PyUnicode_FromFormat("array('%c')", typecode);
@@ -1577,7 +1577,7 @@ array_subscr(arrayobject* self, PyObject* item)
 			return NULL;
 		}
 		if (i < 0)
-			i += Py_Size(self);
+			i += Py_SIZE(self);
 		return array_item(self, i);
 	}
 	else if (PySlice_Check(item)) {
@@ -1586,7 +1586,7 @@ array_subscr(arrayobject* self, PyObject* item)
 		arrayobject* ar;
 		int itemsize = self->ob_descr->itemsize;
 
-		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
+		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
 				 &start, &stop, &step, &slicelength) < 0) {
 			return NULL;
 		}
@@ -1640,8 +1640,8 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 		if (i == -1 && PyErr_Occurred())
 			return -1;
 		if (i < 0)
-			i += Py_Size(self);
-		if (i < 0 || i >= Py_Size(self)) {
+			i += Py_SIZE(self);
+		if (i < 0 || i >= Py_SIZE(self)) {
 			PyErr_SetString(PyExc_IndexError,
 				"array assignment index out of range");
 			return -1;
@@ -1658,7 +1658,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 	}
 	else if (PySlice_Check(item)) {
 		if (PySlice_GetIndicesEx((PySliceObject *)item,
-					 Py_Size(self), &start, &stop,
+					 Py_SIZE(self), &start, &stop,
 					 &step, &slicelength) < 0) {
 			return -1;
 		}
@@ -1674,7 +1674,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 	}
 	else if (array_Check(value)) {
 		other = (arrayobject *)value;
-		needed = Py_Size(other);
+		needed = Py_SIZE(other);
 		if (self == other) {
 			/* Special case "self[i:j] = self" -- copy self first */
 			int ret;
@@ -1693,7 +1693,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 	else {
 		PyErr_Format(PyExc_TypeError,
 	     "can only assign array (not \"%.200s\") to array slice",
-			     Py_Type(value)->tp_name);
+			     Py_TYPE(value)->tp_name);
 		return -1;
 	}
 	itemsize = self->ob_descr->itemsize;
@@ -1705,18 +1705,18 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 		if (slicelength > needed) {
 			memmove(self->ob_item + (start + needed) * itemsize,
 				self->ob_item + stop * itemsize,
-				(Py_Size(self) - stop) * itemsize);
-			if (array_resize(self, Py_Size(self) +
+				(Py_SIZE(self) - stop) * itemsize);
+			if (array_resize(self, Py_SIZE(self) +
 					 needed - slicelength) < 0)
 				return -1;
 		}
 		else if (slicelength < needed) {
-			if (array_resize(self, Py_Size(self) +
+			if (array_resize(self, Py_SIZE(self) +
 					 needed - slicelength) < 0)
 				return -1;
 			memmove(self->ob_item + (start + needed) * itemsize,
 				self->ob_item + stop * itemsize,
-				(Py_Size(self) - start - needed) * itemsize);
+				(Py_SIZE(self) - start - needed) * itemsize);
 		}
 		if (needed > 0)
 			memcpy(self->ob_item + start * itemsize,
@@ -1736,19 +1736,19 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 		     cur += step, i++) {
 			Py_ssize_t lim = step - 1;
 
-			if (cur + step >= Py_Size(self))
-				lim = Py_Size(self) - cur - 1;
+			if (cur + step >= Py_SIZE(self))
+				lim = Py_SIZE(self) - cur - 1;
 			memmove(self->ob_item + (cur - i) * itemsize,
 				self->ob_item + (cur + 1) * itemsize,
 				lim * itemsize);
 		}
 		cur = start + slicelength * step;
-		if (cur < Py_Size(self)) {
+		if (cur < Py_SIZE(self)) {
 			memmove(self->ob_item + (cur-slicelength) * itemsize,
 				self->ob_item + cur * itemsize,
-				(Py_Size(self) - cur) * itemsize);
+				(Py_SIZE(self) - cur) * itemsize);
 		}
-		if (array_resize(self, Py_Size(self) - slicelength) < 0)
+		if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
 			return -1;
 		return 0;
 	}
@@ -1794,14 +1794,14 @@ array_buffer_getbuf(arrayobject *self, Py_buffer *view, int flags)
         view->buf = (void *)self->ob_item;
         if (view->buf == NULL)
                 view->buf = (void *)emptybuf;
-        view->len = (Py_Size(self)) * self->ob_descr->itemsize;
+        view->len = (Py_SIZE(self)) * self->ob_descr->itemsize;
         view->readonly = 0;
         view->ndim = 1;
         view->itemsize = self->ob_descr->itemsize;
         view->suboffsets = NULL;
         view->shape = NULL;
         if ((flags & PyBUF_ND)==PyBUF_ND) {
-                view->shape = &((Py_Size(self)));
+                view->shape = &((Py_SIZE(self)));
         }
         view->strides = NULL;
         if ((flags & PyBUF_STRIDES)==PyBUF_STRIDES)
@@ -1935,9 +1935,9 @@ array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 						return NULL;
 					}
 					self->ob_item = item;
-					Py_Size(self) = n / sizeof(Py_UNICODE);
+					Py_SIZE(self) = n / sizeof(Py_UNICODE);
 					memcpy(item, PyUnicode_AS_DATA(initial), n);
-					self->allocated = Py_Size(self);
+					self->allocated = Py_SIZE(self);
 				}
 			}
 			if (it != NULL) {
@@ -2108,7 +2108,7 @@ static PyObject *
 arrayiter_next(arrayiterobject *it)
 {
 	assert(PyArrayIter_Check(it));
-	if (it->index < Py_Size(it->ao))
+	if (it->index < Py_SIZE(it->ao))
 		return (*it->getitem)(it->ao, it->index++);
 	return NULL;
 }
@@ -2180,7 +2180,7 @@ initarray(void)
 
 	if (PyType_Ready(&Arraytype) < 0)
             return;
-	Py_Type(&PyArrayIter_Type) = &PyType_Type;
+	Py_TYPE(&PyArrayIter_Type) = &PyType_Type;
 	m = Py_InitModule3("array", a_methods, module_doc);
 	if (m == NULL)
 		return;
diff --git a/Modules/bz2module.c b/Modules/bz2module.c
index 32c8106..89d35aa 100644
--- a/Modules/bz2module.c
+++ b/Modules/bz2module.c
@@ -41,7 +41,7 @@ typedef fpos_t Py_off_t;
 #define MODE_READ_EOF 2
 #define MODE_WRITE    3
 
-#define BZ2FileObject_Check(v)	(Py_Type(v) == &BZ2File_Type)
+#define BZ2FileObject_Check(v)	(Py_TYPE(v) == &BZ2File_Type)
 
 
 #ifdef BZ_CONFIG_ERROR
@@ -1240,7 +1240,7 @@ BZ2File_dealloc(BZ2FileObject *self)
 	Util_DropReadAhead(self);
 	if (self->rawfp != NULL)
 		fclose(self->rawfp);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 /* This is a hacked version of Python's fileobject.c:file_getiter(). */
@@ -1552,7 +1552,7 @@ BZ2Comp_dealloc(BZ2CompObject *self)
 		PyThread_free_lock(self->lock);
 #endif
 	BZ2_bzCompressEnd(&self->bzs);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 
@@ -1777,7 +1777,7 @@ BZ2Decomp_dealloc(BZ2DecompObject *self)
 #endif
 	Py_XDECREF(self->unused_data);
 	BZ2_bzDecompressEnd(&self->bzs);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 
@@ -2031,9 +2031,9 @@ initbz2(void)
 {
 	PyObject *m;
 
-	Py_Type(&BZ2File_Type) = &PyType_Type;
-	Py_Type(&BZ2Comp_Type) = &PyType_Type;
-	Py_Type(&BZ2Decomp_Type) = &PyType_Type;
+	Py_TYPE(&BZ2File_Type) = &PyType_Type;
+	Py_TYPE(&BZ2Comp_Type) = &PyType_Type;
+	Py_TYPE(&BZ2Decomp_Type) = &PyType_Type;
 
 	m = Py_InitModule3("bz2", bz2_methods, bz2__doc__);
 	if (m == NULL)
diff --git a/Modules/cStringIO.c b/Modules/cStringIO.c
index 79834f9..1251c1d 100644
--- a/Modules/cStringIO.c
+++ b/Modules/cStringIO.c
@@ -738,8 +738,8 @@ initcStringIO(void) {
   d = PyModule_GetDict(m);
   
   /* Export C API */
-  Py_Type(&Itype)=&PyType_Type;
-  Py_Type(&Otype)=&PyType_Type;
+  Py_TYPE(&Itype)=&PyType_Type;
+  Py_TYPE(&Otype)=&PyType_Type;
   if (PyType_Ready(&Otype) < 0) return;
   if (PyType_Ready(&Itype) < 0) return;
   PyDict_SetItemString(d,"cStringIO_CAPI",
diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c
index 5672fc33..4371db4 100644
--- a/Modules/cjkcodecs/multibytecodec.c
+++ b/Modules/cjkcodecs/multibytecodec.c
@@ -953,7 +953,7 @@ mbiencoder_dealloc(MultibyteIncrementalEncoderObject *self)
 {
 	PyObject_GC_UnTrack(self);
 	ERROR_DECREF(self->errors);
-	Py_Type(self)->tp_free(self);
+	Py_TYPE(self)->tp_free(self);
 }
 
 static PyTypeObject MultibyteIncrementalEncoder_Type = {
@@ -1153,7 +1153,7 @@ mbidecoder_dealloc(MultibyteIncrementalDecoderObject *self)
 {
 	PyObject_GC_UnTrack(self);
 	ERROR_DECREF(self->errors);
-	Py_Type(self)->tp_free(self);
+	Py_TYPE(self)->tp_free(self);
 }
 
 static PyTypeObject MultibyteIncrementalDecoder_Type = {
@@ -1479,7 +1479,7 @@ mbstreamreader_dealloc(MultibyteStreamReaderObject *self)
 	PyObject_GC_UnTrack(self);
 	ERROR_DECREF(self->errors);
 	Py_DECREF(self->stream);
-	Py_Type(self)->tp_free(self);
+	Py_TYPE(self)->tp_free(self);
 }
 
 static PyTypeObject MultibyteStreamReader_Type = {
@@ -1682,7 +1682,7 @@ mbstreamwriter_dealloc(MultibyteStreamWriterObject *self)
 	PyObject_GC_UnTrack(self);
 	ERROR_DECREF(self->errors);
 	Py_DECREF(self->stream);
-	Py_Type(self)->tp_free(self);
+	Py_TYPE(self)->tp_free(self);
 }
 
 static struct PyMethodDef mbstreamwriter_methods[] = {
diff --git a/Modules/datetimemodule.c b/Modules/datetimemodule.c
index 8eb7e04..1e30f7e 100644
--- a/Modules/datetimemodule.c
+++ b/Modules/datetimemodule.c
@@ -764,7 +764,7 @@ check_tzinfo_subclass(PyObject *p)
 	PyErr_Format(PyExc_TypeError,
 		     "tzinfo argument must be None or of a tzinfo subclass, "
 		     "not type '%s'",
-		     Py_Type(p)->tp_name);
+		     Py_TYPE(p)->tp_name);
 	return -1;
 }
 
@@ -855,7 +855,7 @@ call_utc_tzinfo_method(PyObject *tzinfo, char *name, PyObject *tzinfoarg,
 		PyErr_Format(PyExc_TypeError,
 			     "tzinfo.%s() must return None or "
 			     "timedelta, not '%s'",
-			     name, Py_Type(u)->tp_name);
+			     name, Py_TYPE(u)->tp_name);
 	}
 
 	Py_DECREF(u);
@@ -950,7 +950,7 @@ call_tzname(PyObject *tzinfo, PyObject *tzinfoarg)
 		if (!PyUnicode_Check(result)) {
 			PyErr_Format(PyExc_TypeError, "tzinfo.tzname() must "
 				     "return None or a string, not '%s'",
-				     Py_Type(result)->tp_name);
+				     Py_TYPE(result)->tp_name);
 			Py_DECREF(result);
 			result = NULL;
 		}
@@ -1293,7 +1293,7 @@ wrap_strftime(PyObject *object, PyObject *format, PyObject *timetuple,
 			assert(PyUnicode_Check(Zreplacement));
 			ptoappend = PyUnicode_AsStringAndSize(Zreplacement,
                                                               &ntoappend);
-			ntoappend = Py_Size(Zreplacement);
+			ntoappend = Py_SIZE(Zreplacement);
 		}
 		else {
 			/* percent followed by neither z nor Z */
@@ -1425,7 +1425,7 @@ cmperror(PyObject *a, PyObject *b)
 {
 	PyErr_Format(PyExc_TypeError,
 		     "can't compare %s to %s",
-		     Py_Type(a)->tp_name, Py_Type(b)->tp_name);
+		     Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
 	return NULL;
 }
 
@@ -1869,7 +1869,7 @@ accum(const char* tag, PyObject *sofar, PyObject *num, PyObject *factor,
 
 	PyErr_Format(PyExc_TypeError,
 		     "unsupported type for timedelta %s component: %s",
-		     tag, Py_Type(num)->tp_name);
+		     tag, Py_TYPE(num)->tp_name);
 	return NULL;
 }
 
@@ -1973,18 +1973,18 @@ delta_repr(PyDateTime_Delta *self)
 {
 	if (GET_TD_MICROSECONDS(self) != 0)
 		return PyUnicode_FromFormat("%s(%d, %d, %d)",
-		                            Py_Type(self)->tp_name,
+		                            Py_TYPE(self)->tp_name,
 		                            GET_TD_DAYS(self),
 		                            GET_TD_SECONDS(self),
 		                            GET_TD_MICROSECONDS(self));
 	if (GET_TD_SECONDS(self) != 0)
 		return PyUnicode_FromFormat("%s(%d, %d)",
-		                            Py_Type(self)->tp_name,
+		                            Py_TYPE(self)->tp_name,
 		                            GET_TD_DAYS(self),
 		                            GET_TD_SECONDS(self));
 
 	return PyUnicode_FromFormat("%s(%d)",
-	                            Py_Type(self)->tp_name,
+	                            Py_TYPE(self)->tp_name,
 	                            GET_TD_DAYS(self));
 }
 
@@ -2031,7 +2031,7 @@ delta_getstate(PyDateTime_Delta *self)
 static PyObject *
 delta_reduce(PyDateTime_Delta* self)
 {
-	return Py_BuildValue("ON", Py_Type(self), delta_getstate(self));
+	return Py_BuildValue("ON", Py_TYPE(self), delta_getstate(self));
 }
 
 #define OFFSET(field)  offsetof(PyDateTime_Delta, field)
@@ -2385,7 +2385,7 @@ static PyObject *
 date_repr(PyDateTime_Date *self)
 {
 	return PyUnicode_FromFormat("%s(%d, %d, %d)",
-	                            Py_Type(self)->tp_name,
+	                            Py_TYPE(self)->tp_name,
 	                            GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
 }
 
@@ -2522,7 +2522,7 @@ date_replace(PyDateTime_Date *self, PyObject *args, PyObject *kw)
 	tuple = Py_BuildValue("iii", year, month, day);
 	if (tuple == NULL)
 		return NULL;
-	clone = date_new(Py_Type(self), tuple, NULL);
+	clone = date_new(Py_TYPE(self), tuple, NULL);
 	Py_DECREF(tuple);
 	return clone;
 }
@@ -2590,7 +2590,7 @@ date_getstate(PyDateTime_Date *self)
 static PyObject *
 date_reduce(PyDateTime_Date *self, PyObject *arg)
 {
-	return Py_BuildValue("(ON)", Py_Type(self), date_getstate(self));
+	return Py_BuildValue("(ON)", Py_TYPE(self), date_getstate(self));
 }
 
 static PyMethodDef date_methods[] = {
@@ -2893,10 +2893,10 @@ tzinfo_reduce(PyObject *self)
 
 	if (state == Py_None) {
 		Py_DECREF(state);
-		return Py_BuildValue("(ON)", Py_Type(self), args);
+		return Py_BuildValue("(ON)", Py_TYPE(self), args);
 	}
 	else
-		return Py_BuildValue("(ONN)", Py_Type(self), args, state);
+		return Py_BuildValue("(ONN)", Py_TYPE(self), args, state);
 }
 
 static PyMethodDef tzinfo_methods[] = {
@@ -3089,7 +3089,7 @@ time_dealloc(PyDateTime_Time *self)
 	if (HASTZINFO(self)) {
 		Py_XDECREF(self->tzinfo);
 	}
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 /*
@@ -3122,7 +3122,7 @@ time_tzname(PyDateTime_Time *self, PyObject *unused) {
 static PyObject *
 time_repr(PyDateTime_Time *self)
 {
-	const char *type_name = Py_Type(self)->tp_name;
+	const char *type_name = Py_TYPE(self)->tp_name;
 	int h = TIME_GET_HOUR(self);
 	int m = TIME_GET_MINUTE(self);
 	int s = TIME_GET_SECOND(self);
@@ -3346,7 +3346,7 @@ time_replace(PyDateTime_Time *self, PyObject *args, PyObject *kw)
 	tuple = Py_BuildValue("iiiiO", hh, mm, ss, us, tzinfo);
 	if (tuple == NULL)
 		return NULL;
-	clone = time_new(Py_Type(self), tuple, NULL);
+	clone = time_new(Py_TYPE(self), tuple, NULL);
 	Py_DECREF(tuple);
 	return clone;
 }
@@ -3400,7 +3400,7 @@ time_getstate(PyDateTime_Time *self)
 static PyObject *
 time_reduce(PyDateTime_Time *self, PyObject *arg)
 {
-	return Py_BuildValue("(ON)", Py_Type(self), time_getstate(self));
+	return Py_BuildValue("(ON)", Py_TYPE(self), time_getstate(self));
 }
 
 static PyMethodDef time_methods[] = {
@@ -3897,7 +3897,7 @@ datetime_dealloc(PyDateTime_DateTime *self)
 	if (HASTZINFO(self)) {
 		Py_XDECREF(self->tzinfo);
 	}
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 /*
@@ -4045,7 +4045,7 @@ datetime_subtract(PyObject *left, PyObject *right)
 static PyObject *
 datetime_repr(PyDateTime_DateTime *self)
 {
-	const char *type_name = Py_Type(self)->tp_name;
+	const char *type_name = Py_TYPE(self)->tp_name;
 	PyObject *baserepr;
 
 	if (DATE_GET_MICROSECOND(self)) {
@@ -4262,7 +4262,7 @@ datetime_replace(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
 	tuple = Py_BuildValue("iiiiiiiO", y, m, d, hh, mm, ss, us, tzinfo);
 	if (tuple == NULL)
 		return NULL;
-	clone = datetime_new(Py_Type(self), tuple, NULL);
+	clone = datetime_new(Py_TYPE(self), tuple, NULL);
 	Py_DECREF(tuple);
 	return clone;
 }
@@ -4450,7 +4450,7 @@ datetime_getstate(PyDateTime_DateTime *self)
 static PyObject *
 datetime_reduce(PyDateTime_DateTime *self, PyObject *arg)
 {
-	return Py_BuildValue("(ON)", Py_Type(self), datetime_getstate(self));
+	return Py_BuildValue("(ON)", Py_TYPE(self), datetime_getstate(self));
 }
 
 static PyMethodDef datetime_methods[] = {
diff --git a/Modules/dbmmodule.c b/Modules/dbmmodule.c
index 6b05fad..7129c8e 100644
--- a/Modules/dbmmodule.c
+++ b/Modules/dbmmodule.c
@@ -36,7 +36,7 @@ typedef struct {
 
 static PyTypeObject Dbmtype;
 
-#define is_dbmobject(v) (Py_Type(v) == &Dbmtype)
+#define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype)
 #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \
                { PyErr_SetString(DbmError, "DBM object has already been closed"); \
                  return NULL; }
diff --git a/Modules/dlmodule.c b/Modules/dlmodule.c
index aaca4cf..04587f6 100644
--- a/Modules/dlmodule.c
+++ b/Modules/dlmodule.c
@@ -62,7 +62,7 @@ dl_sym(dlobject *xp, PyObject *args)
 		name = PyUnicode_AsString(args);
 	} else {
 		PyErr_Format(PyExc_TypeError, "expected string, found %.200s",
-			     Py_Type(args)->tp_name);
+			     Py_TYPE(args)->tp_name);
 		return NULL;
 	}
 	func = dlsym(xp->dl_handle, name);
@@ -238,7 +238,7 @@ initdl(void)
 	PyObject *m, *d, *x;
 
 	/* Initialize object type */
-	Py_Type(&Dltype) = &PyType_Type;
+	Py_TYPE(&Dltype) = &PyType_Type;
 
 	/* Create the module and add the functions */
 	m = Py_InitModule("dl", dl_methods);
diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
index 5fd8923..37fcc51 100644
--- a/Modules/gcmodule.c
+++ b/Modules/gcmodule.c
@@ -235,7 +235,7 @@ update_refs(PyGC_Head *containers)
 	PyGC_Head *gc = containers->gc.gc_next;
 	for (; gc != containers; gc = gc->gc.gc_next) {
 		assert(gc->gc.gc_refs == GC_REACHABLE);
-		gc->gc.gc_refs = Py_Refcnt(FROM_GC(gc));
+		gc->gc.gc_refs = Py_REFCNT(FROM_GC(gc));
 		/* Python's cyclic gc should never see an incoming refcount
 		 * of 0:  if something decref'ed to 0, it should have been
 		 * deallocated immediately at that time.
@@ -287,7 +287,7 @@ subtract_refs(PyGC_Head *containers)
 	traverseproc traverse;
 	PyGC_Head *gc = containers->gc.gc_next;
 	for (; gc != containers; gc=gc->gc.gc_next) {
-		traverse = Py_Type(FROM_GC(gc))->tp_traverse;
+		traverse = Py_TYPE(FROM_GC(gc))->tp_traverse;
 		(void) traverse(FROM_GC(gc),
 			       (visitproc)visit_decref,
 			       NULL);
@@ -372,7 +372,7 @@ move_unreachable(PyGC_Head *young, PyGC_Head *unreachable)
                          * the next object to visit.
                          */
                         PyObject *op = FROM_GC(gc);
-                        traverseproc traverse = Py_Type(op)->tp_traverse;
+                        traverseproc traverse = Py_TYPE(op)->tp_traverse;
                         assert(gc->gc.gc_refs > 0);
                         gc->gc.gc_refs = GC_REACHABLE;
                         (void) traverse(op,
@@ -456,7 +456,7 @@ move_finalizer_reachable(PyGC_Head *finalizers)
 	PyGC_Head *gc = finalizers->gc.gc_next;
 	for (; gc != finalizers; gc = gc->gc.gc_next) {
 		/* Note that the finalizers list may grow during this. */
-		traverse = Py_Type(FROM_GC(gc))->tp_traverse;
+		traverse = Py_TYPE(FROM_GC(gc))->tp_traverse;
 		(void) traverse(FROM_GC(gc),
 				(visitproc)visit_move,
 				(void *)finalizers);
@@ -501,7 +501,7 @@ handle_weakrefs(PyGC_Head *unreachable, PyGC_Head *old)
 		assert(IS_TENTATIVELY_UNREACHABLE(op));
 		next = gc->gc.gc_next;
 
-		if (! PyType_SUPPORTS_WEAKREFS(Py_Type(op)))
+		if (! PyType_SUPPORTS_WEAKREFS(Py_TYPE(op)))
 			continue;
 
 		/* It supports weakrefs.  Does it have any? */
@@ -620,7 +620,7 @@ static void
 debug_cycle(char *msg, PyObject *op)
 {
 	PySys_WriteStderr("gc: %.100s <%.100s %p>\n",
-			  msg, Py_Type(op)->tp_name, op);
+			  msg, Py_TYPE(op)->tp_name, op);
 }
 
 /* Handle uncollectable garbage (cycles with finalizers, and stuff reachable
@@ -673,7 +673,7 @@ delete_garbage(PyGC_Head *collectable, PyGC_Head *old)
 			PyList_Append(garbage, op);
 		}
 		else {
-			if ((clear = Py_Type(op)->tp_clear) != NULL) {
+			if ((clear = Py_TYPE(op)->tp_clear) != NULL) {
 				Py_INCREF(op);
 				clear(op);
 				Py_DECREF(op);
@@ -1042,7 +1042,7 @@ gc_referrers_for(PyObject *objs, PyGC_Head *list, PyObject *resultlist)
 	traverseproc traverse;
 	for (gc = list->gc.gc_next; gc != list; gc = gc->gc.gc_next) {
 		obj = FROM_GC(gc);
-		traverse = Py_Type(obj)->tp_traverse;
+		traverse = Py_TYPE(obj)->tp_traverse;
 		if (obj == objs || obj == resultlist)
 			continue;
 		if (traverse(obj, (visitproc)referrersvisit, objs)) {
@@ -1099,7 +1099,7 @@ gc_get_referents(PyObject *self, PyObject *args)
 
 		if (! PyObject_IS_GC(obj))
 			continue;
-		traverse = Py_Type(obj)->tp_traverse;
+		traverse = Py_TYPE(obj)->tp_traverse;
 		if (! traverse)
 			continue;
 		if (traverse(obj, (visitproc)referentsvisit, result)) {
@@ -1320,13 +1320,13 @@ _PyObject_GC_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
 PyVarObject *
 _PyObject_GC_Resize(PyVarObject *op, Py_ssize_t nitems)
 {
-	const size_t basicsize = _PyObject_VAR_SIZE(Py_Type(op), nitems);
+	const size_t basicsize = _PyObject_VAR_SIZE(Py_TYPE(op), nitems);
 	PyGC_Head *g = AS_GC(op);
 	g = (PyGC_Head *)PyObject_REALLOC(g,  sizeof(PyGC_Head) + basicsize);
 	if (g == NULL)
 		return (PyVarObject *)PyErr_NoMemory();
 	op = (PyVarObject *) FROM_GC(g);
-	Py_Size(op) = nitems;
+	Py_SIZE(op) = nitems;
 	return op;
 }
 
diff --git a/Modules/gdbmmodule.c b/Modules/gdbmmodule.c
index 86f98c0..9e1b01d 100644
--- a/Modules/gdbmmodule.c
+++ b/Modules/gdbmmodule.c
@@ -36,7 +36,7 @@ typedef struct {
 
 static PyTypeObject Dbmtype;
 
-#define is_dbmobject(v) (Py_Type(v) == &Dbmtype)
+#define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype)
 #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \
     { PyErr_SetString(DbmError, "GDBM object has already been closed"); \
       return NULL; }
diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c
index fc99bd5..132acc5 100644
--- a/Modules/itertoolsmodule.c
+++ b/Modules/itertoolsmodule.c
@@ -59,7 +59,7 @@ groupby_dealloc(groupbyobject *gbo)
 	Py_XDECREF(gbo->tgtkey);
 	Py_XDECREF(gbo->currkey);
 	Py_XDECREF(gbo->currvalue);
-	Py_Type(gbo)->tp_free(gbo);
+	Py_TYPE(gbo)->tp_free(gbo);
 }
 
 static int
@@ -714,7 +714,7 @@ cycle_dealloc(cycleobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->saved);
 	Py_XDECREF(lz->it);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -857,7 +857,7 @@ dropwhile_dealloc(dropwhileobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->func);
 	Py_XDECREF(lz->it);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -877,7 +877,7 @@ dropwhile_next(dropwhileobject *lz)
 	PyObject *(*iternext)(PyObject *);
 
 	assert(PyIter_Check(it));
-	iternext = *Py_Type(it)->tp_iternext;
+	iternext = *Py_TYPE(it)->tp_iternext;
 	for (;;) {
 		item = iternext(it);
 		if (item == NULL)
@@ -1000,7 +1000,7 @@ takewhile_dealloc(takewhileobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->func);
 	Py_XDECREF(lz->it);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -1022,7 +1022,7 @@ takewhile_next(takewhileobject *lz)
 		return NULL;
 
 	assert(PyIter_Check(it));
-	item = (*Py_Type(it)->tp_iternext)(it);
+	item = (*Py_TYPE(it)->tp_iternext)(it);
 	if (item == NULL)
 		return NULL;
 
@@ -1190,7 +1190,7 @@ islice_dealloc(isliceobject *lz)
 {
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->it);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -1209,7 +1209,7 @@ islice_next(isliceobject *lz)
 	PyObject *(*iternext)(PyObject *);
 
 	assert(PyIter_Check(it));
-	iternext = *Py_Type(it)->tp_iternext;
+	iternext = *Py_TYPE(it)->tp_iternext;
 	while (lz->cnt < lz->next) {
 		item = iternext(it);
 		if (item == NULL)
@@ -1333,7 +1333,7 @@ starmap_dealloc(starmapobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->func);
 	Py_XDECREF(lz->it);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -1352,7 +1352,7 @@ starmap_next(starmapobject *lz)
 	PyObject *it = lz->it;
 
 	assert(PyIter_Check(it));
-	args = (*Py_Type(it)->tp_iternext)(it);
+	args = (*Py_TYPE(it)->tp_iternext)(it);
 	if (args == NULL)
 		return NULL;
 	if (!PyTuple_CheckExact(args)) {
@@ -1478,7 +1478,7 @@ imap_dealloc(imapobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->iters);
 	Py_XDECREF(lz->func);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -1656,7 +1656,7 @@ chain_dealloc(chainobject *lz)
 {
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->ittuple);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -1787,7 +1787,7 @@ ifilter_dealloc(ifilterobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->func);
 	Py_XDECREF(lz->it);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -1807,7 +1807,7 @@ ifilter_next(ifilterobject *lz)
 	PyObject *(*iternext)(PyObject *);
 
 	assert(PyIter_Check(it));
-	iternext = *Py_Type(it)->tp_iternext;
+	iternext = *Py_TYPE(it)->tp_iternext;
 	for (;;) {
 		item = iternext(it);
 		if (item == NULL)
@@ -1931,7 +1931,7 @@ ifilterfalse_dealloc(ifilterfalseobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->func);
 	Py_XDECREF(lz->it);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -1951,7 +1951,7 @@ ifilterfalse_next(ifilterfalseobject *lz)
 	PyObject *(*iternext)(PyObject *);
 
 	assert(PyIter_Check(it));
-	iternext = *Py_Type(it)->tp_iternext;
+	iternext = *Py_TYPE(it)->tp_iternext;
 	for (;;) {
 		item = iternext(it);
 		if (item == NULL)
@@ -2253,7 +2253,7 @@ izip_dealloc(izipobject *lz)
 	PyObject_GC_UnTrack(lz);
 	Py_XDECREF(lz->ittuple);
 	Py_XDECREF(lz->result);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -2276,12 +2276,12 @@ izip_next(izipobject *lz)
 
 	if (tuplesize == 0)
 		return NULL;
-	if (Py_Refcnt(result) == 1) {
+	if (Py_REFCNT(result) == 1) {
 		Py_INCREF(result);
 		for (i=0 ; i < tuplesize ; i++) {
 			it = PyTuple_GET_ITEM(lz->ittuple, i);
 			assert(PyIter_Check(it));
-			item = (*Py_Type(it)->tp_iternext)(it);
+			item = (*Py_TYPE(it)->tp_iternext)(it);
 			if (item == NULL) {
 				Py_DECREF(result);
 				return NULL;
@@ -2297,7 +2297,7 @@ izip_next(izipobject *lz)
 		for (i=0 ; i < tuplesize ; i++) {
 			it = PyTuple_GET_ITEM(lz->ittuple, i);
 			assert(PyIter_Check(it));
-			item = (*Py_Type(it)->tp_iternext)(it);
+			item = (*Py_TYPE(it)->tp_iternext)(it);
 			if (item == NULL) {
 				Py_DECREF(result);
 				return NULL;
@@ -2403,7 +2403,7 @@ repeat_dealloc(repeatobject *ro)
 {
 	PyObject_GC_UnTrack(ro);
 	Py_XDECREF(ro->element);
-	Py_Type(ro)->tp_free(ro);
+	Py_TYPE(ro)->tp_free(ro);
 }
 
 static int
@@ -2588,7 +2588,7 @@ izip_longest_dealloc(iziplongestobject *lz)
 	Py_XDECREF(lz->ittuple);
 	Py_XDECREF(lz->result);
 	Py_XDECREF(lz->fillvalue);
-	Py_Type(lz)->tp_free(lz);
+	Py_TYPE(lz)->tp_free(lz);
 }
 
 static int
@@ -2614,7 +2614,7 @@ izip_longest_next(iziplongestobject *lz)
 		return NULL;
         if (lz->numactive == 0)
                 return NULL;
-	if (Py_Refcnt(result) == 1) {
+	if (Py_REFCNT(result) == 1) {
 		Py_INCREF(result);
 		for (i=0 ; i < tuplesize ; i++) {
 			it = PyTuple_GET_ITEM(lz->ittuple, i);
@@ -2623,7 +2623,7 @@ izip_longest_next(iziplongestobject *lz)
                                 item = lz->fillvalue;
                         } else {
                                 assert(PyIter_Check(it));
-                                item = (*Py_Type(it)->tp_iternext)(it);
+                                item = (*Py_TYPE(it)->tp_iternext)(it);
                                 if (item == NULL) {
                                         lz->numactive -= 1;      
                                         if (lz->numactive == 0) {
@@ -2652,7 +2652,7 @@ izip_longest_next(iziplongestobject *lz)
                                 item = lz->fillvalue;
                         } else {
                                 assert(PyIter_Check(it));
-                                item = (*Py_Type(it)->tp_iternext)(it);
+                                item = (*Py_TYPE(it)->tp_iternext)(it);
                                 if (item == NULL) {
                                         lz->numactive -= 1;      
                                         if (lz->numactive == 0) {
@@ -2783,7 +2783,7 @@ inititertools(void)
 		NULL
 	};
 
-	Py_Type(&teedataobject_type) = &PyType_Type;
+	Py_TYPE(&teedataobject_type) = &PyType_Type;
 	m = Py_InitModule3("itertools", module_methods, module_doc);
 	if (m == NULL)
 		return;
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index 864df23..edf5e9b 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -118,7 +118,7 @@ static PyObject * math_ceil(PyObject *self, PyObject *number) {
 			return NULL;
 	}
 
-	method = _PyType_Lookup(Py_Type(number), ceil_str);
+	method = _PyType_Lookup(Py_TYPE(number), ceil_str);
 	if (method == NULL)
 		return math_1(number, ceil);
 	else
@@ -148,7 +148,7 @@ static PyObject * math_floor(PyObject *self, PyObject *number) {
 			return NULL;
 	}
 
-	method = _PyType_Lookup(Py_Type(number), floor_str);
+	method = _PyType_Lookup(Py_TYPE(number), floor_str);
 	if (method == NULL)
 		return math_1(number, floor);
 	else
diff --git a/Modules/md5module.c b/Modules/md5module.c
index 567383a..833eb81 100644
--- a/Modules/md5module.c
+++ b/Modules/md5module.c
@@ -340,7 +340,7 @@ MD5_copy(MD5object *self, PyObject *unused)
 {
     MD5object *newobj;
 
-    if (Py_Type(self) == &MD5type) {
+    if (Py_TYPE(self) == &MD5type) {
         if ( (newobj = newMD5object())==NULL)
             return NULL;
     } else {
@@ -552,7 +552,7 @@ init_md5(void)
 {
     PyObject *m;
 
-    Py_Type(&MD5type) = &PyType_Type;
+    Py_TYPE(&MD5type) = &PyType_Type;
     if (PyType_Ready(&MD5type) < 0)
         return;
     m = Py_InitModule("_md5", MD5_functions);
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index 77aa643..84f909e 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -1253,7 +1253,7 @@ PyMODINIT_FUNC
 	PyObject *dict, *module;
 
 	/* Patch the object type */
-	Py_Type(&mmap_object_type) = &PyType_Type;
+	Py_TYPE(&mmap_object_type) = &PyType_Type;
 
 	module = Py_InitModule("mmap", mmap_functions);
 	if (module == NULL)
diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c
index 87f9e2e..4c00203 100644
--- a/Modules/parsermodule.c
+++ b/Modules/parsermodule.c
@@ -694,7 +694,7 @@ build_node_children(PyObject *tuple, node *root, int *line_num)
                 PyErr_Format(parser_error,
                              "second item in terminal node must be a string,"
                              " found %s",
-                             Py_Type(temp)->tp_name);
+                             Py_TYPE(temp)->tp_name);
                 Py_DECREF(temp);
                 Py_DECREF(elem);
                 return 0;
@@ -708,7 +708,7 @@ build_node_children(PyObject *tuple, node *root, int *line_num)
                         PyErr_Format(parser_error,
                                      "third item in terminal node must be an"
                                      " integer, found %s",
-				     Py_Type(temp)->tp_name);
+				     Py_TYPE(temp)->tp_name);
                         Py_DECREF(o);
                         Py_DECREF(temp);
                         Py_DECREF(elem);
@@ -3056,7 +3056,7 @@ initparser(void)
 {
     PyObject *module, *copyreg;
 
-    Py_Type(&PyST_Type) = &PyType_Type;
+    Py_TYPE(&PyST_Type) = &PyType_Type;
     module = Py_InitModule("parser", parser_functions);
     if (module == NULL)
     	return;
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 92a8b28..12bdde0 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -2706,7 +2706,7 @@ extract_time(PyObject *t, long* sec, long* usec)
 	long intval;
 	if (PyFloat_Check(t)) {
 		double tval = PyFloat_AsDouble(t);
-		PyObject *intobj = Py_Type(t)->tp_as_number->nb_int(t);
+		PyObject *intobj = Py_TYPE(t)->tp_as_number->nb_int(t);
 		if (!intobj)
 			return -1;
 		intval = PyLong_AsLong(intobj);
diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
index 5da00a2..ab917f0 100644
--- a/Modules/pyexpat.c
+++ b/Modules/pyexpat.c
@@ -871,10 +871,10 @@ readinst(char *buf, int buf_size, PyObject *meth)
     else {
         PyErr_Format(PyExc_TypeError,
                      "read() did not return a bytes object (type=%.400s)",
-                     Py_Type(str)->tp_name);
+                     Py_TYPE(str)->tp_name);
         goto finally;
     }
-    len = Py_Size(str);
+    len = Py_SIZE(str);
     if (len > buf_size) {
         PyErr_Format(PyExc_ValueError,
                      "read() returned too much data: "
@@ -1738,7 +1738,7 @@ MODULE_INITFUNC(void)
     if (modelmod_name == NULL)
         return;
 
-    Py_Type(&Xmlparsetype) = &PyType_Type;
+    Py_TYPE(&Xmlparsetype) = &PyType_Type;
 
     /* Create the module and add the functions */
     m = Py_InitModule3(MODULE_NAME, pyexpat_methods,
diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
index 4925b9d..c4ebecc 100644
--- a/Modules/selectmodule.c
+++ b/Modules/selectmodule.c
@@ -701,7 +701,7 @@ initselect(void)
 #else
 	{
 #endif
-		Py_Type(&poll_Type) = &PyType_Type;
+		Py_TYPE(&poll_Type) = &PyType_Type;
 		PyModule_AddIntConstant(m, "POLLIN", POLLIN);
 		PyModule_AddIntConstant(m, "POLLPRI", POLLPRI);
 		PyModule_AddIntConstant(m, "POLLOUT", POLLOUT);
diff --git a/Modules/sha1module.c b/Modules/sha1module.c
index aeba185..9b4d8e5 100644
--- a/Modules/sha1module.c
+++ b/Modules/sha1module.c
@@ -316,7 +316,7 @@ SHA1_copy(SHA1object *self, PyObject *unused)
 {
     SHA1object *newobj;
 
-    if (Py_Type(self) == &SHA1type) {
+    if (Py_TYPE(self) == &SHA1type) {
         if ( (newobj = newSHA1object())==NULL)
             return NULL;
     } else {
@@ -528,7 +528,7 @@ init_sha1(void)
 {
     PyObject *m;
 
-    Py_Type(&SHA1type) = &PyType_Type;
+    Py_TYPE(&SHA1type) = &PyType_Type;
     if (PyType_Ready(&SHA1type) < 0)
         return;
     m = Py_InitModule("_sha1", SHA1_functions);
diff --git a/Modules/sha256module.c b/Modules/sha256module.c
index 928d1d4..f310134 100644
--- a/Modules/sha256module.c
+++ b/Modules/sha256module.c
@@ -409,7 +409,7 @@ SHA256_copy(SHAobject *self, PyObject *unused)
 {
     SHAobject *newobj;
 
-    if (Py_Type(self) == &SHA256type) {
+    if (Py_TYPE(self) == &SHA256type) {
         if ( (newobj = newSHA256object())==NULL)
             return NULL;
     } else {
@@ -687,10 +687,10 @@ init_sha256(void)
 {
     PyObject *m;
 
-    Py_Type(&SHA224type) = &PyType_Type;
+    Py_TYPE(&SHA224type) = &PyType_Type;
     if (PyType_Ready(&SHA224type) < 0)
         return;
-    Py_Type(&SHA256type) = &PyType_Type;
+    Py_TYPE(&SHA256type) = &PyType_Type;
     if (PyType_Ready(&SHA256type) < 0)
         return;
     m = Py_InitModule("_sha256", SHA_functions);
diff --git a/Modules/sha512module.c b/Modules/sha512module.c
index 761d44a..3e32132 100644
--- a/Modules/sha512module.c
+++ b/Modules/sha512module.c
@@ -753,10 +753,10 @@ init_sha512(void)
 {
     PyObject *m;
 
-    Py_Type(&SHA384type) = &PyType_Type;
+    Py_TYPE(&SHA384type) = &PyType_Type;
     if (PyType_Ready(&SHA384type) < 0)
         return;
-    Py_Type(&SHA512type) = &PyType_Type;
+    Py_TYPE(&SHA512type) = &PyType_Type;
     if (PyType_Ready(&SHA512type) < 0)
         return;
     m = Py_InitModule("_sha512", SHA_functions);
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index ddffd23..3909cbc 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -1135,7 +1135,7 @@ getsockaddrarg(PySocketSockObject *s, PyObject *args,
 				PyExc_TypeError,
 				"getsockaddrarg: "
 				"AF_NETLINK address must be tuple, not %.500s",
-				Py_Type(args)->tp_name);
+				Py_TYPE(args)->tp_name);
 			return 0;
 		}
 		if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
@@ -1158,7 +1158,7 @@ getsockaddrarg(PySocketSockObject *s, PyObject *args,
 				PyExc_TypeError,
 				"getsockaddrarg: "
 				"AF_INET address must be tuple, not %.500s",
-				Py_Type(args)->tp_name);
+				Py_TYPE(args)->tp_name);
 			return 0;
 		}
 		if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
@@ -1188,7 +1188,7 @@ getsockaddrarg(PySocketSockObject *s, PyObject *args,
 				PyExc_TypeError,
 				"getsockaddrarg: "
 				"AF_INET6 address must be tuple, not %.500s",
-				Py_Type(args)->tp_name);
+				Py_TYPE(args)->tp_name);
 			return 0;
 		}
 		if (!PyArg_ParseTuple(args, "eti|ii",
@@ -1310,7 +1310,7 @@ getsockaddrarg(PySocketSockObject *s, PyObject *args,
 				PyExc_TypeError,
 				"getsockaddrarg: "
 				"AF_PACKET address must be tuple, not %.500s",
-				Py_Type(args)->tp_name);
+				Py_TYPE(args)->tp_name);
 			return 0;
 		}
 		if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
@@ -2580,7 +2580,7 @@ sock_dealloc(PySocketSockObject *s)
 {
 	if (s->sock_fd != -1)
 		(void) SOCKETCLOSE(s->sock_fd);
-	Py_Type(s)->tp_free((PyObject *)s);
+	Py_TYPE(s)->tp_free((PyObject *)s);
 }
 
 
@@ -3275,7 +3275,7 @@ socket_ntohl(PyObject *self, PyObject *arg)
 	else
 		return PyErr_Format(PyExc_TypeError,
 				    "expected int/long, %s found",
-				    Py_Type(arg)->tp_name);
+				    Py_TYPE(arg)->tp_name);
 	if (x == (unsigned long) -1 && PyErr_Occurred())
 		return NULL;
 	return PyLong_FromUnsignedLong(ntohl(x));
@@ -3334,7 +3334,7 @@ socket_htonl(PyObject *self, PyObject *arg)
 	else
 		return PyErr_Format(PyExc_TypeError,
 				    "expected int/long, %s found",
-				    Py_Type(arg)->tp_name);
+				    Py_TYPE(arg)->tp_name);
 	return PyLong_FromUnsignedLong(htonl((unsigned long)x));
 }
 
@@ -3962,7 +3962,7 @@ init_socket(void)
 	if (!os_init())
 		return;
 
-	Py_Type(&sock_type) = &PyType_Type;
+	Py_TYPE(&sock_type) = &PyType_Type;
 	m = Py_InitModule3(PySocket_MODULE_NAME,
 			   socket_methods,
 			   socket_doc);
diff --git a/Modules/threadmodule.c b/Modules/threadmodule.c
index d948154..b8b7fb5 100644
--- a/Modules/threadmodule.c
+++ b/Modules/threadmodule.c
@@ -250,7 +250,7 @@ local_dealloc(localobject *self)
 	}
 
 	local_clear(self);
-	Py_Type(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
 static PyObject *
@@ -282,8 +282,8 @@ _ldict(localobject *self)
 		Py_INCREF(ldict);
 		self->dict = ldict; /* still borrowed */
 
-		if (Py_Type(self)->tp_init != PyBaseObject_Type.tp_init &&
-		    Py_Type(self)->tp_init((PyObject*)self, 
+		if (Py_TYPE(self)->tp_init != PyBaseObject_Type.tp_init &&
+		    Py_TYPE(self)->tp_init((PyObject*)self, 
 					   self->args, self->kw) < 0) {
 			/* we need to get rid of ldict from thread so
 			   we create a new one the next time we do an attr
@@ -386,7 +386,7 @@ local_getattro(localobject *self, PyObject *name)
 	if (ldict == NULL) 
 		return NULL;
 
-	if (Py_Type(self) != &localtype)
+	if (Py_TYPE(self) != &localtype)
 		/* use generic lookup for subtypes */
 		return PyObject_GenericGetAttr((PyObject *)self, name);
 
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
index c64a356..36a723a 100644
--- a/Modules/timemodule.c
+++ b/Modules/timemodule.c
@@ -365,7 +365,7 @@ gettmarg(PyObject *args, struct tm *p)
 		t = args;
 		Py_INCREF(t);
 	}
-	else if (Py_Type(args) == &StructTimeType) {
+	else if (Py_TYPE(args) == &StructTimeType) {
 		t = structtime_totuple(args);
 	}
 	else {
diff --git a/Modules/unicodedata.c b/Modules/unicodedata.c
index 060642b..b2c8733 100644
--- a/Modules/unicodedata.c
+++ b/Modules/unicodedata.c
@@ -1187,7 +1187,7 @@ initunicodedata(void)
 {
     PyObject *m, *v;
 
-    Py_Type(&UCD_Type) = &PyType_Type;
+    Py_TYPE(&UCD_Type) = &PyType_Type;
 
     m = Py_InitModule3(
         "unicodedata", unicodedata_functions, unicodedata_docstring);
diff --git a/Modules/xxmodule.c b/Modules/xxmodule.c
index 5c371fb..18dcf5c 100644
--- a/Modules/xxmodule.c
+++ b/Modules/xxmodule.c
@@ -25,7 +25,7 @@ typedef struct {
 
 static PyTypeObject Xxo_Type;
 
-#define XxoObject_Check(v)	(Py_Type(v) == &Xxo_Type)
+#define XxoObject_Check(v)	(Py_TYPE(v) == &Xxo_Type)
 
 static XxoObject *
 newXxoObject(PyObject *arg)
diff --git a/Modules/zipimport.c b/Modules/zipimport.c
index 5f41e8d..08322b6 100644
--- a/Modules/zipimport.c
+++ b/Modules/zipimport.c
@@ -171,7 +171,7 @@ zipimporter_dealloc(ZipImporter *self)
 	Py_XDECREF(self->archive);
 	Py_XDECREF(self->prefix);
 	Py_XDECREF(self->files);
-	Py_Type(self)->tp_free((PyObject *)self);
+	Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static PyObject *
diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c
index 55e892a..441d61d 100644
--- a/Modules/zlibmodule.c
+++ b/Modules/zlibmodule.c
@@ -1012,8 +1012,8 @@ PyMODINIT_FUNC
 PyInit_zlib(void)
 {
     PyObject *m, *ver;
-    Py_Type(&Comptype) = &PyType_Type;
-    Py_Type(&Decomptype) = &PyType_Type;
+    Py_TYPE(&Comptype) = &PyType_Type;
+    Py_TYPE(&Decomptype) = &PyType_Type;
     m = Py_InitModule4("zlib", zlib_methods,
 		       zlib_module_documentation,
 		       (PyObject*)NULL,PYTHON_API_VERSION);
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 8b3006a..3410dd8 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -343,7 +343,7 @@ PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
 	if (!PyObject_CheckBuffer(obj)) {
 		PyErr_Format(PyExc_TypeError,
                              "'%100s' does not have the buffer interface",
-                             Py_Type(obj)->tp_name);
+                             Py_TYPE(obj)->tp_name);
 		return -1;
 	}
 	return (*(obj->ob_type->tp_as_buffer->bf_getbuffer))(obj, view, flags);
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
index b0e1b53..45dcb91 100644
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -20,7 +20,7 @@ PyBytes_Init(void)
     if (nullbytes == NULL)
         return 0;
     nullbytes->ob_bytes = NULL;
-    Py_Size(nullbytes) = nullbytes->ob_alloc = 0;
+    Py_SIZE(nullbytes) = nullbytes->ob_alloc = 0;
     nullbytes->ob_exports = 0;
     return 1;
 }
@@ -62,7 +62,7 @@ bytes_getbuffer(PyBytesObject *obj, Py_buffer *view, int flags)
                 ptr = "";
         else
                 ptr = obj->ob_bytes;
-        ret = PyBuffer_FillInfo(view, ptr, Py_Size(obj), 0, flags);
+        ret = PyBuffer_FillInfo(view, ptr, Py_SIZE(obj), 0, flags);
         if (ret >= 0) {
                 obj->ob_exports++;
         }
@@ -78,13 +78,13 @@ bytes_releasebuffer(PyBytesObject *obj, Py_buffer *view)
 static Py_ssize_t
 _getbuffer(PyObject *obj, Py_buffer *view)
 {
-    PyBufferProcs *buffer = Py_Type(obj)->tp_as_buffer;
+    PyBufferProcs *buffer = Py_TYPE(obj)->tp_as_buffer;
 
     if (buffer == NULL || buffer->bf_getbuffer == NULL)
     {
         PyErr_Format(PyExc_TypeError,
                      "Type %.100s doesn't support the buffer API",
-                     Py_Type(obj)->tp_name);
+                     Py_TYPE(obj)->tp_name);
         return -1;
     }
 
@@ -129,7 +129,7 @@ PyBytes_FromStringAndSize(const char *bytes, Py_ssize_t size)
             memcpy(new->ob_bytes, bytes, size);
         new->ob_bytes[size] = '\0';  /* Trailing null byte */
     }
-    Py_Size(new) = size;
+    Py_SIZE(new) = size;
     new->ob_alloc = alloc;
     new->ob_exports = 0;
 
@@ -170,7 +170,7 @@ PyBytes_Resize(PyObject *self, Py_ssize_t size)
     }
     else if (size < alloc) {
         /* Within allocated size; quick exit */
-        Py_Size(self) = size;
+        Py_SIZE(self) = size;
         ((PyBytesObject *)self)->ob_bytes[size] = '\0'; /* Trailing null */
         return 0;
     }
@@ -200,7 +200,7 @@ PyBytes_Resize(PyObject *self, Py_ssize_t size)
     }
 
     ((PyBytesObject *)self)->ob_bytes = sval;
-    Py_Size(self) = size;
+    Py_SIZE(self) = size;
     ((PyBytesObject *)self)->ob_alloc = alloc;
     ((PyBytesObject *)self)->ob_bytes[size] = '\0'; /* Trailing null byte */
 
@@ -219,7 +219,7 @@ PyBytes_Concat(PyObject *a, PyObject *b)
     if (_getbuffer(a, &va) < 0  ||
         _getbuffer(b, &vb) < 0) {
             PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
-                         Py_Type(a)->tp_name, Py_Type(b)->tp_name);
+                         Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
             goto done;
     }
 
@@ -248,7 +248,7 @@ PyBytes_Concat(PyObject *a, PyObject *b)
 static Py_ssize_t
 bytes_length(PyBytesObject *self)
 {
-    return Py_Size(self);
+    return Py_SIZE(self);
 }
 
 static PyObject *
@@ -260,19 +260,19 @@ bytes_iconcat(PyBytesObject *self, PyObject *other)
 
     if (_getbuffer(other, &vo) < 0) {
         PyErr_Format(PyExc_TypeError, "can't concat bytes to %.100s",
-                     Py_Type(self)->tp_name);
+                     Py_TYPE(self)->tp_name);
         return NULL;
     }
 
-    mysize = Py_Size(self);
+    mysize = Py_SIZE(self);
     size = mysize + vo.len;
     if (size < 0) {
         PyObject_ReleaseBuffer(other, &vo);
         return PyErr_NoMemory();
     }
     if (size < self->ob_alloc) {
-        Py_Size(self) = size;
-        self->ob_bytes[Py_Size(self)] = '\0'; /* Trailing null byte */
+        Py_SIZE(self) = size;
+        self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */
     }
     else if (PyBytes_Resize((PyObject *)self, size) < 0) {
         PyObject_ReleaseBuffer(other, &vo);
@@ -293,7 +293,7 @@ bytes_repeat(PyBytesObject *self, Py_ssize_t count)
 
     if (count < 0)
         count = 0;
-    mysize = Py_Size(self);
+    mysize = Py_SIZE(self);
     size = mysize * count;
     if (count != 0 && size / count != mysize)
         return PyErr_NoMemory();
@@ -318,13 +318,13 @@ bytes_irepeat(PyBytesObject *self, Py_ssize_t count)
 
     if (count < 0)
         count = 0;
-    mysize = Py_Size(self);
+    mysize = Py_SIZE(self);
     size = mysize * count;
     if (count != 0 && size / count != mysize)
         return PyErr_NoMemory();
     if (size < self->ob_alloc) {
-        Py_Size(self) = size;
-        self->ob_bytes[Py_Size(self)] = '\0'; /* Trailing null byte */
+        Py_SIZE(self) = size;
+        self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */
     }
     else if (PyBytes_Resize((PyObject *)self, size) < 0)
         return NULL;
@@ -345,8 +345,8 @@ static PyObject *
 bytes_getitem(PyBytesObject *self, Py_ssize_t i)
 {
     if (i < 0)
-        i += Py_Size(self);
-    if (i < 0 || i >= Py_Size(self)) {
+        i += Py_SIZE(self);
+    if (i < 0 || i >= Py_SIZE(self)) {
         PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
         return NULL;
     }
@@ -365,7 +365,7 @@ bytes_subscript(PyBytesObject *self, PyObject *item)
         if (i < 0)
             i += PyBytes_GET_SIZE(self);
 
-        if (i < 0 || i >= Py_Size(self)) {
+        if (i < 0 || i >= Py_SIZE(self)) {
             PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
             return NULL;
         }
@@ -437,7 +437,7 @@ bytes_setslice(PyBytesObject *self, Py_ssize_t lo, Py_ssize_t hi,
             if (_getbuffer(values, &vbytes) < 0) {
                     PyErr_Format(PyExc_TypeError,
                                  "can't set bytes slice from %.100s",
-                                 Py_Type(values)->tp_name);
+                                 Py_TYPE(values)->tp_name);
                     return -1;
             }
             needed = vbytes.len;
@@ -448,8 +448,8 @@ bytes_setslice(PyBytesObject *self, Py_ssize_t lo, Py_ssize_t hi,
         lo = 0;
     if (hi < lo)
         hi = lo;
-    if (hi > Py_Size(self))
-        hi = Py_Size(self);
+    if (hi > Py_SIZE(self))
+        hi = Py_SIZE(self);
 
     avail = hi - lo;
     if (avail < 0)
@@ -464,11 +464,11 @@ 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,
-                    Py_Size(self) - hi);
+                    Py_SIZE(self) - hi);
         }
         /* XXX(nnorwitz): need to verify this can't overflow! */
         if (PyBytes_Resize((PyObject *)self,
-                           Py_Size(self) + needed - avail) < 0) {
+                           Py_SIZE(self) + needed - avail) < 0) {
                 res = -1;
                 goto finish;
         }
@@ -480,7 +480,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,
-                    Py_Size(self) - lo - needed);
+                    Py_SIZE(self) - lo - needed);
         }
     }
 
@@ -500,9 +500,9 @@ bytes_setitem(PyBytesObject *self, Py_ssize_t i, PyObject *value)
     Py_ssize_t ival;
 
     if (i < 0)
-        i += Py_Size(self);
+        i += Py_SIZE(self);
 
-    if (i < 0 || i >= Py_Size(self)) {
+    if (i < 0 || i >= Py_SIZE(self)) {
         PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
         return -1;
     }
@@ -538,7 +538,7 @@ bytes_ass_subscript(PyBytesObject *self, PyObject *item, PyObject *values)
         if (i < 0)
             i += PyBytes_GET_SIZE(self);
 
-        if (i < 0 || i >= Py_Size(self)) {
+        if (i < 0 || i >= Py_SIZE(self)) {
             PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
             return -1;
         }
@@ -592,7 +592,7 @@ bytes_ass_subscript(PyBytesObject *self, PyObject *item, PyObject *values)
     else {
         assert(PyBytes_Check(values));
         bytes = ((PyBytesObject *)values)->ob_bytes;
-        needed = Py_Size(values);
+        needed = Py_SIZE(values);
     }
     /* Make sure b[5:2] = ... inserts before 5, not before 2. */
     if ((step < 0 && start < stop) ||
@@ -608,10 +608,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,
-                        Py_Size(self) - stop);
+                        Py_SIZE(self) - stop);
             }
             if (PyBytes_Resize((PyObject *)self,
-                               Py_Size(self) + needed - slicelen) < 0)
+                               Py_SIZE(self) + needed - slicelen) < 0)
                 return -1;
             if (slicelen < needed) {
                 /*
@@ -621,7 +621,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,
-                        Py_Size(self) - start - needed);
+                        Py_SIZE(self) - start - needed);
             }
         }
 
@@ -692,7 +692,7 @@ bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds)
     PyObject *it;
     PyObject *(*iternext)(PyObject *);
 
-    if (Py_Size(self) != 0) {
+    if (Py_SIZE(self) != 0) {
         /* Empty previous contents (yes, do this first of all!) */
         if (PyBytes_Resize((PyObject *)self, 0) < 0)
             return -1;
@@ -780,7 +780,7 @@ bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds)
     it = PyObject_GetIter(arg);
     if (it == NULL)
         return -1;
-    iternext = *Py_Type(it)->tp_iternext;
+    iternext = *Py_TYPE(it)->tp_iternext;
 
     /* Run the iterator to exhaustion */
     for (;;) {
@@ -812,11 +812,11 @@ bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds)
         }
 
         /* Append the byte */
-        if (Py_Size(self) < self->ob_alloc)
-            Py_Size(self)++;
-        else if (PyBytes_Resize((PyObject *)self, Py_Size(self)+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[Py_Size(self)-1] = value;
+        self->ob_bytes[Py_SIZE(self)-1] = value;
     }
 
     /* Clean up and return success */
@@ -837,7 +837,7 @@ bytes_repr(PyBytesObject *self)
     static const char *hexdigits = "0123456789abcdef";
     const char *quote_prefix = "bytearray(b";
     const char *quote_postfix = ")";
-    Py_ssize_t length = Py_Size(self);
+    Py_ssize_t length = Py_SIZE(self);
     /* 14 == strlen(quote_prefix) + 2 + strlen(quote_postfix) */
     size_t newsize = 14 + 4 * length;
     PyObject *v;
@@ -1008,7 +1008,7 @@ bytes_dealloc(PyBytesObject *self)
     if (self->ob_bytes != 0) {
         PyMem_Free(self->ob_bytes);
     }
-    Py_Type(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 
@@ -1196,7 +1196,7 @@ bytes_contains(PyObject *self, PyObject *arg)
         PyErr_Clear();
         if (_getbuffer(arg, &varg) < 0)
             return -1;
-        pos = stringlib_find(PyBytes_AS_STRING(self), Py_Size(self),
+        pos = stringlib_find(PyBytes_AS_STRING(self), Py_SIZE(self),
                              varg.buf, varg.len, 0);
         PyObject_ReleaseBuffer(arg, &varg);
         return pos >= 0;
@@ -1206,7 +1206,7 @@ bytes_contains(PyObject *self, PyObject *arg)
         return -1;
     }
 
-    return memchr(PyBytes_AS_STRING(self), ival, Py_Size(self)) != NULL;
+    return memchr(PyBytes_AS_STRING(self), ival, Py_SIZE(self)) != NULL;
 }
 
 
@@ -2109,7 +2109,7 @@ bytes_replace(PyBytesObject *self, PyObject *args)
     count++; }
 
 /* Always force the list to the expected size. */
-#define FIX_PREALLOC_SIZE(list) Py_Size(list) = count
+#define FIX_PREALLOC_SIZE(list) Py_SIZE(list) = count
 
 
 Py_LOCAL_INLINE(PyObject *)
@@ -2495,7 +2495,7 @@ static PyObject *
 bytes_reverse(PyBytesObject *self, PyObject *unused)
 {
     char swap, *head, *tail;
-    Py_ssize_t i, j, n = Py_Size(self);
+    Py_ssize_t i, j, n = Py_SIZE(self);
 
     j = n / 2;
     head = self->ob_bytes;
@@ -2517,7 +2517,7 @@ static PyObject *
 bytes_insert(PyBytesObject *self, PyObject *args)
 {
     int value;
-    Py_ssize_t where, n = Py_Size(self);
+    Py_ssize_t where, n = Py_SIZE(self);
 
     if (!PyArg_ParseTuple(args, "ni:insert", &where, &value))
         return NULL;
@@ -2556,7 +2556,7 @@ static PyObject *
 bytes_append(PyBytesObject *self, PyObject *arg)
 {
     int value;
-    Py_ssize_t n = Py_Size(self);
+    Py_ssize_t n = Py_SIZE(self);
 
     if (! _getbytevalue(arg, &value))
         return NULL;
@@ -2588,7 +2588,7 @@ bytes_extend(PyBytesObject *self, PyObject *arg)
 
     /* bytes_setslice code only accepts something supporting PEP 3118. */
     if (PyObject_CheckBuffer(arg)) {
-        if (bytes_setslice(self, Py_Size(self), Py_Size(self), arg) == -1)
+        if (bytes_setslice(self, Py_SIZE(self), Py_SIZE(self), arg) == -1)
             return NULL;
 
         Py_RETURN_NONE;
@@ -2642,7 +2642,7 @@ static PyObject *
 bytes_pop(PyBytesObject *self, PyObject *args)
 {
     int value;
-    Py_ssize_t where = -1, n = Py_Size(self);
+    Py_ssize_t where = -1, n = Py_SIZE(self);
 
     if (!PyArg_ParseTuple(args, "|n:pop", &where))
         return NULL;
@@ -2653,8 +2653,8 @@ bytes_pop(PyBytesObject *self, PyObject *args)
         return NULL;
     }
     if (where < 0)
-        where += Py_Size(self);
-    if (where < 0 || where >= Py_Size(self)) {
+        where += Py_SIZE(self);
+    if (where < 0 || where >= Py_SIZE(self)) {
         PyErr_SetString(PyExc_IndexError, "pop index out of range");
         return NULL;
     }
@@ -2675,7 +2675,7 @@ static PyObject *
 bytes_remove(PyBytesObject *self, PyObject *arg)
 {
     int value;
-    Py_ssize_t where, n = Py_Size(self);
+    Py_ssize_t where, n = Py_SIZE(self);
 
     if (! _getbytevalue(arg, &value))
         return NULL;
@@ -2743,7 +2743,7 @@ bytes_strip(PyBytesObject *self, PyObject *args)
         argsize = varg.len;
     }
     myptr = self->ob_bytes;
-    mysize = Py_Size(self);
+    mysize = Py_SIZE(self);
     left = lstrip_helper(myptr, mysize, argptr, argsize);
     if (left == mysize)
         right = left;
@@ -2779,7 +2779,7 @@ bytes_lstrip(PyBytesObject *self, PyObject *args)
         argsize = varg.len;
     }
     myptr = self->ob_bytes;
-    mysize = Py_Size(self);
+    mysize = Py_SIZE(self);
     left = lstrip_helper(myptr, mysize, argptr, argsize);
     right = mysize;
     if (arg != Py_None)
@@ -2812,7 +2812,7 @@ bytes_rstrip(PyBytesObject *self, PyObject *args)
         argsize = varg.len;
     }
     myptr = self->ob_bytes;
-    mysize = Py_Size(self);
+    mysize = Py_SIZE(self);
     left = 0;
     right = rstrip_helper(myptr, mysize, argptr, argsize);
     if (arg != Py_None)
@@ -2863,7 +2863,7 @@ static PyObject *
 bytes_join(PyBytesObject *self, PyObject *it)
 {
     PyObject *seq;
-    Py_ssize_t mysize = Py_Size(self);
+    Py_ssize_t mysize = Py_SIZE(self);
     Py_ssize_t i;
     Py_ssize_t n;
     PyObject **items;
@@ -2886,12 +2886,12 @@ 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, Py_Type(obj)->tp_name);
+                         (long)i, Py_TYPE(obj)->tp_name);
             goto error;
         }
         if (i > 0)
             totalsize += mysize;
-        totalsize += Py_Size(obj);
+        totalsize += Py_SIZE(obj);
         if (totalsize < 0) {
             PyErr_NoMemory();
             goto error;
@@ -2905,7 +2905,7 @@ bytes_join(PyBytesObject *self, PyObject *it)
     dest = PyBytes_AS_STRING(result);
     for (i = 0; i < n; i++) {
         PyObject *obj = items[i];
-        Py_ssize_t size = Py_Size(obj);
+        Py_ssize_t size = Py_SIZE(obj);
         char *buf;
         if (PyBytes_Check(obj))
            buf = PyBytes_AS_STRING(obj);
@@ -3004,7 +3004,7 @@ bytes_reduce(PyBytesObject *self)
     PyObject *latin1, *dict;
     if (self->ob_bytes)
         latin1 = PyUnicode_DecodeLatin1(self->ob_bytes,
-                                        Py_Size(self), NULL);
+                                        Py_SIZE(self), NULL);
     else
         latin1 = PyUnicode_FromString("");
 
@@ -3015,7 +3015,7 @@ bytes_reduce(PyBytesObject *self)
         Py_INCREF(dict);
     }
 
-    return Py_BuildValue("(O(Ns)N)", Py_Type(self), latin1, "latin-1", dict);
+    return Py_BuildValue("(O(Ns)N)", Py_TYPE(self), latin1, "latin-1", dict);
 }
 
 static PySequenceMethods bytes_as_sequence = {
diff --git a/Objects/classobject.c b/Objects/classobject.c
index e387142..d9f7219 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -208,7 +208,7 @@ method_repr(PyMethodObject *a)
 {
 	PyObject *self = a->im_self;
 	PyObject *func = a->im_func;
-	PyObject *klass = (PyObject*)Py_Type(self);
+	PyObject *klass = (PyObject*)Py_TYPE(self);
 	PyObject *funcname = NULL ,*klassname = NULL, *result = NULL;
 	char *defname = "?";
 
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index abedfaf..3d7ba55 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -203,7 +203,7 @@ PyDict_New(void)
 	if (num_free_dicts) {
 		mp = free_dicts[--num_free_dicts];
 		assert (mp != NULL);
-		assert (Py_Type(mp) == &PyDict_Type);
+		assert (Py_TYPE(mp) == &PyDict_Type);
 		_Py_NewReference((PyObject *)mp);
 		if (mp->ma_fill) {
 			EMPTY_TO_MINSIZE(mp);
@@ -897,10 +897,10 @@ dict_dealloc(register PyDictObject *mp)
 	}
 	if (mp->ma_table != mp->ma_smalltable)
 		PyMem_DEL(mp->ma_table);
-	if (num_free_dicts < MAXFREEDICTS && Py_Type(mp) == &PyDict_Type)
+	if (num_free_dicts < MAXFREEDICTS && Py_TYPE(mp) == &PyDict_Type)
 		free_dicts[num_free_dicts++] = mp;
 	else
-		Py_Type(mp)->tp_free((PyObject *)mp);
+		Py_TYPE(mp)->tp_free((PyObject *)mp);
 	Py_TRASHCAN_SAFE_END(mp)
 }
 
@@ -1014,7 +1014,7 @@ dict_subscript(PyDictObject *mp, register PyObject *key)
 			if (missing_str == NULL)
 				missing_str =
 				  PyUnicode_InternFromString("__missing__");
-			missing = _PyType_Lookup(Py_Type(mp), missing_str);
+			missing = _PyType_Lookup(Py_TYPE(mp), missing_str);
 			if (missing != NULL)
 				return PyObject_CallFunctionObjArgs(missing,
 					(PyObject *)mp, key, NULL);
diff --git a/Objects/enumobject.c b/Objects/enumobject.c
index 6dc5a59..5a08e6d 100644
--- a/Objects/enumobject.c
+++ b/Objects/enumobject.c
@@ -46,7 +46,7 @@ enum_dealloc(enumobject *en)
 	Py_XDECREF(en->en_sit);
 	Py_XDECREF(en->en_result);
 	Py_XDECREF(en->en_longindex);
-	Py_Type(en)->tp_free(en);
+	Py_TYPE(en)->tp_free(en);
 }
 
 static int
@@ -108,7 +108,7 @@ enum_next(enumobject *en)
 	PyObject *result = en->en_result;
 	PyObject *it = en->en_sit;
 
-	next_item = (*Py_Type(it)->tp_iternext)(it);
+	next_item = (*Py_TYPE(it)->tp_iternext)(it);
 	if (next_item == NULL)
 		return NULL;
 
@@ -237,7 +237,7 @@ reversed_dealloc(reversedobject *ro)
 {
 	PyObject_GC_UnTrack(ro);
 	Py_XDECREF(ro->seq);
-	Py_Type(ro)->tp_free(ro);
+	Py_TYPE(ro)->tp_free(ro);
 }
 
 static int
diff --git a/Objects/exceptions.c b/Objects/exceptions.c
index 9655733..ba0c6bd 100644
--- a/Objects/exceptions.c
+++ b/Objects/exceptions.c
@@ -42,7 +42,7 @@ BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 static int
 BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
 {
-    if (!_PyArg_NoKeywords(Py_Type(self)->tp_name, kwds))
+    if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
         return -1;
 
     Py_DECREF(self->args);
@@ -68,7 +68,7 @@ BaseException_dealloc(PyBaseExceptionObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     BaseException_clear(self);
-    Py_Type(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -101,7 +101,7 @@ BaseException_repr(PyBaseExceptionObject *self)
     char *name;
     char *dot;
 
-    name = (char *)Py_Type(self)->tp_name;
+    name = (char *)Py_TYPE(self)->tp_name;
     dot = strrchr(name, '.');
     if (dot != NULL) name = dot+1;
 
@@ -113,9 +113,9 @@ static PyObject *
 BaseException_reduce(PyBaseExceptionObject *self)
 {
     if (self->args && self->dict)
-        return PyTuple_Pack(3, Py_Type(self), self->args, self->dict);
+        return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);
     else
-        return PyTuple_Pack(2, Py_Type(self), self->args);
+        return PyTuple_Pack(2, Py_TYPE(self), self->args);
 }
 
 /*
@@ -465,7 +465,7 @@ SystemExit_dealloc(PySystemExitObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     SystemExit_clear(self);
-    Py_Type(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -570,7 +570,7 @@ EnvironmentError_dealloc(PyEnvironmentErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     EnvironmentError_clear(self);
-    Py_Type(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -636,9 +636,9 @@ EnvironmentError_reduce(PyEnvironmentErrorObject *self)
         Py_INCREF(args);
 
     if (self->dict)
-        res = PyTuple_Pack(3, Py_Type(self), args, self->dict);
+        res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);
     else
-        res = PyTuple_Pack(2, Py_Type(self), args);
+        res = PyTuple_Pack(2, Py_TYPE(self), args);
     Py_DECREF(args);
     return res;
 }
@@ -691,7 +691,7 @@ WindowsError_dealloc(PyWindowsErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     WindowsError_clear(self);
-    Py_Type(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -889,7 +889,7 @@ SyntaxError_dealloc(PySyntaxErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     SyntaxError_clear(self);
-    Py_Type(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
@@ -1316,7 +1316,7 @@ UnicodeError_dealloc(PyUnicodeErrorObject *self)
 {
     _PyObject_GC_UNTRACK(self);
     UnicodeError_clear(self);
-    Py_Type(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index c876c74..0989415 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -44,8 +44,8 @@ fill_free_list(void)
 	p = &((PyFloatBlock *)p)->objects[0];
 	q = p + N_FLOATOBJECTS;
 	while (--q > p)
-		Py_Type(q) = (struct _typeobject *)(q-1);
-	Py_Type(q) = NULL;
+		Py_TYPE(q) = (struct _typeobject *)(q-1);
+	Py_TYPE(q) = NULL;
 	return p + N_FLOATOBJECTS - 1;
 }
 
@@ -105,7 +105,7 @@ PyFloat_FromDouble(double fval)
 	}
 	/* Inline PyObject_New */
 	op = free_list;
-	free_list = (PyFloatObject *)Py_Type(op);
+	free_list = (PyFloatObject *)Py_TYPE(op);
 	PyObject_INIT(op, &PyFloat_Type);
 	op->ob_fval = fval;
 	return (PyObject *) op;
@@ -221,11 +221,11 @@ static void
 float_dealloc(PyFloatObject *op)
 {
 	if (PyFloat_CheckExact(op)) {
-		Py_Type(op) = (struct _typeobject *)free_list;
+		Py_TYPE(op) = (struct _typeobject *)free_list;
 		free_list = op;
 	}
 	else
-		Py_Type(op)->tp_free((PyObject *)op);
+		Py_TYPE(op)->tp_free((PyObject *)op);
 }
 
 double
@@ -243,7 +243,7 @@ PyFloat_AsDouble(PyObject *op)
 		return -1;
 	}
 
-	if ((nb = Py_Type(op)->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;
 	}
@@ -1088,7 +1088,7 @@ float_getformat(PyTypeObject *v, PyObject* arg)
 	if (!PyUnicode_Check(arg)) {
 		PyErr_Format(PyExc_TypeError,
 	     "__getformat__() argument must be string, not %.500s",
-			     Py_Type(arg)->tp_name);
+			     Py_TYPE(arg)->tp_name);
 		return NULL;
 	}
 	s = PyUnicode_AsString(arg);
@@ -1412,7 +1412,7 @@ PyFloat_Fini(void)
 		for (i = 0, p = &list->objects[0];
 		     i < N_FLOATOBJECTS;
 		     i++, p++) {
-			if (PyFloat_CheckExact(p) && Py_Refcnt(p) != 0)
+			if (PyFloat_CheckExact(p) && Py_REFCNT(p) != 0)
 				frem++;
 		}
 		next = list->next;
@@ -1423,8 +1423,8 @@ PyFloat_Fini(void)
 			     i < N_FLOATOBJECTS;
 			     i++, p++) {
 				if (!PyFloat_CheckExact(p) ||
-				    Py_Refcnt(p) == 0) {
-					Py_Type(p) = (struct _typeobject *)
+				    Py_REFCNT(p) == 0) {
+					Py_TYPE(p) = (struct _typeobject *)
 						free_list;
 					free_list = p;
 				}
@@ -1456,7 +1456,7 @@ PyFloat_Fini(void)
 			     i < N_FLOATOBJECTS;
 			     i++, p++) {
 				if (PyFloat_CheckExact(p) &&
-				    Py_Refcnt(p) != 0) {
+				    Py_REFCNT(p) != 0) {
 					char buf[100];
 					format_float(buf, sizeof(buf), p, PREC_STR);
 					/* XXX(twouters) cast refcount to
@@ -1465,7 +1465,7 @@ PyFloat_Fini(void)
 					 */
 					fprintf(stderr,
 			     "#   <float at %p, refcnt=%ld, val=%s>\n",
-						p, (long)Py_Refcnt(p), buf);
+						p, (long)Py_REFCNT(p), buf);
 				}
 			}
 			list = list->next;
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index 266cbd2..deda244 100644
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -630,7 +630,7 @@ PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
 		    --numfree;
 		    f = free_list;
 		    free_list = free_list->f_back;
-		    if (Py_Size(f) < 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 ac68edc..fddb120 100644
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -721,7 +721,7 @@ cm_dealloc(classmethod *cm)
 {
 	_PyObject_GC_UNTRACK((PyObject *)cm);
 	Py_XDECREF(cm->cm_callable);
-	Py_Type(cm)->tp_free((PyObject *)cm);
+	Py_TYPE(cm)->tp_free((PyObject *)cm);
 }
 
 static int
@@ -750,7 +750,7 @@ cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 		return NULL;
 	}
 	if (type == NULL)
-		type = (PyObject *)(Py_Type(obj));
+		type = (PyObject *)(Py_TYPE(obj));
  	return PyMethod_New(cm->cm_callable, type);
 }
 
@@ -877,7 +877,7 @@ sm_dealloc(staticmethod *sm)
 {
 	_PyObject_GC_UNTRACK((PyObject *)sm);
 	Py_XDECREF(sm->sm_callable);
-	Py_Type(sm)->tp_free((PyObject *)sm);
+	Py_TYPE(sm)->tp_free((PyObject *)sm);
 }
 
 static int
diff --git a/Objects/genobject.c b/Objects/genobject.c
index 5dfcda2..7becca2 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 */
-		Py_Type(gen)->tp_del(self);
+		Py_TYPE(gen)->tp_del(self);
 		if (self->ob_refcnt > 0)
 			return;		/* resurrected.  :( */
 	}
diff --git a/Objects/iterobject.c b/Objects/iterobject.c
index e48700c..454c405 100644
--- a/Objects/iterobject.c
+++ b/Objects/iterobject.c
@@ -253,7 +253,7 @@ _PyZip_CreateIter(PyObject* args)
         
         assert(PyTuple_Check(args));
 
-	if (Py_Type(&PyZipIter_Type) == NULL) {
+	if (Py_TYPE(&PyZipIter_Type) == NULL) {
 		if (PyType_Ready(&PyZipIter_Type) < 0)
 			return NULL;
 	}
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 9fbc463..b62bba5 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);
-		Py_Size(self) = 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;
-	Py_Size(self) = 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);
 	}
-	Py_Size(op) = 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 Py_Size(op);
+		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 >= Py_Size(op)) {
+	if (i < 0 || i >= Py_SIZE(op)) {
 		if (indexerr == NULL)
 			indexerr = PyUnicode_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 >= Py_Size(op)) {
+	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 = Py_Size(self);
+	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 = Py_Size(op);
+		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
-		Py_Type(op)->tp_free((PyObject *)op);
+		Py_TYPE(op)->tp_free((PyObject *)op);
 	Py_TRASHCAN_SAFE_END(op)
 }
 
@@ -284,7 +284,7 @@ list_repr(PyListObject *v)
 		return i > 0 ? PyUnicode_FromString("[...]") : NULL;
 	}
 
-	if (Py_Size(v) == 0) {
+	if (Py_SIZE(v) == 0) {
 		result = PyUnicode_FromString("[]");
 		goto Done;
 	}
@@ -295,7 +295,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 < Py_Size(v); ++i) {
+	for (i = 0; i < Py_SIZE(v); ++i) {
 		int status;
 		if (Py_EnterRecursiveCall(" while getting the repr of a list"))
 			goto Done;
@@ -345,7 +345,7 @@ Done:
 static Py_ssize_t
 list_length(PyListObject *a)
 {
-	return Py_Size(a);
+	return Py_SIZE(a);
 }
 
 static int
@@ -354,7 +354,7 @@ list_contains(PyListObject *a, PyObject *el)
 	Py_ssize_t i;
 	int cmp;
 
-	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(a); ++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;
@@ -363,7 +363,7 @@ list_contains(PyListObject *a, PyObject *el)
 static PyObject *
 list_item(PyListObject *a, Py_ssize_t i)
 {
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		if (indexerr == NULL)
 			indexerr = PyUnicode_FromString(
 				"list index out of range");
@@ -382,12 +382,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 > Py_Size(a))
-		ilow = Py_Size(a);
+	else if (ilow > Py_SIZE(a))
+		ilow = Py_SIZE(a);
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > Py_Size(a))
-		ihigh = Py_Size(a);
+	else if (ihigh > Py_SIZE(a))
+		ihigh = Py_SIZE(a);
 	len = ihigh - ilow;
 	np = (PyListObject *) PyList_New(len);
 	if (np == NULL)
@@ -427,7 +427,7 @@ list_concat(PyListObject *a, PyObject *bb)
 		return NULL;
 	}
 #define b ((PyListObject *)bb)
-	size = Py_Size(a) + Py_Size(b);
+	size = Py_SIZE(a) + Py_SIZE(b);
 	if (size < 0)
 		return PyErr_NoMemory();
 	np = (PyListObject *) PyList_New(size);
@@ -436,14 +436,14 @@ list_concat(PyListObject *a, PyObject *bb)
 	}
 	src = a->ob_item;
 	dest = np->ob_item;
-	for (i = 0; i < Py_Size(a); 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 + Py_Size(a);
-	for (i = 0; i < Py_Size(b); 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;
@@ -462,8 +462,8 @@ list_repeat(PyListObject *a, Py_ssize_t n)
 	PyObject *elem;
 	if (n < 0)
 		n = 0;
-	size = Py_Size(a) * n;
-	if (n && size/n != Py_Size(a))
+	size = Py_SIZE(a) * n;
+	if (n && size/n != Py_SIZE(a))
 		return PyErr_NoMemory();
 	if (size == 0)
               return PyList_New(0);
@@ -472,7 +472,7 @@ list_repeat(PyListObject *a, Py_ssize_t n)
 		return NULL;
 
 	items = np->ob_item;
-	if (Py_Size(a) == 1) {
+	if (Py_SIZE(a) == 1) {
 		elem = a->ob_item[0];
 		for (i = 0; i < n; i++) {
 			items[i] = elem;
@@ -483,7 +483,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 < Py_Size(a); j++) {
+		for (j = 0; j < Py_SIZE(a); j++) {
 			*p = items[j];
 			Py_INCREF(*p);
 			p++;
@@ -500,8 +500,8 @@ list_clear(PyListObject *a)
 	if (item != NULL) {
 		/* Because XDECREF can recursively invoke operations on
 		   this list, we make it empty first. */
-		i = Py_Size(a);
-		Py_Size(a) = 0;
+		i = Py_SIZE(a);
+		Py_SIZE(a) = 0;
 		a->ob_item = NULL;
 		a->allocated = 0;
 		while (--i >= 0) {
@@ -547,7 +547,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, Py_Size(b));
+			v = list_slice(b, 0, Py_SIZE(b));
 			if (v == NULL)
 				return result;
 			result = list_ass_slice(a, ilow, ihigh, v);
@@ -562,18 +562,18 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 	}
 	if (ilow < 0)
 		ilow = 0;
-	else if (ilow > Py_Size(a))
-		ilow = Py_Size(a);
+	else if (ilow > Py_SIZE(a))
+		ilow = Py_SIZE(a);
 
 	if (ihigh < ilow)
 		ihigh = ilow;
-	else if (ihigh > Py_Size(a))
-		ihigh = Py_Size(a);
+	else if (ihigh > Py_SIZE(a))
+		ihigh = Py_SIZE(a);
 
 	norig = ihigh - ilow;
 	assert(norig >= 0);
 	d = n - norig;
-	if (Py_Size(a) + d == 0) {
+	if (Py_SIZE(a) + d == 0) {
 		Py_XDECREF(v_as_SF);
 		return list_clear(a);
 	}
@@ -591,12 +591,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],
-			(Py_Size(a) - ihigh)*sizeof(PyObject *));
-		list_resize(a, Py_Size(a) + 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 = Py_Size(a);
+		k = Py_SIZE(a);
 		if (list_resize(a, k+d) < 0)
 			goto Error;
 		item = a->ob_item;
@@ -671,7 +671,7 @@ static int
 list_ass_item(PyListObject *a, Py_ssize_t i, PyObject *v)
 {
 	PyObject *old_value;
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		PyErr_SetString(PyExc_IndexError,
 				"list assignment index out of range");
 		return -1;
@@ -730,7 +730,7 @@ listextend(PyListObject *self, PyObject *b)
 			Py_DECREF(b);
 			Py_RETURN_NONE;
 		}
-		m = Py_Size(self);
+		m = Py_SIZE(self);
 		if (list_resize(self, m + n) == -1) {
 			Py_DECREF(b);
 			return NULL;
@@ -759,14 +759,14 @@ listextend(PyListObject *self, PyObject *b)
 
 	/* Guess a result list size. */
 	n = _PyObject_LengthHint(b, 8);
-	m = Py_Size(self);
+	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. */
-		Py_Size(self) = 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
@@ -785,10 +785,10 @@ listextend(PyListObject *self, PyObject *b)
 			}
 			break;
 		}
-		if (Py_Size(self) < self->allocated) {
+		if (Py_SIZE(self) < self->allocated) {
 			/* steals ref */
-			PyList_SET_ITEM(self, Py_Size(self), item);
-			++Py_Size(self);
+			PyList_SET_ITEM(self, Py_SIZE(self), item);
+			++Py_SIZE(self);
 		}
 		else {
 			int status = app1(self, item);
@@ -799,8 +799,8 @@ listextend(PyListObject *self, PyObject *b)
 	}
 
 	/* Cut back result list if initial guess was too large. */
-	if (Py_Size(self) < self->allocated)
-		list_resize(self, Py_Size(self));  /* 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;
@@ -839,20 +839,20 @@ listpop(PyListObject *self, PyObject *args)
 	if (!PyArg_ParseTuple(args, "|n:pop", &i))
 		return NULL;
 
-	if (Py_Size(self) == 0) {
+	if (Py_SIZE(self) == 0) {
 		/* Special-case most common failure cause */
 		PyErr_SetString(PyExc_IndexError, "pop from empty list");
 		return NULL;
 	}
 	if (i < 0)
-		i += Py_Size(self);
-	if (i < 0 || i >= Py_Size(self)) {
+		i += Py_SIZE(self);
+	if (i < 0 || i >= Py_SIZE(self)) {
 		PyErr_SetString(PyExc_IndexError, "pop index out of range");
 		return NULL;
 	}
 	v = self->ob_item[i];
-	if (i == Py_Size(self) - 1) {
-		status = list_resize(self, Py_Size(self) - 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 */
 	}
@@ -2009,10 +2009,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 = Py_Size(self);
+	saved_ob_size = Py_SIZE(self);
 	saved_ob_item = self->ob_item;
 	saved_allocated = self->allocated;
-	Py_Size(self) = 0;
+	Py_SIZE(self) = 0;
 	self->ob_item = NULL;
 	self->allocated = -1; /* any operation will reset it to >= 0 */
 
@@ -2118,8 +2118,8 @@ fail:
 
 dsu_fail:
 	final_ob_item = self->ob_item;
-	i = Py_Size(self);
-	Py_Size(self) = 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) {
@@ -2154,8 +2154,8 @@ PyList_Sort(PyObject *v)
 static PyObject *
 listreverse(PyListObject *self)
 {
-	if (Py_Size(self) > 1)
-		reverse_slice(self->ob_item, self->ob_item + Py_Size(self));
+	if (Py_SIZE(self) > 1)
+		reverse_slice(self->ob_item, self->ob_item + Py_SIZE(self));
 	Py_RETURN_NONE;
 }
 
@@ -2168,8 +2168,8 @@ PyList_Reverse(PyObject *v)
 		PyErr_BadInternalCall();
 		return -1;
 	}
-	if (Py_Size(self) > 1)
-		reverse_slice(self->ob_item, self->ob_item + Py_Size(self));
+	if (Py_SIZE(self) > 1)
+		reverse_slice(self->ob_item, self->ob_item + Py_SIZE(self));
 	return 0;
 }
 
@@ -2183,7 +2183,7 @@ PyList_AsTuple(PyObject *v)
 		PyErr_BadInternalCall();
 		return NULL;
 	}
-	n = Py_Size(v);
+	n = Py_SIZE(v);
 	w = PyTuple_New(n);
 	if (w == NULL)
 		return NULL;
@@ -2201,7 +2201,7 @@ PyList_AsTuple(PyObject *v)
 static PyObject *
 listindex(PyListObject *self, PyObject *args)
 {
-	Py_ssize_t i, start=0, stop=Py_Size(self);
+	Py_ssize_t i, start=0, stop=Py_SIZE(self);
 	PyObject *v;
 
 	if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
@@ -2209,16 +2209,16 @@ listindex(PyListObject *self, PyObject *args)
 	                            _PyEval_SliceIndex, &stop))
 		return NULL;
 	if (start < 0) {
-		start += Py_Size(self);
+		start += Py_SIZE(self);
 		if (start < 0)
 			start = 0;
 	}
 	if (stop < 0) {
-		stop += Py_Size(self);
+		stop += Py_SIZE(self);
 		if (stop < 0)
 			stop = 0;
 	}
-	for (i = start; i < stop && i < Py_Size(self); 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 PyLong_FromSsize_t(i);
@@ -2235,7 +2235,7 @@ listcount(PyListObject *self, PyObject *v)
 	Py_ssize_t count = 0;
 	Py_ssize_t i;
 
-	for (i = 0; i < Py_Size(self); i++) {
+	for (i = 0; i < Py_SIZE(self); i++) {
 		int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
 		if (cmp > 0)
 			count++;
@@ -2250,7 +2250,7 @@ listremove(PyListObject *self, PyObject *v)
 {
 	Py_ssize_t i;
 
-	for (i = 0; i < Py_Size(self); 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,
@@ -2270,7 +2270,7 @@ list_traverse(PyListObject *o, visitproc visit, void *arg)
 {
 	Py_ssize_t i;
 
-	for (i = Py_Size(o); --i >= 0; )
+	for (i = Py_SIZE(o); --i >= 0; )
 		Py_VISIT(o->ob_item[i]);
 	return 0;
 }
@@ -2289,7 +2289,7 @@ list_richcompare(PyObject *v, PyObject *w, int op)
 	vl = (PyListObject *)v;
 	wl = (PyListObject *)w;
 
-	if (Py_Size(vl) != Py_Size(wl) && (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)
@@ -2301,7 +2301,7 @@ list_richcompare(PyObject *v, PyObject *w, int op)
 	}
 
 	/* Search for the first index where items are different */
-	for (i = 0; i < Py_Size(vl) && i < Py_Size(wl); 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)
@@ -2310,10 +2310,10 @@ list_richcompare(PyObject *v, PyObject *w, int op)
 			break;
 	}
 
-	if (i >= Py_Size(vl) || i >= Py_Size(wl)) {
+	if (i >= Py_SIZE(vl) || i >= Py_SIZE(wl)) {
 		/* No more items to compare -- compare sizes */
-		Py_ssize_t vs = Py_Size(vl);
-		Py_ssize_t ws = Py_Size(wl);
+		Py_ssize_t vs = Py_SIZE(vl);
+		Py_ssize_t ws = Py_SIZE(wl);
 		int cmp;
 		PyObject *res;
 		switch (op) {
@@ -2357,8 +2357,8 @@ list_init(PyListObject *self, PyObject *args, PyObject *kw)
 		return -1;
 
 	/* Verify list invariants established by PyType_GenericAlloc() */
-	assert(0 <= Py_Size(self));
-	assert(Py_Size(self) <= 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);
 
@@ -2454,7 +2454,7 @@ list_subscript(PyListObject* self, PyObject* item)
 		PyObject* it;
 		PyObject **src, **dest;
 
-		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
+		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
 				 &start, &stop, &step, &slicelength) < 0) {
 			return NULL;
 		}
@@ -2503,7 +2503,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, Py_Size(self),
+		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
 				 &start, &stop, &step, &slicelength) < 0) {
 			return -1;
 		}
@@ -2551,8 +2551,8 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
 
 				garbage[i] = PyList_GET_ITEM(self, cur);
 
-				if (cur + step >= Py_Size(self)) {
-					lim = Py_Size(self) - cur - 1;
+				if (cur + step >= Py_SIZE(self)) {
+					lim = Py_SIZE(self) - cur - 1;
 				}
 
 				memmove(self->ob_item + cur - i,
@@ -2560,15 +2560,15 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
 					lim * sizeof(PyObject *));
 			}
 			cur = start + slicelength*step;
-			if (cur < Py_Size(self)) {
+			if (cur < Py_SIZE(self)) {
 				memmove(self->ob_item + cur - slicelength,
 					self->ob_item + cur,
-					(Py_Size(self) - cur) * 
+					(Py_SIZE(self) - cur) * 
 					 sizeof(PyObject *));
 			}
 
-			Py_Size(self) -= slicelength;
-			list_resize(self, Py_Size(self));
+			Py_SIZE(self) -= slicelength;
+			list_resize(self, Py_SIZE(self));
 
 			for (i = 0; i < slicelength; i++) {
 				Py_DECREF(garbage[i]);
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 1df7c5d..15f56d6 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -48,11 +48,11 @@ get_small_int(int ival)
 #define CHECK_SMALL_INT(ival)
 #endif
 
-#define MEDIUM_VALUE(x) (Py_Size(x) < 0 ? -(x)->ob_digit[0] : (Py_Size(x) == 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 (Py_Refcnt(x) == 1) Py_Size(x) = -Py_Size(x);  \
+	do if (Py_REFCNT(x) == 1) Py_SIZE(x) = -Py_SIZE(x);  \
 	   else { PyObject* tmp=PyLong_FromLong(-MEDIUM_VALUE(x));  \
 		   Py_DECREF(x); (x) = (PyLongObject*)tmp; }	   \
         while(0)
@@ -96,13 +96,13 @@ static PyLongObject *divrem1(PyLongObject *, digit, digit *);
 static PyLongObject *
 long_normalize(register PyLongObject *v)
 {
-	Py_ssize_t j = ABS(Py_Size(v));
+	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)
-		Py_Size(v) = (Py_Size(v) < 0) ? -(i) : i;
+		Py_SIZE(v) = (Py_SIZE(v) < 0) ? -(i) : i;
 	return v;
 }
 
@@ -136,18 +136,18 @@ _PyLong_Copy(PyLongObject *src)
 	Py_ssize_t i;
 
 	assert(src != NULL);
-	i = Py_Size(src);
+	i = Py_SIZE(src);
 	if (i < 0)
 		i = -(i);
 	if (i < 2) {
 		int ival = src->ob_digit[0];
-		if (Py_Size(src) < 0)
+		if (Py_SIZE(src) < 0)
 			ival = -ival;
 		CHECK_SMALL_INT(ival);
 	}
 	result = _PyLong_New(i);
 	if (result != NULL) {
-		Py_Size(result) = Py_Size(src);
+		Py_SIZE(result) = Py_SIZE(src);
 		while (--i >= 0)
 			result->ob_digit[i] = src->ob_digit[i];
 	}
@@ -175,7 +175,7 @@ PyLong_FromLong(long ival)
 	if (!(ival>>PyLong_SHIFT)) {
 		v = _PyLong_New(1);
 		if (v) {
-			Py_Size(v) = sign;
+			Py_SIZE(v) = sign;
 			v->ob_digit[0] = ival;
 		}
 		return (PyObject*)v;
@@ -185,7 +185,7 @@ PyLong_FromLong(long ival)
 	if (!(ival >> 2*PyLong_SHIFT)) {
 		v = _PyLong_New(2);
 		if (v) {
-			Py_Size(v) = 2*sign;
+			Py_SIZE(v) = 2*sign;
 			v->ob_digit[0] = (digit)ival & PyLong_MASK;
 			v->ob_digit[1] = ival >> PyLong_SHIFT;
 		}
@@ -201,7 +201,7 @@ PyLong_FromLong(long ival)
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		Py_Size(v) = ndigits*sign;
+		Py_SIZE(v) = ndigits*sign;
 		t = (unsigned long)ival;
 		while (t) {
 			*p++ = (digit)(t & PyLong_MASK);
@@ -231,7 +231,7 @@ PyLong_FromUnsignedLong(unsigned long ival)
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		Py_Size(v) = ndigits;
+		Py_SIZE(v) = ndigits;
 		while (ival) {
 			*p++ = (digit)(ival & PyLong_MASK);
 			ival >>= PyLong_SHIFT;
@@ -273,7 +273,7 @@ PyLong_FromDouble(double dval)
 		frac = ldexp(frac, PyLong_SHIFT);
 	}
 	if (neg)
-		Py_Size(v) = -(Py_Size(v));
+		Py_SIZE(v) = -(Py_SIZE(v));
 	return (PyObject *)v;
 }
 
@@ -330,7 +330,7 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow)
 
 	res = -1;
 	v = (PyLongObject *)vv;
-	i = Py_Size(v);
+	i = Py_SIZE(v);
 
 	switch (i) {
 	case -1:
@@ -353,7 +353,7 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow)
 			prev = x;
 			x = (x << PyLong_SHIFT) + v->ob_digit[i];
 			if ((x >> PyLong_SHIFT) != prev) {
-				*overflow = Py_Size(v) > 0 ? 1 : -1;
+				*overflow = Py_SIZE(v) > 0 ? 1 : -1;
 				goto exit;
 			}
 		}
@@ -367,7 +367,7 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow)
 			res = LONG_MIN;
 		}
 		else {
-			*overflow = Py_Size(v) > 0 ? 1 : -1;
+			*overflow = Py_SIZE(v) > 0 ? 1 : -1;
 			/* res is already set to -1 */
 		}	
 	}
@@ -401,7 +401,7 @@ _PyLong_FitsInLong(PyObject *vv)
 		return 0;
 	}
 	/* conservative estimate */
-	size = Py_Size(vv);
+	size = Py_SIZE(vv);
 	return -2 <= size && size <= 2;
 }
 
@@ -420,7 +420,7 @@ PyLong_AsSsize_t(PyObject *vv) {
 		return -1;
 	}
 	v = (PyLongObject *)vv;
-	i = Py_Size(v);
+	i = Py_SIZE(v);
 	switch (i) {
 	case -1: return -v->ob_digit[0];
 	case 0: return 0;
@@ -470,7 +470,7 @@ PyLong_AsUnsignedLong(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	i = Py_Size(v);
+	i = Py_SIZE(v);
 	x = 0;
 	if (i < 0) {
 		PyErr_SetString(PyExc_OverflowError,
@@ -508,7 +508,7 @@ PyLong_AsSize_t(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	i = Py_Size(v);
+	i = Py_SIZE(v);
 	x = 0;
 	if (i < 0) {
 		PyErr_SetString(PyExc_OverflowError,
@@ -547,7 +547,7 @@ _PyLong_AsUnsignedLongMask(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	i = Py_Size(v);
+	i = Py_SIZE(v);
 	switch (i) {
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
@@ -607,7 +607,7 @@ _PyLong_Sign(PyObject *vv)
 	assert(v != NULL);
 	assert(PyLong_Check(v));
 
-	return Py_Size(v) == 0 ? 0 : (Py_Size(v) < 0 ? -1 : 1);
+	return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1);
 }
 
 size_t
@@ -619,7 +619,7 @@ _PyLong_NumBits(PyObject *vv)
 
 	assert(v != NULL);
 	assert(PyLong_Check(v));
-	ndigits = ABS(Py_Size(v));
+	ndigits = ABS(Py_SIZE(v));
 	assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
 	if (ndigits > 0) {
 		digit msd = v->ob_digit[ndigits - 1];
@@ -745,7 +745,7 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
 		}
 	}
 
-	Py_Size(v) = is_signed ? -idigit : idigit;
+	Py_SIZE(v) = is_signed ? -idigit : idigit;
 	return (PyObject *)long_normalize(v);
 }
 
@@ -766,8 +766,8 @@ _PyLong_AsByteArray(PyLongObject* v,
 
 	assert(v != NULL && PyLong_Check(v));
 
-	if (Py_Size(v) < 0) {
-		ndigits = -(Py_Size(v));
+	if (Py_SIZE(v) < 0) {
+		ndigits = -(Py_SIZE(v));
 		if (!is_signed) {
 			PyErr_SetString(PyExc_TypeError,
 				"can't convert negative int to unsigned");
@@ -776,7 +776,7 @@ _PyLong_AsByteArray(PyLongObject* v,
 		do_twos_comp = 1;
 	}
 	else {
-		ndigits = Py_Size(v);
+		ndigits = Py_SIZE(v);
 		do_twos_comp = 0;
 	}
 
@@ -912,7 +912,7 @@ _PyLong_AsScaledDouble(PyObject *vv, int *exponent)
 		return -1;
 	}
 	v = (PyLongObject *)vv;
-	i = Py_Size(v);
+	i = Py_SIZE(v);
 	sign = 1;
 	if (i < 0) {
 		sign = -1;
@@ -1063,7 +1063,7 @@ PyLong_FromLongLong(PY_LONG_LONG ival)
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		Py_Size(v) = negative ? -ndigits : ndigits;
+		Py_SIZE(v) = negative ? -ndigits : ndigits;
 		t = (unsigned PY_LONG_LONG)ival;
 		while (t) {
 			*p++ = (digit)(t & PyLong_MASK);
@@ -1093,7 +1093,7 @@ PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival)
 	v = _PyLong_New(ndigits);
 	if (v != NULL) {
 		digit *p = v->ob_digit;
-		Py_Size(v) = ndigits;
+		Py_SIZE(v) = ndigits;
 		while (ival) {
 			*p++ = (digit)(ival & PyLong_MASK);
 			ival >>= PyLong_SHIFT;
@@ -1167,7 +1167,7 @@ PyLong_AsLongLong(PyObject *vv)
 	}
 
 	v = (PyLongObject*)vv;
-	switch(Py_Size(v)) {
+	switch(Py_SIZE(v)) {
 	case -1: return -v->ob_digit[0];
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
@@ -1200,7 +1200,7 @@ PyLong_AsUnsignedLongLong(PyObject *vv)
 	}
 
 	v = (PyLongObject*)vv;
-	switch(Py_Size(v)) {
+	switch(Py_SIZE(v)) {
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
 	}
@@ -1232,11 +1232,11 @@ _PyLong_AsUnsignedLongLongMask(PyObject *vv)
 		return (unsigned long) -1;
 	}
 	v = (PyLongObject *)vv;
-	switch(Py_Size(v)) {
+	switch(Py_SIZE(v)) {
 	case 0: return 0;
 	case 1: return v->ob_digit[0];
 	}
-	i = Py_Size(v);
+	i = Py_SIZE(v);
 	sign = 1;
 	x = 0;
 	if (i < 0) {
@@ -1358,7 +1358,7 @@ mul1(PyLongObject *a, wdigit n)
 static PyLongObject *
 muladd1(PyLongObject *a, wdigit n, wdigit extra)
 {
-	Py_ssize_t size_a = ABS(Py_Size(a));
+	Py_ssize_t size_a = ABS(Py_SIZE(a));
 	PyLongObject *z = _PyLong_New(size_a+1);
 	twodigits carry = extra;
 	Py_ssize_t i;
@@ -1404,7 +1404,7 @@ 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(Py_Size(a));
+	const Py_ssize_t size = ABS(Py_SIZE(a));
 	PyLongObject *z;
 
 	assert(n > 0 && n <= PyLong_MASK);
@@ -1435,7 +1435,7 @@ _PyLong_Format(PyObject *aa, int base)
 		return NULL;
 	}
 	assert(base >= 2 && base <= 36);
-	size_a = ABS(Py_Size(a));
+	size_a = ABS(Py_SIZE(a));
 
 	/* Compute a rough upper bound for the length of the string */
 	i = base;
@@ -1457,10 +1457,10 @@ _PyLong_Format(PyObject *aa, int base)
 		return NULL;
 	p = PyUnicode_AS_UNICODE(str) + sz;
 	*p = '\0';
-	if (Py_Size(a) < 0)
+	if (Py_SIZE(a) < 0)
 		sign = '-';
 
-	if (Py_Size(a) == 0) {
+	if (Py_SIZE(a) == 0) {
 		*--p = '0';
 	}
 	else if ((base & (base - 1)) == 0) {
@@ -1853,7 +1853,7 @@ digit beyond the first.
 		z = _PyLong_New(size_z);
 		if (z == NULL)
 			return NULL;
-		Py_Size(z) = 0;
+		Py_SIZE(z) = 0;
 
 		/* `convwidth` consecutive input digits are treated as a single
 		 * digit in base `convmultmax`.
@@ -1883,7 +1883,7 @@ digit beyond the first.
 
 			/* Multiply z by convmult, and add c. */
 			pz = z->ob_digit;
-			pzstop = pz + Py_Size(z);
+			pzstop = pz + Py_SIZE(z);
 			for (; pz < pzstop; ++pz) {
 				c += (twodigits)*pz * convmult;
 				*pz = (digit)(c & PyLong_MASK);
@@ -1892,14 +1892,14 @@ digit beyond the first.
 			/* carry off the current end? */
 			if (c) {
 				assert(c < PyLong_BASE);
-				if (Py_Size(z) < size_z) {
+				if (Py_SIZE(z) < size_z) {
 					*pz = (digit)c;
-					++Py_Size(z);
+					++Py_SIZE(z);
 				}
 				else {
 					PyLongObject *tmp;
 					/* Extremely rare.  Get more space. */
-					assert(Py_Size(z) == size_z);
+					assert(Py_SIZE(z) == size_z);
 					tmp = _PyLong_New(size_z + 1);
 					if (tmp == NULL) {
 						Py_DECREF(z);
@@ -1922,7 +1922,7 @@ digit beyond the first.
 		/* reset the base to 0, else the exception message
 		   doesn't make too much sense */
 		base = 0;
-		if (Py_Size(z) != 0)
+		if (Py_SIZE(z) != 0)
 			goto onError;
 		/* there might still be other problems, therefore base
 		   remains zero here for the same reason */
@@ -1930,7 +1930,7 @@ digit beyond the first.
 	if (str == start)
 		goto onError;
 	if (sign < 0)
-		Py_Size(z) = -(Py_Size(z));
+		Py_SIZE(z) = -(Py_SIZE(z));
 	if (*str == 'L' || *str == 'l')
 		str++;
 	while (*str && isspace(Py_CHARMASK(*str)))
@@ -1985,7 +1985,7 @@ static int
 long_divrem(PyLongObject *a, PyLongObject *b,
 	    PyLongObject **pdiv, PyLongObject **prem)
 {
-	Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
+	Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
 	PyLongObject *z;
 
 	if (size_b == 0) {
@@ -2024,9 +2024,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 ((Py_Size(a) < 0) != (Py_Size(b) < 0))
+	if ((Py_SIZE(a) < 0) != (Py_SIZE(b) < 0))
 		NEGATE(z);
-	if (Py_Size(a) < 0 && Py_Size(*prem) != 0)
+	if (Py_SIZE(a) < 0 && Py_SIZE(*prem) != 0)
 		NEGATE(*prem);
 	*pdiv = z;
 	return 0;
@@ -2037,7 +2037,7 @@ long_divrem(PyLongObject *a, PyLongObject *b,
 static PyLongObject *
 x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 {
-	Py_ssize_t size_v = ABS(Py_Size(v1)), size_w = ABS(Py_Size(w1));
+	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);
@@ -2051,10 +2051,10 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 	}
 
 	assert(size_v >= size_w && size_w > 1); /* Assert checks by div() */
-	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 */
+	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(Py_Size(v));
+	size_v = ABS(Py_SIZE(v));
 	k = size_v - size_w;
 	a = _PyLong_New(k + 1);
 
@@ -2137,7 +2137,7 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
 static void
 long_dealloc(PyObject *v)
 {
-	Py_Type(v)->tp_free(v);
+	Py_TYPE(v)->tp_free(v);
 }
 
 static PyObject *
@@ -2151,21 +2151,21 @@ long_compare(PyLongObject *a, PyLongObject *b)
 {
 	Py_ssize_t sign;
 
-	if (Py_Size(a) != Py_Size(b)) {
-		if (ABS(Py_Size(a)) == 0 && ABS(Py_Size(b)) == 0)
+	if (Py_SIZE(a) != Py_SIZE(b)) {
+		if (ABS(Py_SIZE(a)) == 0 && ABS(Py_SIZE(b)) == 0)
 			sign = 0;
 		else
-			sign = Py_Size(a) - Py_Size(b);
+			sign = Py_SIZE(a) - Py_SIZE(b);
 	}
 	else {
-		Py_ssize_t i = ABS(Py_Size(a));
+		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 (Py_Size(a) < 0)
+			if (Py_SIZE(a) < 0)
 				sign = -sign;
 		}
 	}
@@ -2192,7 +2192,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 = Py_Size(v);
+	i = Py_SIZE(v);
 	switch(i) {
 	case -1: return v->ob_digit[0]==1 ? -2 : -v->ob_digit[0];
 	case 0: return 0;
@@ -2231,7 +2231,7 @@ long_hash(PyLongObject *v)
 static PyLongObject *
 x_add(PyLongObject *a, PyLongObject *b)
 {
-	Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
+	Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
 	PyLongObject *z;
 	int i;
 	digit carry = 0;
@@ -2265,7 +2265,7 @@ x_add(PyLongObject *a, PyLongObject *b)
 static PyLongObject *
 x_sub(PyLongObject *a, PyLongObject *b)
 {
-	Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
+	Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
 	PyLongObject *z;
 	Py_ssize_t i;
 	int sign = 1;
@@ -2322,22 +2322,22 @@ long_add(PyLongObject *a, PyLongObject *b)
 
 	CHECK_BINOP(a, b);
 
-	if (ABS(Py_Size(a)) <= 1 && ABS(Py_Size(b)) <= 1) {
+	if (ABS(Py_SIZE(a)) <= 1 && ABS(Py_SIZE(b)) <= 1) {
 		PyObject *result = PyLong_FromLong(MEDIUM_VALUE(a) +
 						  MEDIUM_VALUE(b));
 		return result;
 	}
-	if (Py_Size(a) < 0) {
-		if (Py_Size(b) < 0) {
+	if (Py_SIZE(a) < 0) {
+		if (Py_SIZE(b) < 0) {
 			z = x_add(a, b);
-			if (z != NULL && Py_Size(z) != 0)
-				Py_Size(z) = -(Py_Size(z));
+			if (z != NULL && Py_SIZE(z) != 0)
+				Py_SIZE(z) = -(Py_SIZE(z));
 		}
 		else
 			z = x_sub(b, a);
 	}
 	else {
-		if (Py_Size(b) < 0)
+		if (Py_SIZE(b) < 0)
 			z = x_sub(a, b);
 		else
 			z = x_add(a, b);
@@ -2352,21 +2352,21 @@ long_sub(PyLongObject *a, PyLongObject *b)
 
 	CHECK_BINOP(a, b);
 
-	if (ABS(Py_Size(a)) <= 1 && ABS(Py_Size(b)) <= 1) {
+	if (ABS(Py_SIZE(a)) <= 1 && ABS(Py_SIZE(b)) <= 1) {
 		PyObject* r;
 		r = PyLong_FromLong(MEDIUM_VALUE(a)-MEDIUM_VALUE(b));
 		return r;
 	}
-	if (Py_Size(a) < 0) {
-		if (Py_Size(b) < 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 && Py_Size(z) != 0)
-			Py_Size(z) = -(Py_Size(z));
+		if (z != NULL && Py_SIZE(z) != 0)
+			Py_SIZE(z) = -(Py_SIZE(z));
 	}
 	else {
-		if (Py_Size(b) < 0)
+		if (Py_SIZE(b) < 0)
 			z = x_add(a, b);
 		else
 			z = x_sub(a, b);
@@ -2381,15 +2381,15 @@ static PyLongObject *
 x_mul(PyLongObject *a, PyLongObject *b)
 {
 	PyLongObject *z;
-	Py_ssize_t size_a = ABS(Py_Size(a));
-	Py_ssize_t size_b = ABS(Py_Size(b));
+	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, Py_Size(z) * 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
@@ -2473,7 +2473,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(Py_Size(n));
+	const Py_ssize_t size_n = ABS(Py_SIZE(n));
 
 	size_lo = MIN(size_n, size);
 	size_hi = size_n - size_lo;
@@ -2502,8 +2502,8 @@ static PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b);
 static PyLongObject *
 k_mul(PyLongObject *a, PyLongObject *b)
 {
-	Py_ssize_t asize = ABS(Py_Size(a));
-	Py_ssize_t bsize = ABS(Py_Size(b));
+	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;
@@ -2555,7 +2555,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(Py_Size(ah) > 0);	/* the split isn't degenerate */
+	assert(Py_SIZE(ah) > 0);	/* the split isn't degenerate */
 
 	if (a == b) {
 		bh = ah;
@@ -2586,20 +2586,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, Py_Size(ret) * 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(Py_Size(t1) >= 0);
-	assert(2*shift + Py_Size(t1) <= Py_Size(ret));
+	assert(Py_SIZE(t1) >= 0);
+	assert(2*shift + Py_SIZE(t1) <= Py_SIZE(ret));
 	memcpy(ret->ob_digit + 2*shift, t1->ob_digit,
-	       Py_Size(t1) * sizeof(digit));
+	       Py_SIZE(t1) * sizeof(digit));
 
 	/* Zero-out the digits higher than the ah*bh copy. */
-	i = Py_Size(ret) - 2*shift - Py_Size(t1);
+	i = Py_SIZE(ret) - 2*shift - Py_SIZE(t1);
 	if (i)
-		memset(ret->ob_digit + 2*shift + Py_Size(t1), 0,
+		memset(ret->ob_digit + 2*shift + Py_SIZE(t1), 0,
 		       i * sizeof(digit));
 
 	/* 3. t2 <- al*bl, and copy into the low digits. */
@@ -2607,23 +2607,23 @@ k_mul(PyLongObject *a, PyLongObject *b)
 		Py_DECREF(t1);
 		goto fail;
 	}
-	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));
+	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 - Py_Size(t2);	/* number of uninitialized digits */
+	i = 2*shift - Py_SIZE(t2);	/* number of uninitialized digits */
 	if (i)
-		memset(ret->ob_digit + Py_Size(t2), 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 = Py_Size(ret) - shift;  /* # digits after shift */
-	(void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_Size(t2));
+	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, Py_Size(t1));
+	(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. */
@@ -2648,12 +2648,12 @@ k_mul(PyLongObject *a, PyLongObject *b)
 	Py_DECREF(t1);
 	Py_DECREF(t2);
 	if (t3 == NULL) goto fail;
-	assert(Py_Size(t3) >= 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, Py_Size(t3));
+	(void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_SIZE(t3));
 	Py_DECREF(t3);
 
 	return long_normalize(ret);
@@ -2723,8 +2723,8 @@ ah*bh and al*bl too.
 static PyLongObject *
 k_lopsided_mul(PyLongObject *a, PyLongObject *b)
 {
-	const Py_ssize_t asize = ABS(Py_Size(a));
-	Py_ssize_t bsize = ABS(Py_Size(b));
+	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;
@@ -2736,7 +2736,7 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b)
 	ret = _PyLong_New(asize + bsize);
 	if (ret == NULL)
 		return NULL;
-	memset(ret->ob_digit, 0, Py_Size(ret) * sizeof(digit));
+	memset(ret->ob_digit, 0, Py_SIZE(ret) * sizeof(digit));
 
 	/* Successive slices of b are copied into bslice. */
 	bslice = _PyLong_New(asize);
@@ -2751,14 +2751,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));
-		Py_Size(bslice) = 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, Py_Size(ret) - nbdone,
-			     product->ob_digit, Py_Size(product));
+		(void)v_iadd(ret->ob_digit + nbdone, Py_SIZE(ret) - nbdone,
+			     product->ob_digit, Py_SIZE(product));
 		Py_DECREF(product);
 
 		bsize -= nbtouse;
@@ -2781,7 +2781,7 @@ long_mul(PyLongObject *a, PyLongObject *b)
 
 	CHECK_BINOP(a, b);
 
-	if (ABS(Py_Size(a)) <= 1 && ABS(Py_Size(b)) <= 1) {
+	if (ABS(Py_SIZE(a)) <= 1 && ABS(Py_SIZE(b)) <= 1) {
 		PyObject *r;
 		r = PyLong_FromLong(MEDIUM_VALUE(a)*MEDIUM_VALUE(b));
 		return r;
@@ -2789,7 +2789,7 @@ long_mul(PyLongObject *a, PyLongObject *b)
 
 	z = k_mul(a, b);
 	/* Negate if exactly one of the inputs is negative. */
-	if (((Py_Size(a) ^ Py_Size(b)) < 0) && z)
+	if (((Py_SIZE(a) ^ Py_SIZE(b)) < 0) && z)
 		NEGATE(z);
 	return (PyObject *)z;
 }
@@ -2823,8 +2823,8 @@ l_divmod(PyLongObject *v, PyLongObject *w,
 
 	if (long_divrem(v, w, &div, &mod) < 0)
 		return -1;
-	if ((Py_Size(mod) < 0 && Py_Size(w) > 0) ||
-	    (Py_Size(mod) > 0 && Py_Size(w) < 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);
@@ -2982,7 +2982,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		return Py_NotImplemented;
 	}
 
-	if (Py_Size(b) < 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");
@@ -3001,7 +3001,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 	if (c) {
 		/* if modulus == 0:
 		       raise ValueError() */
-		if (Py_Size(c) == 0) {
+		if (Py_SIZE(c) == 0) {
 			PyErr_SetString(PyExc_ValueError,
 					"pow() 3rd argument cannot be 0");
 			goto Error;
@@ -3010,7 +3010,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		/* if modulus < 0:
 		       negativeOutput = True
 		       modulus = -modulus */
-		if (Py_Size(c) < 0) {
+		if (Py_SIZE(c) < 0) {
 			negativeOutput = 1;
 			temp = (PyLongObject *)_PyLong_Copy(c);
 			if (temp == NULL)
@@ -3023,7 +3023,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 
 		/* if modulus == 1:
 		       return 0 */
-		if ((Py_Size(c) == 1) && (c->ob_digit[0] == 1)) {
+		if ((Py_SIZE(c) == 1) && (c->ob_digit[0] == 1)) {
 			z = (PyLongObject *)PyLong_FromLong(0L);
 			goto Done;
 		}
@@ -3031,7 +3031,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		/* if base < 0:
 		       base = base % modulus
 		   Having the base positive just makes things easier. */
-		if (Py_Size(a) < 0) {
+		if (Py_SIZE(a) < 0) {
 			if (l_divmod(a, c, NULL, &temp) < 0)
 				goto Error;
 			Py_DECREF(a);
@@ -3072,10 +3072,10 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 	REDUCE(result)					\
 }
 
-	if (Py_Size(b) <= 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 = Py_Size(b) - 1; i >= 0; --i) {
+		for (i = Py_SIZE(b) - 1; i >= 0; --i) {
 			digit bi = b->ob_digit[i];
 
 			for (j = 1 << (PyLong_SHIFT-1); j != 0; j >>= 1) {
@@ -3092,7 +3092,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		for (i = 1; i < 32; ++i)
 			MULT(table[i-1], a, table[i])
 
-		for (i = Py_Size(b) - 1; i >= 0; --i) {
+		for (i = Py_SIZE(b) - 1; i >= 0; --i) {
 			const digit bi = b->ob_digit[i];
 
 			for (j = PyLong_SHIFT - 5; j >= 0; j -= 5) {
@@ -3105,7 +3105,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 		}
 	}
 
-	if (negativeOutput && (Py_Size(z) != 0)) {
+	if (negativeOutput && (Py_SIZE(z) != 0)) {
 		temp = (PyLongObject *)long_sub(z, c);
 		if (temp == NULL)
 			goto Error;
@@ -3122,7 +3122,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
  	}
 	/* fall through */
  Done:
-	if (Py_Size(b) > FIVEARY_CUTOFF) {
+	if (Py_SIZE(b) > FIVEARY_CUTOFF) {
 		for (i = 0; i < 32; ++i)
 			Py_XDECREF(table[i]);
 	}
@@ -3139,7 +3139,7 @@ long_invert(PyLongObject *v)
 	/* Implement ~x as -(x+1) */
 	PyLongObject *x;
 	PyLongObject *w;
-	if (ABS(Py_Size(v)) <=1)
+	if (ABS(Py_SIZE(v)) <=1)
 		return PyLong_FromLong(-(MEDIUM_VALUE(v)+1));
 	w = (PyLongObject *)PyLong_FromLong(1L);
 	if (w == NULL)
@@ -3148,7 +3148,7 @@ long_invert(PyLongObject *v)
 	Py_DECREF(w);
 	if (x == NULL)
 		return NULL;
-	Py_Size(x) = -(Py_Size(x));
+	Py_SIZE(x) = -(Py_SIZE(x));
 	return (PyObject *)x;
 }
 
@@ -3156,18 +3156,18 @@ static PyObject *
 long_neg(PyLongObject *v)
 {
 	PyLongObject *z;
-	if (ABS(Py_Size(v)) <= 1)
+	if (ABS(Py_SIZE(v)) <= 1)
 		return PyLong_FromLong(-MEDIUM_VALUE(v));
 	z = (PyLongObject *)_PyLong_Copy(v);
 	if (z != NULL)
-		Py_Size(z) = -(Py_Size(v));
+		Py_SIZE(z) = -(Py_SIZE(v));
 	return (PyObject *)z;
 }
 
 static PyObject *
 long_abs(PyLongObject *v)
 {
-	if (Py_Size(v) < 0)
+	if (Py_SIZE(v) < 0)
 		return long_neg(v);
 	else
 		return long_long((PyObject *)v);
@@ -3176,7 +3176,7 @@ long_abs(PyLongObject *v)
 static int
 long_bool(PyLongObject *v)
 {
-	return ABS(Py_Size(v)) != 0;
+	return ABS(Py_SIZE(v)) != 0;
 }
 
 static PyObject *
@@ -3189,7 +3189,7 @@ long_rshift(PyLongObject *a, PyLongObject *b)
 
 	CHECK_BINOP(a, b);
 
-	if (Py_Size(a) < 0) {
+	if (Py_SIZE(a) < 0) {
 		/* Right shifting negative numbers is harder */
 		PyLongObject *a1, *a2;
 		a1 = (PyLongObject *) long_invert(a);
@@ -3213,7 +3213,7 @@ long_rshift(PyLongObject *a, PyLongObject *b)
 			goto rshift_error;
 		}
 		wordshift = shiftby / PyLong_SHIFT;
-		newsize = ABS(Py_Size(a)) - wordshift;
+		newsize = ABS(Py_SIZE(a)) - wordshift;
 		if (newsize <= 0) {
 			z = _PyLong_New(0);
 			return (PyObject *)z;
@@ -3225,8 +3225,8 @@ long_rshift(PyLongObject *a, PyLongObject *b)
 		z = _PyLong_New(newsize);
 		if (z == NULL)
 			goto rshift_error;
-		if (Py_Size(a) < 0)
-			Py_Size(z) = -(Py_Size(z));
+		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)
@@ -3269,14 +3269,14 @@ long_lshift(PyObject *v, PyObject *w)
 	wordshift = (int)shiftby / PyLong_SHIFT;
 	remshift  = (int)shiftby - wordshift * PyLong_SHIFT;
 
-	oldsize = ABS(Py_Size(a));
+	oldsize = ABS(Py_SIZE(a));
 	newsize = oldsize + wordshift;
 	if (remshift)
 		++newsize;
 	z = _PyLong_New(newsize);
 	if (z == NULL)
 		goto lshift_error;
-	if (Py_Size(a) < 0)
+	if (Py_SIZE(a) < 0)
 		NEGATE(z);
 	for (i = 0; i < wordshift; i++)
 		z->ob_digit[i] = 0;
@@ -3311,7 +3311,7 @@ long_bitwise(PyLongObject *a,
 	digit diga, digb;
 	PyObject *v;
 
-	if (Py_Size(a) < 0) {
+	if (Py_SIZE(a) < 0) {
 		a = (PyLongObject *) long_invert(a);
 		if (a == NULL)
 			return NULL;
@@ -3321,7 +3321,7 @@ long_bitwise(PyLongObject *a,
 		Py_INCREF(a);
 		maska = 0;
 	}
-	if (Py_Size(b) < 0) {
+	if (Py_SIZE(b) < 0) {
 		b = (PyLongObject *) long_invert(b);
 		if (b == NULL) {
 			Py_DECREF(a);
@@ -3370,8 +3370,8 @@ long_bitwise(PyLongObject *a,
 	   whose length should be ignored.
 	*/
 
-	size_a = Py_Size(a);
-	size_b = Py_Size(b);
+	size_a = Py_SIZE(a);
+	size_b = Py_SIZE(b);
 	size_z = op == '&'
 		? (maska
 		   ? size_b
@@ -3478,7 +3478,7 @@ long_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		/* Since PyLong_FromString doesn't have a length parameter,
 		 * check here for possible NULs in the string. */
 		char *string;
-		int size = Py_Size(x);
+		int size = Py_SIZE(x);
 		if (PyBytes_Check(x))
 			string = PyBytes_AS_STRING(x);
 		else
@@ -3516,7 +3516,7 @@ long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 	if (tmp == NULL)
 		return NULL;
 	assert(PyLong_CheckExact(tmp));
-	n = Py_Size(tmp);
+	n = Py_SIZE(tmp);
 	if (n < 0)
 		n = -n;
 	newobj = (PyLongObject *)type->tp_alloc(type, n);
@@ -3525,7 +3525,7 @@ long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		return NULL;
 	}
 	assert(PyLong_Check(newobj));
-	Py_Size(newobj) = Py_Size(tmp);
+	Py_SIZE(newobj) = Py_SIZE(tmp);
 	for (i = 0; i < n; i++)
 		newobj->ob_digit[i] = tmp->ob_digit[i];
 	Py_DECREF(tmp);
@@ -3719,12 +3719,12 @@ _PyLong_Init(void)
 	PyLongObject *v = small_ints;
 	for (ival = -NSMALLNEGINTS; ival < 0; ival++, v++) {
 		PyObject_INIT(v, &PyLong_Type);
-		Py_Size(v) = -1;
+		Py_SIZE(v) = -1;
 		v->ob_digit[0] = -ival;
 	}
 	for (; ival < NSMALLPOSINTS; ival++, v++) {
 		PyObject_INIT(v, &PyLong_Type);
-		Py_Size(v) = ival ? 1 : 0;
+		Py_SIZE(v) = ival ? 1 : 0;
 		v->ob_digit[0] = ival;
 	}
 #endif
diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c
index bf19f3c..e13233a 100644
--- a/Objects/moduleobject.c
+++ b/Objects/moduleobject.c
@@ -178,7 +178,7 @@ module_dealloc(PyModuleObject *m)
 		_PyModule_Clear((PyObject *)m);
 		Py_DECREF(m->md_dict);
 	}
-	Py_Type(m)->tp_free((PyObject *)m);
+	Py_TYPE(m)->tp_free((PyObject *)m);
 }
 
 static PyObject *
diff --git a/Objects/object.c b/Objects/object.c
index 6414673..d60ccc0 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) */
-	Py_Type(op) = 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;
-	Py_Type(op) = tp;
+	Py_TYPE(op) = tp;
 	_Py_NewReference((PyObject *)op);
 	return op;
 }
@@ -352,7 +352,7 @@ _PyObject_Dump(PyObject* op)
 			"type    : %s\n"
 			"refcount: %ld\n"
 			"address : %p\n",
-			Py_Type(op)==NULL ? "NULL" : Py_Type(op)->tp_name,
+			Py_TYPE(op)==NULL ? "NULL" : Py_TYPE(op)->tp_name,
 			(long)op->ob_refcnt,
 			op);
 	}
@@ -372,7 +372,7 @@ PyObject_Repr(PyObject *v)
 #endif
 	if (v == NULL)
 		return PyUnicode_FromString("<NULL>");
-	if (Py_Type(v)->tp_repr == NULL)
+	if (Py_TYPE(v)->tp_repr == NULL)
 		return PyUnicode_FromFormat("<%s object at %p>",
                                             v->ob_type->tp_name, v);
         res = (*v->ob_type->tp_repr)(v);
@@ -404,21 +404,21 @@ PyObject_Str(PyObject *v)
 		Py_INCREF(v);
 		return v;
 	}
-	if (Py_Type(v)->tp_str == NULL)
+	if (Py_TYPE(v)->tp_str == NULL)
 		return PyObject_Repr(v);
 
 	/* It is possible for a type to have a tp_str representation that loops
 	   infinitely. */
 	if (Py_EnterRecursiveCall(" while getting the str of an object"))
 		return NULL;
-	res = (*Py_Type(v)->tp_str)(v);
+	res = (*Py_TYPE(v)->tp_str)(v);
 	Py_LeaveRecursiveCall();
 	if (res == NULL)
 		return NULL;
 	if (!PyUnicode_Check(res)) {
 		PyErr_Format(PyExc_TypeError,
 			     "__str__ returned non-string (type %.200s)",
-			     Py_Type(res)->tp_name);
+			     Py_TYPE(res)->tp_name);
 		Py_DECREF(res);
 		return NULL;
 	}
@@ -772,8 +772,8 @@ PyObject_GetAttrString(PyObject *v, const char *name)
 {
 	PyObject *w, *res;
 
-	if (Py_Type(v)->tp_getattr != NULL)
-		return (*Py_Type(v)->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;
@@ -800,8 +800,8 @@ PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
 	PyObject *s;
 	int res;
 
-	if (Py_Type(v)->tp_setattr != NULL)
-		return (*Py_Type(v)->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;
@@ -813,7 +813,7 @@ PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
 PyObject *
 PyObject_GetAttr(PyObject *v, PyObject *name)
 {
-	PyTypeObject *tp = Py_Type(v);
+	PyTypeObject *tp = Py_TYPE(v);
 
  	if (!PyUnicode_Check(name)) {
 		PyErr_Format(PyExc_TypeError,
@@ -846,7 +846,7 @@ PyObject_HasAttr(PyObject *v, PyObject *name)
 int
 PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
 {
-	PyTypeObject *tp = Py_Type(v);
+	PyTypeObject *tp = Py_TYPE(v);
 	int err;
 
 	if (!PyUnicode_Check(name)) {
@@ -893,7 +893,7 @@ PyObject **
 _PyObject_GetDictPtr(PyObject *obj)
 {
 	Py_ssize_t dictoffset;
-	PyTypeObject *tp = Py_Type(obj);
+	PyTypeObject *tp = Py_TYPE(obj);
 
 	dictoffset = tp->tp_dictoffset;
 	if (dictoffset == 0)
@@ -926,7 +926,7 @@ PyObject_SelfIter(PyObject *obj)
 PyObject *
 PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 {
-	PyTypeObject *tp = Py_Type(obj);
+	PyTypeObject *tp = Py_TYPE(obj);
 	PyObject *descr = NULL;
 	PyObject *res = NULL;
 	descrgetfunc f;
@@ -1010,7 +1010,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 	}
 
 	if (f != NULL) {
-		res = f(descr, obj, (PyObject *)Py_Type(obj));
+		res = f(descr, obj, (PyObject *)Py_TYPE(obj));
 		Py_DECREF(descr);
 		goto done;
 	}
@@ -1032,7 +1032,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 int
 PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
 {
-	PyTypeObject *tp = Py_Type(obj);
+	PyTypeObject *tp = Py_TYPE(obj);
 	PyObject *descr;
 	descrsetfunc f;
 	PyObject **dictptr;
@@ -1232,7 +1232,7 @@ _dir_locals(void)
 	if (!PyList_Check(names)) {
 		PyErr_Format(PyExc_TypeError,
 			"dir(): expected keys() of locals to be a list, "
-			"not '%.200s'", Py_Type(names)->tp_name);
+			"not '%.200s'", Py_TYPE(names)->tp_name);
 		Py_DECREF(names);
 		return NULL;
 	}
@@ -1360,7 +1360,7 @@ _dir_object(PyObject *obj)
 		if (!PyList_Check(result)) {
 			PyErr_Format(PyExc_TypeError,
 				     "__dir__() must return a list, not %.200s",
-				     Py_Type(result)->tp_name);
+				     Py_TYPE(result)->tp_name);
 			Py_DECREF(result);
 			result = NULL;
 		}
@@ -1558,7 +1558,7 @@ _Py_ForgetReference(register PyObject *op)
 void
 _Py_Dealloc(PyObject *op)
 {
-	destructor dealloc = Py_Type(op)->tp_dealloc;
+	destructor dealloc = Py_TYPE(op)->tp_dealloc;
 	_Py_ForgetReference(op);
 	(*dealloc)(op);
 }
@@ -1589,7 +1589,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, Py_Type(op)->tp_name);
+			op->ob_refcnt, Py_TYPE(op)->tp_name);
 }
 
 PyObject *
@@ -1607,7 +1607,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 && Py_Type(op) != (PyTypeObject *) t)) {
+		       (t != NULL && Py_TYPE(op) != (PyTypeObject *) t)) {
 			op = op->_ob_next;
 			if (op == &refchain)
 				return res;
@@ -1750,7 +1750,7 @@ _PyTrash_destroy_chain(void)
 {
 	while (_PyTrash_delete_later) {
 		PyObject *op = _PyTrash_delete_later;
-		destructor dealloc = Py_Type(op)->tp_dealloc;
+		destructor dealloc = Py_TYPE(op)->tp_dealloc;
 
 		_PyTrash_delete_later =
 			(PyObject*) _Py_AS_GC(op)->gc.gc_prev;
diff --git a/Objects/setobject.c b/Objects/setobject.c
index cd63968..c7fb633 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -564,7 +564,7 @@ set_dealloc(PySetObject *so)
 	if (num_free_sets < MAXFREESETS && PyAnySet_CheckExact(so))
 		free_sets[num_free_sets++] = so;
 	else 
-		Py_Type(so)->tp_free(so);
+		Py_TYPE(so)->tp_free(so);
 	Py_TRASHCAN_SAFE_END(so)
 }
 
@@ -580,13 +580,13 @@ set_repr(PySetObject *so)
 	if (status != 0) {
 		if (status < 0)
 			return NULL;
-		return PyUnicode_FromFormat("%s(...)", Py_Type(so)->tp_name);
+		return PyUnicode_FromFormat("%s(...)", Py_TYPE(so)->tp_name);
 	}
 
 	/* shortcut for the empty set */
 	if (!so->used) {
 		Py_ReprLeave((PyObject*)so);
-		return PyUnicode_FromFormat("%s()", Py_Type(so)->tp_name);
+		return PyUnicode_FromFormat("%s()", Py_TYPE(so)->tp_name);
 	}
 
 	keys = PySequence_List((PyObject *)so);
@@ -611,9 +611,9 @@ set_repr(PySetObject *so)
 		*u++ = '}';
 	}
 	Py_DECREF(listrepr);
-	if (Py_Type(so) != &PySet_Type) {
+	if (Py_TYPE(so) != &PySet_Type) {
 		PyObject *tmp = PyUnicode_FromFormat("%s(%U)",
-						     Py_Type(so)->tp_name,
+						     Py_TYPE(so)->tp_name,
 						     result);
 		Py_DECREF(result);
 		result = tmp;
@@ -979,7 +979,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));
-		Py_Type(so) = type;
+		Py_TYPE(so) = type;
 		_Py_NewReference((PyObject *)so);
 		EMPTY_TO_MINSIZE(so);
 		PyObject_GC_Track(so);
@@ -1105,8 +1105,8 @@ set_swap_bodies(PySetObject *a, PySetObject *b)
 		memcpy(b->smalltable, tab, sizeof(tab));
 	}
 
-	if (PyType_IsSubtype(Py_Type(a), &PyFrozenSet_Type)  &&
-	    PyType_IsSubtype(Py_Type(b), &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;
@@ -1117,7 +1117,7 @@ set_swap_bodies(PySetObject *a, PySetObject *b)
 static PyObject *
 set_copy(PySetObject *so)
 {
-	return make_new_set(Py_Type(so), (PyObject *)so);
+	return make_new_set(Py_TYPE(so), (PyObject *)so);
 }
 
 static PyObject *
@@ -1195,7 +1195,7 @@ set_intersection(PySetObject *so, PyObject *other)
 	if ((PyObject *)so == other)
 		return set_copy(so);
 
-	result = (PySetObject *)make_new_set(Py_Type(so), NULL);
+	result = (PySetObject *)make_new_set(Py_TYPE(so), NULL);
 	if (result == NULL)
 		return NULL;
 
@@ -1449,7 +1449,7 @@ set_difference(PySetObject *so, PyObject *other)
 		return NULL;
 	}
 	
-	result = make_new_set(Py_Type(so), NULL);
+	result = make_new_set(Py_TYPE(so), NULL);
 	if (result == NULL)
 		return NULL;
 
@@ -1550,7 +1550,7 @@ set_symmetric_difference_update(PySetObject *so, PyObject *other)
 		Py_INCREF(other);
 		otherset = (PySetObject *)other;
 	} else {
-		otherset = (PySetObject *)make_new_set(Py_Type(so), other);
+		otherset = (PySetObject *)make_new_set(Py_TYPE(so), other);
 		if (otherset == NULL)
 			return NULL;
 	}
@@ -1581,7 +1581,7 @@ set_symmetric_difference(PySetObject *so, PyObject *other)
 	PyObject *rv;
 	PySetObject *otherset;
 
-	otherset = (PySetObject *)make_new_set(Py_Type(so), other);
+	otherset = (PySetObject *)make_new_set(Py_TYPE(so), other);
 	if (otherset == NULL)
 		return NULL;
 	rv = set_symmetric_difference_update(otherset, (PyObject *)so);
@@ -1844,7 +1844,7 @@ set_reduce(PySetObject *so)
 		dict = Py_None;
 		Py_INCREF(dict);
 	}
-	result = PyTuple_Pack(3, Py_Type(so), args, dict);
+	result = PyTuple_Pack(3, Py_TYPE(so), args, dict);
 done:
 	Py_XDECREF(args);
 	Py_XDECREF(keys);
@@ -1861,7 +1861,7 @@ set_init(PySetObject *self, PyObject *args, PyObject *kwds)
 
 	if (!PyAnySet_Check(self))
 		return -1;
-	if (!PyArg_UnpackTuple(args, Py_Type(self)->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;
@@ -2153,7 +2153,7 @@ PySet_Size(PyObject *anyset)
 int
 PySet_Clear(PyObject *set)
 {
-	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_TYPE(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return -1;
 	}
@@ -2173,7 +2173,7 @@ PySet_Contains(PyObject *anyset, PyObject *key)
 int
 PySet_Discard(PyObject *set, PyObject *key)
 {
-	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_TYPE(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return -1;
 	}
@@ -2183,7 +2183,7 @@ PySet_Discard(PyObject *set, PyObject *key)
 int
 PySet_Add(PyObject *set, PyObject *key)
 {
-	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_TYPE(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return -1;
 	}
@@ -2224,7 +2224,7 @@ _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, long *hash)
 PyObject *
 PySet_Pop(PyObject *set)
 {
-	if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
+	if (!PyType_IsSubtype(Py_TYPE(set), &PySet_Type)) {
 		PyErr_BadInternalCall();
 		return NULL;
 	}
@@ -2234,7 +2234,7 @@ PySet_Pop(PyObject *set)
 int
 _PySet_Update(PyObject *set, PyObject *iterable)
 {
-	if (!PyType_IsSubtype(Py_Type(set), &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 dec4d45..69a035d 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -266,7 +266,7 @@ handling of normal slices.");
 static PyObject *
 slice_reduce(PySliceObject* self)
 {
-	return Py_BuildValue("O(OOO)", Py_Type(self), 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.");
diff --git a/Objects/stringlib/string_format.h b/Objects/stringlib/string_format.h
index 10d150f..2c4510f 100644
--- a/Objects/stringlib/string_format.h
+++ b/Objects/stringlib/string_format.h
@@ -492,8 +492,8 @@ format(PyObject *fieldobj, SubString *format_spec)
     }
 
     /* Make sure the type is initialized.  float gets initialized late */
-    if (Py_Type(fieldobj)->tp_dict == NULL)
-        if (PyType_Ready(Py_Type(fieldobj)) < 0)
+    if (Py_TYPE(fieldobj)->tp_dict == NULL)
+        if (PyType_Ready(Py_TYPE(fieldobj)) < 0)
             return NULL;
 
     /* we need to create an object out of the pointers we have */
@@ -502,11 +502,11 @@ format(PyObject *fieldobj, SubString *format_spec)
         goto done;
 
     /* Find the (unbound!) __format__ method (a borrowed reference) */
-    meth = _PyType_Lookup(Py_Type(fieldobj), format_str);
+    meth = _PyType_Lookup(Py_TYPE(fieldobj), format_str);
     if (meth == NULL) {
         PyErr_Format(PyExc_TypeError,
                      "Type %.100s doesn't define __format__",
-                     Py_Type(fieldobj)->tp_name);
+                     Py_TYPE(fieldobj)->tp_name);
         goto done;
     }
 
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index 619804b..0125a99 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -12,13 +12,13 @@
 static Py_ssize_t
 _getbuffer(PyObject *obj, Py_buffer *view)
 {
-    PyBufferProcs *buffer = Py_Type(obj)->tp_as_buffer;
+    PyBufferProcs *buffer = Py_TYPE(obj)->tp_as_buffer;
 
     if (buffer == NULL || buffer->bf_getbuffer == NULL)
     {
         PyErr_Format(PyExc_TypeError,
                      "Type %.100s doesn't support the buffer API",
-                     Py_Type(obj)->tp_name);
+                     Py_TYPE(obj)->tp_name);
         return -1;
     }
 
@@ -351,7 +351,7 @@ PyString_FromFormat(const char *format, ...)
 static void
 string_dealloc(PyObject *op)
 {
-	Py_Type(op)->tp_free(op);
+	Py_TYPE(op)->tp_free(op);
 }
 
 /* Unescape a backslash-escaped string. If unicode is non-zero,
@@ -509,7 +509,7 @@ PyString_Size(register PyObject *op)
 {
 	if (!PyString_Check(op))
 		return string_getsize(op);
-	return Py_Size(op);
+	return Py_SIZE(op);
 }
 
 /*const*/ char *
@@ -517,7 +517,7 @@ PyString_AsString(register PyObject *op)
 {
 	if (!PyString_Check(op)) {
 		PyErr_Format(PyExc_TypeError,
-		     "expected bytes, %.200s found", Py_Type(op)->tp_name);
+		     "expected bytes, %.200s found", Py_TYPE(op)->tp_name);
 		return NULL;
 	}
 	return ((PyStringObject *)op) -> ob_sval;
@@ -535,7 +535,7 @@ PyString_AsStringAndSize(register PyObject *obj,
 
 	if (!PyString_Check(obj)) {
 		PyErr_Format(PyExc_TypeError,
-		     "expected bytes, %.200s found", Py_Type(obj)->tp_name);
+		     "expected bytes, %.200s found", Py_TYPE(obj)->tp_name);
 		return -1;
 	}
 
@@ -579,7 +579,7 @@ PyString_Repr(PyObject *obj, int smartquotes)
 {
 	static const char *hexdigits = "0123456789abcdef";
 	register PyStringObject* op = (PyStringObject*) obj;
-	Py_ssize_t length = Py_Size(op);
+	Py_ssize_t length = Py_SIZE(op);
 	size_t newsize = 3 + 4 * length;
 	PyObject *v;
 	if (newsize > PY_SSIZE_T_MAX || (newsize-3) / 4 != length) {
@@ -668,7 +668,7 @@ string_str(PyObject *op)
 static Py_ssize_t
 string_length(PyStringObject *a)
 {
-	return Py_Size(a);
+	return Py_SIZE(a);
 }
 
 /* This is also used by PyString_Concat() */
@@ -684,7 +684,7 @@ string_concat(PyObject *a, PyObject *b)
 	if (_getbuffer(a, &va) < 0  ||
 	    _getbuffer(b, &vb) < 0) {
 		PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
-			     Py_Type(a)->tp_name, Py_Type(b)->tp_name);
+			     Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
 		goto done;
 	}
 
@@ -733,13 +733,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 = Py_Size(a) * n;
-	if (n && size / n != Py_Size(a)) {
+	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 == Py_Size(a) && PyString_CheckExact(a)) {
+	if (size == Py_SIZE(a) && PyString_CheckExact(a)) {
 		Py_INCREF(a);
 		return (PyObject *)a;
 	}
@@ -756,14 +756,14 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n)
 	PyObject_INIT_VAR(op, &PyString_Type, size);
 	op->ob_shash = -1;
 	op->ob_sval[size] = '\0';
-	if (Py_Size(a) == 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, Py_Size(a));
-		i = Py_Size(a);
+		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;
@@ -783,7 +783,7 @@ string_contains(PyObject *self, PyObject *arg)
         PyErr_Clear();
         if (_getbuffer(arg, &varg) < 0)
             return -1;
-        pos = stringlib_find(PyString_AS_STRING(self), Py_Size(self),
+        pos = stringlib_find(PyString_AS_STRING(self), Py_SIZE(self),
                              varg.buf, varg.len, 0);
         PyObject_ReleaseBuffer(arg, &varg);
         return pos >= 0;
@@ -793,13 +793,13 @@ string_contains(PyObject *self, PyObject *arg)
         return -1;
     }
 
-    return memchr(PyString_AS_STRING(self), ival, Py_Size(self)) != NULL;
+    return memchr(PyString_AS_STRING(self), ival, Py_SIZE(self)) != NULL;
 }
 
 static PyObject *
 string_item(PyStringObject *a, register Py_ssize_t i)
 {
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		PyErr_SetString(PyExc_IndexError, "string index out of range");
 		return NULL;
 	}
@@ -841,16 +841,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 (Py_Size(a) == Py_Size(b)
+		if (Py_SIZE(a) == Py_SIZE(b)
 		    && (a->ob_sval[0] == b->ob_sval[0]
-			&& memcmp(a->ob_sval, b->ob_sval, Py_Size(a)) == 0)) {
+			&& memcmp(a->ob_sval, b->ob_sval, Py_SIZE(a)) == 0)) {
 			result = Py_True;
 		} else {
 			result = Py_False;
 		}
 		goto out;
 	}
-	len_a = Py_Size(a); len_b = Py_Size(b);
+	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);
@@ -886,12 +886,12 @@ string_hash(PyStringObject *a)
 
 	if (a->ob_shash != -1)
 		return a->ob_shash;
-	len = Py_Size(a);
+	len = Py_SIZE(a);
 	p = (unsigned char *) a->ob_sval;
 	x = *p << 7;
 	while (--len >= 0)
 		x = (1000003*x) ^ *p++;
-	x ^= Py_Size(a);
+	x ^= Py_SIZE(a);
 	if (x == -1)
 		x = -2;
 	a->ob_shash = x;
@@ -960,7 +960,7 @@ string_subscript(PyStringObject* self, PyObject* item)
 	else {
 		PyErr_Format(PyExc_TypeError,
 			     "string indices must be integers, not %.200s",
-			     Py_Type(item)->tp_name);
+			     Py_TYPE(item)->tp_name);
 		return NULL;
 	}
 }
@@ -968,7 +968,7 @@ string_subscript(PyStringObject* self, PyObject* item)
 static int
 string_buffer_getbuffer(PyStringObject *self, Py_buffer *view, int flags)
 {
-	return PyBuffer_FillInfo(view, (void *)self->ob_sval, Py_Size(self),
+	return PyBuffer_FillInfo(view, (void *)self->ob_sval, Py_SIZE(self),
 				 0, flags);
 }
 
@@ -1043,7 +1043,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) Py_Size(list) = count
+#define FIX_PREALLOC_SIZE(list) Py_SIZE(list) = count
 
 #define SKIP_SPACE(s, i, len)    { while (i<len &&  ISSPACE(s[i])) i++; }
 #define SKIP_NONSPACE(s, i, len) { while (i<len && !ISSPACE(s[i])) i++; }
@@ -1474,11 +1474,11 @@ string_join(PyObject *self, PyObject *orig)
 			PyErr_Format(PyExc_TypeError,
 				     "sequence item %zd: expected bytes,"
 				     " %.80s found",
-				     i, Py_Type(item)->tp_name);
+				     i, Py_TYPE(item)->tp_name);
 			Py_DECREF(seq);
 			return NULL;
 		}
-		sz += Py_Size(item);
+		sz += Py_SIZE(item);
 		if (i != 0)
 			sz += seplen;
 		if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
@@ -1508,7 +1508,7 @@ string_join(PyObject *self, PyObject *orig)
 			p += seplen;
 		}
 		item = PySequence_Fast_GET_ITEM(seq, i);
-		n = Py_Size(item);
+		n = Py_SIZE(item);
                 if (PyString_Check(item))
 			q = PyString_AS_STRING(item);
 		else
@@ -2792,7 +2792,7 @@ string_fromhex(PyObject *cls, PyObject *args)
 static PyObject *
 string_getnewargs(PyStringObject *v)
 {
-	return Py_BuildValue("(s#)", v->ob_sval, Py_Size(v));
+	return Py_BuildValue("(s#)", v->ob_sval, Py_SIZE(v));
 }
 
 
@@ -3132,7 +3132,7 @@ _PyString_Resize(PyObject **pv, Py_ssize_t newsize)
 	register PyObject *v;
 	register PyStringObject *sv;
 	v = *pv;
-	if (!PyString_Check(v) || Py_Refcnt(v) != 1 || newsize < 0) {
+	if (!PyString_Check(v) || Py_REFCNT(v) != 1 || newsize < 0) {
 		*pv = 0;
 		Py_DECREF(v);
 		PyErr_BadInternalCall();
@@ -3150,7 +3150,7 @@ _PyString_Resize(PyObject **pv, Py_ssize_t newsize)
 	}
 	_Py_NewReference(*pv);
 	sv = (PyStringObject *) *pv;
-	Py_Size(sv) = newsize;
+	Py_SIZE(sv) = newsize;
 	sv->ob_sval[newsize] = '\0';
 	sv->ob_shash = -1;	/* invalidate cached hash value */
 	return 0;
@@ -3204,7 +3204,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 		if (PyBool_Check(val))
 			result = PyNumber_ToBase(val, 10);
 		else
-			result = Py_Type(val)->tp_str(val);
+			result = Py_TYPE(val)->tp_str(val);
 		break;
 	case 'o':
 		numnondigits = 2;
@@ -3228,7 +3228,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 	}
 
 	/* To modify the string in-place, there can only be one reference. */
-	if (Py_Refcnt(result) != 1) {
+	if (Py_REFCNT(result) != 1) {
 		PyErr_BadInternalCall();
 		return NULL;
 	}
diff --git a/Objects/structseq.c b/Objects/structseq.c
index 91cf57b..96026fc 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) Py_Size(op)
+#define VISIBLE_SIZE(op) Py_SIZE(op)
 #define VISIBLE_SIZE_TP(tp) PyLong_AsLong( \
                       PyDict_GetItemString((tp)->tp_dict, visible_length_key))
 
 #define REAL_SIZE_TP(tp) PyLong_AsLong( \
                       PyDict_GetItemString((tp)->tp_dict, real_length_key))
-#define REAL_SIZE(op) REAL_SIZE_TP(Py_Type(op))
+#define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op))
 
 #define UNNAMED_FIELDS_TP(tp) PyLong_AsLong( \
                       PyDict_GetItemString((tp)->tp_dict, unnamed_fields_key))
-#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_Type(op))
+#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);
-	Py_Size(obj) = VISIBLE_SIZE_TP(type);
+	Py_SIZE(obj) = VISIBLE_SIZE_TP(type);
 
 	return (PyObject*) obj;
 }
@@ -322,12 +322,12 @@ structseq_reduce(PyStructSequence* self)
 	}
 	
 	for (; i < n_fields; i++) {
-		char *n = Py_Type(self)->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))", Py_Type(self), tup, dict);
+	result = Py_BuildValue("(O(OO))", Py_TYPE(self), tup, dict);
 
 	Py_DECREF(tup);
 	Py_DECREF(dict);
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index f1e8057..c9d91e5 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
-		Py_Size(op) = size;
-		Py_Type(op) = &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 Py_Size(op);
+		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 >= Py_Size(op)) {
+	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 >= Py_Size(op)) {
+	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 =  Py_Size(op);
+	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 &&
-		    Py_Type(op) == &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
 	}
-	Py_Type(op)->tp_free((PyObject *)op);
+	Py_TYPE(op)->tp_free((PyObject *)op);
 done:
 	Py_TRASHCAN_SAFE_END(op)
 }
@@ -191,7 +191,7 @@ tuplerepr(PyTupleObject *v)
 	PyObject *s, *temp;
 	PyObject *pieces, *result = NULL;
 
-	n = Py_Size(v);
+	n = Py_SIZE(v);
 	if (n == 0)
 		return PyUnicode_FromString("()");
 
@@ -264,7 +264,7 @@ static long
 tuplehash(PyTupleObject *v)
 {
 	register long x, y;
-	register Py_ssize_t len = Py_Size(v);
+	register Py_ssize_t len = Py_SIZE(v);
 	register PyObject **p;
 	long mult = 1000003L;
 	x = 0x345678L;
@@ -286,7 +286,7 @@ tuplehash(PyTupleObject *v)
 static Py_ssize_t
 tuplelength(PyTupleObject *a)
 {
-	return Py_Size(a);
+	return Py_SIZE(a);
 }
 
 static int
@@ -295,7 +295,7 @@ tuplecontains(PyTupleObject *a, PyObject *el)
 	Py_ssize_t i;
 	int cmp;
 
-	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(a); ++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;
@@ -304,7 +304,7 @@ tuplecontains(PyTupleObject *a, PyObject *el)
 static PyObject *
 tupleitem(register PyTupleObject *a, register Py_ssize_t i)
 {
-	if (i < 0 || i >= Py_Size(a)) {
+	if (i < 0 || i >= Py_SIZE(a)) {
 		PyErr_SetString(PyExc_IndexError, "tuple index out of range");
 		return NULL;
 	}
@@ -322,11 +322,11 @@ tupleslice(register PyTupleObject *a, register Py_ssize_t ilow,
 	Py_ssize_t len;
 	if (ilow < 0)
 		ilow = 0;
-	if (ihigh > Py_Size(a))
-		ihigh = Py_Size(a);
+	if (ihigh > Py_SIZE(a))
+		ihigh = Py_SIZE(a);
 	if (ihigh < ilow)
 		ihigh = ilow;
-	if (ilow == 0 && ihigh == Py_Size(a) && PyTuple_CheckExact(a)) {
+	if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
 		Py_INCREF(a);
 		return (PyObject *)a;
 	}
@@ -364,11 +364,11 @@ tupleconcat(register PyTupleObject *a, register PyObject *bb)
 	if (!PyTuple_Check(bb)) {
 		PyErr_Format(PyExc_TypeError,
        		     "can only concatenate tuple (not \"%.200s\") to tuple",
-			     Py_Type(bb)->tp_name);
+			     Py_TYPE(bb)->tp_name);
 		return NULL;
 	}
 #define b ((PyTupleObject *)bb)
-	size = Py_Size(a) + Py_Size(b);
+	size = Py_SIZE(a) + Py_SIZE(b);
 	if (size < 0)
 		return PyErr_NoMemory();
 	np = (PyTupleObject *) PyTuple_New(size);
@@ -377,14 +377,14 @@ tupleconcat(register PyTupleObject *a, register PyObject *bb)
 	}
 	src = a->ob_item;
 	dest = np->ob_item;
-	for (i = 0; i < Py_Size(a); 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 + Py_Size(a);
-	for (i = 0; i < Py_Size(b); 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;
@@ -402,18 +402,18 @@ tuplerepeat(PyTupleObject *a, Py_ssize_t n)
 	PyObject **p, **items;
 	if (n < 0)
 		n = 0;
-	if (Py_Size(a) == 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 (Py_Size(a) == 0)
+		if (Py_SIZE(a) == 0)
 			return PyTuple_New(0);
 	}
-	size = Py_Size(a) * n;
-	if (size/Py_Size(a) != n)
+	size = Py_SIZE(a) * n;
+	if (size/Py_SIZE(a) != n)
 		return PyErr_NoMemory();
 	np = (PyTupleObject *) PyTuple_New(size);
 	if (np == NULL)
@@ -421,7 +421,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 < Py_Size(a); j++) {
+		for (j = 0; j < Py_SIZE(a); j++) {
 			*p = items[j];
 			Py_INCREF(*p);
 			p++;
@@ -435,7 +435,7 @@ tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
 {
 	Py_ssize_t i;
 
-	for (i = Py_Size(o); --i >= 0; )
+	for (i = Py_SIZE(o); --i >= 0; )
 		Py_VISIT(o->ob_item[i]);
 	return 0;
 }
@@ -455,8 +455,8 @@ tuplerichcompare(PyObject *v, PyObject *w, int op)
 	vt = (PyTupleObject *)v;
 	wt = (PyTupleObject *)w;
 
-	vlen = Py_Size(vt);
-	wlen = Py_Size(wt);
+	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,
@@ -624,7 +624,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
 	else {
 		PyErr_Format(PyExc_TypeError, 
 			     "tuple indices must be integers, not %.200s",
-			     Py_Type(item)->tp_name);
+			     Py_TYPE(item)->tp_name);
 		return NULL;
 	}
 }
@@ -632,7 +632,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
 static PyObject *
 tuple_getnewargs(PyTupleObject *v)
 {
-	return Py_BuildValue("(N)", tupleslice(v, 0, Py_Size(v)));
+	return Py_BuildValue("(N)", tupleslice(v, 0, Py_SIZE(v)));
 	
 }
 
@@ -708,14 +708,14 @@ _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
 	Py_ssize_t oldsize;
 
 	v = (PyTupleObject *) *pv;
-	if (v == NULL || Py_Type(v) != &PyTuple_Type ||
-	    (Py_Size(v) != 0 && Py_Refcnt(v) != 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 = Py_Size(v);
+	oldsize = Py_SIZE(v);
 	if (oldsize == newsize)
 		return 0;
 
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 55a8ec6..bf07188 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -60,7 +60,7 @@ type_set_name(PyTypeObject *type, PyObject *value, void *context)
 	if (!PyUnicode_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "can only assign string to %s.__name__, not '%s'",
-			     type->tp_name, Py_Type(value)->tp_name);
+			     type->tp_name, Py_TYPE(value)->tp_name);
 		return -1;
 	}
 
@@ -216,7 +216,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, Py_Type(value)->tp_name);
+			     type->tp_name, Py_TYPE(value)->tp_name);
 		return -1;
 	}
 	if (PyTuple_GET_SIZE(value) == 0) {
@@ -231,7 +231,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, Py_Type(ob)->tp_name);
+				type->tp_name, Py_TYPE(ob)->tp_name);
 			return -1;
 		}
 		if (PyType_Check(ob)) {
@@ -356,8 +356,8 @@ type_get_doc(PyTypeObject *type, void *context)
 		result = Py_None;
 		Py_INCREF(result);
 	}
-	else if (Py_Type(result)->tp_descr_get) {
-		result = Py_Type(result)->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 {
@@ -430,9 +430,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(Py_Type(obj), type))
+		if (!PyType_IsSubtype(Py_TYPE(obj), type))
 			return obj;
-		type = Py_Type(obj);
+		type = Py_TYPE(obj);
 		if (type->tp_init != NULL &&
 		    type->tp_init(obj, args, kwds) < 0) {
 			Py_DECREF(obj);
@@ -486,7 +486,7 @@ traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg)
 	Py_ssize_t i, n;
 	PyMemberDef *mp;
 
-	n = Py_Size(type);
+	n = Py_SIZE(type);
 	mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
 	for (i = 0; i < n; i++, mp++) {
 		if (mp->type == T_OBJECT_EX) {
@@ -510,10 +510,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 = Py_Type(self);
+	type = Py_TYPE(self);
 	base = type;
 	while ((basetraverse = base->tp_traverse) == subtype_traverse) {
-		if (Py_Size(base)) {
+		if (Py_SIZE(base)) {
 			int err = traverse_slots(base, self, visit, arg);
 			if (err)
 				return err;
@@ -545,7 +545,7 @@ clear_slots(PyTypeObject *type, PyObject *self)
 	Py_ssize_t i, n;
 	PyMemberDef *mp;
 
-	n = Py_Size(type);
+	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)) {
@@ -567,10 +567,10 @@ subtype_clear(PyObject *self)
 
 	/* Find the nearest base with a different tp_clear
 	   and clear slots while we're at it */
-	type = Py_Type(self);
+	type = Py_TYPE(self);
 	base = type;
 	while ((baseclear = base->tp_clear) == subtype_clear) {
-		if (Py_Size(base))
+		if (Py_SIZE(base))
 			clear_slots(base, self);
 		base = base->tp_base;
 		assert(base);
@@ -591,7 +591,7 @@ subtype_dealloc(PyObject *self)
 	destructor basedealloc;
 
 	/* Extract the type; we expect it to be a heap type */
-	type = Py_Type(self);
+	type = Py_TYPE(self);
 	assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
 
 	/* Test whether the type has GC exactly once */
@@ -613,7 +613,7 @@ subtype_dealloc(PyObject *self)
 		/* Find the nearest base with a different tp_dealloc */
 		base = type;
 		while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
-			assert(Py_Size(base) == 0);
+			assert(Py_SIZE(base) == 0);
 			base = base->tp_base;
 			assert(base);
 		}
@@ -681,7 +681,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 (Py_Size(base))
+		if (Py_SIZE(base))
 			clear_slots(base, self);
 		base = base->tp_base;
 		assert(base);
@@ -872,13 +872,13 @@ lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj)
 		if (*attrobj == NULL)
 			return NULL;
 	}
-	res = _PyType_Lookup(Py_Type(self), *attrobj);
+	res = _PyType_Lookup(Py_TYPE(self), *attrobj);
 	if (res != NULL) {
 		descrgetfunc f;
-		if ((f = Py_Type(res)->tp_descr_get) == NULL)
+		if ((f = Py_TYPE(res)->tp_descr_get) == NULL)
 			Py_INCREF(res);
 		else
-			res = f(res, self, (PyObject *)(Py_Type(self)));
+			res = f(res, self, (PyObject *)(Py_TYPE(self)));
 	}
 	return res;
 }
@@ -1251,7 +1251,7 @@ mro_internal(PyTypeObject *type)
 	PyObject *mro, *result, *tuple;
 	int checkit = 0;
 
-	if (Py_Type(type) == &PyType_Type) {
+	if (Py_TYPE(type) == &PyType_Type) {
 		result = mro_implementation(type);
 	}
 	else {
@@ -1284,7 +1284,7 @@ mro_internal(PyTypeObject *type)
 			if (!PyType_Check(cls)) {
 				PyErr_Format(PyExc_TypeError,
 			     "mro() returned a non-class ('%.500s')",
-					     Py_Type(cls)->tp_name);
+					     Py_TYPE(cls)->tp_name);
 				Py_DECREF(tuple);
 				return -1;
 			}
@@ -1440,7 +1440,7 @@ raise_dict_descr_error(PyObject *obj)
 {
 	PyErr_Format(PyExc_TypeError,
 		     "this __dict__ descriptor does not support "
-		     "'%.200s' objects", Py_Type(obj)->tp_name);
+		     "'%.200s' objects", Py_TYPE(obj)->tp_name);
 }
 
 static PyObject *
@@ -1450,7 +1450,7 @@ subtype_dict(PyObject *obj, void *context)
 	PyObject *dict;
 	PyTypeObject *base;
 
-	base = get_builtin_base_with_dict(Py_Type(obj));
+	base = get_builtin_base_with_dict(Py_TYPE(obj));
 	if (base != NULL) {
 		descrgetfunc func;
 		PyObject *descr = get_dict_descriptor(base);
@@ -1458,12 +1458,12 @@ subtype_dict(PyObject *obj, void *context)
 			raise_dict_descr_error(obj);
 			return NULL;
 		}
-		func = Py_Type(descr)->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 *)(Py_Type(obj)));
+		return func(descr, obj, (PyObject *)(Py_TYPE(obj)));
 	}
 
 	dictptr = _PyObject_GetDictPtr(obj);
@@ -1486,7 +1486,7 @@ subtype_setdict(PyObject *obj, PyObject *value, void *context)
 	PyObject *dict;
 	PyTypeObject *base;
 
-	base = get_builtin_base_with_dict(Py_Type(obj));
+	base = get_builtin_base_with_dict(Py_TYPE(obj));
 	if (base != NULL) {
 		descrsetfunc func;
 		PyObject *descr = get_dict_descriptor(base);
@@ -1494,7 +1494,7 @@ subtype_setdict(PyObject *obj, PyObject *value, void *context)
 			raise_dict_descr_error(obj);
 			return -1;
 		}
-		func = Py_Type(descr)->tp_descr_set;
+		func = Py_TYPE(descr)->tp_descr_set;
 		if (func == NULL) {
 			raise_dict_descr_error(obj);
 			return -1;
@@ -1511,7 +1511,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'", Py_Type(value)->tp_name);
+			     "not a '%.200s'", Py_TYPE(value)->tp_name);
 		return -1;
 	}
 	dict = *dictptr;
@@ -1527,16 +1527,16 @@ subtype_getweakref(PyObject *obj, void *context)
 	PyObject **weaklistptr;
 	PyObject *result;
 
-	if (Py_Type(obj)->tp_weaklistoffset == 0) {
+	if (Py_TYPE(obj)->tp_weaklistoffset == 0) {
 		PyErr_SetString(PyExc_AttributeError,
 				"This object has no __weakref__");
 		return NULL;
 	}
-	assert(Py_Type(obj)->tp_weaklistoffset > 0);
-	assert(Py_Type(obj)->tp_weaklistoffset + sizeof(PyObject *) <=
-	       (size_t)(Py_Type(obj)->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 + Py_Type(obj)->tp_weaklistoffset);
+		((char *)obj + Py_TYPE(obj)->tp_weaklistoffset);
 	if (*weaklistptr == NULL)
 		result = Py_None;
 	else
@@ -1573,7 +1573,7 @@ valid_identifier(PyObject *s)
 	if (!PyUnicode_Check(s)) {
 		PyErr_Format(PyExc_TypeError,
 			     "__slots__ items must be strings, not '%.200s'",
-			     Py_Type(s)->tp_name);
+			     Py_TYPE(s)->tp_name);
 		return 0;
 	}
 	if (!PyUnicode_IsIdentifier(s)) {
@@ -1639,8 +1639,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(Py_Type(x));
-			return (PyObject *) Py_Type(x);
+			Py_INCREF(Py_TYPE(x));
+			return (PyObject *) Py_TYPE(x);
 		}
 
 		/* SF bug 475327 -- if that didn't trigger, we need 3
@@ -1668,7 +1668,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 	winner = metatype;
 	for (i = 0; i < nbases; i++) {
 		tmp = PyTuple_GET_ITEM(bases, i);
-		tmptype = Py_Type(tmp);
+		tmptype = Py_TYPE(tmp);
 		if (PyType_IsSubtype(winner, tmptype))
 			continue;
 		if (PyType_IsSubtype(tmptype, winner)) {
@@ -2055,7 +2055,7 @@ _PyType_Lookup(PyTypeObject *type, PyObject *name)
 static PyObject *
 type_getattro(PyTypeObject *type, PyObject *name)
 {
-	PyTypeObject *metatype = Py_Type(type);
+	PyTypeObject *metatype = Py_TYPE(type);
 	PyObject *meta_attribute, *attribute;
 	descrgetfunc meta_get;
 
@@ -2072,7 +2072,7 @@ type_getattro(PyTypeObject *type, PyObject *name)
 	meta_attribute = _PyType_Lookup(metatype, name);
 
 	if (meta_attribute != NULL) {
-		meta_get = Py_Type(meta_attribute)->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
@@ -2090,7 +2090,7 @@ type_getattro(PyTypeObject *type, PyObject *name)
 	attribute = _PyType_Lookup(type, name);
 	if (attribute != NULL) {
 		/* Implement descriptor functionality, if any */
-		descrgetfunc local_get = Py_Type(attribute)->tp_descr_get;
+		descrgetfunc local_get = Py_TYPE(attribute)->tp_descr_get;
 
 		Py_XDECREF(meta_attribute);
 
@@ -2168,7 +2168,7 @@ type_dealloc(PyTypeObject *type)
 	PyObject_Free((char *)type->tp_doc);
 	Py_XDECREF(et->ht_name);
 	Py_XDECREF(et->ht_slots);
-	Py_Type(type)->tp_free((PyObject *)type);
+	Py_TYPE(type)->tp_free((PyObject *)type);
 }
 
 static PyObject *
@@ -2388,7 +2388,7 @@ object_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
 	int err = 0;
 	if (excess_args(args, kwds)) {
-		PyTypeObject *type = Py_Type(self);
+		PyTypeObject *type = Py_TYPE(self);
 		if (type->tp_init != object_init &&
 		    type->tp_new != object_new)
 		{
@@ -2435,7 +2435,7 @@ object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 static void
 object_dealloc(PyObject *self)
 {
-	Py_Type(self)->tp_free(self);
+	Py_TYPE(self)->tp_free(self);
 }
 
 static PyObject *
@@ -2444,7 +2444,7 @@ object_repr(PyObject *self)
 	PyTypeObject *type;
 	PyObject *mod, *name, *rtn;
 
-	type = Py_Type(self);
+	type = Py_TYPE(self);
 	mod = type_module(type, NULL);
 	if (mod == NULL)
 		PyErr_Clear();
@@ -2470,7 +2470,7 @@ object_str(PyObject *self)
 {
 	unaryfunc f;
 
-	f = Py_Type(self)->tp_repr;
+	f = Py_TYPE(self)->tp_repr;
 	if (f == NULL)
 		f = object_repr;
 	return f(self);
@@ -2519,8 +2519,8 @@ object_richcompare(PyObject *self, PyObject *other, int op)
 static PyObject *
 object_get_class(PyObject *self, void *closure)
 {
-	Py_INCREF(Py_Type(self));
-	return (PyObject *)(Py_Type(self));
+	Py_INCREF(Py_TYPE(self));
+	return (PyObject *)(Py_TYPE(self));
 }
 
 static int
@@ -2605,7 +2605,7 @@ compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, char* attr)
 static int
 object_set_class(PyObject *self, PyObject *value, void *closure)
 {
-	PyTypeObject *oldto = Py_Type(self);
+	PyTypeObject *oldto = Py_TYPE(self);
 	PyTypeObject *newto;
 
 	if (value == NULL) {
@@ -2616,7 +2616,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",
-		  Py_Type(value)->tp_name);
+		  Py_TYPE(value)->tp_name);
 		return -1;
 	}
 	newto = (PyTypeObject *)value;
@@ -2629,7 +2629,7 @@ object_set_class(PyObject *self, PyObject *value, void *closure)
 	}
 	if (compatible_for_assignment(newto, oldto, "__class__")) {
 		Py_INCREF(newto);
-		Py_Type(self) = newto;
+		Py_TYPE(self) = newto;
 		Py_DECREF(oldto);
 		return 0;
 	}
@@ -2725,7 +2725,7 @@ reduce_2(PyObject *obj)
 		if (args != NULL && !PyTuple_Check(args)) {
 			PyErr_Format(PyExc_TypeError,
 				"__getnewargs__ should return a tuple, "
-				"not '%.200s'", Py_Type(args)->tp_name);
+				"not '%.200s'", Py_TYPE(args)->tp_name);
 			goto end;
 		}
 	}
@@ -3403,8 +3403,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 (Py_Type(type) == NULL && base != NULL)
-		Py_Type(type) = Py_Type(base);
+	if (Py_TYPE(type) == NULL && base != NULL)
+		Py_TYPE(type) = Py_TYPE(base);
 
 	/* Initialize tp_bases */
 	bases = type->tp_bases;
@@ -3673,7 +3673,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(Py_Type(other), Py_Type(self))) {
+	if (!PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self))) {
 		Py_INCREF(Py_NotImplemented);
 		return Py_NotImplemented;
 	}
@@ -3742,7 +3742,7 @@ getindex(PyObject *self, PyObject *arg)
 	if (i == -1 && PyErr_Occurred())
 		return -1;
 	if (i < 0) {
-		PySequenceMethods *sq = Py_Type(self)->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)
@@ -3874,14 +3874,14 @@ wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
 	if (!check_num_args(args, 1))
 		return NULL;
 	other = PyTuple_GET_ITEM(args, 0);
-	if (Py_Type(other)->tp_compare != func &&
-	    !PyType_IsSubtype(Py_Type(other), Py_Type(self))) {
+	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'",
-			Py_Type(self)->tp_name,
-			Py_Type(self)->tp_name,
-			Py_Type(other)->tp_name);
+			Py_TYPE(self)->tp_name,
+			Py_TYPE(self)->tp_name,
+			Py_TYPE(other)->tp_name);
 		return NULL;
 	}
 	res = (*func)(self, other);
@@ -3895,7 +3895,7 @@ wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
 static int
 hackcheck(PyObject *self, setattrofunc func, char *what)
 {
-	PyTypeObject *type = Py_Type(self);
+	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.
@@ -4095,7 +4095,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,
-			     Py_Type(arg0)->tp_name);
+			     Py_TYPE(arg0)->tp_name);
 		return NULL;
 	}
 	subtype = (PyTypeObject *)arg0;
@@ -4186,14 +4186,14 @@ method_is_overloaded(PyObject *left, PyObject *right, char *name)
 	PyObject *a, *b;
 	int ok;
 
-	b = PyObject_GetAttrString((PyObject *)(Py_Type(right)), 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 *)(Py_Type(left)), name);
+	a = PyObject_GetAttrString((PyObject *)(Py_TYPE(left)), name);
 	if (a == NULL) {
 		PyErr_Clear();
 		Py_DECREF(b);
@@ -4218,14 +4218,14 @@ static PyObject * \
 FUNCNAME(PyObject *self, PyObject *other) \
 { \
 	static PyObject *cache_str, *rcache_str; \
-	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) { \
+	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(Py_Type(other), Py_Type(self)) && \
+		    PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self)) && \
 		    method_is_overloaded(self, other, ROPSTR)) { \
 			r = call_maybe( \
 				other, ROPSTR, &rcache_str, "(O)", self); \
@@ -4237,7 +4237,7 @@ FUNCNAME(PyObject *self, PyObject *other) \
 		r = call_maybe( \
 			self, OPSTR, &cache_str, "(O)", other); \
 		if (r != Py_NotImplemented || \
-		    Py_Type(other) == Py_Type(self)) \
+		    Py_TYPE(other) == Py_TYPE(self)) \
 			return r; \
 		Py_DECREF(r); \
 	} \
@@ -4295,12 +4295,12 @@ slot_sq_item(PyObject *self, Py_ssize_t i)
 		if (getitem_str == NULL)
 			return NULL;
 	}
-	func = _PyType_Lookup(Py_Type(self), getitem_str);
+	func = _PyType_Lookup(Py_TYPE(self), getitem_str);
 	if (func != NULL) {
-		if ((f = Py_Type(func)->tp_descr_get) == NULL)
+		if ((f = Py_TYPE(func)->tp_descr_get) == NULL)
 			Py_INCREF(func);
 		else {
-			func = f(func, self, (PyObject *)(Py_Type(self)));
+			func = f(func, self, (PyObject *)(Py_TYPE(self)));
 			if (func == NULL) {
 				return NULL;
 			}
@@ -4418,8 +4418,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 (Py_Type(self)->tp_as_number != NULL &&
-	    Py_Type(self)->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);
 	}
@@ -4464,7 +4464,7 @@ slot_nb_bool(PyObject *self)
 				PyErr_Format(PyExc_TypeError,
 					 "__bool__ should return "
 					 "bool, returned %s",
-					 Py_Type(temp)->tp_name);
+					 Py_TYPE(temp)->tp_name);
 				result = -1;
 			}
 			Py_DECREF(temp);
@@ -4555,12 +4555,12 @@ _PyObject_SlotCompare(PyObject *self, PyObject *other)
 {
 	int c;
 
-	if (Py_Type(self)->tp_compare == _PyObject_SlotCompare) {
+	if (Py_TYPE(self)->tp_compare == _PyObject_SlotCompare) {
 		c = half_compare(self, other);
 		if (c <= 1)
 			return c;
 	}
-	if (Py_Type(other)->tp_compare == _PyObject_SlotCompare) {
+	if (Py_TYPE(other)->tp_compare == _PyObject_SlotCompare) {
 		c = half_compare(other, self);
 		if (c < -1)
 			return -2;
@@ -4585,7 +4585,7 @@ slot_tp_repr(PyObject *self)
 	}
 	PyErr_Clear();
 	return PyUnicode_FromFormat("<%s object at %p>",
-				   Py_Type(self)->tp_name, self);
+				   Py_TYPE(self)->tp_name, self);
 }
 
 static PyObject *
@@ -4628,7 +4628,7 @@ slot_tp_hash(PyObject *self)
 
 	if (func == NULL) {
 		PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
-			     Py_Type(self)->tp_name);
+			     Py_TYPE(self)->tp_name);
 		return -1;
         }
 
@@ -4684,7 +4684,7 @@ slot_tp_getattro(PyObject *self, PyObject *name)
 static PyObject *
 slot_tp_getattr_hook(PyObject *self, PyObject *name)
 {
-	PyTypeObject *tp = Py_Type(self);
+	PyTypeObject *tp = Py_TYPE(self);
 	PyObject *getattr, *getattribute, *res;
 	static PyObject *getattribute_str = NULL;
 	static PyObject *getattr_str = NULL;
@@ -4708,7 +4708,7 @@ slot_tp_getattr_hook(PyObject *self, PyObject *name)
 	}
 	getattribute = _PyType_Lookup(tp, getattribute_str);
 	if (getattribute == NULL ||
-	    (Py_Type(getattribute) == &PyWrapperDescr_Type &&
+	    (Py_TYPE(getattribute) == &PyWrapperDescr_Type &&
 	     ((PyWrapperDescrObject *)getattribute)->d_wrapped ==
 	     (void *)PyObject_GenericGetAttr))
 		res = PyObject_GenericGetAttr(self, name);
@@ -4767,13 +4767,13 @@ slot_tp_richcompare(PyObject *self, PyObject *other, int op)
 {
 	PyObject *res;
 
-	if (Py_Type(self)->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 (Py_Type(other)->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;
@@ -4806,7 +4806,7 @@ slot_tp_iter(PyObject *self)
 	if (func == NULL) {
 		PyErr_Format(PyExc_TypeError,
 			     "'%.200s' object is not iterable",
-			     Py_Type(self)->tp_name);
+			     Py_TYPE(self)->tp_name);
 		return NULL;
 	}
 	Py_DECREF(func);
@@ -4823,7 +4823,7 @@ slot_tp_iternext(PyObject *self)
 static PyObject *
 slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 {
-	PyTypeObject *tp = Py_Type(self);
+	PyTypeObject *tp = Py_TYPE(self);
 	PyObject *get;
 	static PyObject *get_str = NULL;
 
@@ -4881,7 +4881,7 @@ slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
 	if (res != Py_None) {
 		PyErr_Format(PyExc_TypeError,
 			     "__init__() should return None, not '%.200s'",
-			     Py_Type(res)->tp_name);
+			     Py_TYPE(res)->tp_name);
 		Py_DECREF(res);
 		return -1;
 	}
@@ -4966,7 +4966,7 @@ slot_tp_del(PyObject *self)
 		_Py_NewReference(self);
 		self->ob_refcnt = refcnt;
 	}
-	assert(!PyType_IS_GC(Py_Type(self)) ||
+	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. */
@@ -4978,8 +4978,8 @@ slot_tp_del(PyObject *self)
 	 * undone.
 	 */
 #ifdef COUNT_ALLOCS
-	--Py_Type(self)->tp_frees;
-	--Py_Type(self)->tp_allocs;
+	--Py_TYPE(self)->tp_frees;
+	--Py_TYPE(self)->tp_allocs;
 #endif
 }
 
@@ -5314,7 +5314,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
 		descr = _PyType_Lookup(type, p->name_strobj);
 		if (descr == NULL)
 			continue;
-		if (Py_Type(descr) == &PyWrapperDescr_Type) {
+		if (Py_TYPE(descr) == &PyWrapperDescr_Type) {
 			void **tptr = resolve_slotdups(type, p->name_strobj);
 			if (tptr == NULL || tptr == ptr)
 				generic = p->function;
@@ -5329,7 +5329,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
 					use_generic = 1;
 			}
 		}
-		else if (Py_Type(descr) == &PyCFunction_Type &&
+		else if (Py_TYPE(descr) == &PyCFunction_Type &&
 			 PyCFunction_GET_FUNCTION(descr) ==
 			 (PyCFunction)tp_new_wrapper &&
 			 strcmp(p->name, "__new__") == 0)
@@ -5600,7 +5600,7 @@ super_dealloc(PyObject *self)
 	Py_XDECREF(su->obj);
 	Py_XDECREF(su->type);
 	Py_XDECREF(su->obj_type);
-	Py_Type(self)->tp_free(self);
+	Py_TYPE(self)->tp_free(self);
 }
 
 static PyObject *
@@ -5663,7 +5663,7 @@ super_getattro(PyObject *self, PyObject *name)
 			res = PyDict_GetItem(dict, name);
 			if (res != NULL) {
 				Py_INCREF(res);
-				f = Py_Type(res)->tp_descr_get;
+				f = Py_TYPE(res)->tp_descr_get;
 				if (f != NULL) {
 					tmp = f(res,
 						/* Only pass 'obj' param if
@@ -5699,7 +5699,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
-	   Py_Type(obj) 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.
 	*/
 
@@ -5710,9 +5710,9 @@ supercheck(PyTypeObject *type, PyObject *obj)
 	}
 
 	/* Normal case */
-	if (PyType_IsSubtype(Py_Type(obj), type)) {
-		Py_INCREF(Py_Type(obj));
-		return Py_Type(obj);
+	if (PyType_IsSubtype(Py_TYPE(obj), type)) {
+		Py_INCREF(Py_TYPE(obj));
+		return Py_TYPE(obj);
 	}
 	else {
 		/* Try the slow way */
@@ -5729,7 +5729,7 @@ supercheck(PyTypeObject *type, PyObject *obj)
 
 		if (class_attr != NULL &&
 		    PyType_Check(class_attr) &&
-		    (PyTypeObject *)class_attr != Py_Type(obj))
+		    (PyTypeObject *)class_attr != Py_TYPE(obj))
 		{
 			int ok = PyType_IsSubtype(
 				(PyTypeObject *)class_attr, type);
@@ -5760,10 +5760,10 @@ super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 		Py_INCREF(self);
 		return self;
 	}
-	if (Py_Type(su) != &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 *)Py_Type(su),
+		return PyObject_CallFunctionObjArgs((PyObject *)Py_TYPE(su),
 						    su->type, obj, NULL);
 	else {
 		/* Inline the common case */
@@ -5845,7 +5845,7 @@ super_init(PyObject *self, PyObject *args, PyObject *kwds)
 				if (!PyType_Check(type)) {
 				    PyErr_Format(PyExc_SystemError,
 				      "super(): __class__ is not a type (%s)",
-				      Py_Type(type)->tp_name);
+				      Py_TYPE(type)->tp_name);
 				    return -1;
 				}
 				break;
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 6d1d069..5b94b0f 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -313,7 +313,7 @@ void unicode_dealloc(register PyUnicodeObject *unicode)
 
         case SSTATE_INTERNED_MORTAL:
             /* revive dead object temporarily for DelItem */
-            Py_Refcnt(unicode) = 3;
+            Py_REFCNT(unicode) = 3;
             if (PyDict_DelItem(interned, (PyObject *)unicode) != 0)
                 Py_FatalError(
                     "deletion of interned unicode string failed");
@@ -346,7 +346,7 @@ void unicode_dealloc(register PyUnicodeObject *unicode)
     else {
 	PyMem_DEL(unicode->str);
 	Py_XDECREF(unicode->defenc);
-	Py_Type(unicode)->tp_free((PyObject *)unicode);
+	Py_TYPE(unicode)->tp_free((PyObject *)unicode);
     }
 }
 
@@ -360,7 +360,7 @@ int PyUnicode_Resize(PyObject **unicode, Py_ssize_t length)
 	return -1;
     }
     v = (PyUnicodeObject *)*unicode;
-    if (v == NULL || !PyUnicode_Check(v) || Py_Refcnt(v) != 1 || length < 0) {
+    if (v == NULL || !PyUnicode_Check(v) || Py_REFCNT(v) != 1 || length < 0) {
 	PyErr_BadInternalCall();
 	return -1;
     }
@@ -1000,7 +1000,7 @@ PyObject *PyUnicode_FromObject(register PyObject *obj)
     }
     PyErr_Format(PyExc_TypeError,
                  "Can't convert '%.100s' object to str implicitly",
-                 Py_Type(obj)->tp_name);
+                 Py_TYPE(obj)->tp_name);
     return NULL;
 }
 
@@ -1035,7 +1035,7 @@ PyObject *PyUnicode_FromEncodedObject(register PyObject *obj,
 	PyErr_Format(PyExc_TypeError,
 			 "coercing to Unicode: need string or buffer, "
 			 "%.80s found",
-		     Py_Type(obj)->tp_name);
+		     Py_TYPE(obj)->tp_name);
 	goto onError;
     }
 
@@ -1115,7 +1115,7 @@ PyObject *PyUnicode_Decode(const char *s,
     if (!PyUnicode_Check(unicode)) {
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return an unicode object (type=%.400s)",
-                     Py_Type(unicode)->tp_name);
+                     Py_TYPE(unicode)->tp_name);
         Py_DECREF(unicode);
         goto onError;
     }
@@ -2351,7 +2351,7 @@ PyUnicode_EncodeUTF32(const Py_UNICODE *s,
     }
 
   done:
-    result = PyString_FromStringAndSize(PyBytes_AS_STRING(v), Py_Size(v));
+    result = PyString_FromStringAndSize(PyBytes_AS_STRING(v), Py_SIZE(v));
     Py_DECREF(v);
     return result;
 #undef STORECHAR
@@ -2615,7 +2615,7 @@ PyUnicode_EncodeUTF16(const Py_UNICODE *s,
     }
 
   done:
-    result = PyString_FromStringAndSize(PyBytes_AS_STRING(v), Py_Size(v));
+    result = PyString_FromStringAndSize(PyBytes_AS_STRING(v), Py_SIZE(v));
     Py_DECREF(v);
     return result;
 #undef STORECHAR
@@ -4367,7 +4367,7 @@ charmapencode_result charmapencode_output(Py_UNICODE c, PyObject *mapping,
     char *outstart;
     Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
 
-    if (Py_Type(mapping) == &EncodingMapType) {
+    if (Py_TYPE(mapping) == &EncodingMapType) {
         int res = encoding_map_lookup(c, mapping);
 	Py_ssize_t requiredsize = *outpos+1;
         if (res == -1)
@@ -4439,7 +4439,7 @@ int charmap_encoding_error(
     /* find all unencodable characters */
     while (collendpos < size) {
         PyObject *rep;
-        if (Py_Type(mapping) == &EncodingMapType) {
+        if (Py_TYPE(mapping) == &EncodingMapType) {
 	    int res = encoding_map_lookup(p[collendpos], mapping);
 	    if (res != -1)
 		break;
@@ -5482,7 +5482,7 @@ PyUnicode_Join(PyObject *separator, PyObject *seq)
 	    PyErr_Format(PyExc_TypeError,
 			 "sequence item %zd: expected str instance,"
 			 " %.80s found",
-			 i, Py_Type(item)->tp_name);
+			 i, Py_TYPE(item)->tp_name);
 	    goto onError;
 	}
 	item = PyUnicode_FromObject(item);
@@ -6505,7 +6505,7 @@ unicode_encode(PyUnicodeObject *self, PyObject *args)
         PyErr_Format(PyExc_TypeError,
                      "encoder did not return a bytes object "
                      "(type=%.400s)",
-                     Py_Type(v)->tp_name);
+                     Py_TYPE(v)->tp_name);
         Py_DECREF(v);
         return NULL;
     }
@@ -6647,12 +6647,12 @@ unicode_hash(PyUnicodeObject *self)
 
     if (self->hash != -1)
         return self->hash;
-    len = Py_Size(self);
+    len = Py_SIZE(self);
     p = self->str;
     x = *p << 7;
     while (--len >= 0)
         x = (1000003*x) ^ *p++;
-    x ^= Py_Size(self);
+    x ^= Py_SIZE(self);
     if (x == -1)
         x = -2;
     self->hash = x;
@@ -8514,7 +8514,7 @@ PyObject *PyUnicode_Format(PyObject *format,
 	arglen = -1;
 	argidx = -2;
     }
-    if (Py_Type(args)->tp_as_mapping && !PyTuple_Check(args) &&
+    if (Py_TYPE(args)->tp_as_mapping && !PyTuple_Check(args) &&
         !PyUnicode_Check(args))
 	dict = args;
 
@@ -9120,7 +9120,7 @@ PyUnicode_InternInPlace(PyObject **p)
 	PyThreadState_GET()->recursion_critical = 0;
 	/* The two references in interned are not counted by refcnt.
 	   The deallocator will take care of this */
-	Py_Refcnt(s) -= 2;
+	Py_REFCNT(s) -= 2;
 	PyUnicode_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
 }
 
@@ -9174,11 +9174,11 @@ void _Py_ReleaseInternedUnicodeStrings(void)
 			/* XXX Shouldn't happen */
 			break;
 		case SSTATE_INTERNED_IMMORTAL:
-			Py_Refcnt(s) += 1;
+			Py_REFCNT(s) += 1;
 			immortal_size += s->length;
 			break;
 		case SSTATE_INTERNED_MORTAL:
-			Py_Refcnt(s) += 2;
+			Py_REFCNT(s) += 2;
 			mortal_size += s->length;
 			break;
 		default:
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index 0aa4703..c7dce8f 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);
-    Py_Type(self)->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,
-		      Py_Type(PyWeakref_GET_OBJECT(self))->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(Py_Type(ob))) {
+        if (!PyType_SUPPORTS_WEAKREFS(Py_TYPE(ob))) {
             PyErr_Format(PyExc_TypeError,
                          "cannot create weak reference to '%s' object",
-                         Py_Type(ob)->tp_name);
+                         Py_TYPE(ob)->tp_name);
             return NULL;
         }
         if (callback == Py_None)
@@ -448,7 +448,7 @@ proxy_repr(PyWeakReference *proxy)
     char buf[160];
     PyOS_snprintf(buf, sizeof(buf),
 		  "<weakproxy at %p to %.100s at %p>", proxy,
-		  Py_Type(PyWeakref_GET_OBJECT(proxy))->tp_name,
+		  Py_TYPE(PyWeakref_GET_OBJECT(proxy))->tp_name,
 		  PyWeakref_GET_OBJECT(proxy));
     return PyUnicode_FromString(buf);
 }
@@ -699,10 +699,10 @@ PyWeakref_NewRef(PyObject *ob, PyObject *callback)
     PyWeakReference **list;
     PyWeakReference *ref, *proxy;
 
-    if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
+    if (!PyType_SUPPORTS_WEAKREFS(Py_TYPE(ob))) {
         PyErr_Format(PyExc_TypeError,
 		     "cannot create weak reference to '%s' object",
-                     Py_Type(ob)->tp_name);
+                     Py_TYPE(ob)->tp_name);
         return NULL;
     }
     list = GET_WEAKREFS_LISTPTR(ob);
@@ -758,10 +758,10 @@ PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
     PyWeakReference **list;
     PyWeakReference *ref, *proxy;
 
-    if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
+    if (!PyType_SUPPORTS_WEAKREFS(Py_TYPE(ob))) {
         PyErr_Format(PyExc_TypeError,
 		     "cannot create weak reference to '%s' object",
-                     Py_Type(ob)->tp_name);
+                     Py_TYPE(ob)->tp_name);
         return NULL;
     }
     list = GET_WEAKREFS_LISTPTR(ob);
@@ -784,9 +784,9 @@ PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
             PyWeakReference *prev;
 
             if (PyCallable_Check(ob))
-                Py_Type(result) = &_PyWeakref_CallableProxyType;
+                Py_TYPE(result) = &_PyWeakref_CallableProxyType;
             else
-                Py_Type(result) = &_PyWeakref_ProxyType;
+                Py_TYPE(result) = &_PyWeakref_ProxyType;
             get_basic_refs(*list, &ref, &proxy);
             if (callback == NULL) {
                 if (proxy != NULL) {
@@ -851,7 +851,7 @@ PyObject_ClearWeakRefs(PyObject *object)
     PyWeakReference **list;
 
     if (object == NULL
-        || !PyType_SUPPORTS_WEAKREFS(Py_Type(object))
+        || !PyType_SUPPORTS_WEAKREFS(Py_TYPE(object))
         || object->ob_refcnt != 0) {
         PyErr_BadInternalCall();
         return;
diff --git a/PC/_subprocess.c b/PC/_subprocess.c
index fec7b22..a752950 100644
--- a/PC/_subprocess.c
+++ b/PC/_subprocess.c
@@ -269,7 +269,7 @@ gethandle(PyObject* obj, char* name)
 		PyErr_Clear(); /* FIXME: propagate error? */
 		return NULL;
 	}
-	if (Py_Type(value) != &sp_handle_type)
+	if (Py_TYPE(value) != &sp_handle_type)
 		ret = NULL;
 	else
 		ret = value->handle;
@@ -552,7 +552,7 @@ init_subprocess()
 	PyObject *m;
 
 	/* patch up object descriptors */
-	Py_Type(&sp_handle_type) = &PyType_Type;
+	Py_TYPE(&sp_handle_type) = &PyType_Type;
 	sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int;
 
 	m = Py_InitModule("_subprocess", sp_functions);
diff --git a/PC/_winreg.c b/PC/_winreg.c
index e1145b1..2fdc5b5 100644
--- a/PC/_winreg.c
+++ b/PC/_winreg.c
@@ -522,7 +522,7 @@ PyHKEY_getattr(PyObject *self, const char *name)
 		return PyLong_FromVoidPtr(((PyHKEYObject *)self)->hkey);
 	PyErr_Format(PyExc_AttributeError,
                      "'%.50s' object has no attribute '%.400s'",
-                     Py_Type(self)->tp_name, name);
+                     Py_TYPE(self)->tp_name, name);
 	return NULL;
 }
 
@@ -1388,7 +1388,7 @@ PyMODINIT_FUNC init_winreg(void)
 	if (m == NULL)
 		return;
 	d = PyModule_GetDict(m);
-	Py_Type(&PyHKEY_Type) = &PyType_Type;
+	Py_TYPE(&PyHKEY_Type) = &PyType_Type;
 	PyHKEY_Type.tp_doc = PyHKEY_doc;
 	Py_INCREF(&PyHKEY_Type);
 	if (PyDict_SetItemString(d, "HKEYType",
diff --git a/Parser/tokenizer.c b/Parser/tokenizer.c
index 2c7da7c..d17da2a 100644
--- a/Parser/tokenizer.c
+++ b/Parser/tokenizer.c
@@ -1600,7 +1600,7 @@ PyTokenizer_RestoreEncoding(struct tok_state* tok, int len, int *offset)
 							       tok->buf,
 							       *offset-1);
 				if (offsetobj) {
-					*offset = 1 + Py_Size(offsetobj);
+					*offset = 1 + Py_SIZE(offsetobj);
 					Py_DECREF(offsetobj);
 				}
 			}
diff --git a/Python/ast.c b/Python/ast.c
index f32f587..3169de9 100644
--- a/Python/ast.c
+++ b/Python/ast.c
@@ -3156,7 +3156,7 @@ decode_unicode(const char *s, size_t len, int rawmode, const char *encoding)
                     return NULL;
                 }
                 r = PyString_AS_STRING(w);
-                rn = Py_Size(w);
+                rn = Py_SIZE(w);
                 assert(rn % 2 == 0);
                 for (i = 0; i < rn; i += 2) {
                     sprintf(p, "\\u%02x%02x",
diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index d1e6680..3e2f2a1 100644
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -309,16 +309,16 @@ builtin_format(PyObject *self, PyObject *args)
     }
 
     /* Make sure the type is initialized.  float gets initialized late */
-    if (Py_Type(value)->tp_dict == NULL)
-        if (PyType_Ready(Py_Type(value)) < 0)
+    if (Py_TYPE(value)->tp_dict == NULL)
+        if (PyType_Ready(Py_TYPE(value)) < 0)
             goto done;
 
     /* Find the (unbound!) __format__ method (a borrowed reference) */
-    meth = _PyType_Lookup(Py_Type(value), format_str);
+    meth = _PyType_Lookup(Py_TYPE(value), format_str);
     if (meth == NULL) {
         PyErr_Format(PyExc_TypeError,
                 "Type %.100s doesn't define __format__",
-                Py_Type(value)->tp_name);
+                Py_TYPE(value)->tp_name);
             goto done;
     }
 
@@ -1433,8 +1433,8 @@ builtin_round(PyObject *self, PyObject *args, PyObject *kwds)
                 kwlist, &number, &ndigits))
                 return NULL;
 
-	if (Py_Type(number)->tp_dict == NULL) {
-		if (PyType_Ready(Py_Type(number)) < 0)
+	if (Py_TYPE(number)->tp_dict == NULL) {
+		if (PyType_Ready(Py_TYPE(number)) < 0)
 			return NULL;
 	}
 
@@ -1444,11 +1444,11 @@ builtin_round(PyObject *self, PyObject *args, PyObject *kwds)
 			return NULL;
 	}
 
-	round = _PyType_Lookup(Py_Type(number), round_str);
+	round = _PyType_Lookup(Py_TYPE(number), round_str);
 	if (round == NULL) {
 		PyErr_Format(PyExc_TypeError,
 			     "type %.100s doesn't define __round__ method",
-			     Py_Type(number)->tp_name);
+			     Py_TYPE(number)->tp_name);
 		return NULL;
 	}
 
@@ -1552,8 +1552,8 @@ builtin_trunc(PyObject *self, PyObject *number)
 	static PyObject *trunc_str = NULL;
 	PyObject *trunc;
 
-	if (Py_Type(number)->tp_dict == NULL) {
-		if (PyType_Ready(Py_Type(number)) < 0)
+	if (Py_TYPE(number)->tp_dict == NULL) {
+		if (PyType_Ready(Py_TYPE(number)) < 0)
 			return NULL;
 	}
 
@@ -1563,11 +1563,11 @@ builtin_trunc(PyObject *self, PyObject *number)
 			return NULL;
 	}
 
-	trunc = _PyType_Lookup(Py_Type(number), trunc_str);
+	trunc = _PyType_Lookup(Py_TYPE(number), trunc_str);
 	if (trunc == NULL) {
 		PyErr_Format(PyExc_TypeError,
 			     "type %.100s doesn't define __trunc__ method",
-			     Py_Type(number)->tp_name);
+			     Py_TYPE(number)->tp_name);
 		return NULL;
 	}
 	return PyObject_CallFunction(trunc, "O", number);
diff --git a/Python/ceval.c b/Python/ceval.c
index 57e6cd5..778bbe0 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -3006,7 +3006,7 @@ unpack_iterable(PyObject *v, int argcnt, int argcntafter, PyObject **sp)
 		*--sp = PyList_GET_ITEM(l, ll - j);
 	}
 	/* Resize the list. */
-	Py_Size(l) = ll - argcntafter;
+	Py_SIZE(l) = ll - argcntafter;
 	Py_DECREF(it);
 	return 1;
 
@@ -3496,7 +3496,7 @@ fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
 	}
 	if (argdefs != NULL) {
 		d = &PyTuple_GET_ITEM(argdefs, 0);
-		nd = Py_Size(argdefs);
+		nd = Py_SIZE(argdefs);
 	}
 	return PyEval_EvalCodeEx(co, globals,
 				 (PyObject *)NULL, (*pp_stack)-n, na,
diff --git a/Python/codecs.c b/Python/codecs.c
index c8926fc..5a0e488 100644
--- a/Python/codecs.c
+++ b/Python/codecs.c
@@ -354,7 +354,7 @@ PyObject *PyCodec_Encode(PyObject *object,
             v = NULL;
             goto onError;
         }
-        v = PyString_FromStringAndSize(PyBytes_AS_STRING(v), Py_Size(v));
+        v = PyString_FromStringAndSize(PyBytes_AS_STRING(v), Py_SIZE(v));
     }
     else if (PyString_Check(v))
         Py_INCREF(v);
diff --git a/Python/marshal.c b/Python/marshal.c
index c06ef8b..4ea43da 100644
--- a/Python/marshal.c
+++ b/Python/marshal.c
@@ -153,7 +153,7 @@ w_object(PyObject *v, WFILE *p)
 			PyLongObject *ob = (PyLongObject *)v;
 			PyErr_Clear();
 			w_byte(TYPE_LONG, p);
-			n = Py_Size(ob);
+			n = Py_SIZE(ob);
 			w_long((long)n, p);
 			if (n < 0)
 				n = -n;
@@ -557,7 +557,7 @@ r_object(RFILE *p)
 				retval = NULL;
 				break;
 			}
-			Py_Size(ob) = n;
+			Py_SIZE(ob) = n;
 			for (i = 0; i < size; i++) {
 				int digit = r_short(p);
 				if (digit < 0) {