Changeset 388 for python/vendor/current/Modules/pyexpat.c

Timestamp:

Mar 19, 2014, 11:11:30 AM (11 years ago)

Author:

dmik

Message:

python: Update vendor to 2.7.6.

File:

• python/vendor/current/Modules/pyexpat.c (modified) (38 diffs)

python/vendor/current/Modules/pyexpat.c

@@ -246 +246 @@
    used right after `flag_error()` is called. */
 static void
-noop_character_data_handler(void *userData, const XML_Char *data, int len) 
+noop_character_data_handler(void *userData, const XML_Char *data, int len)
 {
     /* Do nothing. */
@@ -262 +262 @@
 getcode(enum HandlerTypes slot, char* func_name, int lineno)
 {
-    PyObject *code = NULL;
-    PyObject *name = NULL;
-    PyObject *nulltuple = NULL;
-    PyObject *filename = NULL;
-
     if (handler_info[slot].tb_code == NULL) {
-        code = PyString_FromString("");
-        if (code == NULL)
-            goto failed;
-        name = PyString_FromString(func_name);
-        if (name == NULL)
-            goto failed;
-        nulltuple = PyTuple_New(0);
-        if (nulltuple == NULL)
-            goto failed;
-        filename = PyString_FromString(__FILE__);
         handler_info[slot].tb_code =
-            PyCode_New(0,               /* argcount */
-                       0,               /* nlocals */
-                       0,               /* stacksize */
-                       0,               /* flags */
-                       code,            /* code */
-                       nulltuple,       /* consts */
-                       nulltuple,       /* names */
-                       nulltuple,       /* varnames */
-#if PYTHON_API_VERSION >= 1010
-                       nulltuple,       /* freevars */
-                       nulltuple,       /* cellvars */
-#endif
-                       filename,        /* filename */
-                       name,            /* name */
-                       lineno,          /* firstlineno */
-                       code             /* lnotab */
-                       );
-        if (handler_info[slot].tb_code == NULL)
-            goto failed;
-        Py_DECREF(code);
-        Py_DECREF(nulltuple);
-        Py_DECREF(filename);
-        Py_DECREF(name);
+            PyCode_NewEmpty(__FILE__, func_name, lineno);
     }
     return handler_info[slot].tb_code;
- failed:
-    Py_XDECREF(code);
-    Py_XDECREF(name);
-    return NULL;
 }
 
@@ -316 +275 @@
     int result = 0;
     if (!tstate->use_tracing || tstate->tracing)
-        return 0;
+        return 0;
     if (tstate->c_profilefunc != NULL) {
-        tstate->tracing++;
-        result = tstate->c_profilefunc(tstate->c_profileobj,
-                                       f, code , val);
-        tstate->use_tracing = ((tstate->c_tracefunc != NULL)
-                               || (tstate->c_profilefunc != NULL));
-        tstate->tracing--;
-        if (result)
-            return result;
+        tstate->tracing++;
+        result = tstate->c_profilefunc(tstate->c_profileobj,
+                                       f, code , val);
+        tstate->use_tracing = ((tstate->c_tracefunc != NULL)
+                               || (tstate->c_profilefunc != NULL));
+        tstate->tracing--;
+        if (result)
+            return result;
     }
     if (tstate->c_tracefunc != NULL) {
-        tstate->tracing++;
-        result = tstate->c_tracefunc(tstate->c_traceobj,
-                                     f, code , val);
-        tstate->use_tracing = ((tstate->c_tracefunc != NULL)
-                               || (tstate->c_profilefunc != NULL));
-        tstate->tracing--;
-    }   
+        tstate->tracing++;
+        result = tstate->c_tracefunc(tstate->c_traceobj,
+                                     f, code , val);
+        tstate->use_tracing = ((tstate->c_tracefunc != NULL)
+                               || (tstate->c_profilefunc != NULL));
+        tstate->tracing--;
+    }
     return result;
 }
