Added all PyTypeObjects to the appropriate header files.

Before the patch a lot of internal types weren't available in the header files. The patch exposes the new iterators, views and some other types to all C modules. I've also renamed some of the types and tp_names.

diff --git a/Include/bytesobject.h b/Include/bytesobject.h
index 4d9c53fe10e9a5ca68a840d4e8b1df2c347590e9..e9c319c87ee41a2acb3266ccb568b0dd9ac6e36b 100644 (file)
--- a/Include/bytesobject.h
+++ b/Include/bytesobject.h
@@ -29,6 +29,7 @@ typedef struct {
 
 /* Type object */
 PyAPI_DATA(PyTypeObject) PyBytes_Type;
+PyAPI_DATA(PyTypeObject) PyBytesIter_Type;
 
 /* Type check macros */
 #define PyBytes_Check(self) PyObject_TypeCheck(self, &PyBytes_Type)

diff --git a/Include/descrobject.h b/Include/descrobject.h
index a45a80132ca24648a6ea167eb91e976d2f1b63ba..badfa5b238a789772c5137d9146f4ded2f63563c 100644 (file)
--- a/Include/descrobject.h
+++ b/Include/descrobject.h
@@ -67,7 +67,12 @@ typedef struct {
        void *d_wrapped; /* This can be any function pointer */
 } PyWrapperDescrObject;
 
+PyAPI_DATA(PyTypeObject) PyClassMethodDescr_Type;
+PyAPI_DATA(PyTypeObject) PyGetSetDescr_Type;
+PyAPI_DATA(PyTypeObject) PyMemberDescr_Type;
+PyAPI_DATA(PyTypeObject) PyMethodDescr_Type;
 PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type;
+PyAPI_DATA(PyTypeObject) PyDictProxy_Type;
 
 PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);

diff --git a/Include/dictobject.h b/Include/dictobject.h
index fec62958fe1a90d295adfd41f89b82678b3ec7d2..0d8a09bce13969a907987b11db21528d767a3441 100644 (file)
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -89,10 +89,23 @@ struct _dictobject {
 };
 
 PyAPI_DATA(PyTypeObject) PyDict_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterKey_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterValue_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterItem_Type;
+PyAPI_DATA(PyTypeObject) PyDictKeys_Type;
+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)
+/* This excludes Values, since they are not sets. */
+# define PyDictViewSet_Check(op) \
+       (PyDictKeys_Check(op) || PyDictItems_Check(op))
+
 
 PyAPI_FUNC(PyObject *) PyDict_New(void);
 PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key);

diff --git a/Include/iterobject.h b/Include/iterobject.h
index 12853b4146608dc8243ee3b9e442f417dbc8d0d9..ba1b482fc719874278be03cb9a03d196388367b1 100644 (file)
--- a/Include/iterobject.h
+++ b/Include/iterobject.h
@@ -6,12 +6,14 @@ extern "C" {
 #endif
 
 PyAPI_DATA(PyTypeObject) PySeqIter_Type;
+PyAPI_DATA(PyTypeObject) PyCallIter_Type;
+PyAPI_DATA(PyTypeObject) PyZipIter_Type;
+PyAPI_DATA(PyTypeObject) PyCmpWrapper_Type;
 
 #define PySeqIter_Check(op) (Py_Type(op) == &PySeqIter_Type)
 
 PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *);
 
-PyAPI_DATA(PyTypeObject) PyCallIter_Type;
 
 #define PyCallIter_Check(op) (Py_Type(op) == &PyCallIter_Type)
 

diff --git a/Include/listobject.h b/Include/listobject.h
index e8b192adff2cc66447b738a55f93e6d60f5820f6..d39588934f8e9f20b011000e423782a4c7f063fc 100644 (file)
--- a/Include/listobject.h
+++ b/Include/listobject.h
@@ -39,6 +39,9 @@ typedef struct {
 } PyListObject;
 
 PyAPI_DATA(PyTypeObject) PyList_Type;
