+++ /dev/null
-#include "Python.h"\r
-#include <ctype.h>\r
-\r
-#include "frameobject.h"\r
-#include "expat.h"\r
-\r
-#include "pyexpat.h"\r
-\r
-#define XML_COMBINED_VERSION (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)\r
-\r
-#ifndef PyDoc_STRVAR\r
-\r
-/*\r
- * fdrake says:\r
- * Don't change the PyDoc_STR macro definition to (str), because\r
- * '''the parentheses cause compile failures\r
- * ("non-constant static initializer" or something like that)\r
- * on some platforms (Irix?)'''\r
- */\r
-#define PyDoc_STR(str) str\r
-#define PyDoc_VAR(name) static char name[]\r
-#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)\r
-#endif\r
-\r
-#if (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2)\r
-/* In Python 2.0 and 2.1, disabling Unicode was not possible. */\r
-#define Py_USING_UNICODE\r
-#else\r
-#define FIX_TRACE\r
-#endif\r
-\r
-enum HandlerTypes {\r
- StartElement,\r
- EndElement,\r
- ProcessingInstruction,\r
- CharacterData,\r
- UnparsedEntityDecl,\r
- NotationDecl,\r
- StartNamespaceDecl,\r
- EndNamespaceDecl,\r
- Comment,\r
- StartCdataSection,\r
- EndCdataSection,\r
- Default,\r
- DefaultHandlerExpand,\r
- NotStandalone,\r
- ExternalEntityRef,\r
- StartDoctypeDecl,\r
- EndDoctypeDecl,\r
- EntityDecl,\r
- XmlDecl,\r
- ElementDecl,\r
- AttlistDecl,\r
-#if XML_COMBINED_VERSION >= 19504\r
- SkippedEntity,\r
-#endif\r
- _DummyDecl\r
-};\r
-\r
-static PyObject *ErrorObject;\r
-\r
-/* ----------------------------------------------------- */\r
-\r
-/* Declarations for objects of type xmlparser */\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
-\r
- XML_Parser itself;\r
- int returns_unicode; /* True if Unicode strings are returned;\r
- if false, UTF-8 strings are returned */\r
- int ordered_attributes; /* Return attributes as a list. */\r
- int specified_attributes; /* Report only specified attributes. */\r
- int in_callback; /* Is a callback active? */\r
- int ns_prefixes; /* Namespace-triplets mode? */\r
- XML_Char *buffer; /* Buffer used when accumulating characters */\r
- /* NULL if not enabled */\r
- int buffer_size; /* Size of buffer, in XML_Char units */\r
- int buffer_used; /* Buffer units in use */\r
- PyObject *intern; /* Dictionary to intern strings */\r
- PyObject **handlers;\r
-} xmlparseobject;\r
-\r
-#define CHARACTER_DATA_BUFFER_SIZE 8192\r
-\r
-static PyTypeObject Xmlparsetype;\r
-\r
-typedef void (*xmlhandlersetter)(XML_Parser self, void *meth);\r
-typedef void* xmlhandler;\r
-\r
-struct HandlerInfo {\r
- const char *name;\r
- xmlhandlersetter setter;\r
- xmlhandler handler;\r
- PyCodeObject *tb_code;\r
- PyObject *nameobj;\r
-};\r
-\r
-static struct HandlerInfo handler_info[64];\r
-\r
-/* Set an integer attribute on the error object; return true on success,\r
- * false on an exception.\r
- */\r
-static int\r
-set_error_attr(PyObject *err, char *name, int value)\r
-{\r
- PyObject *v = PyInt_FromLong(value);\r
-\r
- if (v == NULL || PyObject_SetAttrString(err, name, v) == -1) {\r
- Py_XDECREF(v);\r
- return 0;\r
- }\r
- Py_DECREF(v);\r
- return 1;\r
-}\r
-\r
-/* Build and set an Expat exception, including positioning\r
- * information. Always returns NULL.\r
- */\r
-static PyObject *\r
-set_error(xmlparseobject *self, enum XML_Error code)\r
-{\r
- PyObject *err;\r
- char buffer[256];\r
- XML_Parser parser = self->itself;\r
- int lineno = XML_GetErrorLineNumber(parser);\r
- int column = XML_GetErrorColumnNumber(parser);\r
-\r
- /* There is no risk of overflowing this buffer, since\r
- even for 64-bit integers, there is sufficient space. */\r
- sprintf(buffer, "%.200s: line %i, column %i",\r
- XML_ErrorString(code), lineno, column);\r
- err = PyObject_CallFunction(ErrorObject, "s", buffer);\r
- if ( err != NULL\r
- && set_error_attr(err, "code", code)\r
- && set_error_attr(err, "offset", column)\r
- && set_error_attr(err, "lineno", lineno)) {\r
- PyErr_SetObject(ErrorObject, err);\r
- }\r
- Py_XDECREF(err);\r
- return NULL;\r
-}\r
-\r
-static int\r
-have_handler(xmlparseobject *self, int type)\r
-{\r
- PyObject *handler = self->handlers[type];\r
- return handler != NULL;\r
-}\r
-\r
-static PyObject *\r
-get_handler_name(struct HandlerInfo *hinfo)\r
-{\r
- PyObject *name = hinfo->nameobj;\r
- if (name == NULL) {\r
- name = PyString_FromString(hinfo->name);\r
- hinfo->nameobj = name;\r
- }\r
- Py_XINCREF(name);\r
- return name;\r
-}\r
-\r
-\r
-#ifdef Py_USING_UNICODE\r
-/* Convert a string of XML_Chars into a Unicode string.\r
- Returns None if str is a null pointer. */\r
-\r
-static PyObject *\r
-conv_string_to_unicode(const XML_Char *str)\r
-{\r
- /* XXX currently this code assumes that XML_Char is 8-bit,\r
- and hence in UTF-8. */\r
- /* UTF-8 from Expat, Unicode desired */\r
- if (str == NULL) {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- return PyUnicode_DecodeUTF8(str, strlen(str), "strict");\r
-}\r
-\r
-static PyObject *\r
-conv_string_len_to_unicode(const XML_Char *str, int len)\r
-{\r
- /* XXX currently this code assumes that XML_Char is 8-bit,\r
- and hence in UTF-8. */\r
- /* UTF-8 from Expat, Unicode desired */\r
- if (str == NULL) {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- return PyUnicode_DecodeUTF8((const char *)str, len, "strict");\r
-}\r
-#endif\r
-\r
-/* Convert a string of XML_Chars into an 8-bit Python string.\r
- Returns None if str is a null pointer. */\r
-\r
-static PyObject *\r
-conv_string_to_utf8(const XML_Char *str)\r
-{\r
- /* XXX currently this code assumes that XML_Char is 8-bit,\r
- and hence in UTF-8. */\r
- /* UTF-8 from Expat, UTF-8 desired */\r
- if (str == NULL) {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- return PyString_FromString(str);\r
-}\r
-\r
-static PyObject *\r
-conv_string_len_to_utf8(const XML_Char *str, int len)\r
-{\r
- /* XXX currently this code assumes that XML_Char is 8-bit,\r
- and hence in UTF-8. */\r
- /* UTF-8 from Expat, UTF-8 desired */\r
- if (str == NULL) {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- return PyString_FromStringAndSize((const char *)str, len);\r
-}\r
-\r
-/* Callback routines */\r
-\r
-static void clear_handlers(xmlparseobject *self, int initial);\r
-\r
-/* This handler is used when an error has been detected, in the hope\r
- that actual parsing can be terminated early. This will only help\r
- if an external entity reference is encountered. */\r
-static int\r
-error_external_entity_ref_handler(XML_Parser parser,\r
- const XML_Char *context,\r
- const XML_Char *base,\r
- const XML_Char *systemId,\r
- const XML_Char *publicId)\r
-{\r
- return 0;\r
-}\r
-\r
-/* Dummy character data handler used when an error (exception) has\r
- been detected, and the actual parsing can be terminated early.\r
- This is needed since character data handler can't be safely removed\r
- from within the character data handler, but can be replaced. It is\r
- used only from the character data handler trampoline, and must be\r
- used right after `flag_error()` is called. */\r
-static void\r
-noop_character_data_handler(void *userData, const XML_Char *data, int len)\r
-{\r
- /* Do nothing. */\r
-}\r
-\r
-static void\r
-flag_error(xmlparseobject *self)\r
-{\r
- clear_handlers(self, 0);\r
- XML_SetExternalEntityRefHandler(self->itself,\r
- error_external_entity_ref_handler);\r
-}\r
-\r
-static PyCodeObject*\r
-getcode(enum HandlerTypes slot, char* func_name, int lineno)\r
-{\r
- if (handler_info[slot].tb_code == NULL) {\r
- handler_info[slot].tb_code =\r
- PyCode_NewEmpty(__FILE__, func_name, lineno);\r
- }\r
- return handler_info[slot].tb_code;\r
-}\r
-\r
-#ifdef FIX_TRACE\r
-static int\r
-trace_frame(PyThreadState *tstate, PyFrameObject *f, int code, PyObject *val)\r
-{\r
- int result = 0;\r
- if (!tstate->use_tracing || tstate->tracing)\r
- return 0;\r
- if (tstate->c_profilefunc != NULL) {\r
- tstate->tracing++;\r
- result = tstate->c_profilefunc(tstate->c_profileobj,\r
- f, code , val);\r
- tstate->use_tracing = ((tstate->c_tracefunc != NULL)\r
- || (tstate->c_profilefunc != NULL));\r
- tstate->tracing--;\r
- if (result)\r
- return result;\r
- }\r
- if (tstate->c_tracefunc != NULL) {\r
- tstate->tracing++;\r
- result = tstate->c_tracefunc(tstate->c_traceobj,\r
- f, code , val);\r
- tstate->use_tracing = ((tstate->c_tracefunc != NULL)\r
- || (tstate->c_profilefunc != NULL));\r
- tstate->tracing--;\r
- }\r
- return result;\r
-}\r
-\r
-static int\r
-trace_frame_exc(PyThreadState *tstate, PyFrameObject *f)\r
-{\r
- PyObject *type, *value, *traceback, *arg;\r
- int err;\r
-\r
- if (tstate->c_tracefunc == NULL)\r
- return 0;\r
-\r
- PyErr_Fetch(&type, &value, &traceback);\r
- if (value == NULL) {\r
- value = Py_None;\r
- Py_INCREF(value);\r
- }\r
-#if PY_VERSION_HEX < 0x02040000\r
- arg = Py_BuildValue("(OOO)", type, value, traceback);\r
-#else\r
- arg = PyTuple_Pack(3, type, value, traceback);\r
-#endif\r
- if (arg == NULL) {\r
- PyErr_Restore(type, value, traceback);\r
- return 0;\r
- }\r
- err = trace_frame(tstate, f, PyTrace_EXCEPTION, arg);\r
- Py_DECREF(arg);\r
- if (err == 0)\r
- PyErr_Restore(type, value, traceback);\r
- else {\r
- Py_XDECREF(type);\r
- Py_XDECREF(value);\r
- Py_XDECREF(traceback);\r
- }\r
- return err;\r
-}\r
-#endif\r
-\r
-static PyObject*\r
-call_with_frame(PyCodeObject *c, PyObject* func, PyObject* args,\r
- xmlparseobject *self)\r
-{\r
- PyThreadState *tstate = PyThreadState_GET();\r
- PyFrameObject *f;\r
- PyObject *res;\r
-\r
- if (c == NULL)\r
- return NULL;\r
-\r
- f = PyFrame_New(tstate, c, PyEval_GetGlobals(), NULL);\r
- if (f == NULL)\r
- return NULL;\r
- tstate->frame = f;\r
-#ifdef FIX_TRACE\r
- if (trace_frame(tstate, f, PyTrace_CALL, Py_None) < 0) {\r
- return NULL;\r
- }\r
-#endif\r
- res = PyEval_CallObject(func, args);\r
- if (res == NULL) {\r
- if (tstate->curexc_traceback == NULL)\r
- PyTraceBack_Here(f);\r
- XML_StopParser(self->itself, XML_FALSE);\r
-#ifdef FIX_TRACE\r
- if (trace_frame_exc(tstate, f) < 0) {\r
- return NULL;\r
- }\r
- }\r
- else {\r
- if (trace_frame(tstate, f, PyTrace_RETURN, res) < 0) {\r
- Py_XDECREF(res);\r
- res = NULL;\r
- }\r
- }\r
-#else\r
- }\r
-#endif\r
- tstate->frame = f->f_back;\r
- Py_DECREF(f);\r
- return res;\r
-}\r
-\r
-#ifndef Py_USING_UNICODE\r
-#define STRING_CONV_FUNC conv_string_to_utf8\r
-#else\r
-/* Python 2.0 and later versions, when built with Unicode support */\r
-#define STRING_CONV_FUNC (self->returns_unicode \\r
- ? conv_string_to_unicode : conv_string_to_utf8)\r
-#endif\r
-\r
-static PyObject*\r
-string_intern(xmlparseobject *self, const char* str)\r
-{\r
- PyObject *result = STRING_CONV_FUNC(str);\r
- PyObject *value;\r
- /* result can be NULL if the unicode conversion failed. */\r
- if (!result)\r
- return result;\r
- if (!self->intern)\r
- return result;\r
- value = PyDict_GetItem(self->intern, result);\r
- if (!value) {\r
- if (PyDict_SetItem(self->intern, result, result) == 0)\r
- return result;\r
- else\r
- return NULL;\r
- }\r
- Py_INCREF(value);\r
- Py_DECREF(result);\r
- return value;\r
-}\r
-\r
-/* Return 0 on success, -1 on exception.\r
- * flag_error() will be called before return if needed.\r
- */\r
-static int\r
-call_character_handler(xmlparseobject *self, const XML_Char *buffer, int len)\r
-{\r
- PyObject *args;\r
- PyObject *temp;\r
-\r
- if (!have_handler(self, CharacterData))\r
- return -1;\r
-\r
- args = PyTuple_New(1);\r
- if (args == NULL)\r
- return -1;\r
-#ifdef Py_USING_UNICODE\r
- temp = (self->returns_unicode\r
- ? conv_string_len_to_unicode(buffer, len)\r
- : conv_string_len_to_utf8(buffer, len));\r
-#else\r
- temp = conv_string_len_to_utf8(buffer, len);\r
-#endif\r
- if (temp == NULL) {\r
- Py_DECREF(args);\r
- flag_error(self);\r
- XML_SetCharacterDataHandler(self->itself,\r
- noop_character_data_handler);\r
- return -1;\r
- }\r
- PyTuple_SET_ITEM(args, 0, temp);\r
- /* temp is now a borrowed reference; consider it unused. */\r
- self->in_callback = 1;\r
- temp = call_with_frame(getcode(CharacterData, "CharacterData", __LINE__),\r
- self->handlers[CharacterData], args, self);\r
- /* temp is an owned reference again, or NULL */\r
- self->in_callback = 0;\r
- Py_DECREF(args);\r
- if (temp == NULL) {\r
- flag_error(self);\r
- XML_SetCharacterDataHandler(self->itself,\r
- noop_character_data_handler);\r
- return -1;\r
- }\r
- Py_DECREF(temp);\r
- return 0;\r
-}\r
-\r
-static int\r
-flush_character_buffer(xmlparseobject *self)\r
-{\r
- int rc;\r
- if (self->buffer == NULL || self->buffer_used == 0)\r
- return 0;\r
- rc = call_character_handler(self, self->buffer, self->buffer_used);\r
- self->buffer_used = 0;\r
- return rc;\r
-}\r
-\r
-static void\r
-my_CharacterDataHandler(void *userData, const XML_Char *data, int len)\r
-{\r
- xmlparseobject *self = (xmlparseobject *) userData;\r
- if (self->buffer == NULL)\r
- call_character_handler(self, data, len);\r
- else {\r
- if ((self->buffer_used + len) > self->buffer_size) {\r
- if (flush_character_buffer(self) < 0)\r
- return;\r
- /* handler might have changed; drop the rest on the floor\r
- * if there isn't a handler anymore\r
- */\r
- if (!have_handler(self, CharacterData))\r
- return;\r
- }\r
- if (len > self->buffer_size) {\r
- call_character_handler(self, data, len);\r
- self->buffer_used = 0;\r
- }\r
- else {\r
- memcpy(self->buffer + self->buffer_used,\r
- data, len * sizeof(XML_Char));\r
- self->buffer_used += len;\r
- }\r
- }\r
-}\r
-\r
-static void\r
-my_StartElementHandler(void *userData,\r
- const XML_Char *name, const XML_Char *atts[])\r
-{\r
- xmlparseobject *self = (xmlparseobject *)userData;\r
-\r
- if (have_handler(self, StartElement)) {\r
- PyObject *container, *rv, *args;\r
- int i, max;\r
-\r
- if (flush_character_buffer(self) < 0)\r
- return;\r
- /* Set max to the number of slots filled in atts[]; max/2 is\r
- * the number of attributes we need to process.\r
- */\r
- if (self->specified_attributes) {\r
- max = XML_GetSpecifiedAttributeCount(self->itself);\r
- }\r
- else {\r
- max = 0;\r
- while (atts[max] != NULL)\r
- max += 2;\r
- }\r
- /* Build the container. */\r
- if (self->ordered_attributes)\r
- container = PyList_New(max);\r
- else\r
- container = PyDict_New();\r
- if (container == NULL) {\r
- flag_error(self);\r
- return;\r
- }\r
- for (i = 0; i < max; i += 2) {\r
- PyObject *n = string_intern(self, (XML_Char *) atts[i]);\r
- PyObject *v;\r
- if (n == NULL) {\r
- flag_error(self);\r
- Py_DECREF(container);\r
- return;\r
- }\r
- v = STRING_CONV_FUNC((XML_Char *) atts[i+1]);\r
- if (v == NULL) {\r
- flag_error(self);\r
- Py_DECREF(container);\r
- Py_DECREF(n);\r
- return;\r
- }\r
- if (self->ordered_attributes) {\r
- PyList_SET_ITEM(container, i, n);\r
- PyList_SET_ITEM(container, i+1, v);\r
- }\r
- else if (PyDict_SetItem(container, n, v)) {\r
- flag_error(self);\r
- Py_DECREF(n);\r
- Py_DECREF(v);\r
- return;\r
- }\r
- else {\r
- Py_DECREF(n);\r
- Py_DECREF(v);\r
- }\r
- }\r
- args = string_intern(self, name);\r
- if (args != NULL)\r
- args = Py_BuildValue("(NN)", args, container);\r
- if (args == NULL) {\r
- Py_DECREF(container);\r
- return;\r
- }\r
- /* Container is now a borrowed reference; ignore it. */\r
- self->in_callback = 1;\r
- rv = call_with_frame(getcode(StartElement, "StartElement", __LINE__),\r
- self->handlers[StartElement], args, self);\r
- self->in_callback = 0;\r
- Py_DECREF(args);\r
- if (rv == NULL) {\r
- flag_error(self);\r
- return;\r
- }\r
- Py_DECREF(rv);\r
- }\r
-}\r
-\r
-#define RC_HANDLER(RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, \\r
- RETURN, GETUSERDATA) \\r
-static RC \\r
-my_##NAME##Handler PARAMS {\\r
- xmlparseobject *self = GETUSERDATA ; \\r
- PyObject *args = NULL; \\r
- PyObject *rv = NULL; \\r
- INIT \\r
-\\r
- if (have_handler(self, NAME)) { \\r
- if (flush_character_buffer(self) < 0) \\r
- return RETURN; \\r
- args = Py_BuildValue PARAM_FORMAT ;\\r
- if (!args) { flag_error(self); return RETURN;} \\r
- self->in_callback = 1; \\r
- rv = call_with_frame(getcode(NAME,#NAME,__LINE__), \\r
- self->handlers[NAME], args, self); \\r
- self->in_callback = 0; \\r
- Py_DECREF(args); \\r
- if (rv == NULL) { \\r
- flag_error(self); \\r
- return RETURN; \\r
- } \\r
- CONVERSION \\r
- Py_DECREF(rv); \\r
- } \\r
- return RETURN; \\r
-}\r
-\r
-#define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \\r
- RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\\r
- (xmlparseobject *)userData)\r
-\r
-#define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\\r
- RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \\r
- rc = PyInt_AsLong(rv);, rc, \\r
- (xmlparseobject *)userData)\r
-\r
-VOID_HANDLER(EndElement,\r
- (void *userData, const XML_Char *name),\r
- ("(N)", string_intern(self, name)))\r
-\r
-VOID_HANDLER(ProcessingInstruction,\r
- (void *userData,\r
- const XML_Char *target,\r
- const XML_Char *data),\r
- ("(NO&)", string_intern(self, target), STRING_CONV_FUNC,data))\r
-\r
-VOID_HANDLER(UnparsedEntityDecl,\r
- (void *userData,\r
- const XML_Char *entityName,\r
- const XML_Char *base,\r
- const XML_Char *systemId,\r
- const XML_Char *publicId,\r
- const XML_Char *notationName),\r
- ("(NNNNN)",\r
- string_intern(self, entityName), string_intern(self, base),\r
- string_intern(self, systemId), string_intern(self, publicId),\r
- string_intern(self, notationName)))\r
-\r
-#ifndef Py_USING_UNICODE\r
-VOID_HANDLER(EntityDecl,\r
- (void *userData,\r
- const XML_Char *entityName,\r
- int is_parameter_entity,\r
- const XML_Char *value,\r
- int value_length,\r
- const XML_Char *base,\r
- const XML_Char *systemId,\r
- const XML_Char *publicId,\r
- const XML_Char *notationName),\r
- ("NiNNNNN",\r
- string_intern(self, entityName), is_parameter_entity,\r
- conv_string_len_to_utf8(value, value_length),\r
- string_intern(self, base), string_intern(self, systemId),\r
- string_intern(self, publicId),\r
- string_intern(self, notationName)))\r
-#else\r
-VOID_HANDLER(EntityDecl,\r
- (void *userData,\r
- const XML_Char *entityName,\r
- int is_parameter_entity,\r
- const XML_Char *value,\r
- int value_length,\r
- const XML_Char *base,\r
- const XML_Char *systemId,\r
- const XML_Char *publicId,\r
- const XML_Char *notationName),\r
- ("NiNNNNN",\r
- string_intern(self, entityName), is_parameter_entity,\r
- (self->returns_unicode\r
- ? conv_string_len_to_unicode(value, value_length)\r
- : conv_string_len_to_utf8(value, value_length)),\r
- string_intern(self, base), string_intern(self, systemId),\r
- string_intern(self, publicId),\r
- string_intern(self, notationName)))\r
-#endif\r
-\r
-VOID_HANDLER(XmlDecl,\r
- (void *userData,\r
- const XML_Char *version,\r
- const XML_Char *encoding,\r
- int standalone),\r
- ("(O&O&i)",\r
- STRING_CONV_FUNC,version, STRING_CONV_FUNC,encoding,\r
- standalone))\r
-\r
-static PyObject *\r
-conv_content_model(XML_Content * const model,\r
- PyObject *(*conv_string)(const XML_Char *))\r
-{\r
- PyObject *result = NULL;\r
- PyObject *children = PyTuple_New(model->numchildren);\r
- int i;\r
-\r
- if (children != NULL) {\r
- assert(model->numchildren < INT_MAX);\r
- for (i = 0; i < (int)model->numchildren; ++i) {\r
- PyObject *child = conv_content_model(&model->children[i],\r
- conv_string);\r
- if (child == NULL) {\r
- Py_XDECREF(children);\r
- return NULL;\r
- }\r
- PyTuple_SET_ITEM(children, i, child);\r
- }\r
- result = Py_BuildValue("(iiO&N)",\r
- model->type, model->quant,\r
- conv_string,model->name, children);\r
- }\r
- return result;\r
-}\r
-\r
-static void\r
-my_ElementDeclHandler(void *userData,\r
- const XML_Char *name,\r
- XML_Content *model)\r
-{\r
- xmlparseobject *self = (xmlparseobject *)userData;\r
- PyObject *args = NULL;\r
-\r
- if (have_handler(self, ElementDecl)) {\r
- PyObject *rv = NULL;\r
- PyObject *modelobj, *nameobj;\r
-\r
- if (flush_character_buffer(self) < 0)\r
- goto finally;\r
-#ifdef Py_USING_UNICODE\r
- modelobj = conv_content_model(model,\r
- (self->returns_unicode\r
- ? conv_string_to_unicode\r
- : conv_string_to_utf8));\r
-#else\r
- modelobj = conv_content_model(model, conv_string_to_utf8);\r
-#endif\r
- if (modelobj == NULL) {\r
- flag_error(self);\r
- goto finally;\r
- }\r
- nameobj = string_intern(self, name);\r
- if (nameobj == NULL) {\r
- Py_DECREF(modelobj);\r
- flag_error(self);\r
- goto finally;\r
- }\r
- args = Py_BuildValue("NN", nameobj, modelobj);\r
- if (args == NULL) {\r
- Py_DECREF(modelobj);\r
- flag_error(self);\r
- goto finally;\r
- }\r
- self->in_callback = 1;\r
- rv = call_with_frame(getcode(ElementDecl, "ElementDecl", __LINE__),\r
- self->handlers[ElementDecl], args, self);\r
- self->in_callback = 0;\r
- if (rv == NULL) {\r
- flag_error(self);\r
- goto finally;\r
- }\r
- Py_DECREF(rv);\r
- }\r
- finally:\r
- Py_XDECREF(args);\r
- XML_FreeContentModel(self->itself, model);\r
- return;\r
-}\r
-\r
-VOID_HANDLER(AttlistDecl,\r
- (void *userData,\r
- const XML_Char *elname,\r
- const XML_Char *attname,\r
- const XML_Char *att_type,\r
- const XML_Char *dflt,\r
- int isrequired),\r
- ("(NNO&O&i)",\r
- string_intern(self, elname), string_intern(self, attname),\r
- STRING_CONV_FUNC,att_type, STRING_CONV_FUNC,dflt,\r
- isrequired))\r
-\r
-#if XML_COMBINED_VERSION >= 19504\r
-VOID_HANDLER(SkippedEntity,\r
- (void *userData,\r
- const XML_Char *entityName,\r
- int is_parameter_entity),\r
- ("Ni",\r
- string_intern(self, entityName), is_parameter_entity))\r
-#endif\r
-\r
-VOID_HANDLER(NotationDecl,\r
- (void *userData,\r
- const XML_Char *notationName,\r
- const XML_Char *base,\r
- const XML_Char *systemId,\r
- const XML_Char *publicId),\r
- ("(NNNN)",\r
- string_intern(self, notationName), string_intern(self, base),\r
- string_intern(self, systemId), string_intern(self, publicId)))\r
-\r
-VOID_HANDLER(StartNamespaceDecl,\r
- (void *userData,\r
- const XML_Char *prefix,\r
- const XML_Char *uri),\r
- ("(NN)",\r
- string_intern(self, prefix), string_intern(self, uri)))\r
-\r
-VOID_HANDLER(EndNamespaceDecl,\r
- (void *userData,\r
- const XML_Char *prefix),\r
- ("(N)", string_intern(self, prefix)))\r
-\r
-VOID_HANDLER(Comment,\r
- (void *userData, const XML_Char *data),\r
- ("(O&)", STRING_CONV_FUNC,data))\r
-\r
-VOID_HANDLER(StartCdataSection,\r
- (void *userData),\r
- ("()"))\r
-\r
-VOID_HANDLER(EndCdataSection,\r
- (void *userData),\r
- ("()"))\r
-\r
-#ifndef Py_USING_UNICODE\r
-VOID_HANDLER(Default,\r
- (void *userData, const XML_Char *s, int len),\r
- ("(N)", conv_string_len_to_utf8(s,len)))\r
-\r
-VOID_HANDLER(DefaultHandlerExpand,\r
- (void *userData, const XML_Char *s, int len),\r
- ("(N)", conv_string_len_to_utf8(s,len)))\r
-#else\r
-VOID_HANDLER(Default,\r
- (void *userData, const XML_Char *s, int len),\r
- ("(N)", (self->returns_unicode\r
- ? conv_string_len_to_unicode(s,len)\r
- : conv_string_len_to_utf8(s,len))))\r
-\r
-VOID_HANDLER(DefaultHandlerExpand,\r
- (void *userData, const XML_Char *s, int len),\r
- ("(N)", (self->returns_unicode\r
- ? conv_string_len_to_unicode(s,len)\r
- : conv_string_len_to_utf8(s,len))))\r
-#endif\r
-\r
-INT_HANDLER(NotStandalone,\r
- (void *userData),\r
- ("()"))\r
-\r
-RC_HANDLER(int, ExternalEntityRef,\r
- (XML_Parser parser,\r
- const XML_Char *context,\r
- const XML_Char *base,\r
- const XML_Char *systemId,\r
- const XML_Char *publicId),\r
- int rc=0;,\r
- ("(O&NNN)",\r
- STRING_CONV_FUNC,context, string_intern(self, base),\r
- string_intern(self, systemId), string_intern(self, publicId)),\r
- rc = PyInt_AsLong(rv);, rc,\r
- XML_GetUserData(parser))\r
-\r
-/* XXX UnknownEncodingHandler */\r
-\r
-VOID_HANDLER(StartDoctypeDecl,\r
- (void *userData, const XML_Char *doctypeName,\r
- const XML_Char *sysid, const XML_Char *pubid,\r
- int has_internal_subset),\r
- ("(NNNi)", string_intern(self, doctypeName),\r
- string_intern(self, sysid), string_intern(self, pubid),\r
- has_internal_subset))\r
-\r
-VOID_HANDLER(EndDoctypeDecl, (void *userData), ("()"))\r
-\r
-/* ---------------------------------------------------------------- */\r
-\r
-static PyObject *\r
-get_parse_result(xmlparseobject *self, int rv)\r
-{\r
- if (PyErr_Occurred()) {\r
- return NULL;\r
- }\r
- if (rv == 0) {\r
- return set_error(self, XML_GetErrorCode(self->itself));\r
- }\r
- if (flush_character_buffer(self) < 0) {\r
- return NULL;\r
- }\r
- return PyInt_FromLong(rv);\r
-}\r
-\r
-PyDoc_STRVAR(xmlparse_Parse__doc__,\r
-"Parse(data[, isfinal])\n\\r
-Parse XML data. `isfinal' should be true at end of input.");\r
-\r
-static PyObject *\r
-xmlparse_Parse(xmlparseobject *self, PyObject *args)\r
-{\r
- char *s;\r
- int slen;\r
- int isFinal = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "s#|i:Parse", &s, &slen, &isFinal))\r
- return NULL;\r
-\r
- return get_parse_result(self, XML_Parse(self->itself, s, slen, isFinal));\r
-}\r
-\r
-/* File reading copied from cPickle */\r
-\r
-#define BUF_SIZE 2048\r
-\r
-static int\r
-readinst(char *buf, int buf_size, PyObject *meth)\r
-{\r
- PyObject *arg = NULL;\r
- PyObject *bytes = NULL;\r
- PyObject *str = NULL;\r
- int len = -1;\r
-\r
- if ((bytes = PyInt_FromLong(buf_size)) == NULL)\r
- goto finally;\r
-\r
- if ((arg = PyTuple_New(1)) == NULL) {\r
- Py_DECREF(bytes);\r
- goto finally;\r
- }\r
-\r
- PyTuple_SET_ITEM(arg, 0, bytes);\r
-\r
-#if PY_VERSION_HEX < 0x02020000\r
- str = PyObject_CallObject(meth, arg);\r
-#else\r
- str = PyObject_Call(meth, arg, NULL);\r
-#endif\r
- if (str == NULL)\r
- goto finally;\r
-\r
- /* XXX what to do if it returns a Unicode string? */\r
- if (!PyString_Check(str)) {\r
- PyErr_Format(PyExc_TypeError,\r
- "read() did not return a string object (type=%.400s)",\r
- Py_TYPE(str)->tp_name);\r
- goto finally;\r
- }\r
- len = PyString_GET_SIZE(str);\r
- if (len > buf_size) {\r
- PyErr_Format(PyExc_ValueError,\r
- "read() returned too much data: "\r
- "%i bytes requested, %i returned",\r
- buf_size, len);\r
- goto finally;\r
- }\r
- memcpy(buf, PyString_AsString(str), len);\r
-finally:\r
- Py_XDECREF(arg);\r
- Py_XDECREF(str);\r
- return len;\r
-}\r
-\r
-PyDoc_STRVAR(xmlparse_ParseFile__doc__,\r
-"ParseFile(file)\n\\r
-Parse XML data from file-like object.");\r
-\r
-static PyObject *\r
-xmlparse_ParseFile(xmlparseobject *self, PyObject *f)\r
-{\r
- int rv = 1;\r
- PyObject *readmethod = NULL;\r
-\r
- readmethod = PyObject_GetAttrString(f, "read");\r
- if (readmethod == NULL) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "argument must have 'read' attribute");\r
- return NULL;\r
-\r
- }\r
- for (;;) {\r
- int bytes_read;\r
- void *buf = XML_GetBuffer(self->itself, BUF_SIZE);\r
- if (buf == NULL) {\r
- Py_XDECREF(readmethod);\r
- return get_parse_result(self, 0);\r
- }\r
-\r
- bytes_read = readinst(buf, BUF_SIZE, readmethod);\r
- if (bytes_read < 0) {\r
- Py_XDECREF(readmethod);\r
- return NULL;\r
- }\r
-\r
- rv = XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);\r
- if (PyErr_Occurred()) {\r
- Py_XDECREF(readmethod);\r
- return NULL;\r
- }\r
-\r
- if (!rv || bytes_read == 0)\r
- break;\r
- }\r
- Py_XDECREF(readmethod);\r
- return get_parse_result(self, rv);\r
-}\r
-\r
-PyDoc_STRVAR(xmlparse_SetBase__doc__,\r
-"SetBase(base_url)\n\\r
-Set the base URL for the parser.");\r
-\r
-static PyObject *\r
-xmlparse_SetBase(xmlparseobject *self, PyObject *args)\r
-{\r
- char *base;\r
-\r
- if (!PyArg_ParseTuple(args, "s:SetBase", &base))\r
- return NULL;\r
- if (!XML_SetBase(self->itself, base)) {\r
- return PyErr_NoMemory();\r
- }\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(xmlparse_GetBase__doc__,\r
-"GetBase() -> url\n\\r
-Return base URL string for the parser.");\r
-\r
-static PyObject *\r
-xmlparse_GetBase(xmlparseobject *self, PyObject *unused)\r
-{\r
- return Py_BuildValue("z", XML_GetBase(self->itself));\r
-}\r
-\r
-PyDoc_STRVAR(xmlparse_GetInputContext__doc__,\r
-"GetInputContext() -> string\n\\r
-Return the untranslated text of the input that caused the current event.\n\\r
-If the event was generated by a large amount of text (such as a start tag\n\\r
-for an element with many attributes), not all of the text may be available.");\r
-\r
-static PyObject *\r
-xmlparse_GetInputContext(xmlparseobject *self, PyObject *unused)\r
-{\r
- if (self->in_callback) {\r
- int offset, size;\r
- const char *buffer\r
- = XML_GetInputContext(self->itself, &offset, &size);\r
-\r
- if (buffer != NULL)\r
- return PyString_FromStringAndSize(buffer + offset,\r
- size - offset);\r
- else\r
- Py_RETURN_NONE;\r
- }\r
- else\r
- Py_RETURN_NONE;\r
-}\r
-\r
-PyDoc_STRVAR(xmlparse_ExternalEntityParserCreate__doc__,\r
-"ExternalEntityParserCreate(context[, encoding])\n\\r
-Create a parser for parsing an external entity based on the\n\\r
-information passed to the ExternalEntityRefHandler.");\r
-\r
-static PyObject *\r
-xmlparse_ExternalEntityParserCreate(xmlparseobject *self, PyObject *args)\r
-{\r
- char *context;\r
- char *encoding = NULL;\r
- xmlparseobject *new_parser;\r
- int i;\r
-\r
- if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate",\r
- &context, &encoding)) {\r
- return NULL;\r
- }\r
-\r
-#ifndef Py_TPFLAGS_HAVE_GC\r
- /* Python versions 2.0 and 2.1 */\r
- new_parser = PyObject_New(xmlparseobject, &Xmlparsetype);\r
-#else\r
- /* Python versions 2.2 and later */\r
- new_parser = PyObject_GC_New(xmlparseobject, &Xmlparsetype);\r
-#endif\r
-\r
- if (new_parser == NULL)\r
- return NULL;\r
- new_parser->buffer_size = self->buffer_size;\r
- new_parser->buffer_used = 0;\r
- if (self->buffer != NULL) {\r
- new_parser->buffer = malloc(new_parser->buffer_size);\r
- if (new_parser->buffer == NULL) {\r
-#ifndef Py_TPFLAGS_HAVE_GC\r
- /* Code for versions 2.0 and 2.1 */\r
- PyObject_Del(new_parser);\r
-#else\r
- /* Code for versions 2.2 and later. */\r
- PyObject_GC_Del(new_parser);\r
-#endif\r
- return PyErr_NoMemory();\r
- }\r
- }\r
- else\r
- new_parser->buffer = NULL;\r
- new_parser->returns_unicode = self->returns_unicode;\r
- new_parser->ordered_attributes = self->ordered_attributes;\r
- new_parser->specified_attributes = self->specified_attributes;\r
- new_parser->in_callback = 0;\r
- new_parser->ns_prefixes = self->ns_prefixes;\r
- new_parser->itself = XML_ExternalEntityParserCreate(self->itself, context,\r
- encoding);\r
- new_parser->handlers = 0;\r
- new_parser->intern = self->intern;\r
- Py_XINCREF(new_parser->intern);\r
-#ifdef Py_TPFLAGS_HAVE_GC\r
- PyObject_GC_Track(new_parser);\r
-#else\r
- PyObject_GC_Init(new_parser);\r
-#endif\r
-\r
- if (!new_parser->itself) {\r
- Py_DECREF(new_parser);\r
- return PyErr_NoMemory();\r
- }\r
-\r
- XML_SetUserData(new_parser->itself, (void *)new_parser);\r
-\r
- /* allocate and clear handlers first */\r
- for (i = 0; handler_info[i].name != NULL; i++)\r
- /* do nothing */;\r
-\r
- new_parser->handlers = malloc(sizeof(PyObject *) * i);\r
- if (!new_parser->handlers) {\r
- Py_DECREF(new_parser);\r
- return PyErr_NoMemory();\r
- }\r
- clear_handlers(new_parser, 1);\r
-\r
- /* then copy handlers from self */\r
- for (i = 0; handler_info[i].name != NULL; i++) {\r
- PyObject *handler = self->handlers[i];\r
- if (handler != NULL) {\r
- Py_INCREF(handler);\r
- new_parser->handlers[i] = handler;\r
- handler_info[i].setter(new_parser->itself,\r
- handler_info[i].handler);\r
- }\r
- }\r
- return (PyObject *)new_parser;\r
-}\r
-\r
-PyDoc_STRVAR(xmlparse_SetParamEntityParsing__doc__,\r
-"SetParamEntityParsing(flag) -> success\n\\r
-Controls parsing of parameter entities (including the external DTD\n\\r
-subset). Possible flag values are XML_PARAM_ENTITY_PARSING_NEVER,\n\\r
-XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE and\n\\r
-XML_PARAM_ENTITY_PARSING_ALWAYS. Returns true if setting the flag\n\\r
-was successful.");\r
-\r
-static PyObject*\r
-xmlparse_SetParamEntityParsing(xmlparseobject *p, PyObject* args)\r
-{\r
- int flag;\r
- if (!PyArg_ParseTuple(args, "i", &flag))\r
- return NULL;\r
- flag = XML_SetParamEntityParsing(p->itself, flag);\r
- return PyInt_FromLong(flag);\r
-}\r
-\r
-\r
-#if XML_COMBINED_VERSION >= 19505\r
-PyDoc_STRVAR(xmlparse_UseForeignDTD__doc__,\r
-"UseForeignDTD([flag])\n\\r
-Allows the application to provide an artificial external subset if one is\n\\r
-not specified as part of the document instance. This readily allows the\n\\r
-use of a 'default' document type controlled by the application, while still\n\\r
-getting the advantage of providing document type information to the parser.\n\\r
-'flag' defaults to True if not provided.");\r
-\r
-static PyObject *\r
-xmlparse_UseForeignDTD(xmlparseobject *self, PyObject *args)\r
-{\r
- PyObject *flagobj = NULL;\r
- int flag = 1;\r
- enum XML_Error rc;\r
- if (!PyArg_ParseTuple(args, "|O:UseForeignDTD", &flagobj))\r
- return NULL;\r
- if (flagobj != NULL) {\r
- flag = PyObject_IsTrue(flagobj);\r
- if (flag < 0)\r
- return NULL;\r
- }\r
- rc = XML_UseForeignDTD(self->itself, flag ? XML_TRUE : XML_FALSE);\r
- if (rc != XML_ERROR_NONE) {\r
- return set_error(self, rc);\r
- }\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-static struct PyMethodDef xmlparse_methods[] = {\r
- {"Parse", (PyCFunction)xmlparse_Parse,\r
- METH_VARARGS, xmlparse_Parse__doc__},\r
- {"ParseFile", (PyCFunction)xmlparse_ParseFile,\r
- METH_O, xmlparse_ParseFile__doc__},\r
- {"SetBase", (PyCFunction)xmlparse_SetBase,\r
- METH_VARARGS, xmlparse_SetBase__doc__},\r
- {"GetBase", (PyCFunction)xmlparse_GetBase,\r
- METH_NOARGS, xmlparse_GetBase__doc__},\r
- {"ExternalEntityParserCreate", (PyCFunction)xmlparse_ExternalEntityParserCreate,\r
- METH_VARARGS, xmlparse_ExternalEntityParserCreate__doc__},\r
- {"SetParamEntityParsing", (PyCFunction)xmlparse_SetParamEntityParsing,\r
- METH_VARARGS, xmlparse_SetParamEntityParsing__doc__},\r
- {"GetInputContext", (PyCFunction)xmlparse_GetInputContext,\r
- METH_NOARGS, xmlparse_GetInputContext__doc__},\r
-#if XML_COMBINED_VERSION >= 19505\r
- {"UseForeignDTD", (PyCFunction)xmlparse_UseForeignDTD,\r
- METH_VARARGS, xmlparse_UseForeignDTD__doc__},\r
-#endif\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-/* ---------- */\r
-\r
-\r
-#ifdef Py_USING_UNICODE\r
-\r
-/* pyexpat international encoding support.\r
- Make it as simple as possible.\r
-*/\r
-\r
-static char template_buffer[257];\r
-PyObject *template_string = NULL;\r
-\r
-static void\r
-init_template_buffer(void)\r
-{\r
- int i;\r
- for (i = 0; i < 256; i++) {\r
- template_buffer[i] = i;\r
- }\r
- template_buffer[256] = 0;\r
-}\r
-\r
-static int\r
-PyUnknownEncodingHandler(void *encodingHandlerData,\r
- const XML_Char *name,\r
- XML_Encoding *info)\r
-{\r
- PyUnicodeObject *_u_string = NULL;\r
- int result = 0;\r
- int i;\r
-\r
- /* Yes, supports only 8bit encodings */\r
- _u_string = (PyUnicodeObject *)\r
- PyUnicode_Decode(template_buffer, 256, name, "replace");\r
-\r
- if (_u_string == NULL)\r
- return result;\r
-\r
- if (PyUnicode_GET_SIZE(_u_string) != 256) {\r
- Py_DECREF(_u_string);\r
- PyErr_SetString(PyExc_ValueError,\r
- "multi-byte encodings are not supported");\r
- return result;\r
- }\r
-\r
- for (i = 0; i < 256; i++) {\r
- /* Stupid to access directly, but fast */\r
- Py_UNICODE c = _u_string->str[i];\r
- if (c == Py_UNICODE_REPLACEMENT_CHARACTER)\r
- info->map[i] = -1;\r
- else\r
- info->map[i] = c;\r
- }\r
- info->data = NULL;\r
- info->convert = NULL;\r
- info->release = NULL;\r
- result = 1;\r
- Py_DECREF(_u_string);\r
- return result;\r
-}\r
-\r
-#endif\r
-\r
-static PyObject *\r
-newxmlparseobject(char *encoding, char *namespace_separator, PyObject *intern)\r
-{\r
- int i;\r
- xmlparseobject *self;\r
-\r
-#ifdef Py_TPFLAGS_HAVE_GC\r
- /* Code for versions 2.2 and later */\r
- self = PyObject_GC_New(xmlparseobject, &Xmlparsetype);\r
-#else\r
- self = PyObject_New(xmlparseobject, &Xmlparsetype);\r
-#endif\r
- if (self == NULL)\r
- return NULL;\r
-\r
-#ifdef Py_USING_UNICODE\r
- self->returns_unicode = 1;\r
-#else\r
- self->returns_unicode = 0;\r
-#endif\r
-\r
- self->buffer = NULL;\r
- self->buffer_size = CHARACTER_DATA_BUFFER_SIZE;\r
- self->buffer_used = 0;\r
- self->ordered_attributes = 0;\r
- self->specified_attributes = 0;\r
- self->in_callback = 0;\r
- self->ns_prefixes = 0;\r
- self->handlers = NULL;\r
- if (namespace_separator != NULL) {\r
- self->itself = XML_ParserCreateNS(encoding, *namespace_separator);\r
- }\r
- else {\r
- self->itself = XML_ParserCreate(encoding);\r
- }\r
-#if ((XML_MAJOR_VERSION >= 2) && (XML_MINOR_VERSION >= 1)) || defined(XML_HAS_SET_HASH_SALT)\r
- /* This feature was added upstream in libexpat 2.1.0. Our expat copy\r
- * has a backport of this feature where we also define XML_HAS_SET_HASH_SALT\r
- * to indicate that we can still use it. */\r
- XML_SetHashSalt(self->itself,\r
- (unsigned long)_Py_HashSecret.prefix);\r
-#endif\r
- self->intern = intern;\r
- Py_XINCREF(self->intern);\r
-#ifdef Py_TPFLAGS_HAVE_GC\r
- PyObject_GC_Track(self);\r
-#else\r
- PyObject_GC_Init(self);\r
-#endif\r
- if (self->itself == NULL) {\r
- PyErr_SetString(PyExc_RuntimeError,\r
- "XML_ParserCreate failed");\r
- Py_DECREF(self);\r
- return NULL;\r
- }\r
- XML_SetUserData(self->itself, (void *)self);\r
-#ifdef Py_USING_UNICODE\r
- XML_SetUnknownEncodingHandler(self->itself,\r
- (XML_UnknownEncodingHandler) PyUnknownEncodingHandler, NULL);\r
-#endif\r
-\r
- for (i = 0; handler_info[i].name != NULL; i++)\r
- /* do nothing */;\r
-\r
- self->handlers = malloc(sizeof(PyObject *) * i);\r
- if (!self->handlers) {\r
- Py_DECREF(self);\r
- return PyErr_NoMemory();\r
- }\r
- clear_handlers(self, 1);\r
-\r
- return (PyObject*)self;\r
-}\r
-\r
-\r
-static void\r
-xmlparse_dealloc(xmlparseobject *self)\r
-{\r
- int i;\r
-#ifdef Py_TPFLAGS_HAVE_GC\r
- PyObject_GC_UnTrack(self);\r
-#else\r
- PyObject_GC_Fini(self);\r
-#endif\r
- if (self->itself != NULL)\r
- XML_ParserFree(self->itself);\r
- self->itself = NULL;\r
-\r
- if (self->handlers != NULL) {\r
- PyObject *temp;\r
- for (i = 0; handler_info[i].name != NULL; i++) {\r
- temp = self->handlers[i];\r
- self->handlers[i] = NULL;\r
- Py_XDECREF(temp);\r
- }\r
- free(self->handlers);\r
- self->handlers = NULL;\r
- }\r
- if (self->buffer != NULL) {\r
- free(self->buffer);\r
- self->buffer = NULL;\r
- }\r
- Py_XDECREF(self->intern);\r
-#ifndef Py_TPFLAGS_HAVE_GC\r
- /* Code for versions 2.0 and 2.1 */\r
- PyObject_Del(self);\r
-#else\r
- /* Code for versions 2.2 and later. */\r
- PyObject_GC_Del(self);\r
-#endif\r
-}\r
-\r
-static int\r
-handlername2int(const char *name)\r
-{\r
- int i;\r
- for (i = 0; handler_info[i].name != NULL; i++) {\r
- if (strcmp(name, handler_info[i].name) == 0) {\r
- return i;\r
- }\r
- }\r
- return -1;\r
-}\r
-\r
-static PyObject *\r
-get_pybool(int istrue)\r
-{\r
- PyObject *result = istrue ? Py_True : Py_False;\r
- Py_INCREF(result);\r
- return result;\r
-}\r
-\r
-static PyObject *\r
-xmlparse_getattr(xmlparseobject *self, char *name)\r
-{\r
- int handlernum = handlername2int(name);\r
-\r
- if (handlernum != -1) {\r
- PyObject *result = self->handlers[handlernum];\r
- if (result == NULL)\r
- result = Py_None;\r
- Py_INCREF(result);\r
- return result;\r
- }\r
- if (name[0] == 'E') {\r
- if (strcmp(name, "ErrorCode") == 0)\r
- return PyInt_FromLong((long)\r
- XML_GetErrorCode(self->itself));\r
- if (strcmp(name, "ErrorLineNumber") == 0)\r
- return PyInt_FromLong((long)\r
- XML_GetErrorLineNumber(self->itself));\r
- if (strcmp(name, "ErrorColumnNumber") == 0)\r
- return PyInt_FromLong((long)\r
- XML_GetErrorColumnNumber(self->itself));\r
- if (strcmp(name, "ErrorByteIndex") == 0)\r
- return PyInt_FromLong((long)\r
- XML_GetErrorByteIndex(self->itself));\r
- }\r
- if (name[0] == 'C') {\r
- if (strcmp(name, "CurrentLineNumber") == 0)\r
- return PyInt_FromLong((long)\r
- XML_GetCurrentLineNumber(self->itself));\r
- if (strcmp(name, "CurrentColumnNumber") == 0)\r
- return PyInt_FromLong((long)\r
- XML_GetCurrentColumnNumber(self->itself));\r
- if (strcmp(name, "CurrentByteIndex") == 0)\r
- return PyInt_FromLong((long)\r
- XML_GetCurrentByteIndex(self->itself));\r
- }\r
- if (name[0] == 'b') {\r
- if (strcmp(name, "buffer_size") == 0)\r
- return PyInt_FromLong((long) self->buffer_size);\r
- if (strcmp(name, "buffer_text") == 0)\r
- return get_pybool(self->buffer != NULL);\r
- if (strcmp(name, "buffer_used") == 0)\r
- return PyInt_FromLong((long) self->buffer_used);\r
- }\r
- if (strcmp(name, "namespace_prefixes") == 0)\r
- return get_pybool(self->ns_prefixes);\r
- if (strcmp(name, "ordered_attributes") == 0)\r
- return get_pybool(self->ordered_attributes);\r
- if (strcmp(name, "returns_unicode") == 0)\r
- return get_pybool((long) self->returns_unicode);\r
- if (strcmp(name, "specified_attributes") == 0)\r
- return get_pybool((long) self->specified_attributes);\r
- if (strcmp(name, "intern") == 0) {\r
- if (self->intern == NULL) {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- else {\r
- Py_INCREF(self->intern);\r
- return self->intern;\r
- }\r
- }\r
-\r
-#define APPEND(list, str) \\r
- do { \\r
- PyObject *o = PyString_FromString(str); \\r
- if (o != NULL) \\r
- PyList_Append(list, o); \\r
- Py_XDECREF(o); \\r
- } while (0)\r
-\r
- if (strcmp(name, "__members__") == 0) {\r
- int i;\r
- PyObject *rc = PyList_New(0);\r
- if (!rc)\r
- return NULL;\r
- for (i = 0; handler_info[i].name != NULL; i++) {\r
- PyObject *o = get_handler_name(&handler_info[i]);\r
- if (o != NULL)\r
- PyList_Append(rc, o);\r
- Py_XDECREF(o);\r
- }\r
- APPEND(rc, "ErrorCode");\r
- APPEND(rc, "ErrorLineNumber");\r
- APPEND(rc, "ErrorColumnNumber");\r
- APPEND(rc, "ErrorByteIndex");\r
- APPEND(rc, "CurrentLineNumber");\r
- APPEND(rc, "CurrentColumnNumber");\r
- APPEND(rc, "CurrentByteIndex");\r
- APPEND(rc, "buffer_size");\r
- APPEND(rc, "buffer_text");\r
- APPEND(rc, "buffer_used");\r
- APPEND(rc, "namespace_prefixes");\r
- APPEND(rc, "ordered_attributes");\r
- APPEND(rc, "returns_unicode");\r
- APPEND(rc, "specified_attributes");\r
- APPEND(rc, "intern");\r
-\r
-#undef APPEND\r
- return rc;\r
- }\r
- return Py_FindMethod(xmlparse_methods, (PyObject *)self, name);\r
-}\r
-\r
-static int\r
-sethandler(xmlparseobject *self, const char *name, PyObject* v)\r
-{\r
- int handlernum = handlername2int(name);\r
- if (handlernum >= 0) {\r
- xmlhandler c_handler = NULL;\r
- PyObject *temp = self->handlers[handlernum];\r
-\r
- if (v == Py_None) {\r
- /* If this is the character data handler, and a character\r
- data handler is already active, we need to be more\r
- careful. What we can safely do is replace the existing\r
- character data handler callback function with a no-op\r
- function that will refuse to call Python. The downside\r
- is that this doesn't completely remove the character\r
- data handler from the C layer if there's any callback\r
- active, so Expat does a little more work than it\r
- otherwise would, but that's really an odd case. A more\r
- elaborate system of handlers and state could remove the\r
- C handler more effectively. */\r
- if (handlernum == CharacterData && self->in_callback)\r
- c_handler = noop_character_data_handler;\r
- v = NULL;\r
- }\r
- else if (v != NULL) {\r
- Py_INCREF(v);\r
- c_handler = handler_info[handlernum].handler;\r
- }\r
- self->handlers[handlernum] = v;\r
- Py_XDECREF(temp);\r
- handler_info[handlernum].setter(self->itself, c_handler);\r
- return 1;\r
- }\r
- return 0;\r
-}\r
-\r
-static int\r
-xmlparse_setattr(xmlparseobject *self, char *name, PyObject *v)\r
-{\r
- /* Set attribute 'name' to value 'v'. v==NULL means delete */\r
- if (v == NULL) {\r
- PyErr_SetString(PyExc_RuntimeError, "Cannot delete attribute");\r
- return -1;\r
- }\r
- if (strcmp(name, "buffer_text") == 0) {\r
- int b = PyObject_IsTrue(v);\r
- if (b < 0)\r
- return -1;\r
- if (b) {\r
- if (self->buffer == NULL) {\r
- self->buffer = malloc(self->buffer_size);\r
- if (self->buffer == NULL) {\r
- PyErr_NoMemory();\r
- return -1;\r
- }\r
- self->buffer_used = 0;\r
- }\r
- }\r
- else if (self->buffer != NULL) {\r
- if (flush_character_buffer(self) < 0)\r
- return -1;\r
- free(self->buffer);\r
- self->buffer = NULL;\r
- }\r
- return 0;\r
- }\r
- if (strcmp(name, "namespace_prefixes") == 0) {\r
- int b = PyObject_IsTrue(v);\r
- if (b < 0)\r
- return -1;\r
- self->ns_prefixes = b;\r
- XML_SetReturnNSTriplet(self->itself, self->ns_prefixes);\r
- return 0;\r
- }\r
- if (strcmp(name, "ordered_attributes") == 0) {\r
- int b = PyObject_IsTrue(v);\r
- if (b < 0)\r
- return -1;\r
- self->ordered_attributes = b;\r
- return 0;\r
- }\r
- if (strcmp(name, "returns_unicode") == 0) {\r
- int b = PyObject_IsTrue(v);\r
- if (b < 0)\r
- return -1;\r
-#ifndef Py_USING_UNICODE\r
- if (b) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "Unicode support not available");\r
- return -1;\r
- }\r
-#endif\r
- self->returns_unicode = b;\r
- return 0;\r
- }\r
- if (strcmp(name, "specified_attributes") == 0) {\r
- int b = PyObject_IsTrue(v);\r
- if (b < 0)\r
- return -1;\r
- self->specified_attributes = b;\r
- return 0;\r
- }\r
-\r
- if (strcmp(name, "buffer_size") == 0) {\r
- long new_buffer_size;\r
- if (!PyInt_Check(v)) {\r
- PyErr_SetString(PyExc_TypeError, "buffer_size must be an integer");\r
- return -1;\r
- }\r
-\r
- new_buffer_size=PyInt_AS_LONG(v);\r
- /* trivial case -- no change */\r
- if (new_buffer_size == self->buffer_size) {\r
- return 0;\r
- }\r
-\r
- if (new_buffer_size <= 0) {\r
- PyErr_SetString(PyExc_ValueError, "buffer_size must be greater than zero");\r
- return -1;\r
- }\r
-\r
- /* check maximum */\r
- if (new_buffer_size > INT_MAX) {\r
- char errmsg[100];\r
- sprintf(errmsg, "buffer_size must not be greater than %i", INT_MAX);\r
- PyErr_SetString(PyExc_ValueError, errmsg);\r
- return -1;\r
- }\r
-\r
- if (self->buffer != NULL) {\r
- /* there is already a buffer */\r
- if (self->buffer_used != 0) {\r
- flush_character_buffer(self);\r
- }\r
- /* free existing buffer */\r
- free(self->buffer);\r
- }\r
- self->buffer = malloc(new_buffer_size);\r
- if (self->buffer == NULL) {\r
- PyErr_NoMemory();\r
- return -1;\r
- }\r
- self->buffer_size = new_buffer_size;\r
- return 0;\r
- }\r
-\r
- if (strcmp(name, "CharacterDataHandler") == 0) {\r
- /* If we're changing the character data handler, flush all\r
- * cached data with the old handler. Not sure there's a\r
- * "right" thing to do, though, but this probably won't\r
- * happen.\r
- */\r
- if (flush_character_buffer(self) < 0)\r
- return -1;\r
- }\r
- if (sethandler(self, name, v)) {\r
- return 0;\r
- }\r
- PyErr_SetString(PyExc_AttributeError, name);\r
- return -1;\r
-}\r
-\r
-#ifdef WITH_CYCLE_GC\r
-static int\r
-xmlparse_traverse(xmlparseobject *op, visitproc visit, void *arg)\r
-{\r
- int i;\r
- for (i = 0; handler_info[i].name != NULL; i++)\r
- Py_VISIT(op->handlers[i]);\r
- return 0;\r
-}\r
-\r
-static int\r
-xmlparse_clear(xmlparseobject *op)\r
-{\r
- clear_handlers(op, 0);\r
- Py_CLEAR(op->intern);\r
- return 0;\r
-}\r
-#endif\r
-\r
-PyDoc_STRVAR(Xmlparsetype__doc__, "XML parser");\r
-\r
-static PyTypeObject Xmlparsetype = {\r
- PyVarObject_HEAD_INIT(NULL, 0)\r
- "pyexpat.xmlparser", /*tp_name*/\r
- sizeof(xmlparseobject) + PyGC_HEAD_SIZE,/*tp_basicsize*/\r
- 0, /*tp_itemsize*/\r
- /* methods */\r
- (destructor)xmlparse_dealloc, /*tp_dealloc*/\r
- (printfunc)0, /*tp_print*/\r
- (getattrfunc)xmlparse_getattr, /*tp_getattr*/\r
- (setattrfunc)xmlparse_setattr, /*tp_setattr*/\r
- (cmpfunc)0, /*tp_compare*/\r
- (reprfunc)0, /*tp_repr*/\r
- 0, /*tp_as_number*/\r
- 0, /*tp_as_sequence*/\r
- 0, /*tp_as_mapping*/\r
- (hashfunc)0, /*tp_hash*/\r
- (ternaryfunc)0, /*tp_call*/\r
- (reprfunc)0, /*tp_str*/\r
- 0, /* tp_getattro */\r
- 0, /* tp_setattro */\r
- 0, /* tp_as_buffer */\r
-#ifdef Py_TPFLAGS_HAVE_GC\r
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/\r
-#else\r
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /*tp_flags*/\r
-#endif\r
- Xmlparsetype__doc__, /* tp_doc - Documentation string */\r
-#ifdef WITH_CYCLE_GC\r
- (traverseproc)xmlparse_traverse, /* tp_traverse */\r
- (inquiry)xmlparse_clear /* tp_clear */\r
-#else\r
- 0, 0\r
-#endif\r
-};\r
-\r
-/* End of code for xmlparser objects */\r
-/* -------------------------------------------------------- */\r
-\r
-PyDoc_STRVAR(pyexpat_ParserCreate__doc__,\r
-"ParserCreate([encoding[, namespace_separator]]) -> parser\n\\r
-Return a new XML parser object.");\r
-\r
-static PyObject *\r
-pyexpat_ParserCreate(PyObject *notused, PyObject *args, PyObject *kw)\r
-{\r
- char *encoding = NULL;\r
- char *namespace_separator = NULL;\r
- PyObject *intern = NULL;\r
- PyObject *result;\r
- int intern_decref = 0;\r
- static char *kwlist[] = {"encoding", "namespace_separator",\r
- "intern", NULL};\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "|zzO:ParserCreate", kwlist,\r
- &encoding, &namespace_separator, &intern))\r
- return NULL;\r
- if (namespace_separator != NULL\r
- && strlen(namespace_separator) > 1) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "namespace_separator must be at most one"\r
- " character, omitted, or None");\r
- return NULL;\r
- }\r
- /* Explicitly passing None means no interning is desired.\r
- Not passing anything means that a new dictionary is used. */\r
- if (intern == Py_None)\r
- intern = NULL;\r
- else if (intern == NULL) {\r
- intern = PyDict_New();\r
- if (!intern)\r
- return NULL;\r
- intern_decref = 1;\r
- }\r
- else if (!PyDict_Check(intern)) {\r
- PyErr_SetString(PyExc_TypeError, "intern must be a dictionary");\r
- return NULL;\r
- }\r
-\r
- result = newxmlparseobject(encoding, namespace_separator, intern);\r
- if (intern_decref) {\r
- Py_DECREF(intern);\r
- }\r
- return result;\r
-}\r
-\r
-PyDoc_STRVAR(pyexpat_ErrorString__doc__,\r
-"ErrorString(errno) -> string\n\\r
-Returns string error for given number.");\r
-\r
-static PyObject *\r
-pyexpat_ErrorString(PyObject *self, PyObject *args)\r
-{\r
- long code = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "l:ErrorString", &code))\r
- return NULL;\r
- return Py_BuildValue("z", XML_ErrorString((int)code));\r
-}\r
-\r
-/* List of methods defined in the module */\r
-\r
-static struct PyMethodDef pyexpat_methods[] = {\r
- {"ParserCreate", (PyCFunction)pyexpat_ParserCreate,\r
- METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},\r
- {"ErrorString", (PyCFunction)pyexpat_ErrorString,\r
- METH_VARARGS, pyexpat_ErrorString__doc__},\r
-\r
- {NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */\r
-};\r
-\r
-/* Module docstring */\r
-\r
-PyDoc_STRVAR(pyexpat_module_documentation,\r
-"Python wrapper for Expat parser.");\r
-\r
-/* Initialization function for the module */\r
-\r
-#ifndef MODULE_NAME\r
-#define MODULE_NAME "pyexpat"\r
-#endif\r
-\r
-#ifndef MODULE_INITFUNC\r
-#define MODULE_INITFUNC initpyexpat\r
-#endif\r
-\r
-#ifndef PyMODINIT_FUNC\r
-# ifdef MS_WINDOWS\r
-# define PyMODINIT_FUNC __declspec(dllexport) void\r
-# else\r
-# define PyMODINIT_FUNC void\r
-# endif\r
-#endif\r
-\r
-PyMODINIT_FUNC MODULE_INITFUNC(void); /* avoid compiler warnings */\r
-\r
-PyMODINIT_FUNC\r
-MODULE_INITFUNC(void)\r
-{\r
- PyObject *m, *d;\r
- PyObject *errmod_name = PyString_FromString(MODULE_NAME ".errors");\r
- PyObject *errors_module;\r
- PyObject *modelmod_name;\r
- PyObject *model_module;\r
- PyObject *sys_modules;\r
- PyObject *version;\r
- static struct PyExpat_CAPI capi;\r
- PyObject* capi_object;\r
-\r
- if (errmod_name == NULL)\r
- return;\r
- modelmod_name = PyString_FromString(MODULE_NAME ".model");\r
- if (modelmod_name == NULL)\r
- return;\r
-\r
- Py_TYPE(&Xmlparsetype) = &PyType_Type;\r
-\r
- /* Create the module and add the functions */\r
- m = Py_InitModule3(MODULE_NAME, pyexpat_methods,\r
- pyexpat_module_documentation);\r
- if (m == NULL)\r
- return;\r
-\r
- /* Add some symbolic constants to the module */\r
- if (ErrorObject == NULL) {\r
- ErrorObject = PyErr_NewException("xml.parsers.expat.ExpatError",\r
- NULL, NULL);\r
- if (ErrorObject == NULL)\r
- return;\r
- }\r
- Py_INCREF(ErrorObject);\r
- PyModule_AddObject(m, "error", ErrorObject);\r
- Py_INCREF(ErrorObject);\r
- PyModule_AddObject(m, "ExpatError", ErrorObject);\r
- Py_INCREF(&Xmlparsetype);\r
- PyModule_AddObject(m, "XMLParserType", (PyObject *) &Xmlparsetype);\r
-\r
- version = PyString_FromString(PY_VERSION);\r
- if (!version)\r
- return;\r
- PyModule_AddObject(m, "__version__", version);\r
- PyModule_AddStringConstant(m, "EXPAT_VERSION",\r
- (char *) XML_ExpatVersion());\r
- {\r
- XML_Expat_Version info = XML_ExpatVersionInfo();\r
- PyModule_AddObject(m, "version_info",\r
- Py_BuildValue("(iii)", info.major,\r
- info.minor, info.micro));\r
- }\r
-#ifdef Py_USING_UNICODE\r
- init_template_buffer();\r
-#endif\r
- /* XXX When Expat supports some way of figuring out how it was\r
- compiled, this should check and set native_encoding\r
- appropriately.\r
- */\r
- PyModule_AddStringConstant(m, "native_encoding", "UTF-8");\r
-\r
- sys_modules = PySys_GetObject("modules");\r
- d = PyModule_GetDict(m);\r
- errors_module = PyDict_GetItem(d, errmod_name);\r
- if (errors_module == NULL) {\r
- errors_module = PyModule_New(MODULE_NAME ".errors");\r
- if (errors_module != NULL) {\r
- PyDict_SetItem(sys_modules, errmod_name, errors_module);\r
- /* gives away the reference to errors_module */\r
- PyModule_AddObject(m, "errors", errors_module);\r
- }\r
- }\r
- Py_DECREF(errmod_name);\r
- model_module = PyDict_GetItem(d, modelmod_name);\r
- if (model_module == NULL) {\r
- model_module = PyModule_New(MODULE_NAME ".model");\r
- if (model_module != NULL) {\r
- PyDict_SetItem(sys_modules, modelmod_name, model_module);\r
- /* gives away the reference to model_module */\r
- PyModule_AddObject(m, "model", model_module);\r
- }\r
- }\r
- Py_DECREF(modelmod_name);\r
- if (errors_module == NULL || model_module == NULL)\r
- /* Don't core dump later! */\r
- return;\r
-\r
-#if XML_COMBINED_VERSION > 19505\r
- {\r
- const XML_Feature *features = XML_GetFeatureList();\r
- PyObject *list = PyList_New(0);\r
- if (list == NULL)\r
- /* just ignore it */\r
- PyErr_Clear();\r
- else {\r
- int i = 0;\r
- for (; features[i].feature != XML_FEATURE_END; ++i) {\r
- int ok;\r
- PyObject *item = Py_BuildValue("si", features[i].name,\r
- features[i].value);\r
- if (item == NULL) {\r
- Py_DECREF(list);\r
- list = NULL;\r
- break;\r
- }\r
- ok = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (ok < 0) {\r
- PyErr_Clear();\r
- break;\r
- }\r
- }\r
- if (list != NULL)\r
- PyModule_AddObject(m, "features", list);\r
- }\r
- }\r
-#endif\r
-\r
-#define MYCONST(name) \\r
- PyModule_AddStringConstant(errors_module, #name, \\r
- (char*)XML_ErrorString(name))\r
-\r
- MYCONST(XML_ERROR_NO_MEMORY);\r
- MYCONST(XML_ERROR_SYNTAX);\r
- MYCONST(XML_ERROR_NO_ELEMENTS);\r
- MYCONST(XML_ERROR_INVALID_TOKEN);\r
- MYCONST(XML_ERROR_UNCLOSED_TOKEN);\r
- MYCONST(XML_ERROR_PARTIAL_CHAR);\r
- MYCONST(XML_ERROR_TAG_MISMATCH);\r
- MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE);\r
- MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT);\r
- MYCONST(XML_ERROR_PARAM_ENTITY_REF);\r
- MYCONST(XML_ERROR_UNDEFINED_ENTITY);\r
- MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF);\r
- MYCONST(XML_ERROR_ASYNC_ENTITY);\r
- MYCONST(XML_ERROR_BAD_CHAR_REF);\r
- MYCONST(XML_ERROR_BINARY_ENTITY_REF);\r
- MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF);\r
- MYCONST(XML_ERROR_MISPLACED_XML_PI);\r
- MYCONST(XML_ERROR_UNKNOWN_ENCODING);\r
- MYCONST(XML_ERROR_INCORRECT_ENCODING);\r
- MYCONST(XML_ERROR_UNCLOSED_CDATA_SECTION);\r
- MYCONST(XML_ERROR_EXTERNAL_ENTITY_HANDLING);\r
- MYCONST(XML_ERROR_NOT_STANDALONE);\r
- MYCONST(XML_ERROR_UNEXPECTED_STATE);\r
- MYCONST(XML_ERROR_ENTITY_DECLARED_IN_PE);\r
- MYCONST(XML_ERROR_FEATURE_REQUIRES_XML_DTD);\r
- MYCONST(XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING);\r
- /* Added in Expat 1.95.7. */\r
- MYCONST(XML_ERROR_UNBOUND_PREFIX);\r
- /* Added in Expat 1.95.8. */\r
- MYCONST(XML_ERROR_UNDECLARING_PREFIX);\r
- MYCONST(XML_ERROR_INCOMPLETE_PE);\r
- MYCONST(XML_ERROR_XML_DECL);\r
- MYCONST(XML_ERROR_TEXT_DECL);\r
- MYCONST(XML_ERROR_PUBLICID);\r
- MYCONST(XML_ERROR_SUSPENDED);\r
- MYCONST(XML_ERROR_NOT_SUSPENDED);\r
- MYCONST(XML_ERROR_ABORTED);\r
- MYCONST(XML_ERROR_FINISHED);\r
- MYCONST(XML_ERROR_SUSPEND_PE);\r
-\r
- PyModule_AddStringConstant(errors_module, "__doc__",\r
- "Constants used to describe error conditions.");\r
-\r
-#undef MYCONST\r
-\r
-#define MYCONST(c) PyModule_AddIntConstant(m, #c, c)\r
- MYCONST(XML_PARAM_ENTITY_PARSING_NEVER);\r
- MYCONST(XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);\r
- MYCONST(XML_PARAM_ENTITY_PARSING_ALWAYS);\r
-#undef MYCONST\r
-\r
-#define MYCONST(c) PyModule_AddIntConstant(model_module, #c, c)\r
- PyModule_AddStringConstant(model_module, "__doc__",\r
- "Constants used to interpret content model information.");\r
-\r
- MYCONST(XML_CTYPE_EMPTY);\r
- MYCONST(XML_CTYPE_ANY);\r
- MYCONST(XML_CTYPE_MIXED);\r
- MYCONST(XML_CTYPE_NAME);\r
- MYCONST(XML_CTYPE_CHOICE);\r
- MYCONST(XML_CTYPE_SEQ);\r
-\r
- MYCONST(XML_CQUANT_NONE);\r
- MYCONST(XML_CQUANT_OPT);\r
- MYCONST(XML_CQUANT_REP);\r
- MYCONST(XML_CQUANT_PLUS);\r
-#undef MYCONST\r
-\r
- /* initialize pyexpat dispatch table */\r
- capi.size = sizeof(capi);\r
- capi.magic = PyExpat_CAPI_MAGIC;\r
- capi.MAJOR_VERSION = XML_MAJOR_VERSION;\r
- capi.MINOR_VERSION = XML_MINOR_VERSION;\r
- capi.MICRO_VERSION = XML_MICRO_VERSION;\r
- capi.ErrorString = XML_ErrorString;\r
- capi.GetErrorCode = XML_GetErrorCode;\r
- capi.GetErrorColumnNumber = XML_GetErrorColumnNumber;\r
- capi.GetErrorLineNumber = XML_GetErrorLineNumber;\r
- capi.Parse = XML_Parse;\r
- capi.ParserCreate_MM = XML_ParserCreate_MM;\r
- capi.ParserFree = XML_ParserFree;\r
- capi.SetCharacterDataHandler = XML_SetCharacterDataHandler;\r
- capi.SetCommentHandler = XML_SetCommentHandler;\r
- capi.SetDefaultHandlerExpand = XML_SetDefaultHandlerExpand;\r
- capi.SetElementHandler = XML_SetElementHandler;\r
- capi.SetNamespaceDeclHandler = XML_SetNamespaceDeclHandler;\r
- capi.SetProcessingInstructionHandler = XML_SetProcessingInstructionHandler;\r
- capi.SetUnknownEncodingHandler = XML_SetUnknownEncodingHandler;\r
- capi.SetUserData = XML_SetUserData;\r
-\r
- /* export using capsule */\r
- capi_object = PyCapsule_New(&capi, PyExpat_CAPSULE_NAME, NULL);\r
- if (capi_object)\r
- PyModule_AddObject(m, "expat_CAPI", capi_object);\r
-}\r
-\r
-static void\r
-clear_handlers(xmlparseobject *self, int initial)\r
-{\r
- int i = 0;\r
- PyObject *temp;\r
-\r
- for (; handler_info[i].name != NULL; i++) {\r
- if (initial)\r
- self->handlers[i] = NULL;\r
- else {\r
- temp = self->handlers[i];\r
- self->handlers[i] = NULL;\r
- Py_XDECREF(temp);\r
- handler_info[i].setter(self->itself, NULL);\r
- }\r
- }\r
-}\r
-\r
-static struct HandlerInfo handler_info[] = {\r
- {"StartElementHandler",\r
- (xmlhandlersetter)XML_SetStartElementHandler,\r
- (xmlhandler)my_StartElementHandler},\r
- {"EndElementHandler",\r
- (xmlhandlersetter)XML_SetEndElementHandler,\r
- (xmlhandler)my_EndElementHandler},\r
- {"ProcessingInstructionHandler",\r
- (xmlhandlersetter)XML_SetProcessingInstructionHandler,\r
- (xmlhandler)my_ProcessingInstructionHandler},\r
- {"CharacterDataHandler",\r
- (xmlhandlersetter)XML_SetCharacterDataHandler,\r
- (xmlhandler)my_CharacterDataHandler},\r
- {"UnparsedEntityDeclHandler",\r
- (xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,\r
- (xmlhandler)my_UnparsedEntityDeclHandler},\r
- {"NotationDeclHandler",\r
- (xmlhandlersetter)XML_SetNotationDeclHandler,\r
- (xmlhandler)my_NotationDeclHandler},\r
- {"StartNamespaceDeclHandler",\r
- (xmlhandlersetter)XML_SetStartNamespaceDeclHandler,\r
- (xmlhandler)my_StartNamespaceDeclHandler},\r
- {"EndNamespaceDeclHandler",\r
- (xmlhandlersetter)XML_SetEndNamespaceDeclHandler,\r
- (xmlhandler)my_EndNamespaceDeclHandler},\r
- {"CommentHandler",\r
- (xmlhandlersetter)XML_SetCommentHandler,\r
- (xmlhandler)my_CommentHandler},\r
- {"StartCdataSectionHandler",\r
- (xmlhandlersetter)XML_SetStartCdataSectionHandler,\r
- (xmlhandler)my_StartCdataSectionHandler},\r
- {"EndCdataSectionHandler",\r
- (xmlhandlersetter)XML_SetEndCdataSectionHandler,\r
- (xmlhandler)my_EndCdataSectionHandler},\r
- {"DefaultHandler",\r
- (xmlhandlersetter)XML_SetDefaultHandler,\r
- (xmlhandler)my_DefaultHandler},\r
- {"DefaultHandlerExpand",\r
- (xmlhandlersetter)XML_SetDefaultHandlerExpand,\r
- (xmlhandler)my_DefaultHandlerExpandHandler},\r
- {"NotStandaloneHandler",\r
- (xmlhandlersetter)XML_SetNotStandaloneHandler,\r
- (xmlhandler)my_NotStandaloneHandler},\r
- {"ExternalEntityRefHandler",\r
- (xmlhandlersetter)XML_SetExternalEntityRefHandler,\r
- (xmlhandler)my_ExternalEntityRefHandler},\r
- {"StartDoctypeDeclHandler",\r
- (xmlhandlersetter)XML_SetStartDoctypeDeclHandler,\r
- (xmlhandler)my_StartDoctypeDeclHandler},\r
- {"EndDoctypeDeclHandler",\r
- (xmlhandlersetter)XML_SetEndDoctypeDeclHandler,\r
- (xmlhandler)my_EndDoctypeDeclHandler},\r
- {"EntityDeclHandler",\r
- (xmlhandlersetter)XML_SetEntityDeclHandler,\r
- (xmlhandler)my_EntityDeclHandler},\r
- {"XmlDeclHandler",\r
- (xmlhandlersetter)XML_SetXmlDeclHandler,\r
- (xmlhandler)my_XmlDeclHandler},\r
- {"ElementDeclHandler",\r
- (xmlhandlersetter)XML_SetElementDeclHandler,\r
- (xmlhandler)my_ElementDeclHandler},\r
- {"AttlistDeclHandler",\r
- (xmlhandlersetter)XML_SetAttlistDeclHandler,\r
- (xmlhandler)my_AttlistDeclHandler},\r
-#if XML_COMBINED_VERSION >= 19504\r
- {"SkippedEntityHandler",\r
- (xmlhandlersetter)XML_SetSkippedEntityHandler,\r
- (xmlhandler)my_SkippedEntityHandler},\r
-#endif\r
-\r
- {NULL, NULL, NULL} /* sentinel */\r
-};\r
projects / mirror_edk2.git / blobdiff