@@ -345 +304 @@
 
     if (tstate->c_tracefunc == NULL)
-        return 0;
+        return 0;
 
     PyErr_Fetch(&type, &value, &traceback);
     if (value == NULL) {
-        value = Py_None;
-        Py_INCREF(value);
+        value = Py_None;
+        Py_INCREF(value);
     }
 #if PY_VERSION_HEX < 0x02040000
@@ -358 +317 @@
 #endif
     if (arg == NULL) {
-        PyErr_Restore(type, value, traceback);
-        return 0;
+        PyErr_Restore(type, value, traceback);
+        return 0;
     }
     err = trace_frame(tstate, f, PyTrace_EXCEPTION, arg);
     Py_DECREF(arg);
     if (err == 0)
-        PyErr_Restore(type, value, traceback);
+        PyErr_Restore(type, value, traceback);
     else {
-        Py_XDECREF(type);
-        Py_XDECREF(value);
-        Py_XDECREF(traceback);
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(traceback);
     }
     return err;
@@ -384 +343 @@
     if (c == NULL)
         return NULL;
-    
+
     f = PyFrame_New(tstate, c, PyEval_GetGlobals(), NULL);
     if (f == NULL)
@@ -391 +350 @@
 #ifdef FIX_TRACE
     if (trace_frame(tstate, f, PyTrace_CALL, Py_None) < 0) {
-        return NULL;
+        return NULL;
     }
 #endif
     res = PyEval_CallObject(func, args);
     if (res == NULL) {
-        if (tstate->curexc_traceback == NULL)
-            PyTraceBack_Here(f);
+        if (tstate->curexc_traceback == NULL)
+            PyTraceBack_Here(f);
         XML_StopParser(self->itself, XML_FALSE);
 #ifdef FIX_TRACE
-        if (trace_frame_exc(tstate, f) < 0) {
-            return NULL;
-        }
+        if (trace_frame_exc(tstate, f) < 0) {
+            return NULL;
+        }
     }
     else {
-        if (trace_frame(tstate, f, PyTrace_RETURN, res) < 0) {
-            Py_XDECREF(res);
-            res = NULL;
-        }
+        if (trace_frame(tstate, f, PyTrace_RETURN, res) < 0) {
+            Py_XDECREF(res);
+            res = NULL;
+        }
     }
 #else
@@ -433 +392 @@
     /* result can be NULL if the unicode conversion failed. */
     if (!result)
-        return result;
+        return result;
     if (!self->intern)
-        return result;
+        return result;
     value = PyDict_GetItem(self->intern, result);
     if (!value) {
-        if (PyDict_SetItem(self->intern, result, result) == 0)
+        if (PyDict_SetItem(self->intern, result, result) == 0)
             return result;
         else
@@ -457 +416 @@
     PyObject *temp;
 
+    if (!have_handler(self, CharacterData))
+        return -1;
+
     args = PyTuple_New(1);
     if (args == NULL)
         return -1;
 #ifdef Py_USING_UNICODE
-    temp = (self->returns_unicode 
-            ? conv_string_len_to_unicode(buffer, len) 
+    temp = (self->returns_unicode
+            ? conv_string_len_to_unicode(buffer, len)
             : conv_string_len_to_utf8(buffer, len));
 #else
@@ -504 +466 @@
 
 static void
-my_CharacterDataHandler(void *userData, const XML_Char *data, int len) 
+my_CharacterDataHandler(void *userData, const XML_Char *data, int len)
 {
     xmlparseobject *self = (xmlparseobject *) userData;
@@ -644 +606 @@
 
 #define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \
-        RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\
-        (xmlparseobject *)userData)
+        RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\
+        (xmlparseobject *)userData)
 
 #define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\
-        RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \
-                        rc = PyInt_AsLong(rv);, rc, \
-        (xmlparseobject *)userData)
+        RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \
+                        rc = PyInt_AsLong(rv);, rc, \
+        (xmlparseobject *)userData)
 
 VOID_HANDLER(EndElement,
@@ -823 +785 @@
 
 VOID_HANDLER(NotationDecl,
-                (void *userData,
-                        const XML_Char *notationName,
-                        const XML_Char *base,
-                        const XML_Char *systemId,
-                        const XML_Char *publicId),
+                (void *userData,
+                        const XML_Char *notationName,
+                        const XML_Char *base,
+                        const XML_Char *systemId,
+                        const XML_Char *publicId),
                 ("(NNNN)",
-                 string_intern(self, notationName), string_intern(self, base),
-                 string_intern(self, systemId), string_intern(self, publicId)))
+                 string_intern(self, notationName), string_intern(self, base),
+                 string_intern(self, systemId), string_intern(self, publicId)))
 
 VOID_HANDLER(StartNamespaceDecl,
-                (void *userData,
-                      const XML_Char *prefix,
-                      const XML_Char *uri),
+                (void *userData,
+                      const XML_Char *prefix,
+                      const XML_Char *uri),
                 ("(NN)",
                  string_intern(self, prefix), string_intern(self, uri)))
 
 VOID_HANDLER(EndNamespaceDecl,
-                (void *userData,
-                    const XML_Char *prefix),
+                (void *userData,
+                    const XML_Char *prefix),
                 ("(N)", string_intern(self, prefix)))
 