+PyAPI_DATA(PyTypeObject) PyListIter_Type;
+PyAPI_DATA(PyTypeObject) PyListRevIter_Type;
+PyAPI_DATA(PyTypeObject) PySortWrapper_Type;
 
 #define PyList_Check(op) \
                PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_LIST_SUBCLASS)

diff --git a/Include/rangeobject.h b/Include/rangeobject.h
index 2403807081697fa3d623767c84c6b0986e13537c..2746454e84b11224cf3587a97d04e5028586edee 100644 (file)
--- a/Include/rangeobject.h
+++ b/Include/rangeobject.h
@@ -16,6 +16,8 @@ they are represented by a start, stop, and step datamembers.
 */
 
 PyAPI_DATA(PyTypeObject) PyRange_Type;
+PyAPI_DATA(PyTypeObject) PyRangeIter_Type;
+PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type;
 
 #define PyRange_Check(op) (Py_Type(op) == &PyRange_Type)
 

diff --git a/Include/setobject.h b/Include/setobject.h
index 891474959e5e613a5ca93a0553c0a1c3eb15511c..5b97fcba8dffaa6c107033634acb10f8f9141542 100644 (file)
--- a/Include/setobject.h
+++ b/Include/setobject.h
@@ -58,6 +58,7 @@ struct _setobject {
 
 PyAPI_DATA(PyTypeObject) PySet_Type;
 PyAPI_DATA(PyTypeObject) PyFrozenSet_Type;
+PyAPI_DATA(PyTypeObject) PySetIter_Type;
 
 /* Invariants for frozensets:
  *     data is immutable.

diff --git a/Include/stringobject.h b/Include/stringobject.h
index 8241f1e52dda9b0063d458dee54761ed48815187..184bcdd3342f8335e43ec5b9d7626e876c0f0043 100644 (file)
--- a/Include/stringobject.h
+++ b/Include/stringobject.h
@@ -40,6 +40,7 @@ typedef struct {
 } PyStringObject;
 
 PyAPI_DATA(PyTypeObject) PyString_Type;
+PyAPI_DATA(PyTypeObject) PyStringIter_Type;
 
 #define PyString_Check(op) \
                  PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_STRING_SUBCLASS)

diff --git a/Include/tupleobject.h b/Include/tupleobject.h
index 423103a2777374bc69a9aaf91128203cb904c1db..7e9cdb5ca6bb05c2c1ee85c9dd7324e716f096b4 100644 (file)
--- a/Include/tupleobject.h
+++ b/Include/tupleobject.h
@@ -32,6 +32,7 @@ typedef struct {
 } PyTupleObject;
 
 PyAPI_DATA(PyTypeObject) PyTuple_Type;
+PyAPI_DATA(PyTypeObject) PyTupleIter_Type;
 
 #define PyTuple_Check(op) \
                  PyType_FastSubclass(Py_Type(op), Py_TPFLAGS_TUPLE_SUBCLASS)

diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h
index f3c37fe63b6fb9cd0377ffe26b7943385c98dc2d..4e94f7698bee0c0d67179fdcb2825fb4011fde3e 100644 (file)
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -417,6 +417,7 @@ typedef struct {
 } PyUnicodeObject;
 
 PyAPI_DATA(PyTypeObject) PyUnicode_Type;
+PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type;
 
 #define SSTATE_NOT_INTERNED 0
 #define SSTATE_INTERNED_MORTAL 1

diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index 294c7b316480c4802893b92709958050def4c668..c4d55e48db70ad2db93a9fb590a5495c0bbb08b0 100644 (file)
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -383,7 +383,7 @@ descr_traverse(PyObject *self, visitproc visit, void *arg)
        return 0;
 }
 
-static PyTypeObject PyMethodDescr_Type = {
+PyTypeObject PyMethodDescr_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "method_descriptor",
        sizeof(PyMethodDescrObject),
@@ -421,7 +421,7 @@ static PyTypeObject PyMethodDescr_Type = {
 };
 
 /* This is for METH_CLASS in C, not for "f = classmethod(f)" in Python! */
-static PyTypeObject PyClassMethodDescr_Type = {
+PyTypeObject PyClassMethodDescr_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "classmethod_descriptor",
        sizeof(PyMethodDescrObject),
@@ -458,7 +458,7 @@ static PyTypeObject PyClassMethodDescr_Type = {
        0,                                      /* tp_descr_set */
 };
 
-static PyTypeObject PyMemberDescr_Type = {
+PyTypeObject PyMemberDescr_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "member_descriptor",
        sizeof(PyMemberDescrObject),
@@ -495,7 +495,7 @@ static PyTypeObject PyMemberDescr_Type = {
        (descrsetfunc)member_set,               /* tp_descr_set */
 };
 
-static PyTypeObject PyGetSetDescr_Type = {
+PyTypeObject PyGetSetDescr_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "getset_descriptor",
        sizeof(PyGetSetDescrObject),
@@ -786,7 +786,7 @@ proxy_richcompare(proxyobject *v, PyObject *w, int op)
        return PyObject_RichCompare(v->dict, w, op);
 }
 
-static PyTypeObject proxytype = {
+PyTypeObject PyDictProxy_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "dictproxy",                            /* tp_name */
        sizeof(proxyobject),                    /* tp_basicsize */
@@ -829,7 +829,7 @@ PyDictProxy_New(PyObject *dict)
 {
        proxyobject *pp;
 
-       pp = PyObject_GC_New(proxyobject, &proxytype);
+       pp = PyObject_GC_New(proxyobject, &PyDictProxy_Type);
        if (pp != NULL) {
                Py_INCREF(dict);
                pp->dict = dict;

diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index d1ebf1fe19a05c414225e406a5dd72f09d441e2d..dad98552e056c62f4a4aee18229f6dbfd92434b7 100644 (file)
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -1798,13 +1798,8 @@ dict_tp_clear(PyObject *op)
        return 0;
 }
 
-
-extern PyTypeObject PyDictIterKey_Type; /* Forward */
-extern PyTypeObject PyDictIterValue_Type; /* Forward */
-extern PyTypeObject PyDictIterItem_Type; /* Forward */
 static PyObject *dictiter_new(PyDictObject *, PyTypeObject *);
 
-
 PyDoc_STRVAR(contains__doc__,
 "D.__contains__(k) -> True if D has a key k, else False");
 
@@ -2401,19 +2396,6 @@ dictview_new(PyObject *dict, PyTypeObject *type)
    - if public then they should probably be in builtins
 */
 
-/* Forward */
-PyTypeObject PyDictKeys_Type;
-PyTypeObject PyDictItems_Type;
-PyTypeObject PyDictValues_Type;
-
-#define PyDictKeys_Check(obj) ((obj)->ob_type == &PyDictKeys_Type)
-#define PyDictItems_Check(obj) ((obj)->ob_type == &PyDictItems_Type)
-#define PyDictValues_Check(obj) ((obj)->ob_type == &PyDictValues_Type)
-
-/* This excludes Values, since they are not sets. */
-# define PyDictViewSet_Check(obj) \
-       (PyDictKeys_Check(obj) || PyDictItems_Check(obj))
-
 /* Return 1 if self is a subset of other, iterating over self;
    0 if not; -1 if an error occurred. */
 static int

diff --git a/Objects/iterobject.c b/Objects/iterobject.c
index ce9c661c4cd37bc5c5340a27fc8d7d50dbc24dd6..12b603a826d79c1bfa9fa98408cb5a88031a1308 100644 (file)
--- a/Objects/iterobject.c
+++ b/Objects/iterobject.c
@@ -199,7 +199,7 @@ calliter_iternext(calliterobject *it)
 
 PyTypeObject PyCallIter_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
-       "callable-iterator",                    /* tp_name */
+       "callable_iterator",                    /* tp_name */
        sizeof(calliterobject),                 /* tp_basicsize */
        0,                                      /* tp_itemsize */
        /* methods */
@@ -240,7 +240,7 @@ typedef struct zipiterobject_t {
        PyTupleObject *result;  /* Reusable tuple for optimization */
 } zipiterobject;
 
-static PyTypeObject PyZipIter_Type; /* Forward */
+ /* Forward */
 
 PyObject *
 _PyZip_CreateIter(PyObject* args)
@@ -367,7 +367,7 @@ zipiter_next(zipiterobject *zit)
        return result;
 }
 
-static PyTypeObject PyZipIter_Type = {
+PyTypeObject PyZipIter_Type = {
        PyVarObject_HEAD_INIT(0, 0)
        "zip_iterator",                         /* tp_name */
        sizeof(zipiterobject),                  /* tp_basicsize */

diff --git a/Objects/listobject.c b/Objects/listobject.c
index 1d82e354104a4af14f8377db0d465ab6926a7379..ea10abf4cf05d31f0231229abe0706ae4ddabce9 100644 (file)
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -1790,7 +1790,7 @@ sortwrapper_richcompare(sortwrapperobject *, sortwrapperobject *, int);
 static void
 sortwrapper_dealloc(sortwrapperobject *);
 
-static PyTypeObject sortwrapper_type = {
+PyTypeObject PySortWrapper_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "sortwrapper",                          /* tp_name */
        sizeof(sortwrapperobject),              /* tp_basicsize */
@@ -1822,7 +1822,7 @@ static PyTypeObject sortwrapper_type = {
 static PyObject *
 sortwrapper_richcompare(sortwrapperobject *a, sortwrapperobject *b, int op)
 {
-       if (!PyObject_TypeCheck(b, &sortwrapper_type)) {
+       if (!PyObject_TypeCheck(b, &PySortWrapper_Type)) {
                PyErr_SetString(PyExc_TypeError,
                        "expected a sortwrapperobject");
                return NULL;
@@ -1846,7 +1846,7 @@ build_sortwrapper(PyObject *key, PyObject *value)
 {
        sortwrapperobject *so;
 
-       so = PyObject_New(sortwrapperobject, &sortwrapper_type);
+       so = PyObject_New(sortwrapperobject, &PySortWrapper_Type);
        if (so == NULL)
                return NULL;
        so->key = key;
@@ -1860,7 +1860,7 @@ sortwrapper_getvalue(PyObject *so)
 {
        PyObject *value;
 
-       if (!PyObject_TypeCheck(so, &sortwrapper_type)) {
+       if (!PyObject_TypeCheck(so, &PySortWrapper_Type)) {
                PyErr_SetString(PyExc_TypeError,
                        "expected a sortwrapperobject");
                return NULL;
@@ -1893,8 +1893,8 @@ cmpwrapper_call(cmpwrapperobject *co, PyObject *args, PyObject *kwds)
 
        if (!PyArg_UnpackTuple(args, "", 2, 2, &x, &y))
                return NULL;
-       if (!PyObject_TypeCheck(x, &sortwrapper_type) ||
-           !PyObject_TypeCheck(y, &sortwrapper_type)) {
+       if (!PyObject_TypeCheck(x, &PySortWrapper_Type) ||
+           !PyObject_TypeCheck(y, &PySortWrapper_Type)) {
                PyErr_SetString(PyExc_TypeError,
                        "expected a sortwrapperobject");
                return NULL;
@@ -1906,7 +1906,7 @@ cmpwrapper_call(cmpwrapperobject *co, PyObject *args, PyObject *kwds)
 
 PyDoc_STRVAR(cmpwrapper_doc, "cmp() wrapper for sort with custom keys.");
 
-static PyTypeObject cmpwrapper_type = {
+PyTypeObject PyCmpWrapper_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "cmpwrapper",                           /* tp_name */
        sizeof(cmpwrapperobject),               /* tp_basicsize */
@@ -1936,7 +1936,7 @@ build_cmpwrapper(PyObject *cmpfunc)
 {
        cmpwrapperobject *co;
 
-       co = PyObject_New(cmpwrapperobject, &cmpwrapper_type);
+       co = PyObject_New(cmpwrapperobject, &PyCmpWrapper_Type);
        if (co == NULL)
                return NULL;
        Py_INCREF(cmpfunc);

diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c
index d1c959a1bf589b20fe9b0c2d39f437ce0aa45758..0b7be4355bb1d40e0dd8e28447ed3f844ca9150b 100644 (file)
--- a/Objects/rangeobject.c
+++ b/Objects/rangeobject.c
@@ -367,7 +367,7 @@ static PyMethodDef rangeiter_methods[] = {
     {NULL,             NULL}           /* sentinel */
 };
 
-PyTypeObject Pyrangeiter_Type = {
+PyTypeObject PyRangeIter_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "range_iterator",                        /* tp_name */
        sizeof(rangeiterobject),                /* tp_basicsize */
@@ -441,7 +441,7 @@ get_len_of_range(long lo, long hi, long step)
 static PyObject *
 int_range_iter(long start, long stop, long step)
 {
-    rangeiterobject *it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
+    rangeiterobject *it = PyObject_New(rangeiterobject, &PyRangeIter_Type);
     if (it == NULL)
         return NULL;
     it->start = start;
@@ -519,9 +519,9 @@ longrangeiter_next(longrangeiterobject *r)
     return result;
 }
 
-static PyTypeObject Pylongrangeiter_Type = {
+PyTypeObject PyLongRangeIter_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
-       "rangeiterator",                        /* tp_name */
+       "longrange_iterator",                   /* tp_name */
        sizeof(longrangeiterobject),            /* tp_basicsize */
        0,                                      /* tp_itemsize */
        /* methods */
@@ -567,7 +567,7 @@ range_iter(PyObject *seq)
                       PyLong_AsLong(r->stop),
                       PyLong_AsLong(r->step));
 
-    it = PyObject_New(longrangeiterobject, &Pylongrangeiter_Type);
+    it = PyObject_New(longrangeiterobject, &PyLongRangeIter_Type);
     if (it == NULL)
         return NULL;
 
@@ -627,7 +627,7 @@ range_reverse(PyObject *seq)
         return int_range_iter(new_start, new_stop, -step);
     }
 
-    it = PyObject_New(longrangeiterobject, &Pylongrangeiter_Type);
+    it = PyObject_New(longrangeiterobject, &PyLongRangeIter_Type);
     if (it == NULL)
         return NULL;
 

diff --git a/Objects/setobject.c b/Objects/setobject.c
index e4e7780e8de31518c2b455b817ddf733fdb73c15..11ca407cc1c912ba694cc8780e1283b78570b2d2 100644 (file)
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -849,7 +849,7 @@ fail:
        return NULL;
 }
 
-static PyTypeObject PySetIter_Type = {
+PyTypeObject PySetIter_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "set_iterator",                         /* tp_name */
        sizeof(setiterobject),                  /* tp_basicsize */

diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index c22785ddee313a743be7473bdb618aec5ca50196..fcfd09d58e567fe6456e3e438137a1669b8b4d09 100644 (file)
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -840,7 +840,7 @@ static PyMethodDef tupleiter_methods[] = {
 
 PyTypeObject PyTupleIter_Type = {
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
-       "tupleiterator",                        /* tp_name */
+       "tuple_iterator",                       /* tp_name */
        sizeof(tupleiterobject),                /* tp_basicsize */
        0,                                      /* tp_itemsize */
        /* methods */