/*********************************************************** Copyright 2000 by Stichting Mathematisch Centrum, Amsterdam, The Netherlands. All Rights Reserved Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. Copyright (c) 1990-1995, Stichting Mathematisch Centrum. All rights reserved. See the file "Misc/COPYRIGHT" for information on usage and redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. ******************************************************************/ #include "Python.h" #include "xmlparse.h" /* ** The version number should match the one in _checkversion */ #define VERSION "1.9" enum HandlerTypes{ StartElement, EndElement, ProcessingInstruction, CharacterData, UnparsedEntityDecl, NotationDecl, StartNamespaceDecl, EndNamespaceDecl, Comment, StartCdataSection, EndCdataSection, Default, DefaultHandlerExpand, NotStandalone, ExternalEntityRef }; static PyObject *ErrorObject; /* ----------------------------------------------------- */ /* Declarations for objects of type xmlparser */ typedef struct { PyObject_HEAD XML_Parser itself; int returns_unicode; /* True if Unicode strings are returned; if false, UTF-8 strings are returned */ PyObject **handlers; } xmlparseobject; staticforward PyTypeObject Xmlparsetype; typedef void (*xmlhandlersetter)( XML_Parser *self, void *meth ); typedef void* xmlhandler; struct HandlerInfo { const char *name; xmlhandlersetter setter; xmlhandler handler; }; staticforward struct HandlerInfo handler_info[]; /* Convert an array of attributes and their values into a Python dict */ static PyObject *conv_atts_using_string( XML_Char **atts){ PyObject *attrs_obj=NULL; XML_Char **attrs_p, **attrs_k; int attrs_len; PyObject *rv; if( (attrs_obj = PyDict_New()) == NULL ) goto finally; for(attrs_len=0, attrs_p = atts; *attrs_p; attrs_p++, attrs_len++) { if (attrs_len%2) { rv=PyString_FromString(*attrs_p); if (! rv) { Py_DECREF(attrs_obj); attrs_obj=NULL; goto finally; } if (PyDict_SetItemString( attrs_obj, (char*)*attrs_k, rv) < 0){ Py_DECREF(attrs_obj); attrs_obj=NULL; goto finally; } Py_DECREF(rv); } else attrs_k=attrs_p; } finally: return attrs_obj; } #if !(PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6) static PyObject *conv_atts_using_unicode( XML_Char **atts){ PyObject *attrs_obj=NULL; XML_Char **attrs_p, **attrs_k; int attrs_len; if( (attrs_obj = PyDict_New()) == NULL ) goto finally; for(attrs_len=0, attrs_p = atts; *attrs_p; attrs_p++, attrs_len++) { if (attrs_len%2) { PyObject *attr_str, *value_str; const char *p = (const char *) (*attrs_k); attr_str=PyUnicode_DecodeUTF8(p, strlen(p), "strict"); if (! attr_str) { Py_DECREF(attrs_obj); attrs_obj=NULL; goto finally; } p = (const char *) *attrs_p; value_str=PyUnicode_DecodeUTF8(p, strlen(p), "strict"); if (! value_str) { Py_DECREF(attrs_obj); Py_DECREF(attr_str); attrs_obj=NULL; goto finally; } if (PyDict_SetItem(attrs_obj, attr_str, value_str) < 0) { Py_DECREF(attrs_obj); attrs_obj=NULL; goto finally; } Py_DECREF(attr_str); Py_DECREF(value_str); } else attrs_k=attrs_p; } finally: return attrs_obj; } /* Convert a string of XML_Chars into a Unicode string. Returns None if str is a null pointer. */ static PyObject *conv_string_to_unicode( XML_Char *str ) { /* 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( (const char *)str, strlen( (const char *)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, and hence in UTF-8. */ /* UTF-8 from Expat, Unicode desired */ if (str == NULL) {Py_INCREF(Py_None); return Py_None;} return PyUnicode_DecodeUTF8( (const char *)str, len, "strict" ); } #endif /* Convert a string of XML_Chars into an 8-bit Python string. Returns None if str is a null pointer. */ static PyObject *conv_string_to_utf8( XML_Char *str ) { /* 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) {Py_INCREF(Py_None); return Py_None;} return PyString_FromString( (const char *)str ); } static PyObject *conv_string_len_to_utf8( const XML_Char *str, int len ) { /* 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) {Py_INCREF(Py_None); return Py_None;} return PyString_FromStringAndSize( (const char *)str, len ); } /* Callback routines */ static void clear_handlers( xmlparseobject *self ); static void flag_error( xmlparseobject *self ){ clear_handlers(self); } #define RC_HANDLER( RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, \ RETURN, GETUSERDATA) \ \ static RC my_##NAME##Handler PARAMS {\ xmlparseobject *self = GETUSERDATA ; \ PyObject *args=NULL; \ PyObject *rv=NULL; \ INIT \ \ if (self->handlers[NAME] \ && self->handlers[NAME] != Py_None) { \ args = Py_BuildValue PARAM_FORMAT ;\ if (!args) return RETURN; \ rv = PyEval_CallObject(self->handlers[NAME], args); \ Py_DECREF(args); \ if (rv == NULL) { \ flag_error( self ); \ return RETURN; \ } \ CONVERSION \ Py_DECREF(rv); \ } \ return RETURN; \ } #if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 #define STRING_CONV_FUNC conv_string_to_utf8 #else /* Python 1.6 and later versions */ #define STRING_CONV_FUNC (self->returns_unicode \ ? conv_string_to_unicode : conv_string_to_utf8) #endif #define VOID_HANDLER( NAME, PARAMS, PARAM_FORMAT ) \ 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 ) #if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 VOID_HANDLER( StartElement, (void *userData, const XML_Char *name, const XML_Char **atts ), ("(O&O&)", STRING_CONV_FUNC, name, conv_atts_using_string, atts ) ) #else /* Python 1.6 and later */ VOID_HANDLER( StartElement, (void *userData, const XML_Char *name, const XML_Char **atts ), ("(O&O&)", STRING_CONV_FUNC, name, (self->returns_unicode ? conv_atts_using_unicode : conv_atts_using_string), atts ) ) #endif VOID_HANDLER( EndElement, (void *userData, const XML_Char *name ), ("(O&)", STRING_CONV_FUNC, name) ) VOID_HANDLER( ProcessingInstruction, (void *userData, const XML_Char *target, const XML_Char *data), ("(O&O&)",STRING_CONV_FUNC,target, STRING_CONV_FUNC,data )) #if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 VOID_HANDLER( CharacterData, (void *userData, const XML_Char *data, int len), ("(O)", conv_string_len_to_utf8(data,len) ) ) #else VOID_HANDLER( CharacterData, (void *userData, const XML_Char *data, int len), ("(O)", (self->returns_unicode ? conv_string_len_to_unicode(data,len) : conv_string_len_to_utf8(data,len) ) ) ) #endif VOID_HANDLER( UnparsedEntityDecl, (void *userData, const XML_Char *entityName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName), ("(O&O&O&O&O&)", STRING_CONV_FUNC,entityName, STRING_CONV_FUNC,base, STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId, STRING_CONV_FUNC,notationName)) VOID_HANDLER( NotationDecl, (void *userData, const XML_Char *notationName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId), ("(O&O&O&O&)", STRING_CONV_FUNC,notationName, STRING_CONV_FUNC,base, STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId)) VOID_HANDLER( StartNamespaceDecl, (void *userData, const XML_Char *prefix, const XML_Char *uri), ("(O&O&)", STRING_CONV_FUNC,prefix, STRING_CONV_FUNC,uri )) VOID_HANDLER( EndNamespaceDecl, (void *userData, const XML_Char *prefix), ("(O&)", STRING_CONV_FUNC,prefix )) VOID_HANDLER( Comment, (void *userData, const XML_Char *prefix), ("(O&)", STRING_CONV_FUNC,prefix)) VOID_HANDLER( StartCdataSection, (void *userData), ("()" )) VOID_HANDLER( EndCdataSection, (void *userData), ("()" )) #if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 VOID_HANDLER( Default, (void *userData, const XML_Char *s, int len), ("(O)", conv_string_len_to_utf8(s,len) ) ) VOID_HANDLER( DefaultHandlerExpand, (void *userData, const XML_Char *s, int len), ("(O)", conv_string_len_to_utf8(s,len) ) ) #else VOID_HANDLER( Default, (void *userData, const XML_Char *s, int len), ("(O)", (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), ("(O)", (self->returns_unicode ? conv_string_len_to_unicode(s,len) : conv_string_len_to_utf8(s,len) ) ) ) #endif INT_HANDLER( NotStandalone, (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;, ("(O&O&O&O&)", STRING_CONV_FUNC,context, STRING_CONV_FUNC,base, STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId ), rc = PyInt_AsLong( rv );, rc, XML_GetUserData( parser ) ) /* File reading copied from cPickle */ #define UNLESS(E) if (!(E)) /* static int read_other(xmlparseobject *self, char **s, int n) { PyObject *bytes=NULL, *str=NULL, *arg=NULL; int res = -1; UNLESS(bytes = PyInt_FromLong(n)) { if (!PyErr_Occurred()) PyErr_SetNone(PyExc_EOFError); goto finally; } UNLESS(arg) UNLESS(arg = PyTuple_New(1)) goto finally; Py_INCREF(bytes); if (PyTuple_SetItem(arg, 0, bytes) < 0) goto finally; UNLESS(str = PyObject_CallObject(self->read, arg)) goto finally; *s = PyString_AsString(str); res = n; finally: Py_XDECREF(arg); Py_XDECREF(bytes); return res; } */ /* ---------------------------------------------------------------- */ static char xmlparse_Parse__doc__[] = "(data [,isfinal]) - Parse XML data" ; static PyObject * xmlparse_Parse( xmlparseobject *self, PyObject *args ) { char *s; int slen; int isFinal = 0; int rv; if (!PyArg_ParseTuple(args, "s#|i", &s, &slen, &isFinal)) return NULL; rv = XML_Parse(self->itself, s, slen, isFinal); if( PyErr_Occurred() ){ return NULL; } else if (rv == 0) { PyErr_Format(ErrorObject, "%.200s: line %i, column %i", XML_ErrorString( XML_GetErrorCode(self->itself) ), XML_GetErrorLineNumber(self->itself), XML_GetErrorColumnNumber(self->itself) ); return NULL; } return Py_BuildValue("i", rv); } #define BUF_SIZE 2048 int readinst(char *buf, int buf_size, PyObject *meth){ PyObject *arg=NULL; PyObject *bytes=NULL; PyObject *str=NULL; int len; UNLESS(bytes = PyInt_FromLong(buf_size)) { if (!PyErr_Occurred()) PyErr_SetNone(PyExc_EOFError); goto finally; } UNLESS(arg) UNLESS(arg = PyTuple_New(1)) goto finally; Py_INCREF(bytes); if (PyTuple_SetItem(arg, 0, bytes) < 0) goto finally; UNLESS(str = PyObject_CallObject(meth, arg)) goto finally; UNLESS(PyString_Check( str )) goto finally; len=PyString_GET_SIZE( str ); strncpy( buf, PyString_AsString(str), len ); Py_XDECREF( str ); finally: return len; } static char xmlparse_ParseFile__doc__[] = "(file) - Parse XML data" ; static PyObject * xmlparse_ParseFile( xmlparseobject *self, PyObject *args ) { int rv=1; PyObject *f; FILE *fp; PyObject *readmethod=NULL; if (!PyArg_ParseTuple(args, "O", &f)) return NULL; if (PyFile_Check(f)) { fp = PyFile_AsFile(f); }else{ fp = NULL; UNLESS(readmethod = PyObject_GetAttrString(f, "read")) { PyErr_Clear(); PyErr_SetString( PyExc_TypeError, "argument must have 'read' attribute" ); return 0; } } for (;;) { int bytes_read; void *buf = XML_GetBuffer(self->itself, BUF_SIZE); if (buf == NULL) { PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } if( fp ){ bytes_read=fread( buf, sizeof( char ), BUF_SIZE, fp); }else{ bytes_read=readinst( buf, BUF_SIZE, readmethod ); } if (bytes_read < 0) { PyErr_SetFromErrno(PyExc_IOError); return NULL; } rv=XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0); if( PyErr_Occurred() ){ return NULL; } if (!rv || bytes_read == 0) break; } return Py_BuildValue("i", rv); } static char xmlparse_SetBase__doc__[] = "(base_url) - Base URL string" ; static PyObject * xmlparse_SetBase( xmlparseobject *self, PyObject *args ){ char *base; if (!PyArg_ParseTuple(args, "s", &base)) return NULL; if( !XML_SetBase( self->itself, base ) ){ PyErr_SetNone(PyExc_MemoryError); return NULL; } Py_INCREF(Py_None); return Py_None; } static char xmlparse_GetBase__doc__[] = "() - returns base URL string " ; static PyObject * xmlparse_GetBase( xmlparseobject *self, PyObject *args ){ const XML_Char *base; PyObject *rc; if( PyTuple_Size( args )!=0 ){ PyArg_ParseTuple(args, "()" ); /* get good error reporting */ return NULL; } base=XML_GetBase( self->itself ); if( base ){ rc=Py_BuildValue("s", base); }else{ Py_INCREF(Py_None); rc=Py_None; } return rc; } static struct PyMethodDef xmlparse_methods[] = { {"Parse", (PyCFunction)xmlparse_Parse, METH_VARARGS, xmlparse_Parse__doc__}, {"ParseFile", (PyCFunction)xmlparse_ParseFile, METH_VARARGS, xmlparse_ParseFile__doc__}, {"SetBase", (PyCFunction)xmlparse_SetBase, METH_VARARGS, xmlparse_SetBase__doc__}, {"GetBase", (PyCFunction)xmlparse_GetBase, METH_VARARGS, xmlparse_GetBase__doc__}, {NULL, NULL} /* sentinel */ }; /* ---------- */ static xmlparseobject * newxmlparseobject( char *encoding, char *namespace_separator){ int i; xmlparseobject *self; #if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 self = PyObject_NEW(xmlparseobject, &Xmlparsetype); if (self == NULL) return NULL; self->returns_unicode = 0; #else /* Code for versions 1.6 and later */ self = PyObject_New(xmlparseobject, &Xmlparsetype); if (self == NULL) return NULL; self->returns_unicode = 1; #endif if (namespace_separator) { self->itself = XML_ParserCreateNS(encoding, *namespace_separator); }else{ self->itself = XML_ParserCreate(encoding); } if( self->itself==NULL ){ PyErr_SetString(PyExc_RuntimeError, "XML_ParserCreate failed"); Py_DECREF(self); return NULL; } XML_SetUserData(self->itself, (void *)self); for( i=0; handler_info[i].name!=NULL;i++); self->handlers=malloc( sizeof( PyObject *)*i ); clear_handlers( self ); return self; } static void xmlparse_dealloc( xmlparseobject *self ) { int i; if (self->itself) XML_ParserFree(self->itself); self->itself = NULL; for( i=0; handler_info[i].name!=NULL; i++ ){ Py_XDECREF( self->handlers[i] ); } #if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 /* Code for versions before 1.6 */ free(self); #else /* Code for versions 1.6 and later */ PyObject_Del(self); #endif } static int handlername2int( const char *name ){ int i; for( i=0;handler_info[i].name!=NULL;i++){ if( strcmp( name, handler_info[i].name )==0 ){ return i; } } return -1; } static PyObject * xmlparse_getattr(xmlparseobject *self, char *name) { int handlernum; if (strcmp(name, "ErrorCode") == 0) return Py_BuildValue("l", (long)XML_GetErrorCode(self->itself)); if (strcmp(name, "ErrorLineNumber") == 0) return Py_BuildValue("l", (long)XML_GetErrorLineNumber(self->itself)); if (strcmp(name, "ErrorColumnNumber") == 0) return Py_BuildValue("l", (long)XML_GetErrorColumnNumber(self->itself)); if (strcmp(name, "ErrorByteIndex") == 0) return Py_BuildValue("l", XML_GetErrorByteIndex(self->itself)); if (strcmp(name, "returns_unicode") == 0) return Py_BuildValue("i", self->returns_unicode); 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 ) ); } PyList_Append( rc, PyString_FromString( "ErrorCode" )); PyList_Append( rc, PyString_FromString( "ErrorLineNumber" )); PyList_Append( rc, PyString_FromString( "ErrorColumnNumber")); PyList_Append( rc, PyString_FromString( "ErrorByteIndex" )); return rc; } return Py_FindMethod(xmlparse_methods, (PyObject *)self, name); } static int sethandler( xmlparseobject *self, const char *name, PyObject* v ){ int handlernum = handlername2int( name ); if( handlernum!=-1 ){ Py_INCREF( v ); Py_XDECREF( self->handlers[handlernum] ); self->handlers[handlernum]=v; handler_info[handlernum].setter( self->itself, handler_info[handlernum].handler ); return 1; } return 0; } static int xmlparse_setattr( xmlparseobject *self, char *name, PyObject *v) { /* Set attribute 'name' to value 'v'. v==NULL means delete */ if (v==NULL) { PyErr_SetString(PyExc_RuntimeError, "Cannot delete attribute"); return -1; } if (strcmp(name, "returns_unicode") == 0) { PyObject *intobj = PyNumber_Int(v); if (intobj == NULL) return -1; if (PyInt_AsLong(intobj)) { #if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 PyErr_SetString(PyExc_ValueError, "Cannot return Unicode strings in Python 1.5"); return -1; #else self->returns_unicode = 1; #endif } else self->returns_unicode = 0; Py_DECREF(intobj); return 0; } if( sethandler( self, name, v ) ){ return 0; } PyErr_SetString( PyExc_AttributeError, name ); return -1; } static char Xmlparsetype__doc__[] = "XML parser" ; static PyTypeObject Xmlparsetype = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "xmlparser", /*tp_name*/ sizeof(xmlparseobject), /*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*/ /* Space for future expansion */ 0L,0L,0L,0L, Xmlparsetype__doc__ /* Documentation string */ }; /* End of code for xmlparser objects */ /* -------------------------------------------------------- */ static char pyexpat_ParserCreate__doc__[] = "([encoding, namespace_separator]) - Return a new XML parser object" ; static PyObject * pyexpat_ParserCreate(PyObject *notused, PyObject *args, PyObject *kw) { char *encoding = NULL, *namespace_separator=NULL; static char *kwlist[] = {"encoding", "namespace_separator", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kw, "|zz", kwlist, &encoding, &namespace_separator)) return NULL; return (PyObject *)newxmlparseobject(encoding, namespace_separator); } static char pyexpat_ErrorString__doc__[] = "(errno) Returns string error for given number" ; static PyObject * pyexpat_ErrorString(self, args) PyObject *self; /* Not used */ PyObject *args; { long code; if (!PyArg_ParseTuple(args, "l", &code)) return NULL; return Py_BuildValue("z", XML_ErrorString((int)code)); } /* List of methods defined in the module */ static struct PyMethodDef pyexpat_methods[] = { {"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 */ }; /* Module docstring */ static char pyexpat_module_documentation[] = "Python wrapper for Expat parser." ; /* Initialization function for the module */ void initpyexpat(){ PyObject *m, *d; char *rev="$Revision$"; PyObject *errors_module, *errors_dict; Xmlparsetype.ob_type = &PyType_Type; /* Create the module and add the functions */ m = Py_InitModule4("pyexpat", pyexpat_methods, pyexpat_module_documentation, (PyObject*)NULL,PYTHON_API_VERSION); /* Add some symbolic constants to the module */ d = PyModule_GetDict(m); ErrorObject = PyString_FromString("pyexpat.error"); PyDict_SetItemString(d, "error", ErrorObject); PyDict_SetItemString(d,"__version__", PyString_FromStringAndSize(rev+11, strlen(rev+11)-2)); errors_module=PyModule_New( "errors" ); PyDict_SetItemString(d,"errors", errors_module ); /* XXX When Expat supports some way of figuring out how it was compiled, this should check and set native_encoding appropriately. */ PyDict_SetItemString(d, "native_encoding", PyString_FromString("UTF-8") ); errors_dict=PyModule_GetDict( errors_module ); #define MYCONST(name) \ PyDict_SetItemString(errors_dict, #name, \ PyString_FromString( XML_ErrorString(name))) MYCONST(XML_ERROR_NO_MEMORY); MYCONST(XML_ERROR_SYNTAX); MYCONST(XML_ERROR_NO_ELEMENTS); MYCONST(XML_ERROR_INVALID_TOKEN); MYCONST(XML_ERROR_UNCLOSED_TOKEN); MYCONST(XML_ERROR_PARTIAL_CHAR); MYCONST(XML_ERROR_TAG_MISMATCH); MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE); MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT); MYCONST(XML_ERROR_PARAM_ENTITY_REF); MYCONST(XML_ERROR_UNDEFINED_ENTITY); MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF); MYCONST(XML_ERROR_ASYNC_ENTITY); MYCONST(XML_ERROR_BAD_CHAR_REF); MYCONST(XML_ERROR_BINARY_ENTITY_REF); MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF); MYCONST(XML_ERROR_MISPLACED_XML_PI); MYCONST(XML_ERROR_UNKNOWN_ENCODING); MYCONST(XML_ERROR_INCORRECT_ENCODING); /* Check for errors */ if (PyErr_Occurred()) Py_FatalError("can't initialize module pyexpat"); } void clear_handlers( xmlparseobject *self ){ int i=0; for( i=0;handler_info[i].name!=NULL;i++ ){ self->handlers[i]=NULL; handler_info[i].setter( self->itself, NULL ); } } typedef void (*pairsetter)( XML_Parser, void *handler1, void *handler2 ); 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[endHandler]!=Py_None ){ start_handler=handler_info[startHandler].handler; } if( self->handlers[EndElement] && self->handlers[EndElement] !=Py_None ){ end_handler=handler_info[endHandler].handler; } setter(self->itself, start_handler, end_handler); } void pyxml_SetStartElementHandler( XML_Parser *parser, void *junk){ pyxml_UpdatePairedHandlers( (xmlparseobject *)XML_GetUserData( parser ), StartElement, EndElement, (pairsetter)XML_SetElementHandler); } void pyxml_SetEndElementHandler( XML_Parser *parser, void *junk){ pyxml_UpdatePairedHandlers( (xmlparseobject *)XML_GetUserData( parser ), StartElement, EndElement, (pairsetter)XML_SetElementHandler); } void pyxml_SetStartNamespaceDeclHandler( XML_Parser *parser, void *junk){ pyxml_UpdatePairedHandlers( (xmlparseobject *)XML_GetUserData( parser ), StartNamespaceDecl, EndNamespaceDecl, (pairsetter)XML_SetNamespaceDeclHandler); } void pyxml_SetEndNamespaceDeclHandler( XML_Parser *parser, void *junk){ pyxml_UpdatePairedHandlers( (xmlparseobject *)XML_GetUserData( parser ), StartNamespaceDecl, EndNamespaceDecl, (pairsetter)XML_SetNamespaceDeclHandler); } void pyxml_SetStartCdataSection( XML_Parser *parser, void *junk){ pyxml_UpdatePairedHandlers( (xmlparseobject *)XML_GetUserData( parser ), StartCdataSection, EndCdataSection, (pairsetter)XML_SetCdataSectionHandler); } void pyxml_SetEndCdataSection( XML_Parser *parser, void *junk){ pyxml_UpdatePairedHandlers( (xmlparseobject *)XML_GetUserData( parser ), StartCdataSection, EndCdataSection, (pairsetter)XML_SetCdataSectionHandler); } statichere struct HandlerInfo handler_info[]= {{"StartElementHandler", pyxml_SetStartElementHandler, my_StartElementHandler}, {"EndElementHandler", pyxml_SetEndElementHandler, my_EndElementHandler}, {"ProcessingInstructionHandler", (xmlhandlersetter)XML_SetProcessingInstructionHandler, my_ProcessingInstructionHandler}, {"CharacterDataHandler", (xmlhandlersetter)XML_SetCharacterDataHandler, my_CharacterDataHandler}, {"UnparsedEntityDeclHandler", (xmlhandlersetter)XML_SetUnparsedEntityDeclHandler, my_UnparsedEntityDeclHandler }, {"NotationDeclHandler", (xmlhandlersetter)XML_SetNotationDeclHandler, my_NotationDeclHandler }, {"StartNamespaceDeclHandler", pyxml_SetStartNamespaceDeclHandler, my_StartNamespaceDeclHandler }, {"EndNamespaceDeclHandler", pyxml_SetEndNamespaceDeclHandler, my_EndNamespaceDeclHandler }, {"CommentHandler", (xmlhandlersetter)XML_SetCommentHandler, my_CommentHandler}, {"StartCdataSectionHandler", pyxml_SetStartCdataSection, my_StartCdataSectionHandler}, {"EndCdataSectionHandler", pyxml_SetEndCdataSection, my_EndCdataSectionHandler}, {"DefaultHandler", (xmlhandlersetter)XML_SetDefaultHandler, my_DefaultHandler}, {"DefaultHandlerExpand", (xmlhandlersetter)XML_SetDefaultHandlerExpand, my_DefaultHandlerExpandHandler}, {"NotStandaloneHandler", (xmlhandlersetter)XML_SetNotStandaloneHandler, my_NotStandaloneHandler}, {"ExternalEntityRefHandler", (xmlhandlersetter)XML_SetExternalEntityRefHandler, my_ExternalEntityRefHandler }, {NULL, NULL, NULL } /* sentinel */ };