@@ -850 +812 @@
 VOID_HANDLER(StartCdataSection,
                (void *userData),
-                ("()"))
+                ("()"))
 
 VOID_HANDLER(EndCdataSection,
                (void *userData),
-                ("()"))
+                ("()"))
 
 #ifndef Py_USING_UNICODE
 VOID_HANDLER(Default,
-              (void *userData, const XML_Char *s, int len),
-              ("(N)", conv_string_len_to_utf8(s,len)))
+              (void *userData, const XML_Char *s, int len),
+              ("(N)", conv_string_len_to_utf8(s,len)))
 
 VOID_HANDLER(DefaultHandlerExpand,
-              (void *userData, const XML_Char *s, int len),
-              ("(N)", conv_string_len_to_utf8(s,len)))
+              (void *userData, const XML_Char *s, int len),
+              ("(N)", conv_string_len_to_utf8(s,len)))
 #else
 VOID_HANDLER(Default,
-              (void *userData, const XML_Char *s, int len),
-              ("(N)", (self->returns_unicode
-                       ? conv_string_len_to_unicode(s,len)
-                       : conv_string_len_to_utf8(s,len))))
+              (void *userData, const XML_Char *s, int len),
+              ("(N)", (self->returns_unicode
+                       ? conv_string_len_to_unicode(s,len)
+                       : conv_string_len_to_utf8(s,len))))
 
 VOID_HANDLER(DefaultHandlerExpand,
-              (void *userData, const XML_Char *s, int len),
-              ("(N)", (self->returns_unicode
-                       ? conv_string_len_to_unicode(s,len)
-                       : conv_string_len_to_utf8(s,len))))
+              (void *userData, const XML_Char *s, int len),
+              ("(N)", (self->returns_unicode
+                       ? conv_string_len_to_unicode(s,len)
+                       : conv_string_len_to_utf8(s,len))))
 #endif
 
 INT_HANDLER(NotStandalone,
-                (void *userData),
-                ("()"))
+                (void *userData),
+                ("()"))
 
 RC_HANDLER(int, ExternalEntityRef,
-                (XML_Parser parser,
-                    const XML_Char *context,
-                    const XML_Char *base,
-                    const XML_Char *systemId,
-                    const XML_Char *publicId),
-                int rc=0;,
+                (XML_Parser parser,
+                    const XML_Char *context,
+                    const XML_Char *base,
+                    const XML_Char *systemId,
+                    const XML_Char *publicId),
+                int rc=0;,
                 ("(O&NNN)",
-                 STRING_CONV_FUNC,context, string_intern(self, base),
-                 string_intern(self, systemId), string_intern(self, publicId)),
-                rc = PyInt_AsLong(rv);, rc,
-                XML_GetUserData(parser))
+                 STRING_CONV_FUNC,context, string_intern(self, base),
+                 string_intern(self, systemId), string_intern(self, publicId)),
+                rc = PyInt_AsLong(rv);, rc,
+                XML_GetUserData(parser))
 
 /* XXX UnknownEncodingHandler */
