1 #include "Python.h"

     2 #include <ctype.h>

     3 

     4 #include "frameobject.h"

     5 #include "expat.h"

     6 

     7 #include "pyexpat.h"

     8 

     9 #define XML_COMBINED_VERSION (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)

    10 

    11 #ifndef PyDoc_STRVAR

    12 

    13 /*

    14  * fdrake says:

    15  * Don't change the PyDoc_STR macro definition to (str), because

    16  * '''the parentheses cause compile failures

    17  * ("non-constant static initializer" or something like that)

    18  * on some platforms (Irix?)'''

    19  */

    20 #define PyDoc_STR(str)         str

    21 #define PyDoc_VAR(name)        static char name[]

    22 #define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)

    23 #endif

    24 

    25 #if (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2)

    26 /* In Python 2.0 and  2.1, disabling Unicode was not possible. */

    27 #define Py_USING_UNICODE

    28 #else

    29 #define FIX_TRACE

    30 #endif

    31 

    32 enum HandlerTypes {

    33     StartElement,

    34     EndElement,

    35     ProcessingInstruction,

    36     CharacterData,

    37     UnparsedEntityDecl,

    38     NotationDecl,

    39     StartNamespaceDecl,

    40     EndNamespaceDecl,

    41     Comment,

    42     StartCdataSection,

    43     EndCdataSection,

    44     Default,

    45     DefaultHandlerExpand,

    46     NotStandalone,

    47     ExternalEntityRef,

    48     StartDoctypeDecl,

    49     EndDoctypeDecl,

    50     EntityDecl,

    51     XmlDecl,

    52     ElementDecl,

    53     AttlistDecl,

    54 #if XML_COMBINED_VERSION >= 19504

    55     SkippedEntity,

    56 #endif

    57     _DummyDecl

    58 };

    59 

    60 static PyObject *ErrorObject;

    61 

    62 /* ----------------------------------------------------- */

    63 

    64 /* Declarations for objects of type xmlparser */

    65 

    66 typedef struct {

    67     PyObject_HEAD

    68 

    69     XML_Parser itself;

    70     int returns_unicode;        /* True if Unicode strings are returned;

    71                                    if false, UTF-8 strings are returned */

    72     int ordered_attributes;     /* Return attributes as a list. */

    73     int specified_attributes;   /* Report only specified attributes. */

    74     int in_callback;            /* Is a callback active? */

    75     int ns_prefixes;            /* Namespace-triplets mode? */

    76     XML_Char *buffer;           /* Buffer used when accumulating characters */

    77                                 /* NULL if not enabled */

    78     int buffer_size;            /* Size of buffer, in XML_Char units */

    79     int buffer_used;            /* Buffer units in use */

    80     PyObject *intern;           /* Dictionary to intern strings */

    81     PyObject **handlers;

    82 } xmlparseobject;

    83 

    84 #define CHARACTER_DATA_BUFFER_SIZE 8192

    85 

    86 static PyTypeObject Xmlparsetype;

    87 

    88 typedef void (*xmlhandlersetter)(XML_Parser self, void *meth);

    89 typedef void* xmlhandler;

    90 

    91 struct HandlerInfo {

    92     const char *name;

    93     xmlhandlersetter setter;

    94     xmlhandler handler;

    95     PyCodeObject *tb_code;

    96     PyObject *nameobj;

    97 };

    98 

    99 static struct HandlerInfo handler_info[64];

   100 

   101 /* Set an integer attribute on the error object; return true on success,

   102  * false on an exception.

   103  */

   104 static int

   105 set_error_attr(PyObject *err, char *name, int value)

   106 {

   107     PyObject *v = PyInt_FromLong(value);

   108 

   109     if (v == NULL || PyObject_SetAttrString(err, name, v) == -1) {

   110         Py_XDECREF(v);

   111         return 0;

   112     }

   113     Py_DECREF(v);

   114     return 1;

   115 }

   116 

   117 /* Build and set an Expat exception, including positioning

   118  * information.  Always returns NULL.

   119  */

   120 static PyObject *

   121 set_error(xmlparseobject *self, enum XML_Error code)

   122 {

   123     PyObject *err;

   124     char buffer[256];

   125     XML_Parser parser = self->itself;

   126     int lineno = XML_GetErrorLineNumber(parser);

   127     int column = XML_GetErrorColumnNumber(parser);

   128 

   129     /* There is no risk of overflowing this buffer, since

   130        even for 64-bit integers, there is sufficient space. */

   131     sprintf(buffer, "%.200s: line %i, column %i",

   132             XML_ErrorString(code), lineno, column);

   133     err = PyObject_CallFunction(ErrorObject, "s", buffer);

   134     if (  err != NULL

   135           && set_error_attr(err, "code", code)

   136           && set_error_attr(err, "offset", column)

   137           && set_error_attr(err, "lineno", lineno)) {

   138         PyErr_SetObject(ErrorObject, err);

   139     }

   140     Py_XDECREF(err);

   141     return NULL;

   142 }

   143 

   144 static int

   145 have_handler(xmlparseobject *self, int type)

   146 {

   147     PyObject *handler = self->handlers[type];

   148     return handler != NULL;

   149 }

   150 

   151 static PyObject *

   152 get_handler_name(struct HandlerInfo *hinfo)

   153 {

   154     PyObject *name = hinfo->nameobj;

   155     if (name == NULL) {

   156         name = PyString_FromString(hinfo->name);

   157         hinfo->nameobj = name;

   158     }

   159     Py_XINCREF(name);

   160     return name;

   161 }

   162 

   163 

   164 #ifdef Py_USING_UNICODE

   165 /* Convert a string of XML_Chars into a Unicode string.

   166    Returns None if str is a null pointer. */

   167 

   168 static PyObject *

   169 conv_string_to_unicode(const XML_Char *str)

   170 {

   171     /* XXX currently this code assumes that XML_Char is 8-bit,

   172        and hence in UTF-8.  */

   173     /* UTF-8 from Expat, Unicode desired */

   174     if (str == NULL) {

   175         Py_INCREF(Py_None);

   176         return Py_None;

   177     }

   178     return PyUnicode_DecodeUTF8(str, strlen(str), "strict");

   179 }

   180 

   181 static PyObject *

   182 conv_string_len_to_unicode(const XML_Char *str, int len)

   183 {

   184     /* XXX currently this code assumes that XML_Char is 8-bit,

   185        and hence in UTF-8.  */

   186     /* UTF-8 from Expat, Unicode desired */

   187     if (str == NULL) {

   188         Py_INCREF(Py_None);

   189         return Py_None;

   190     }

   191     return PyUnicode_DecodeUTF8((const char *)str, len, "strict");

   192 }

   193 #endif

   194 

   195 /* Convert a string of XML_Chars into an 8-bit Python string.

   196    Returns None if str is a null pointer. */

   197 

   198 static PyObject *

   199 conv_string_to_utf8(const XML_Char *str)

   200 {

   201     /* XXX currently this code assumes that XML_Char is 8-bit,

   202        and hence in UTF-8.  */

   203     /* UTF-8 from Expat, UTF-8 desired */

   204     if (str == NULL) {

   205         Py_INCREF(Py_None);

   206         return Py_None;

   207     }

   208     return PyString_FromString(str);

   209 }

   210 

   211 static PyObject *

   212 conv_string_len_to_utf8(const XML_Char *str, int len)

   213 {

   214     /* XXX currently this code assumes that XML_Char is 8-bit,

   215        and hence in UTF-8.  */

   216     /* UTF-8 from Expat, UTF-8 desired */

   217     if (str == NULL) {

   218         Py_INCREF(Py_None);

   219         return Py_None;

   220     }

   221     return PyString_FromStringAndSize((const char *)str, len);

   222 }

   223 

   224 /* Callback routines */

   225 

   226 static void clear_handlers(xmlparseobject *self, int initial);

   227 

   228 /* This handler is used when an error has been detected, in the hope

   229    that actual parsing can be terminated early.  This will only help

   230    if an external entity reference is encountered. */

   231 static int

   232 error_external_entity_ref_handler(XML_Parser parser,

   233                                   const XML_Char *context,

   234                                   const XML_Char *base,

   235                                   const XML_Char *systemId,

   236                                   const XML_Char *publicId)

   237 {

   238     return 0;

   239 }

   240 

   241 /* Dummy character data handler used when an error (exception) has

   242    been detected, and the actual parsing can be terminated early.

   243    This is needed since character data handler can't be safely removed

   244    from within the character data handler, but can be replaced.  It is

   245    used only from the character data handler trampoline, and must be

   246    used right after `flag_error()` is called. */

   247 static void

   248 noop_character_data_handler(void *userData, const XML_Char *data, int len) 

   249 {

   250     /* Do nothing. */

   251 }

   252 

   253 static void

   254 flag_error(xmlparseobject *self)

   255 {

   256     clear_handlers(self, 0);

   257     XML_SetExternalEntityRefHandler(self->itself,

   258                                     error_external_entity_ref_handler);

   259 }

   260 

   261 static PyCodeObject*

   262 getcode(enum HandlerTypes slot, char* func_name, int lineno)

   263 {

   264     PyObject *code = NULL;

   265     PyObject *name = NULL;

   266     PyObject *nulltuple = NULL;

   267     PyObject *filename = NULL;

   268 

   269     if (handler_info[slot].tb_code == NULL) {

   270         code = PyString_FromString("");

   271         if (code == NULL)

   272             goto failed;

   273         name = PyString_FromString(func_name);

   274         if (name == NULL)

   275             goto failed;

   276         nulltuple = PyTuple_New(0);

   277         if (nulltuple == NULL)

   278             goto failed;

   279         filename = PyString_FromString(__FILE__);

   280         handler_info[slot].tb_code =

   281             PyCode_New(0,		/* argcount */

   282                        0,		/* nlocals */

   283                        0,		/* stacksize */

   284                        0,		/* flags */

   285                        code,		/* code */

   286                        nulltuple,	/* consts */

   287                        nulltuple,	/* names */

   288                        nulltuple,	/* varnames */

   289 #if PYTHON_API_VERSION >= 1010

   290                        nulltuple,	/* freevars */

   291                        nulltuple,	/* cellvars */

   292 #endif

   293                        filename,	/* filename */

   294                        name,		/* name */

   295                        lineno,		/* firstlineno */

   296                        code		/* lnotab */

   297                        );

   298         if (handler_info[slot].tb_code == NULL)

   299             goto failed;

   300         Py_DECREF(code);

   301         Py_DECREF(nulltuple);

   302         Py_DECREF(filename);

   303         Py_DECREF(name);

   304     }

   305     return handler_info[slot].tb_code;

   306  failed:

   307     Py_XDECREF(code);

   308     Py_XDECREF(name);

   309     return NULL;

   310 }

   311 

   312 #ifdef FIX_TRACE

   313 static int

   314 trace_frame(PyThreadState *tstate, PyFrameObject *f, int code, PyObject *val)

   315 {

   316     int result = 0;

   317     if (!tstate->use_tracing || tstate->tracing)

   318 	return 0;

   319     if (tstate->c_profilefunc != NULL) {

   320 	tstate->tracing++;

   321 	result = tstate->c_profilefunc(tstate->c_profileobj,

   322 				       f, code , val);

   323 	tstate->use_tracing = ((tstate->c_tracefunc != NULL)

   324 			       || (tstate->c_profilefunc != NULL));

   325 	tstate->tracing--;

   326 	if (result)

   327 	    return result;

   328     }

   329     if (tstate->c_tracefunc != NULL) {

   330 	tstate->tracing++;

   331 	result = tstate->c_tracefunc(tstate->c_traceobj,

   332 				     f, code , val);

   333 	tstate->use_tracing = ((tstate->c_tracefunc != NULL)

   334 			       || (tstate->c_profilefunc != NULL));

   335 	tstate->tracing--;

   336     }	

   337     return result;

   338 }

   339 

   340 static int

   341 trace_frame_exc(PyThreadState *tstate, PyFrameObject *f)

   342 {

   343     PyObject *type, *value, *traceback, *arg;

   344     int err;

   345 

   346     if (tstate->c_tracefunc == NULL)

   347 	return 0;

   348 

   349     PyErr_Fetch(&type, &value, &traceback);

   350     if (value == NULL) {

   351 	value = Py_None;

   352 	Py_INCREF(value);

   353     }

   354 #if PY_VERSION_HEX < 0x02040000

   355     arg = Py_BuildValue("(OOO)", type, value, traceback);

   356 #else

   357     arg = PyTuple_Pack(3, type, value, traceback);

   358 #endif

   359     if (arg == NULL) {

   360 	PyErr_Restore(type, value, traceback);

   361 	return 0;

   362     }

   363     err = trace_frame(tstate, f, PyTrace_EXCEPTION, arg);

   364     Py_DECREF(arg);

   365     if (err == 0)

   366 	PyErr_Restore(type, value, traceback);

   367     else {

   368 	Py_XDECREF(type);

   369 	Py_XDECREF(value);

   370 	Py_XDECREF(traceback);

   371     }

   372     return err;

   373 }

   374 #endif

   375 

   376 static PyObject*

   377 call_with_frame(PyCodeObject *c, PyObject* func, PyObject* args,

   378                 xmlparseobject *self)

   379 {

   380     PyThreadState *tstate = PyThreadState_GET();

   381     PyFrameObject *f;

   382     PyObject *res;

   383 

   384     if (c == NULL)

   385         return NULL;

   386     

   387     f = PyFrame_New(tstate, c, PyEval_GetGlobals(), NULL);

   388     if (f == NULL)

   389         return NULL;

   390     tstate->frame = f;

   391 #ifdef FIX_TRACE

   392     if (trace_frame(tstate, f, PyTrace_CALL, Py_None) < 0) {

   393 	return NULL;

   394     }

   395 #endif

   396     res = PyEval_CallObject(func, args);

   397     if (res == NULL) {

   398 	if (tstate->curexc_traceback == NULL)

   399 	    PyTraceBack_Here(f);

   400         XML_StopParser(self->itself, XML_FALSE);

   401 #ifdef FIX_TRACE

   402 	if (trace_frame_exc(tstate, f) < 0) {

   403 	    return NULL;

   404 	}

   405     }

   406     else {

   407 	if (trace_frame(tstate, f, PyTrace_RETURN, res) < 0) {

   408 	    Py_XDECREF(res);

   409 	    res = NULL;

   410 	}

   411     }

   412 #else

   413     }

   414 #endif

   415     tstate->frame = f->f_back;

   416     Py_DECREF(f);

   417     return res;

   418 }

   419 

   420 #ifndef Py_USING_UNICODE

   421 #define STRING_CONV_FUNC conv_string_to_utf8

   422 #else

   423 /* Python 2.0 and later versions, when built with Unicode support */

   424 #define STRING_CONV_FUNC (self->returns_unicode \

   425                           ? conv_string_to_unicode : conv_string_to_utf8)

   426 #endif

   427 

   428 static PyObject*

   429 string_intern(xmlparseobject *self, const char* str)

   430 {

   431     PyObject *result = STRING_CONV_FUNC(str);

   432     PyObject *value;

   433     /* result can be NULL if the unicode conversion failed. */

   434     if (!result)

   435 	return result;

   436     if (!self->intern)

   437 	return result;

   438     value = PyDict_GetItem(self->intern, result);

   439     if (!value) {

   440 	if (PyDict_SetItem(self->intern, result, result) == 0)

   441             return result;

   442         else

   443             return NULL;

   444     }

   445     Py_INCREF(value);

   446     Py_DECREF(result);

   447     return value;

   448 }

   449 

   450 /* Return 0 on success, -1 on exception.

   451  * flag_error() will be called before return if needed.

   452  */

   453 static int

   454 call_character_handler(xmlparseobject *self, const XML_Char *buffer, int len)

   455 {

   456     PyObject *args;

   457     PyObject *temp;

   458 

   459     args = PyTuple_New(1);

   460     if (args == NULL)

   461         return -1;

   462 #ifdef Py_USING_UNICODE

   463     temp = (self->returns_unicode 

   464             ? conv_string_len_to_unicode(buffer, len) 

   465             : conv_string_len_to_utf8(buffer, len));

   466 #else

   467     temp = conv_string_len_to_utf8(buffer, len);

   468 #endif

   469     if (temp == NULL) {

   470         Py_DECREF(args);

   471         flag_error(self);

   472         XML_SetCharacterDataHandler(self->itself,

   473                                     noop_character_data_handler);

   474         return -1;

   475     }

   476     PyTuple_SET_ITEM(args, 0, temp);

   477     /* temp is now a borrowed reference; consider it unused. */

   478     self->in_callback = 1;

   479     temp = call_with_frame(getcode(CharacterData, "CharacterData", __LINE__),

   480                            self->handlers[CharacterData], args, self);

   481     /* temp is an owned reference again, or NULL */

   482     self->in_callback = 0;

   483     Py_DECREF(args);

   484     if (temp == NULL) {

   485         flag_error(self);

   486         XML_SetCharacterDataHandler(self->itself,

   487                                     noop_character_data_handler);

   488         return -1;

   489     }

   490     Py_DECREF(temp);

   491     return 0;

   492 }

   493 

   494 static int

   495 flush_character_buffer(xmlparseobject *self)

   496 {

   497     int rc;

   498     if (self->buffer == NULL || self->buffer_used == 0)

   499         return 0;

   500     rc = call_character_handler(self, self->buffer, self->buffer_used);

   501     self->buffer_used = 0;

   502     return rc;

   503 }

   504 

   505 static void

   506 my_CharacterDataHandler(void *userData, const XML_Char *data, int len) 

   507 {

   508     xmlparseobject *self = (xmlparseobject *) userData;

   509     if (self->buffer == NULL)

   510         call_character_handler(self, data, len);

   511     else {

   512         if ((self->buffer_used + len) > self->buffer_size) {

   513             if (flush_character_buffer(self) < 0)

   514                 return;

   515             /* handler might have changed; drop the rest on the floor

   516              * if there isn't a handler anymore

   517              */

   518             if (!have_handler(self, CharacterData))

   519                 return;

   520         }

   521         if (len > self->buffer_size) {

   522             call_character_handler(self, data, len);

   523             self->buffer_used = 0;

   524         }

   525         else {

   526             memcpy(self->buffer + self->buffer_used,

   527                    data, len * sizeof(XML_Char));

   528             self->buffer_used += len;

   529         }

   530     }

   531 }

   532 

   533 static void

   534 my_StartElementHandler(void *userData,

   535                        const XML_Char *name, const XML_Char *atts[])

   536 {

   537     xmlparseobject *self = (xmlparseobject *)userData;

   538 

   539     if (have_handler(self, StartElement)) {

   540         PyObject *container, *rv, *args;

   541         int i, max;

   542 

   543         if (flush_character_buffer(self) < 0)

   544             return;

   545         /* Set max to the number of slots filled in atts[]; max/2 is

   546          * the number of attributes we need to process.

   547          */

   548         if (self->specified_attributes) {

   549             max = XML_GetSpecifiedAttributeCount(self->itself);

   550         }

   551         else {

   552             max = 0;

   553             while (atts[max] != NULL)

   554                 max += 2;

   555         }

   556         /* Build the container. */

   557         if (self->ordered_attributes)

   558             container = PyList_New(max);

   559         else

   560             container = PyDict_New();

   561         if (container == NULL) {

   562             flag_error(self);

   563             return;

   564         }

   565         for (i = 0; i < max; i += 2) {

   566             PyObject *n = string_intern(self, (XML_Char *) atts[i]);

   567             PyObject *v;

   568             if (n == NULL) {

   569                 flag_error(self);

   570                 Py_DECREF(container);

   571                 return;

   572             }

   573             v = STRING_CONV_FUNC((XML_Char *) atts[i+1]);

   574             if (v == NULL) {

   575                 flag_error(self);

   576                 Py_DECREF(container);

   577                 Py_DECREF(n);

   578                 return;

   579             }

   580             if (self->ordered_attributes) {

   581                 PyList_SET_ITEM(container, i, n);

   582                 PyList_SET_ITEM(container, i+1, v);

   583             }

   584             else if (PyDict_SetItem(container, n, v)) {

   585                 flag_error(self);

   586                 Py_DECREF(n);

   587                 Py_DECREF(v);

   588                 return;

   589             }

   590             else {

   591                 Py_DECREF(n);

   592                 Py_DECREF(v);

   593             }

   594         }

   595         args = string_intern(self, name);

   596         if (args != NULL)

   597             args = Py_BuildValue("(NN)", args, container);

   598         if (args == NULL) {

   599             Py_DECREF(container);

   600             return;

   601         }

   602         /* Container is now a borrowed reference; ignore it. */

   603         self->in_callback = 1;

   604         rv = call_with_frame(getcode(StartElement, "StartElement", __LINE__),

   605                              self->handlers[StartElement], args, self);

   606         self->in_callback = 0;

   607         Py_DECREF(args);

   608         if (rv == NULL) {

   609             flag_error(self);

   610             return;

   611         }

   612         Py_DECREF(rv);

   613     }

   614 }

   615 

   616 #define RC_HANDLER(RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, \

   617                 RETURN, GETUSERDATA) \

   618 static RC \

   619 my_##NAME##Handler PARAMS {\

   620     xmlparseobject *self = GETUSERDATA ; \

   621     PyObject *args = NULL; \

   622     PyObject *rv = NULL; \

   623     INIT \

   624 \

   625     if (have_handler(self, NAME)) { \

   626         if (flush_character_buffer(self) < 0) \

   627             return RETURN; \

   628         args = Py_BuildValue PARAM_FORMAT ;\

   629         if (!args) { flag_error(self); return RETURN;} \

   630         self->in_callback = 1; \

   631         rv = call_with_frame(getcode(NAME,#NAME,__LINE__), \

   632                              self->handlers[NAME], args, self); \

   633         self->in_callback = 0; \

   634         Py_DECREF(args); \

   635         if (rv == NULL) { \

   636             flag_error(self); \

   637             return RETURN; \

   638         } \

   639         CONVERSION \

   640         Py_DECREF(rv); \

   641     } \

   642     return RETURN; \

   643 }

   644 

   645 #define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \

   646 	RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\

   647 	(xmlparseobject *)userData)

   648 

   649 #define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\

   650 	RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \

   651 			rc = PyInt_AsLong(rv);, rc, \

   652 	(xmlparseobject *)userData)

   653 

   654 VOID_HANDLER(EndElement,

   655              (void *userData, const XML_Char *name),

   656              ("(N)", string_intern(self, name)))

   657 

   658 VOID_HANDLER(ProcessingInstruction,

   659              (void *userData,

   660               const XML_Char *target,

   661               const XML_Char *data),

   662              ("(NO&)", string_intern(self, target), STRING_CONV_FUNC,data))

   663 

   664 VOID_HANDLER(UnparsedEntityDecl,

   665              (void *userData,

   666               const XML_Char *entityName,

   667               const XML_Char *base,

   668               const XML_Char *systemId,

   669               const XML_Char *publicId,

   670               const XML_Char *notationName),

   671              ("(NNNNN)",

   672               string_intern(self, entityName), string_intern(self, base),

   673               string_intern(self, systemId), string_intern(self, publicId),

   674               string_intern(self, notationName)))

   675 

   676 #ifndef Py_USING_UNICODE

   677 VOID_HANDLER(EntityDecl,

   678              (void *userData,

   679               const XML_Char *entityName,

   680               int is_parameter_entity,

   681               const XML_Char *value,

   682               int value_length,

   683               const XML_Char *base,

   684               const XML_Char *systemId,

   685               const XML_Char *publicId,

   686               const XML_Char *notationName),

   687              ("NiNNNNN",

   688               string_intern(self, entityName), is_parameter_entity,

   689               conv_string_len_to_utf8(value, value_length),

   690               string_intern(self, base), string_intern(self, systemId),

   691               string_intern(self, publicId),

   692               string_intern(self, notationName)))

   693 #else

   694 VOID_HANDLER(EntityDecl,

   695              (void *userData,

   696               const XML_Char *entityName,

   697               int is_parameter_entity,

   698               const XML_Char *value,

   699               int value_length,

   700               const XML_Char *base,

   701               const XML_Char *systemId,

   702               const XML_Char *publicId,

   703               const XML_Char *notationName),

   704              ("NiNNNNN",

   705               string_intern(self, entityName), is_parameter_entity,

   706               (self->returns_unicode

   707                ? conv_string_len_to_unicode(value, value_length)

   708                : conv_string_len_to_utf8(value, value_length)),

   709               string_intern(self, base), string_intern(self, systemId),

   710               string_intern(self, publicId),

   711               string_intern(self, notationName)))

   712 #endif

   713 

   714 VOID_HANDLER(XmlDecl,

   715              (void *userData,

   716               const XML_Char *version,

   717               const XML_Char *encoding,

   718               int standalone),

   719              ("(O&O&i)",

   720               STRING_CONV_FUNC,version, STRING_CONV_FUNC,encoding,

   721               standalone))

   722 

   723 static PyObject *

   724 conv_content_model(XML_Content * const model,

   725                    PyObject *(*conv_string)(const XML_Char *))

   726 {

   727     PyObject *result = NULL;

   728     PyObject *children = PyTuple_New(model->numchildren);

   729     int i;

   730 

   731     if (children != NULL) {

   732         assert(model->numchildren < INT_MAX);

   733         for (i = 0; i < (int)model->numchildren; ++i) {

   734             PyObject *child = conv_content_model(&model->children[i],

   735                                                  conv_string);

   736             if (child == NULL) {

   737                 Py_XDECREF(children);

   738                 return NULL;

   739             }

   740             PyTuple_SET_ITEM(children, i, child);

   741         }

   742         result = Py_BuildValue("(iiO&N)",

   743                                model->type, model->quant,

   744                                conv_string,model->name, children);

   745     }

   746     return result;

   747 }

   748 

   749 static void

   750 my_ElementDeclHandler(void *userData,

   751                       const XML_Char *name,

   752                       XML_Content *model)

   753 {

   754     xmlparseobject *self = (xmlparseobject *)userData;

   755     PyObject *args = NULL;

   756 

   757     if (have_handler(self, ElementDecl)) {

   758         PyObject *rv = NULL;

   759         PyObject *modelobj, *nameobj;

   760 

   761         if (flush_character_buffer(self) < 0)

   762             goto finally;

   763 #ifdef Py_USING_UNICODE

   764         modelobj = conv_content_model(model,

   765                                       (self->returns_unicode

   766                                        ? conv_string_to_unicode

   767                                        : conv_string_to_utf8));

   768 #else

   769         modelobj = conv_content_model(model, conv_string_to_utf8);

   770 #endif

   771         if (modelobj == NULL) {

   772             flag_error(self);

   773             goto finally;

   774         }

   775         nameobj = string_intern(self, name);

   776         if (nameobj == NULL) {

   777             Py_DECREF(modelobj);

   778             flag_error(self);

   779             goto finally;

   780         }

   781         args = Py_BuildValue("NN", nameobj, modelobj);

   782         if (args == NULL) {

   783             Py_DECREF(modelobj);

   784             flag_error(self);

   785             goto finally;

   786         }

   787         self->in_callback = 1;

   788         rv = call_with_frame(getcode(ElementDecl, "ElementDecl", __LINE__),

   789                              self->handlers[ElementDecl], args, self);

   790         self->in_callback = 0;

   791         if (rv == NULL) {

   792             flag_error(self);

   793             goto finally;

   794         }

   795         Py_DECREF(rv);

   796     }

   797  finally:

   798     Py_XDECREF(args);

   799     XML_FreeContentModel(self->itself, model);

   800     return;

   801 }

   802 

   803 VOID_HANDLER(AttlistDecl,

   804              (void *userData,

   805               const XML_Char *elname,

   806               const XML_Char *attname,

   807               const XML_Char *att_type,

   808               const XML_Char *dflt,

   809               int isrequired),

   810              ("(NNO&O&i)",

   811               string_intern(self, elname), string_intern(self, attname),

   812               STRING_CONV_FUNC,att_type, STRING_CONV_FUNC,dflt,

   813               isrequired))

   814 

   815 #if XML_COMBINED_VERSION >= 19504

   816 VOID_HANDLER(SkippedEntity,

   817              (void *userData,

   818               const XML_Char *entityName,

   819               int is_parameter_entity),

   820              ("Ni",

   821               string_intern(self, entityName), is_parameter_entity))

   822 #endif

   823 

   824 VOID_HANDLER(NotationDecl,

   825 		(void *userData,

   826 			const XML_Char *notationName,

   827 			const XML_Char *base,

   828 			const XML_Char *systemId,

   829 			const XML_Char *publicId),

   830                 ("(NNNN)",

   831 		 string_intern(self, notationName), string_intern(self, base),

   832 		 string_intern(self, systemId), string_intern(self, publicId)))

   833 

   834 VOID_HANDLER(StartNamespaceDecl,

   835 		(void *userData,

   836 		      const XML_Char *prefix,

   837 		      const XML_Char *uri),

   838                 ("(NN)",

   839                  string_intern(self, prefix), string_intern(self, uri)))

   840 

   841 VOID_HANDLER(EndNamespaceDecl,

   842 		(void *userData,

   843 		    const XML_Char *prefix),

   844                 ("(N)", string_intern(self, prefix)))

   845 

   846 VOID_HANDLER(Comment,

   847                (void *userData, const XML_Char *data),

   848                 ("(O&)", STRING_CONV_FUNC,data))

   849 

   850 VOID_HANDLER(StartCdataSection,

   851                (void *userData),

   852 		("()"))

   853 

   854 VOID_HANDLER(EndCdataSection,

   855                (void *userData),

   856 		("()"))

   857 

   858 #ifndef Py_USING_UNICODE

   859 VOID_HANDLER(Default,

   860 	      (void *userData, const XML_Char *s, int len),

   861 	      ("(N)", conv_string_len_to_utf8(s,len)))

   862 

   863 VOID_HANDLER(DefaultHandlerExpand,

   864 	      (void *userData, const XML_Char *s, int len),

   865 	      ("(N)", conv_string_len_to_utf8(s,len)))

   866 #else

   867 VOID_HANDLER(Default,

   868 	      (void *userData, const XML_Char *s, int len),

   869 	      ("(N)", (self->returns_unicode

   870 		       ? conv_string_len_to_unicode(s,len)

   871 		       : conv_string_len_to_utf8(s,len))))

   872 

   873 VOID_HANDLER(DefaultHandlerExpand,

   874 	      (void *userData, const XML_Char *s, int len),

   875 	      ("(N)", (self->returns_unicode

   876 		       ? conv_string_len_to_unicode(s,len)

   877 		       : conv_string_len_to_utf8(s,len))))

   878 #endif

   879 

   880 INT_HANDLER(NotStandalone,

   881 		(void *userData),

   882 		("()"))

   883 

   884 RC_HANDLER(int, ExternalEntityRef,

   885 		(XML_Parser parser,

   886 		    const XML_Char *context,

   887 		    const XML_Char *base,

   888 		    const XML_Char *systemId,

   889 		    const XML_Char *publicId),

   890 		int rc=0;,

   891                 ("(O&NNN)",

   892 		 STRING_CONV_FUNC,context, string_intern(self, base),

   893 		 string_intern(self, systemId), string_intern(self, publicId)),

   894 		rc = PyInt_AsLong(rv);, rc,

   895 		XML_GetUserData(parser))

   896 

   897 /* XXX UnknownEncodingHandler */

   898 

   899 VOID_HANDLER(StartDoctypeDecl,

   900              (void *userData, const XML_Char *doctypeName,

   901               const XML_Char *sysid, const XML_Char *pubid,

   902               int has_internal_subset),

   903              ("(NNNi)", string_intern(self, doctypeName),

   904               string_intern(self, sysid), string_intern(self, pubid),

   905               has_internal_subset))

   906 

   907 VOID_HANDLER(EndDoctypeDecl, (void *userData), ("()"))

   908 

   909 /* ---------------------------------------------------------------- */

   910 

   911 static PyObject *

   912 get_parse_result(xmlparseobject *self, int rv)

   913 {

   914     if (PyErr_Occurred()) {

   915         return NULL;

   916     }

   917     if (rv == 0) {

   918         return set_error(self, XML_GetErrorCode(self->itself));

   919     }

   920     if (flush_character_buffer(self) < 0) {

   921         return NULL;

   922     }

   923     return PyInt_FromLong(rv);

   924 }

   925 

   926 PyDoc_STRVAR(xmlparse_Parse__doc__,

   927 "Parse(data[, isfinal])\n\

   928 Parse XML data.  `isfinal' should be true at end of input.");

   929 

   930 static PyObject *

   931 xmlparse_Parse(xmlparseobject *self, PyObject *args)

   932 {

   933     char *s;

   934     int slen;

   935     int isFinal = 0;

   936 

   937     if (!PyArg_ParseTuple(args, "s#|i:Parse", &s, &slen, &isFinal))

   938         return NULL;

   939 

   940     return get_parse_result(self, XML_Parse(self->itself, s, slen, isFinal));

   941 }

   942 

   943 /* File reading copied from cPickle */

   944 

   945 #define BUF_SIZE 2048

   946 

   947 static int

   948 readinst(char *buf, int buf_size, PyObject *meth)

   949 {

   950     PyObject *arg = NULL;

   951     PyObject *bytes = NULL;

   952     PyObject *str = NULL;

   953     int len = -1;

   954 

   955     if ((bytes = PyInt_FromLong(buf_size)) == NULL)

   956         goto finally;

   957 

   958     if ((arg = PyTuple_New(1)) == NULL) {

   959         Py_DECREF(bytes);

   960         goto finally;

   961     }

   962 

   963     PyTuple_SET_ITEM(arg, 0, bytes);

   964 

   965 #if PY_VERSION_HEX < 0x02020000

   966     str = PyObject_CallObject(meth, arg);

   967 #else

   968     str = PyObject_Call(meth, arg, NULL);

   969 #endif

   970     if (str == NULL)

   971         goto finally;

   972 

   973     /* XXX what to do if it returns a Unicode string? */

   974     if (!PyString_Check(str)) {

   975         PyErr_Format(PyExc_TypeError,

   976                      "read() did not return a string object (type=%.400s)",

   977                      Py_TYPE(str)->tp_name);

   978         goto finally;

   979     }

   980     len = PyString_GET_SIZE(str);

   981     if (len > buf_size) {

   982         PyErr_Format(PyExc_ValueError,

   983                      "read() returned too much data: "

   984                      "%i bytes requested, %i returned",

   985                      buf_size, len);

   986         goto finally;

   987     }

   988     memcpy(buf, PyString_AsString(str), len);

   989 finally:

   990     Py_XDECREF(arg);

   991     Py_XDECREF(str);

   992     return len;

   993 }

   994 

   995 PyDoc_STRVAR(xmlparse_ParseFile__doc__,

   996 "ParseFile(file)\n\

   997 Parse XML data from file-like object.");

   998 

   999 static PyObject *

  1000 xmlparse_ParseFile(xmlparseobject *self, PyObject *f)

  1001 {

  1002     int rv = 1;

  1003     FILE *fp;

  1004     PyObject *readmethod = NULL;

  1005 

  1006     if (PyFile_Check(f)) {

  1007         fp = PyFile_AsFile(f);

  1008     }

  1009     else {

  1010         fp = NULL;

  1011         readmethod = PyObject_GetAttrString(f, "read");

  1012         if (readmethod == NULL) {

  1013             PyErr_Clear();

  1014             PyErr_SetString(PyExc_TypeError,

  1015                             "argument must have 'read' attribute");

  1016             return NULL;

  1017         }

  1018     }

  1019     for (;;) {

  1020         int bytes_read;

  1021         void *buf = XML_GetBuffer(self->itself, BUF_SIZE);

  1022         if (buf == NULL) {

  1023             Py_XDECREF(readmethod);

  1024             return PyErr_NoMemory();

  1025         }

  1026 

  1027         if (fp) {

  1028             bytes_read = fread(buf, sizeof(char), BUF_SIZE, fp);

  1029             if (bytes_read < 0) {

  1030                 PyErr_SetFromErrno(PyExc_IOError);

  1031                 return NULL;

  1032             }

  1033         }

  1034         else {

  1035             bytes_read = readinst(buf, BUF_SIZE, readmethod);

  1036             if (bytes_read < 0) {

  1037                 Py_DECREF(readmethod);

  1038                 return NULL;

  1039             }

  1040         }

  1041         rv = XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);

  1042         if (PyErr_Occurred()) {

  1043             Py_XDECREF(readmethod);

  1044             return NULL;

  1045         }

  1046 

  1047         if (!rv || bytes_read == 0)

  1048             break;

  1049     }

  1050     Py_XDECREF(readmethod);

  1051     return get_parse_result(self, rv);

  1052 }

  1053 

  1054 PyDoc_STRVAR(xmlparse_SetBase__doc__,

  1055 "SetBase(base_url)\n\

  1056 Set the base URL for the parser.");

  1057 

  1058 static PyObject *

  1059 xmlparse_SetBase(xmlparseobject *self, PyObject *args)

  1060 {

  1061     char *base;

  1062 

  1063     if (!PyArg_ParseTuple(args, "s:SetBase", &base))

  1064         return NULL;

  1065     if (!XML_SetBase(self->itself, base)) {

  1066 	return PyErr_NoMemory();

  1067     }

  1068     Py_INCREF(Py_None);

  1069     return Py_None;

  1070 }

  1071 

  1072 PyDoc_STRVAR(xmlparse_GetBase__doc__,

  1073 "GetBase() -> url\n\

  1074 Return base URL string for the parser.");

  1075 

  1076 static PyObject *

  1077 xmlparse_GetBase(xmlparseobject *self, PyObject *unused)

  1078 {

  1079     return Py_BuildValue("z", XML_GetBase(self->itself));

  1080 }

  1081 

  1082 PyDoc_STRVAR(xmlparse_GetInputContext__doc__,

  1083 "GetInputContext() -> string\n\

  1084 Return the untranslated text of the input that caused the current event.\n\

  1085 If the event was generated by a large amount of text (such as a start tag\n\

  1086 for an element with many attributes), not all of the text may be available.");

  1087 

  1088 static PyObject *

  1089 xmlparse_GetInputContext(xmlparseobject *self, PyObject *unused)

  1090 {

  1091     if (self->in_callback) {

  1092         int offset, size;

  1093         const char *buffer

  1094             = XML_GetInputContext(self->itself, &offset, &size);

  1095 

  1096         if (buffer != NULL)

  1097             return PyString_FromStringAndSize(buffer + offset,

  1098                                               size - offset);

  1099         else

  1100             Py_RETURN_NONE;

  1101     }

  1102     else

  1103         Py_RETURN_NONE;

  1104 }

  1105 

  1106 PyDoc_STRVAR(xmlparse_ExternalEntityParserCreate__doc__,

  1107 "ExternalEntityParserCreate(context[, encoding])\n\

  1108 Create a parser for parsing an external entity based on the\n\

  1109 information passed to the ExternalEntityRefHandler.");

  1110 

  1111 static PyObject *

  1112 xmlparse_ExternalEntityParserCreate(xmlparseobject *self, PyObject *args)

  1113 {

  1114     char *context;

  1115     char *encoding = NULL;

  1116     xmlparseobject *new_parser;

  1117     int i;

  1118 

  1119     if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate",

  1120                           &context, &encoding)) {

  1121         return NULL;

  1122     }

  1123 

  1124 #ifndef Py_TPFLAGS_HAVE_GC

  1125     /* Python versions 2.0 and 2.1 */

  1126     new_parser = PyObject_New(xmlparseobject, &Xmlparsetype);

  1127 #else

  1128     /* Python versions 2.2 and later */

  1129     new_parser = PyObject_GC_New(xmlparseobject, &Xmlparsetype);

  1130 #endif

  1131 

  1132     if (new_parser == NULL)

  1133         return NULL;

  1134     new_parser->buffer_size = self->buffer_size;

  1135     new_parser->buffer_used = 0;