xmlhandlersetter setter;
xmlhandler handler;
PyCodeObject *tb_code;
+ PyObject *nameobj;
};
staticforward struct HandlerInfo handler_info[64];
return NULL;
}
+static int
+have_handler(xmlparseobject *self, int type)
+{
+ PyObject *handler = self->handlers[type];
+ return handler != NULL;
+}
+
+static PyObject *
+get_handler_name(struct HandlerInfo *hinfo)
+{
+ PyObject *name = hinfo->nameobj;
+ if (name == NULL) {
+ name = PyString_FromString(hinfo->name);
+ hinfo->nameobj = name;
+ }
+ Py_XINCREF(name);
+ return name;
+}
+
#ifdef Py_USING_UNICODE
/* Convert a string of XML_Chars into a Unicode string.
static PyObject *
conv_string_to_unicode(const XML_Char *str)
{
- /* XXX currently this code assumes that XML_Char is 8-bit,
+ /* XXX currently this code assumes that XML_Char is 8-bit,
and hence in UTF-8. */
/* UTF-8 from Expat, Unicode desired */
if (str == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
- return PyUnicode_DecodeUTF8(str, strlen(str),
- "strict");
+ return PyUnicode_DecodeUTF8(str, strlen(str), "strict");
}
static PyObject *
conv_string_len_to_unicode(const XML_Char *str, int len)
{
- /* XXX currently this code assumes that XML_Char is 8-bit,
+ /* XXX currently this code assumes that XML_Char is 8-bit,
and hence in UTF-8. */
/* UTF-8 from Expat, Unicode desired */
if (str == NULL) {
static PyObject *
conv_string_to_utf8(const XML_Char *str)
{
- /* XXX currently this code assumes that XML_Char is 8-bit,
+ /* XXX currently this code assumes that XML_Char is 8-bit,
and hence in UTF-8. */
/* UTF-8 from Expat, UTF-8 desired */
if (str == NULL) {
}
static PyObject *
-conv_string_len_to_utf8(const XML_Char *str, int len)
+conv_string_len_to_utf8(const XML_Char *str, int len)
{
- /* XXX currently this code assumes that XML_Char is 8-bit,
+ /* XXX currently this code assumes that XML_Char is 8-bit,
and hence in UTF-8. */
/* UTF-8 from Expat, UTF-8 desired */
if (str == NULL) {
static void
my_StartElementHandler(void *userData,
- const XML_Char *name, const XML_Char **atts)
+ const XML_Char *name, const XML_Char *atts[])
{
xmlparseobject *self = (xmlparseobject *)userData;
- if (self->handlers[StartElement]
- && self->handlers[StartElement] != Py_None) {
+ if (have_handler(self, StartElement)) {
PyObject *container, *rv, *args;
int i, max;
PyObject *rv = NULL; \
INIT \
\
- if (self->handlers[NAME] \
- && self->handlers[NAME] != Py_None) { \
+ if (have_handler(self, NAME)) { \
args = Py_BuildValue PARAM_FORMAT ;\
if (!args) { flag_error(self); return RETURN;} \
self->in_callback = 1; \
rc = PyInt_AsLong(rv);, rc, \
(xmlparseobject *)userData)
-VOID_HANDLER(EndElement,
- (void *userData, const XML_Char *name),
+VOID_HANDLER(EndElement,
+ (void *userData, const XML_Char *name),
("(N)", string_intern(self, name)))
VOID_HANDLER(ProcessingInstruction,
- (void *userData,
- const XML_Char *target,
+ (void *userData,
+ const XML_Char *target,
const XML_Char *data),
("(NO&)", string_intern(self, target), STRING_CONV_FUNC,data))
#ifndef Py_USING_UNICODE
-VOID_HANDLER(CharacterData,
- (void *userData, const XML_Char *data, int len),
+VOID_HANDLER(CharacterData,
+ (void *userData, const XML_Char *data, int len),
("(N)", conv_string_len_to_utf8(data,len)))
#else
-VOID_HANDLER(CharacterData,
- (void *userData, const XML_Char *data, int len),
- ("(N)", (self->returns_unicode
- ? conv_string_len_to_unicode(data,len)
+VOID_HANDLER(CharacterData,
+ (void *userData, const XML_Char *data, int len),
+ ("(N)", (self->returns_unicode
+ ? conv_string_len_to_unicode(data,len)
: conv_string_len_to_utf8(data,len))))
#endif
VOID_HANDLER(UnparsedEntityDecl,
- (void *userData,
+ (void *userData,
const XML_Char *entityName,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId,
const XML_Char *notationName),
("(NNNNN)",
- string_intern(self, entityName), string_intern(self, base),
- string_intern(self, systemId), string_intern(self, publicId),
+ string_intern(self, entityName), string_intern(self, base),
+ string_intern(self, systemId), string_intern(self, publicId),
string_intern(self, notationName)))
#ifndef Py_USING_UNICODE
const XML_Char *notationName),
("NiNNNNN",
string_intern(self, entityName), is_parameter_entity,
- (self->returns_unicode
- ? conv_string_len_to_unicode(value, value_length)
+ (self->returns_unicode
+ ? conv_string_len_to_unicode(value, value_length)
: conv_string_len_to_utf8(value, value_length)),
string_intern(self, base), string_intern(self, systemId),
string_intern(self, publicId),
const XML_Char *encoding,
int standalone),
("(O&O&i)",
- STRING_CONV_FUNC,version, STRING_CONV_FUNC,encoding,
+ STRING_CONV_FUNC,version, STRING_CONV_FUNC,encoding,
standalone))
static PyObject *
STRING_CONV_FUNC,att_type, STRING_CONV_FUNC,dflt,
isrequired))
-VOID_HANDLER(NotationDecl,
+VOID_HANDLER(NotationDecl,
(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, notationName), string_intern(self, base),
string_intern(self, systemId), string_intern(self, publicId)))
VOID_HANDLER(StartNamespaceDecl,
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),
+ (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),
+ (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)
+ (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)
+ (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),
+INT_HANDLER(NotStandalone,
+ (void *userData),
("()"))
RC_HANDLER(int, ExternalEntityRef,
const XML_Char *publicId),
int rc=0;,
("(O&NNN)",
- STRING_CONV_FUNC,context, string_intern(self, base),
+ STRING_CONV_FUNC,context, string_intern(self, base),
string_intern(self, systemId), string_intern(self, publicId)),
rc = PyInt_AsLong(rv);, rc,
XML_GetUserData(parser))
/* ---------------------------------------------------------------- */
+static PyObject *
+get_parse_result(xmlparseobject *self, int rv)
+{
+ if (PyErr_Occurred()) {
+ return NULL;
+ }
+ if (rv == 0) {
+ return set_error(self);
+ }
+ return PyInt_FromLong(rv);
+}
+
PyDoc_STRVAR(xmlparse_Parse__doc__,
"Parse(data[, isfinal])\n\
Parse XML data. `isfinal' should be true at end of input.");
char *s;
int slen;
int isFinal = 0;
- int rv;
if (!PyArg_ParseTuple(args, "s#|i:Parse", &s, &slen, &isFinal))
return NULL;
- rv = XML_Parse(self->itself, s, slen, isFinal);
- if (PyErr_Occurred()) {
- return NULL;
- }
- else if (rv == 0) {
- return set_error(self);
- }
- return PyInt_FromLong(rv);
+
+ return get_parse_result(self, XML_Parse(self->itself, s, slen, isFinal));
}
/* File reading copied from cPickle */
/* XXX what to do if it returns a Unicode string? */
if (!PyString_Check(str)) {
- PyErr_Format(PyExc_TypeError,
+ PyErr_Format(PyExc_TypeError,
"read() did not return a string object (type=%.400s)",
str->ob_type->tp_name);
goto finally;
readmethod = PyObject_GetAttrString(f, "read");
if (readmethod == NULL) {
PyErr_Clear();
- PyErr_SetString(PyExc_TypeError,
+ PyErr_SetString(PyExc_TypeError,
"argument must have 'read' attribute");
return 0;
}
if (!rv || bytes_read == 0)
break;
}
- if (rv == 0) {
- return set_error(self);
- }
- return Py_BuildValue("i", rv);
+ return get_parse_result(self, rv);
}
PyDoc_STRVAR(xmlparse_SetBase__doc__,
/* then copy handlers from self */
for (i = 0; handler_info[i].name != NULL; i++) {
- if (self->handlers[i]) {
- Py_INCREF(self->handlers[i]);
- new_parser->handlers[i] = self->handlers[i];
- handler_info[i].setter(new_parser->itself,
+ PyObject *handler = self->handlers[i];
+ if (handler != NULL) {
+ Py_INCREF(handler);
+ new_parser->handlers[i] = handler;
+ handler_info[i].setter(new_parser->itself,
handler_info[i].handler);
}
}
- return (PyObject *)new_parser;
+ return (PyObject *)new_parser;
}
PyDoc_STRVAR(xmlparse_SetParamEntityParsing__doc__,
#ifdef Py_USING_UNICODE
-/*
- pyexpat international encoding support.
- Make it as simple as possible.
+/* pyexpat international encoding support.
+ Make it as simple as possible.
*/
static char template_buffer[257];
PyObject *template_string = NULL;
-static void
+static void
init_template_buffer(void)
{
int i;
template_buffer[256] = 0;
}
-int
-PyUnknownEncodingHandler(void *encodingHandlerData,
-const XML_Char *name,
-XML_Encoding * info)
+static int
+PyUnknownEncodingHandler(void *encodingHandlerData,
+ const XML_Char *name,
+ XML_Encoding *info)
{
PyUnicodeObject *_u_string = NULL;
int result = 0;
int i;
-
+
/* Yes, supports only 8bit encodings */
_u_string = (PyUnicodeObject *)
PyUnicode_Decode(template_buffer, 256, name, "replace");
-
+
if (_u_string == NULL)
return result;
-
+
for (i = 0; i < 256; i++) {
/* Stupid to access directly, but fast */
Py_UNICODE c = _u_string->str[i];
else
info->map[i] = c;
}
-
info->data = NULL;
info->convert = NULL;
info->release = NULL;
- result=1;
-
+ result = 1;
Py_DECREF(_u_string);
return result;
}
{
int i;
xmlparseobject *self;
-
+
#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
self = PyObject_NEW(xmlparseobject, &Xmlparsetype);
if (self == NULL)
PyObject_GC_Init(self);
#endif
if (self->itself == NULL) {
- PyErr_SetString(PyExc_RuntimeError,
+ PyErr_SetString(PyExc_RuntimeError,
"XML_ParserCreate failed");
Py_DECREF(self);
return NULL;
self->handlers = malloc(sizeof(PyObject *)*i);
if (!self->handlers){
- Py_DECREF(self);
- return PyErr_NoMemory();
+ Py_DECREF(self);
+ return PyErr_NoMemory();
}
clear_handlers(self, 1);
Py_XDECREF(temp);
}
free(self->handlers);
+ self->handlers = NULL;
}
Py_XDECREF(self->intern);
#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
handlername2int(const char *name)
{
int i;
- for (i=0; handler_info[i].name != NULL; i++) {
+ for (i = 0; handler_info[i].name != NULL; i++) {
if (strcmp(name, handler_info[i].name) == 0) {
return i;
}
return -1;
}
+static PyObject *
+get_pybool(int istrue)
+{
+ PyObject *result = istrue ? Py_True : Py_False;
+ Py_INCREF(result);
+ return result;
+}
+
static PyObject *
xmlparse_getattr(xmlparseobject *self, char *name)
{
- int handlernum;
- if (strcmp(name, "ErrorCode") == 0)
- return PyInt_FromLong((long) XML_GetErrorCode(self->itself));
- if (strcmp(name, "ErrorLineNumber") == 0)
- return PyInt_FromLong((long) XML_GetErrorLineNumber(self->itself));
- if (strcmp(name, "ErrorColumnNumber") == 0)
- return PyInt_FromLong((long) XML_GetErrorColumnNumber(self->itself));
- if (strcmp(name, "ErrorByteIndex") == 0)
- return PyInt_FromLong((long) XML_GetErrorByteIndex(self->itself));
+ int handlernum = handlername2int(name);
+
+ if (handlernum != -1) {
+ PyObject *result = self->handlers[handlernum];
+ if (result == NULL)
+ result = Py_None;
+ Py_INCREF(result);
+ return result;
+ }
+ if (name[0] == 'E') {
+ if (strcmp(name, "ErrorCode") == 0)
+ return PyInt_FromLong((long)
+ XML_GetErrorCode(self->itself));
+ if (strcmp(name, "ErrorLineNumber") == 0)
+ return PyInt_FromLong((long)
+ XML_GetErrorLineNumber(self->itself));
+ if (strcmp(name, "ErrorColumnNumber") == 0)
+ return PyInt_FromLong((long)
+ XML_GetErrorColumnNumber(self->itself));
+ if (strcmp(name, "ErrorByteIndex") == 0)
+ return PyInt_FromLong((long)
+ XML_GetErrorByteIndex(self->itself));
+ }
if (strcmp(name, "ordered_attributes") == 0)
- return PyInt_FromLong((long) self->ordered_attributes);
+ return get_pybool(self->ordered_attributes);
if (strcmp(name, "returns_unicode") == 0)
- return PyInt_FromLong((long) self->returns_unicode);
+ return get_pybool((long) self->returns_unicode);
if (strcmp(name, "specified_attributes") == 0)
- return PyInt_FromLong((long) self->specified_attributes);
+ return get_pybool((long) self->specified_attributes);
if (strcmp(name, "intern") == 0) {
if (self->intern == NULL) {
Py_INCREF(Py_None);
}
}
- handlernum = handlername2int(name);
-
- if (handlernum != -1 && self->handlers[handlernum] != NULL) {
- Py_INCREF(self->handlers[handlernum]);
- return self->handlers[handlernum];
- }
if (strcmp(name, "__members__") == 0) {
int i;
PyObject *rc = PyList_New(0);
- for(i = 0; handler_info[i].name != NULL; i++) {
- PyList_Append(rc, PyString_FromString(handler_info[i].name));
+ for (i = 0; handler_info[i].name != NULL; i++) {
+ PyList_Append(rc, get_handler_name(&handler_info[i]));
}
PyList_Append(rc, PyString_FromString("ErrorCode"));
PyList_Append(rc, PyString_FromString("ErrorLineNumber"));
sethandler(xmlparseobject *self, const char *name, PyObject* v)
{
int handlernum = handlername2int(name);
- if (handlernum != -1) {
- Py_INCREF(v);
- Py_XDECREF(self->handlers[handlernum]);
+ if (handlernum >= 0) {
+ xmlhandler c_handler = NULL;
+ PyObject *temp = self->handlers[handlernum];
+
+ if (v == Py_None)
+ v = NULL;
+ else if (v != NULL) {
+ Py_INCREF(v);
+ c_handler = handler_info[handlernum].handler;
+ }
self->handlers[handlernum] = v;
- handler_info[handlernum].setter(self->itself,
- handler_info[handlernum].handler);
+ Py_XDECREF(temp);
+ handler_info[handlernum].setter(self->itself, c_handler);
return 1;
}
return 0;
if (strcmp(name, "returns_unicode") == 0) {
if (PyObject_IsTrue(v)) {
#ifndef Py_USING_UNICODE
- PyErr_SetString(PyExc_ValueError,
- "Cannot return Unicode strings in Python 1.5");
+ PyErr_SetString(PyExc_ValueError,
+ "Unicode support not available");
return -1;
#else
self->returns_unicode = 1;
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*/
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /*tp_flags*/
#endif
Xmlparsetype__doc__, /* Documentation string */
#ifdef WITH_CYCLE_GC
PyObject *intern = NULL;
PyObject *result;
int intern_decref = 0;
- static char *kwlist[] = {"encoding", "namespace_separator",
+ static char *kwlist[] = {"encoding", "namespace_separator",
"intern", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kw, "|zzO:ParserCreate", kwlist,
if (!intern)
return NULL;
intern_decref = 1;
- }
+ }
else if (!PyDict_Check(intern)) {
PyErr_SetString(PyExc_TypeError, "intern must be a dictionary");
return NULL;
METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
{"ErrorString", (PyCFunction)pyexpat_ErrorString,
METH_VARARGS, pyexpat_ErrorString__doc__},
-
+
{NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
};
return 0;
}
-int
+static int
PyModule_AddIntConstant(PyObject *m, char *name, long value)
{
return PyModule_AddObject(m, name, PyInt_FromLong(value));
}
-static int
+static int
PyModule_AddStringConstant(PyObject *m, char *name, char *value)
{
return PyModule_AddObject(m, name, PyString_FromString(value));
init_template_buffer();
#endif
/* XXX When Expat supports some way of figuring out how it was
- compiled, this should check and set native_encoding
- appropriately.
+ compiled, this should check and set native_encoding
+ appropriately.
*/
PyModule_AddStringConstant(m, "native_encoding", "UTF-8");
int i = 0;
PyObject *temp;
- for (; handler_info[i].name!=NULL; i++) {
+ for (; handler_info[i].name != NULL; i++) {
if (initial)
- self->handlers[i]=NULL;
+ self->handlers[i] = NULL;
else {
temp = self->handlers[i];
self->handlers[i] = NULL;
}
}
-typedef void (*pairsetter)(XML_Parser, void *handler1, void *handler2);
-
-static void
-pyxml_UpdatePairedHandlers(xmlparseobject *self,
- int startHandler,
- int endHandler,
- pairsetter setter)
-{
- void *start_handler = NULL;
- void *end_handler = NULL;
-
- if (self->handlers[startHandler]
- && self->handlers[startHandler] != Py_None) {
- start_handler = handler_info[startHandler].handler;
- }
- if (self->handlers[endHandler]
- && self->handlers[endHandler] != Py_None) {
- end_handler = handler_info[endHandler].handler;
- }
- setter(self->itself, start_handler, end_handler);
-}
-
-static void
-pyxml_SetStartElementHandler(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartElement, EndElement,
- (pairsetter)XML_SetElementHandler);
-}
-
-static void
-pyxml_SetEndElementHandler(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartElement, EndElement,
- (pairsetter)XML_SetElementHandler);
-}
-
-static void
-pyxml_SetStartNamespaceDeclHandler(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartNamespaceDecl, EndNamespaceDecl,
- (pairsetter)XML_SetNamespaceDeclHandler);
-}
-
-static void
-pyxml_SetEndNamespaceDeclHandler(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartNamespaceDecl, EndNamespaceDecl,
- (pairsetter)XML_SetNamespaceDeclHandler);
-}
-
-static void
-pyxml_SetStartCdataSection(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartCdataSection, EndCdataSection,
- (pairsetter)XML_SetCdataSectionHandler);
-}
-
-static void
-pyxml_SetEndCdataSection(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartCdataSection, EndCdataSection,
- (pairsetter)XML_SetCdataSectionHandler);
-}
-
-static void
-pyxml_SetStartDoctypeDeclHandler(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartDoctypeDecl, EndDoctypeDecl,
- (pairsetter)XML_SetDoctypeDeclHandler);
-}
-
-static void
-pyxml_SetEndDoctypeDeclHandler(XML_Parser *parser, void *junk)
-{
- pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
- StartDoctypeDecl, EndDoctypeDecl,
- (pairsetter)XML_SetDoctypeDeclHandler);
-}
-
statichere struct HandlerInfo handler_info[] = {
- {"StartElementHandler",
- pyxml_SetStartElementHandler,
+ {"StartElementHandler",
+ (xmlhandlersetter)XML_SetStartElementHandler,
(xmlhandler)my_StartElementHandler},
- {"EndElementHandler",
- pyxml_SetEndElementHandler,
+ {"EndElementHandler",
+ (xmlhandlersetter)XML_SetEndElementHandler,
(xmlhandler)my_EndElementHandler},
- {"ProcessingInstructionHandler",
+ {"ProcessingInstructionHandler",
(xmlhandlersetter)XML_SetProcessingInstructionHandler,
(xmlhandler)my_ProcessingInstructionHandler},
- {"CharacterDataHandler",
+ {"CharacterDataHandler",
(xmlhandlersetter)XML_SetCharacterDataHandler,
(xmlhandler)my_CharacterDataHandler},
- {"UnparsedEntityDeclHandler",
+ {"UnparsedEntityDeclHandler",
(xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,
(xmlhandler)my_UnparsedEntityDeclHandler },
- {"NotationDeclHandler",
+ {"NotationDeclHandler",
(xmlhandlersetter)XML_SetNotationDeclHandler,
(xmlhandler)my_NotationDeclHandler },
- {"StartNamespaceDeclHandler",
- pyxml_SetStartNamespaceDeclHandler,
+ {"StartNamespaceDeclHandler",
+ (xmlhandlersetter)XML_SetStartNamespaceDeclHandler,
(xmlhandler)my_StartNamespaceDeclHandler },
- {"EndNamespaceDeclHandler",
- pyxml_SetEndNamespaceDeclHandler,
+ {"EndNamespaceDeclHandler",
+ (xmlhandlersetter)XML_SetEndNamespaceDeclHandler,
(xmlhandler)my_EndNamespaceDeclHandler },
{"CommentHandler",
(xmlhandlersetter)XML_SetCommentHandler,
(xmlhandler)my_CommentHandler},
{"StartCdataSectionHandler",
- pyxml_SetStartCdataSection,
+ (xmlhandlersetter)XML_SetStartCdataSectionHandler,
(xmlhandler)my_StartCdataSectionHandler},
{"EndCdataSectionHandler",
- pyxml_SetEndCdataSection,
+ (xmlhandlersetter)XML_SetEndCdataSectionHandler,
(xmlhandler)my_EndCdataSectionHandler},
{"DefaultHandler",
(xmlhandlersetter)XML_SetDefaultHandler,
(xmlhandlersetter)XML_SetExternalEntityRefHandler,
(xmlhandler)my_ExternalEntityRefHandler },
{"StartDoctypeDeclHandler",
- pyxml_SetStartDoctypeDeclHandler,
+ (xmlhandlersetter)XML_SetStartDoctypeDeclHandler,
(xmlhandler)my_StartDoctypeDeclHandler},
{"EndDoctypeDeclHandler",
- pyxml_SetEndDoctypeDeclHandler,
+ (xmlhandlersetter)XML_SetEndDoctypeDeclHandler,
(xmlhandler)my_EndDoctypeDeclHandler},
{"EntityDeclHandler",
(xmlhandlersetter)XML_SetEntityDeclHandler,
projects / python / commitdiff