@@ -1001 +963 @@
 {
     int rv = 1;
-    FILE *fp;
     PyObject *readmethod = NULL;
 
-    if (PyFile_Check(f)) {
-        fp = PyFile_AsFile(f);
-    }
-    else {
-        fp = NULL;
-        readmethod = PyObject_GetAttrString(f, "read");
-        if (readmethod == NULL) {
-            PyErr_Clear();
-            PyErr_SetString(PyExc_TypeError,
-                            "argument must have 'read' attribute");
-            return NULL;
-        }
+    readmethod = PyObject_GetAttrString(f, "read");
+    if (readmethod == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "argument must have 'read' attribute");
+        return NULL;
+
     }
     for (;;) {
@@ -1025 +980 @@
         }
 
-        if (fp) {
-            bytes_read = fread(buf, sizeof(char), BUF_SIZE, fp);
-            if (bytes_read < 0) {
-                PyErr_SetFromErrno(PyExc_IOError);
-                return NULL;
-            }
-        }
-        else {
-            bytes_read = readinst(buf, BUF_SIZE, readmethod);
-            if (bytes_read < 0) {
-                Py_DECREF(readmethod);
-                return NULL;
-            }
-        }
+        bytes_read = readinst(buf, BUF_SIZE, readmethod);
+        if (bytes_read < 0) {
+            Py_XDECREF(readmethod);
+            return NULL;
+        }
+
         rv = XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);
         if (PyErr_Occurred()) {
@@ -1064 +1011 @@
         return NULL;
     if (!XML_SetBase(self->itself, base)) {
-        return PyErr_NoMemory();
+        return PyErr_NoMemory();
     }
     Py_INCREF(Py_None);
@@ -1155 +1102 @@
     new_parser->ns_prefixes = self->ns_prefixes;
     new_parser->itself = XML_ExternalEntityParserCreate(self->itself, context,
-                                                        encoding);
+                                                        encoding);
     new_parser->handlers = 0;
     new_parser->intern = self->intern;
@@ -1228 +1175 @@
 {
     PyObject *flagobj = NULL;
-    XML_Bool flag = XML_TRUE;
+    int flag = 1;
     enum XML_Error rc;
-    if (!PyArg_UnpackTuple(args, "UseForeignDTD", 0, 1, &flagobj))
+    if (!PyArg_ParseTuple(args, "|O:UseForeignDTD", &flagobj))
         return NULL;
-    if (flagobj != NULL)
-        flag = PyObject_IsTrue(flagobj) ? XML_TRUE : XML_FALSE;
-    rc = XML_UseForeignDTD(self->itself, flag);
+    if (flagobj != NULL) {
+        flag = PyObject_IsTrue(flagobj);
+        if (flag < 0)
+            return NULL;
+    }
+    rc = XML_UseForeignDTD(self->itself, flag ? XML_TRUE : XML_FALSE);
     if (rc != XML_ERROR_NONE) {
         return set_error(self, rc);
@@ -1244 +1194 @@
 
 static struct PyMethodDef xmlparse_methods[] = {
-    {"Parse",     (PyCFunction)xmlparse_Parse,
-                  METH_VARARGS, xmlparse_Parse__doc__},
+    {"Parse",     (PyCFunction)xmlparse_Parse,
+                  METH_VARARGS, xmlparse_Parse__doc__},
     {"ParseFile", (PyCFunction)xmlparse_ParseFile,
-                  METH_O,       xmlparse_ParseFile__doc__},
+                  METH_O,       xmlparse_ParseFile__doc__},
     {"SetBase",   (PyCFunction)xmlparse_SetBase,
-                  METH_VARARGS, xmlparse_SetBase__doc__},
+                  METH_VARARGS, xmlparse_SetBase__doc__},
     {"GetBase",   (PyCFunction)xmlparse_GetBase,
-                  METH_NOARGS, xmlparse_GetBase__doc__},
+                  METH_NOARGS, xmlparse_GetBase__doc__},
     {"ExternalEntityParserCreate", (PyCFunction)xmlparse_ExternalEntityParserCreate,
-                  METH_VARARGS, xmlparse_ExternalEntityParserCreate__doc__},
+                  METH_VARARGS, xmlparse_ExternalEntityParserCreate__doc__},
     {"SetParamEntityParsing", (PyCFunction)xmlparse_SetParamEntityParsing,
-                  METH_VARARGS, xmlparse_SetParamEntityParsing__doc__},
+                  METH_VARARGS, xmlparse_SetParamEntityParsing__doc__},
     {"GetInputContext", (PyCFunction)xmlparse_GetInputContext,
-                  METH_NOARGS, xmlparse_GetInputContext__doc__},
+                  METH_NOARGS, xmlparse_GetInputContext__doc__},
 #if XML_COMBINED_VERSION >= 19505
     {"UseForeignDTD", (PyCFunction)xmlparse_UseForeignDTD,
-                  METH_VARARGS, xmlparse_UseForeignDTD__doc__},
-#endif
-    {NULL,        NULL}         /* sentinel */
+                  METH_VARARGS, xmlparse_UseForeignDTD__doc__},
+#endif
+    {NULL,        NULL}         /* sentinel */
 };
 
@@ -1282 +1232 @@
     int i;
     for (i = 0; i < 256; i++) {
-        template_buffer[i] = i;
+        template_buffer[i] = i;
     }
     template_buffer[256] = 0;
@@ -1301 +1251 @@
 
     if (_u_string == NULL)
-        return result;
+        return result;
+
+    if (PyUnicode_GET_SIZE(_u_string) != 256) {
+        Py_DECREF(_u_string);
+        PyErr_SetString(PyExc_ValueError,
+                        "multi-byte encodings are not supported");
+        return result;
+    }
 
     for (i = 0; i < 256; i++) {
-        /* Stupid to access directly, but fast */
-        Py_UNICODE c = _u_string->str[i];
-        if (c == Py_UNICODE_REPLACEMENT_CHARACTER)
-            info->map[i] = -1;
-        else
-            info->map[i] = c;
+        /* Stupid to access directly, but fast */
+        Py_UNICODE c = _u_string->str[i];
+        if (c == Py_UNICODE_REPLACEMENT_CHARACTER)
+            info->map[i] = -1;
+        else
+            info->map[i] = c;
     }
     info->data = NULL;
@@ -1356 +1313 @@
         self->itself = XML_ParserCreate(encoding);
     }
+#if ((XML_MAJOR_VERSION >= 2) && (XML_MINOR_VERSION >= 1)) || defined(XML_HAS_SET_HASH_SALT)
+    /* This feature was added upstream in libexpat 2.1.0.  Our expat copy
+     * has a backport of this feature where we also define XML_HAS_SET_HASH_SALT
+     * to indicate that we can still use it. */
+    XML_SetHashSalt(self->itself,
+                    (unsigned long)_Py_HashSecret.prefix);
+#endif
     self->intern = intern;
     Py_XINCREF(self->intern);
@@ -1510 +1474 @@
     }
 
-#define APPEND(list, str)                               \
-        do {                                            \
-                PyObject *o = PyString_FromString(str); \
-                if (o != NULL)                          \
-                        PyList_Append(list, o);         \
-                Py_XDECREF(o);                          \
+#define APPEND(list, str)                               \
+        do {                                            \
+                PyObject *o = PyString_FromString(str); \
+                if (o != NULL)                          \
+                        PyList_Append(list, o);         \
+                Py_XDECREF(o);                          \
         } while (0)
 
@@ -1521 +1485 @@
         int i;
         PyObject *rc = PyList_New(0);
-        if (!rc)
-                return NULL;
+        if (!rc)
+                return NULL;
         for (i = 0; handler_info[i].name != NULL; i++) {
             PyObject *o = get_handler_name(&handler_info[i]);
@@ -1596 +1560 @@
     }
     if (strcmp(name, "buffer_text") == 0) {
-        if (PyObject_IsTrue(v)) {
+        int b = PyObject_IsTrue(v);
+        if (b < 0)
+            return -1;
+        if (b) {
             if (self->buffer == NULL) {
                 self->buffer = malloc(self->buffer_size);
@@ -1615 +1582 @@
     }
     if (strcmp(name, "namespace_prefixes") == 0) {
-        if (PyObject_IsTrue(v))
-            self->ns_prefixes = 1;
-        else
-            self->ns_prefixes = 0;
+        int b = PyObject_IsTrue(v);
+        if (b < 0)
+            return -1;
+        self->ns_prefixes = b;
         XML_SetReturnNSTriplet(self->itself, self->ns_prefixes);
         return 0;
     }
     if (strcmp(name, "ordered_attributes") == 0) {
-        if (PyObject_IsTrue(v))
-            self->ordered_attributes = 1;
-        else
-            self->ordered_attributes = 0;
+        int b = PyObject_IsTrue(v);
+        if (b < 0)
+            return -1;
+        self->ordered_attributes = b;
         return 0;
     }
     if (strcmp(name, "returns_unicode") == 0) {
-        if (PyObject_IsTrue(v)) {
+        int b = PyObject_IsTrue(v);
+        if (b < 0)
+            return -1;
 #ifndef Py_USING_UNICODE
+        if (b) {
             PyErr_SetString(PyExc_ValueError,
                             "Unicode support not available");
             return -1;
-#else
-            self->returns_unicode = 1;
-#endif
-        }
-        else
-            self->returns_unicode = 0;
+        }
+#endif
+        self->returns_unicode = b;
         return 0;
     }
     if (strcmp(name, "specified_attributes") == 0) {
-        if (PyObject_IsTrue(v))
-            self->specified_attributes = 1;
-        else
-            self->specified_attributes = 0;
+        int b = PyObject_IsTrue(v);
+        if (b < 0)
+            return -1;
+        self->specified_attributes = b;
         return 0;
     }
@@ -1654 +1621 @@
       long new_buffer_size;
       if (!PyInt_Check(v)) {
-        PyErr_SetString(PyExc_TypeError, "buffer_size must be an integer");
-        return -1;
+        PyErr_SetString(PyExc_TypeError, "buffer_size must be an integer");
+        return -1;
       }
 
@@ -1661 +1628 @@
       /* trivial case -- no change */
       if (new_buffer_size == self->buffer_size) {
-        return 0;
+        return 0;
       }
 
       if (new_buffer_size <= 0) {
-        PyErr_SetString(PyExc_ValueError, "buffer_size must be greater than zero");
-        return -1;
+        PyErr_SetString(PyExc_ValueError, "buffer_size must be greater than zero");
+        return -1;
       }
 
       /* check maximum */
       if (new_buffer_size > INT_MAX) {
-        char errmsg[100];
-        sprintf(errmsg, "buffer_size must not be greater than %i", INT_MAX);
-        PyErr_SetString(PyExc_ValueError, errmsg);
-        return -1;      
+        char errmsg[100];
+        sprintf(errmsg, "buffer_size must not be greater than %i", INT_MAX);
+        PyErr_SetString(PyExc_ValueError, errmsg);
+        return -1;
       }
 
       if (self->buffer != NULL) {
-        /* there is already a buffer */
-        if (self->buffer_used != 0) {
-          flush_character_buffer(self);
-        }
-        /* free existing buffer */
-        free(self->buffer);
+        /* there is already a buffer */
+        if (self->buffer_used != 0) {
+          flush_character_buffer(self);
+        }
+        /* free existing buffer */
+        free(self->buffer);
       }
       self->buffer = malloc(new_buffer_size);
       if (self->buffer == NULL) {
-        PyErr_NoMemory();
-        return -1;
-      }   
+        PyErr_NoMemory();
+        return -1;
+      }
       self->buffer_size = new_buffer_size;
       return 0;
@@ -1732 +1699 @@
 
 static PyTypeObject Xmlparsetype = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        "pyexpat.xmlparser",            /*tp_name*/
-        sizeof(xmlparseobject) + PyGC_HEAD_SIZE,/*tp_basicsize*/
-        0,                              /*tp_itemsize*/
-        /* methods */
-        (destructor)xmlparse_dealloc,   /*tp_dealloc*/
-        (printfunc)0,           /*tp_print*/
-        (getattrfunc)xmlparse_getattr,  /*tp_getattr*/
-        (setattrfunc)xmlparse_setattr,  /*tp_setattr*/
-        (cmpfunc)0,             /*tp_compare*/
-        (reprfunc)0,            /*tp_repr*/
-        0,                      /*tp_as_number*/
-        0,              /*tp_as_sequence*/
-        0,              /*tp_as_mapping*/
-        (hashfunc)0,            /*tp_hash*/
-        (ternaryfunc)0,         /*tp_call*/
-        (reprfunc)0,            /*tp_str*/
-        0,              /* tp_getattro */
-        0,              /* tp_setattro */
-        0,              /* tp_as_buffer */
+        PyVarObject_HEAD_INIT(NULL, 0)
+        "pyexpat.xmlparser",            /*tp_name*/
+        sizeof(xmlparseobject) + PyGC_HEAD_SIZE,/*tp_basicsize*/
+        0,                              /*tp_itemsize*/
+        /* methods */
+        (destructor)xmlparse_dealloc,   /*tp_dealloc*/
+        (printfunc)0,           /*tp_print*/
+        (getattrfunc)xmlparse_getattr,  /*tp_getattr*/
+        (setattrfunc)xmlparse_setattr,  /*tp_setattr*/
+        (cmpfunc)0,             /*tp_compare*/
+        (reprfunc)0,            /*tp_repr*/
+        0,                      /*tp_as_number*/
+        0,              /*tp_as_sequence*/
+        0,              /*tp_as_mapping*/
+        (hashfunc)0,            /*tp_hash*/
+        (ternaryfunc)0,         /*tp_call*/
+        (reprfunc)0,            /*tp_str*/
+        0,              /* tp_getattro */
+        0,              /* tp_setattro */
+        0,              /* tp_as_buffer */
 #ifdef Py_TPFLAGS_HAVE_GC
-        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
 #else
-        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /*tp_flags*/
-#endif
-        Xmlparsetype__doc__, /* tp_doc - Documentation string */
+        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /*tp_flags*/
+#endif
+        Xmlparsetype__doc__, /* tp_doc - Documentation string */
 #ifdef WITH_CYCLE_GC
-        (traverseproc)xmlparse_traverse,        /* tp_traverse */
-        (inquiry)xmlparse_clear         /* tp_clear */
+        (traverseproc)xmlparse_traverse,        /* tp_traverse */
+        (inquiry)xmlparse_clear         /* tp_clear */
 #else
-        0, 0
+        0, 0
 #endif
 };
@@ -1797 +1764 @@
        Not passing anything means that a new dictionary is used. */
     if (intern == Py_None)
-        intern = NULL;
+        intern = NULL;
     else if (intern == NULL) {
-        intern = PyDict_New();
-        if (!intern)
-            return NULL;
-        intern_decref = 1;
+        intern = PyDict_New();
+        if (!intern)
+            return NULL;
+        intern_decref = 1;
     }
     else if (!PyDict_Check(intern)) {
-        PyErr_SetString(PyExc_TypeError, "intern must be a dictionary");
-        return NULL;
+        PyErr_SetString(PyExc_TypeError, "intern must be a dictionary");
+        return NULL;
     }
 
     result = newxmlparseobject(encoding, namespace_separator, intern);
     if (intern_decref) {
-        Py_DECREF(intern);
+        Py_DECREF(intern);
     }
     return result;
@@ -1833 +1800 @@
 
 static struct PyMethodDef pyexpat_methods[] = {
-    {"ParserCreate",    (PyCFunction)pyexpat_ParserCreate,
+    {"ParserCreate",    (PyCFunction)pyexpat_ParserCreate,
      METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
-    {"ErrorString",     (PyCFunction)pyexpat_ErrorString,
-     METH_VARARGS,      pyexpat_ErrorString__doc__},
-
-    {NULL,       (PyCFunction)NULL, 0, NULL}            /* sentinel */
+    {"ErrorString",     (PyCFunction)pyexpat_ErrorString,
+     METH_VARARGS,      pyexpat_ErrorString__doc__},
+
+    {NULL,       (PyCFunction)NULL, 0, NULL}            /* sentinel */
 };
 
@@ -1845 +1812 @@
 PyDoc_STRVAR(pyexpat_module_documentation,
 "Python wrapper for Expat parser.");
-
-/* Return a Python string that represents the version number without the
- * extra cruft added by revision control, even if the right options were
- * given to the "cvs export" command to make it not include the extra
- * cruft.
- */
-static PyObject *
-get_version_string(void)
-{
-    static char *rcsid = "$Revision: 64048 $";
-    char *rev = rcsid;
-    int i = 0;
-
-    while (!isdigit(Py_CHARMASK(*rev)))
-        ++rev;
-    while (rev[i] != ' ' && rev[i] != '\0')
-        ++i;
-
-    return PyString_FromStringAndSize(rev, i);
-}
 
 /* Initialization function for the module */
@@ -1895 +1842 @@
     PyObject *model_module;
     PyObject *sys_modules;
+    PyObject *version;
     static struct PyExpat_CAPI capi;
     PyObject* capi_object;
@@ -1910 +1858 @@
                        pyexpat_module_documentation);
     if (m == NULL)
-        return;
+        return;
 
     /* Add some symbolic constants to the module */
@@ -1926 +1874 @@
     PyModule_AddObject(m, "XMLParserType", (PyObject *) &Xmlparsetype);
 
-    PyModule_AddObject(m, "__version__", get_version_string());
+    version = PyString_FromString(PY_VERSION);
+    if (!version)
+        return;
+    PyModule_AddObject(m, "__version__", version);
     PyModule_AddStringConstant(m, "EXPAT_VERSION",
                                (char *) XML_ExpatVersion());
@@ -1969 +1920 @@
         /* Don't core dump later! */
         return;
-    
+
 #if XML_COMBINED_VERSION > 19505
     {
@@ -2094 +2045 @@
     capi.SetUnknownEncodingHandler = XML_SetUnknownEncodingHandler;
     capi.SetUserData = XML_SetUserData;
-    
-    /* export as cobject */
-    capi_object = PyCObject_FromVoidPtr(&capi, NULL);
+
+    /* export using capsule */
+    capi_object = PyCapsule_New(&capi, PyExpat_CAPSULE_NAME, NULL);
     if (capi_object)
         PyModule_AddObject(m, "expat_CAPI", capi_object);
@@ -2109 +2060 @@
     for (; handler_info[i].name != NULL; i++) {
         if (initial)
-            self->handlers[i] = NULL;
-        else {
+            self->handlers[i] = NULL;
+        else {
             temp = self->handlers[i];
             self->handlers[i] = NULL;
             Py_XDECREF(temp);
-            handler_info[i].setter(self->itself, NULL);
+            handler_info[i].setter(self->itself, NULL);
         }
     }