#include "Python.h"

#if PY_VERSION_HEX < 0x020000B1

#include <assert.h>

#endif

#include <ctype.h>

#include "compile.h"

#include "frameobject.h"

#include "expat.h"

#ifndef PyGC_HEAD_SIZE

#define PyGC_HEAD_SIZE 0

#define PyObject_GC_Init(x)

#define PyObject_GC_Fini(m)

#define Py_TPFLAGS_GC 0

#endif

#if (PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION > 5) || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2)

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

#define Py_USING_UNICODE

#endif

enum HandlerTypes {

StartElement,

EndElement,

ProcessingInstruction,

CharacterData,

UnparsedEntityDecl,

NotationDecl,

StartNamespaceDecl,

EndNamespaceDecl,

Comment,

StartCdataSection,

EndCdataSection,

Default,

DefaultHandlerExpand,

NotStandalone,

ExternalEntityRef,

StartDoctypeDecl,

EndDoctypeDecl,

EntityDecl,

XmlDecl,

ElementDecl,

AttlistDecl,

_DummyDecl

};

static PyObject *ErrorObject;

/* ----------------------------------------------------- */

/* Declarations for objects of type xmlparser */

typedef struct {

PyObject_HEAD

XML_Parser itself;

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

if false, UTF-8 strings are returned */

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

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

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

PyObject **handlers;

} xmlparseobject;

staticforward PyTypeObject Xmlparsetype;

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

typedef void* xmlhandler;

struct HandlerInfo {

const char *name;

xmlhandlersetter setter;

xmlhandler handler;

PyCodeObject *tb_code;

};

staticforward struct HandlerInfo handler_info[64];

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

* false on an exception.

*/

static int

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

{

PyObject *v = PyInt_FromLong(value);

if (v != NULL && PyObject_SetAttrString(err, name, v) == -1) {

Py_DECREF(v);

return 0;

}

return 1;

}

/* Build and set an Expat exception, including positioning

* information. Always returns NULL.

*/

static PyObject *

set_error(xmlparseobject *self)

{

PyObject *err;

char buffer[256];

XML_Parser parser = self->itself;

int lineno = XML_GetErrorLineNumber(parser);

int column = XML_GetErrorColumnNumber(parser);

enum XML_Error code = XML_GetErrorCode(parser);

PyOS_snprintf(buffer, sizeof(buffer), "%.200s: line %i, column %i",

XML_ErrorString(code), lineno, column);

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

if ( err != NULL

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

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

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

PyErr_SetObject(ErrorObject, err);

}

return NULL;

}

#ifdef Py_USING_UNICODE

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

Returns None if str is a null pointer. */

static PyObject *

conv_string_to_unicode(XML_Char *str)

{

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

and hence in UTF-8. */

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

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyUnicode_DecodeUTF8((const char *)str,

strlen((const char *)str),

"strict");

}

static PyObject *

conv_string_len_to_unicode(const XML_Char *str, int len)

{

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

and hence in UTF-8. */

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

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

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

}

#endif

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

Returns None if str is a null pointer. */

static PyObject *

conv_string_to_utf8(XML_Char *str)

{

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

and hence in UTF-8. */

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

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyString_FromString((const char *)str);

}

static PyObject *

conv_string_len_to_utf8(const XML_Char *str, int len)

{

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

and hence in UTF-8. */

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

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

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

}

/* Callback routines */

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

static void

flag_error(xmlparseobject *self)

{

clear_handlers(self, 0);

}

static PyCodeObject*

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

{

PyObject *code = NULL;

PyObject *name = NULL;

PyObject *nulltuple = NULL;

PyObject *filename = NULL;

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

code = PyString_FromString("");

if (code == NULL)

goto failed;

name = PyString_FromString(func_name);

if (name == NULL)

goto failed;

nulltuple = PyTuple_New(0);

if (nulltuple == NULL)

goto failed;

filename = PyString_FromString(__FILE__);

handler_info[slot].tb_code =

PyCode_New(0, /* argcount */

0, /* nlocals */

0, /* stacksize */

0, /* flags */

code, /* code */

nulltuple, /* consts */

nulltuple, /* names */

nulltuple, /* varnames */

#if PYTHON_API_VERSION >= 1010

nulltuple, /* freevars */

nulltuple, /* cellvars */

#endif

filename, /* filename */

name, /* name */

lineno, /* firstlineno */

code /* lnotab */

);

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

goto failed;

Py_DECREF(code);

Py_DECREF(nulltuple);

Py_DECREF(filename);

Py_DECREF(name);

}

return handler_info[slot].tb_code;

failed:

Py_XDECREF(code);

Py_XDECREF(name);

return NULL;

}

static PyObject*

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

{

PyThreadState *tstate = PyThreadState_GET();

PyFrameObject *f;

PyObject *res;

if (c == NULL)

return NULL;

f = PyFrame_New(

tstate, /*back*/

c, /*code*/

tstate->frame->f_globals, /*globals*/

NULL /*locals*/

);

if (f == NULL)

return NULL;

tstate->frame = f;

res = PyEval_CallObject(func, args);

if (res == NULL && tstate->curexc_traceback == NULL)

PyTraceBack_Here(f);

tstate->frame = f->f_back;

Py_DECREF(f);

return res;

}

#ifndef Py_USING_UNICODE

#define STRING_CONV_FUNC conv_string_to_utf8

#else

/* Python 1.6 and later versions */

#define STRING_CONV_FUNC (self->returns_unicode \

? conv_string_to_unicode : conv_string_to_utf8)

#endif

static void

my_StartElementHandler(void *userData,

const XML_Char *name, const XML_Char **atts)

{

xmlparseobject *self = (xmlparseobject *)userData;

if (self->handlers[StartElement]

&& self->handlers[StartElement] != Py_None) {

PyObject *container, *rv, *args;

int i, max;

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

* the number of attributes we need to process.

*/

if (self->specified_attributes) {

max = XML_GetSpecifiedAttributeCount(self->itself);

}

else {

max = 0;

while (atts[max] != NULL)

max += 2;

}

/* Build the container. */

if (self->ordered_attributes)

container = PyList_New(max);

else

container = PyDict_New();

if (container == NULL) {

flag_error(self);

return;

}

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

PyObject *n = STRING_CONV_FUNC((XML_Char *) atts[i]);

PyObject *v;

if (n == NULL) {

flag_error(self);

Py_DECREF(container);

return;

}

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

if (v == NULL) {

flag_error(self);

Py_DECREF(container);

Py_DECREF(n);

return;

}

if (self->ordered_attributes) {

PyList_SET_ITEM(container, i, n);

PyList_SET_ITEM(container, i+1, v);

}

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

flag_error(self);

Py_DECREF(n);

Py_DECREF(v);

return;

}

else {

Py_DECREF(n);

Py_DECREF(v);

}

}

args = Py_BuildValue("(O&N)", STRING_CONV_FUNC,name, container);

if (args == NULL) {

Py_DECREF(container);

return;

}

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

self->in_callback = 1;

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

self->handlers[StartElement], args);

self->in_callback = 0;

Py_DECREF(args);

if (rv == NULL) {

flag_error(self);

return;

}

Py_DECREF(rv);

}

}

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

RETURN, GETUSERDATA) \

static RC \

my_##NAME##Handler PARAMS {\

xmlparseobject *self = GETUSERDATA ; \

PyObject *args = NULL; \

PyObject *rv = NULL; \

INIT \

\

if (self->handlers[NAME] \

&& self->handlers[NAME] != Py_None) { \

args = Py_BuildValue PARAM_FORMAT ;\

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

self->in_callback = 1; \

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

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

self->in_callback = 0; \

Py_DECREF(args); \

if (rv == NULL) { \

flag_error(self); \

return RETURN; \

} \

CONVERSION \

Py_DECREF(rv); \

} \

return RETURN; \

}

#define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \

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

(xmlparseobject *)userData)

#define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\

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

rc = PyInt_AsLong(rv);, rc, \

(xmlparseobject *)userData)

VOID_HANDLER(EndElement,

(void *userData, const XML_Char *name),

("(O&)", STRING_CONV_FUNC, name))

VOID_HANDLER(ProcessingInstruction,

(void *userData,

const XML_Char *target,

const XML_Char *data),

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

#ifndef Py_USING_UNICODE

VOID_HANDLER(CharacterData,

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

("(N)", conv_string_len_to_utf8(data,len)))

#else

VOID_HANDLER(CharacterData,

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

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

? conv_string_len_to_unicode(data,len)

: conv_string_len_to_utf8(data,len))))

#endif

VOID_HANDLER(UnparsedEntityDecl,

(void *userData,

const XML_Char *entityName,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId,

const XML_Char *notationName),

("(O&O&O&O&O&)",

STRING_CONV_FUNC,entityName, STRING_CONV_FUNC,base,

STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId,

STRING_CONV_FUNC,notationName))

#ifndef Py_USING_UNICODE

VOID_HANDLER(EntityDecl,

(void *userData,

const XML_Char *entityName,

int is_parameter_entity,

const XML_Char *value,

int value_length,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId,

const XML_Char *notationName),

("O&iNO&O&O&O&",

STRING_CONV_FUNC,entityName, is_parameter_entity,

conv_string_len_to_utf8(value, value_length),

STRING_CONV_FUNC,base, STRING_CONV_FUNC,systemId,

STRING_CONV_FUNC,publicId, STRING_CONV_FUNC,notationName))

#else

VOID_HANDLER(EntityDecl,

(void *userData,

const XML_Char *entityName,

int is_parameter_entity,

const XML_Char *value,

int value_length,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId,

const XML_Char *notationName),

("O&iNO&O&O&O&",

STRING_CONV_FUNC,entityName, is_parameter_entity,

(self->returns_unicode

? conv_string_len_to_unicode(value, value_length)

: conv_string_len_to_utf8(value, value_length)),

STRING_CONV_FUNC,base, STRING_CONV_FUNC,systemId,

STRING_CONV_FUNC,publicId, STRING_CONV_FUNC,notationName))

#endif

VOID_HANDLER(XmlDecl,

(void *userData,

const XML_Char *version,

const XML_Char *encoding,

int standalone),

("(O&O&i)",

STRING_CONV_FUNC,version, STRING_CONV_FUNC,encoding,

standalone))

static PyObject *

conv_content_model(XML_Content * const model,

PyObject *(*conv_string)(XML_Char *))

{

PyObject *result = NULL;

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

int i;

if (children != NULL) {

assert(model->numchildren < INT_MAX);

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

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

conv_string);

if (child == NULL) {

Py_XDECREF(children);

return NULL;

}

PyTuple_SET_ITEM(children, i, child);

}

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

model->type, model->quant,

conv_string,model->name, children);

}

return result;

}

static PyObject *

conv_content_model_utf8(XML_Content * const model)

{

return conv_content_model(model, conv_string_to_utf8);

}

#ifdef Py_USING_UNICODE

static PyObject *

conv_content_model_unicode(XML_Content * const model)

{

return conv_content_model(model, conv_string_to_unicode);

}

VOID_HANDLER(ElementDecl,

(void *userData,

const XML_Char *name,

XML_Content *model),

("O&O&",

STRING_CONV_FUNC,name,

(self->returns_unicode ? conv_content_model_unicode

: conv_content_model_utf8),model))

#else

VOID_HANDLER(ElementDecl,

(void *userData,

const XML_Char *name,

XML_Content *model),

("O&O&",

STRING_CONV_FUNC,name, conv_content_model_utf8,model))

#endif

VOID_HANDLER(AttlistDecl,

(void *userData,

const XML_Char *elname,

const XML_Char *attname,

const XML_Char *att_type,

const XML_Char *dflt,

int isrequired),

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

STRING_CONV_FUNC,elname, STRING_CONV_FUNC,attname,

STRING_CONV_FUNC,att_type, STRING_CONV_FUNC,dflt,

isrequired))

VOID_HANDLER(NotationDecl,

(void *userData,

const XML_Char *notationName,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId),

("(O&O&O&O&)",

STRING_CONV_FUNC,notationName, STRING_CONV_FUNC,base,

STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId))

VOID_HANDLER(StartNamespaceDecl,

(void *userData,

const XML_Char *prefix,

const XML_Char *uri),

("(O&O&)", STRING_CONV_FUNC,prefix, STRING_CONV_FUNC,uri))

VOID_HANDLER(EndNamespaceDecl,

(void *userData,

const XML_Char *prefix),

("(O&)", STRING_CONV_FUNC,prefix))

VOID_HANDLER(Comment,

(void *userData, const XML_Char *prefix),

("(O&)", STRING_CONV_FUNC,prefix))

VOID_HANDLER(StartCdataSection,

(void *userData),

("()"))

VOID_HANDLER(EndCdataSection,

(void *userData),

("()"))

#ifndef Py_USING_UNICODE

VOID_HANDLER(Default,

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

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

VOID_HANDLER(DefaultHandlerExpand,

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

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

#else

VOID_HANDLER(Default,

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

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

? conv_string_len_to_unicode(s,len)

: conv_string_len_to_utf8(s,len))))

VOID_HANDLER(DefaultHandlerExpand,

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

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

? conv_string_len_to_unicode(s,len)

: conv_string_len_to_utf8(s,len))))

#endif

INT_HANDLER(NotStandalone,

(void *userData),

("()"))

RC_HANDLER(int, ExternalEntityRef,

(XML_Parser parser,

const XML_Char *context,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId),

int rc=0;,

("(O&O&O&O&)",

STRING_CONV_FUNC,context, STRING_CONV_FUNC,base,

STRING_CONV_FUNC,systemId, STRING_CONV_FUNC,publicId),

rc = PyInt_AsLong(rv);, rc,

XML_GetUserData(parser))

/* XXX UnknownEncodingHandler */

VOID_HANDLER(StartDoctypeDecl,

(void *userData, const XML_Char *doctypeName,

const XML_Char *sysid, const XML_Char *pubid,

int has_internal_subset),

("(O&O&O&i)", STRING_CONV_FUNC,doctypeName,

STRING_CONV_FUNC,sysid, STRING_CONV_FUNC,pubid,

has_internal_subset))

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

/* ---------------------------------------------------------------- */

static char xmlparse_Parse__doc__[] =

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

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

static PyObject *

xmlparse_Parse(xmlparseobject *self, PyObject *args)

{

char *s;

int slen;

int isFinal = 0;

int rv;

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

return NULL;

rv = XML_Parse(self->itself, s, slen, isFinal);

if (PyErr_Occurred()) {

return NULL;

}

else if (rv == 0) {

return set_error(self);

}

return PyInt_FromLong(rv);

}

/* File reading copied from cPickle */

#define BUF_SIZE 2048

static int

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

{

PyObject *arg = NULL;

PyObject *bytes = NULL;

PyObject *str = NULL;

int len = -1;

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

goto finally;

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

goto finally;

PyTuple_SET_ITEM(arg, 0, bytes);

if ((str = PyObject_CallObject(meth, arg)) == NULL)

goto finally;

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

if (!PyString_Check(str)) {

PyErr_Format(PyExc_TypeError,

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

str->ob_type->tp_name);

goto finally;

}

len = PyString_GET_SIZE(str);

if (len > buf_size) {

PyErr_Format(PyExc_ValueError,

"read() returned too much data: "

"%i bytes requested, %i returned",

buf_size, len);

Py_DECREF(str);

goto finally;

}

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

finally:

Py_XDECREF(arg);

Py_XDECREF(str);

return len;

}

static char xmlparse_ParseFile__doc__[] =

"ParseFile(file)\n\

Parse XML data from file-like object.";

static PyObject *

xmlparse_ParseFile(xmlparseobject *self, PyObject *args)

{

int rv = 1;

PyObject *f;

FILE *fp;

PyObject *readmethod = NULL;

if (!PyArg_ParseTuple(args, "O:ParseFile", &f))

return NULL;

if (PyFile_Check(f)) {

fp = PyFile_AsFile(f);

}

else{

fp = NULL;

readmethod = PyObject_GetAttrString(f, "read");

if (readmethod == NULL) {

PyErr_Clear();

PyErr_SetString(PyExc_TypeError,

"argument must have 'read' attribute");

return 0;

}

}

for (;;) {

int bytes_read;

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

if (buf == NULL)

return PyErr_NoMemory();

if (fp) {

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

if (bytes_read < 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

}

else {

bytes_read = readinst(buf, BUF_SIZE, readmethod);

if (bytes_read < 0)

return NULL;

}

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

if (PyErr_Occurred())

return NULL;

if (!rv || bytes_read == 0)

break;

}

if (rv == 0) {

return set_error(self);

}

return Py_BuildValue("i", rv);

}

static char xmlparse_SetBase__doc__[] =

"SetBase(base_url)\n\

Set the base URL for the parser.";

static PyObject *

xmlparse_SetBase(xmlparseobject *self, PyObject *args)

{

char *base;

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

return NULL;

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

return PyErr_NoMemory();

}

Py_INCREF(Py_None);

return Py_None;

}

static char xmlparse_GetBase__doc__[] =

"GetBase() -> url\n\

Return base URL string for the parser.";

static PyObject *

xmlparse_GetBase(xmlparseobject *self, PyObject *args)

{

if (!PyArg_ParseTuple(args, ":GetBase"))

return NULL;

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

}

static char xmlparse_GetInputContext__doc__[] =

"GetInputContext() -> string\n\

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

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

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

static PyObject *

xmlparse_GetInputContext(xmlparseobject *self, PyObject *args)

{

PyObject *result = NULL;

if (PyArg_ParseTuple(args, ":GetInputContext")) {

if (self->in_callback) {

int offset, size;

const char *buffer

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

if (buffer != NULL)

result = PyString_FromStringAndSize(buffer + offset, size);

else {

result = Py_None;

Py_INCREF(result);

}

}

else {

result = Py_None;

Py_INCREF(result);

}

}

return result;

}

static char xmlparse_ExternalEntityParserCreate__doc__[] =

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

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

information passed to the ExternalEntityRefHandler.";

static PyObject *

xmlparse_ExternalEntityParserCreate(xmlparseobject *self, PyObject *args)

{

char *context;

char *encoding = NULL;

xmlparseobject *new_parser;

int i;

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

&context, &encoding)) {

return NULL;

}

#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6

new_parser = PyObject_NEW(xmlparseobject, &Xmlparsetype);

#else

#ifndef Py_TPFLAGS_HAVE_GC

/* Python versions 1.6 to 2.1 */

new_parser = PyObject_New(xmlparseobject, &Xmlparsetype);

#else

/* Python versions 2.2 and later */

new_parser = PyObject_GC_New(xmlparseobject, &Xmlparsetype);

#endif

#endif

if (new_parser == NULL)

return NULL;

new_parser->returns_unicode = self->returns_unicode;

new_parser->ordered_attributes = self->ordered_attributes;

new_parser->specified_attributes = self->specified_attributes;

new_parser->in_callback = 0;

new_parser->itself = XML_ExternalEntityParserCreate(self->itself, context,

encoding);

new_parser->handlers = 0;

#ifdef Py_TPFLAGS_HAVE_GC

PyObject_GC_Track(new_parser);

#else

PyObject_GC_Init(new_parser);

#endif

if (!new_parser->itself) {

Py_DECREF(new_parser);

return PyErr_NoMemory();

}

XML_SetUserData(new_parser->itself, (void *)new_parser);

/* allocate and clear handlers first */

for(i = 0; handler_info[i].name != NULL; i++)

/* do nothing */;

new_parser->handlers = malloc(sizeof(PyObject *)*i);

if (!new_parser->handlers) {

Py_DECREF(new_parser);

return PyErr_NoMemory();

}

clear_handlers(new_parser, 1);

/* then copy handlers from self */

for (i = 0; handler_info[i].name != NULL; i++) {

if (self->handlers[i]) {

Py_INCREF(self->handlers[i]);

new_parser->handlers[i] = self->handlers[i];

handler_info[i].setter(new_parser->itself,

handler_info[i].handler);

}

}

return (PyObject *)new_parser;

}

static char xmlparse_SetParamEntityParsing__doc__[] =

"SetParamEntityParsing(flag) -> success\n\

Controls parsing of parameter entities (including the external DTD\n\

subset). Possible flag values are XML_PARAM_ENTITY_PARSING_NEVER,\n\

XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE and\n\

XML_PARAM_ENTITY_PARSING_ALWAYS. Returns true if setting the flag\n\

was successful.";

static PyObject*

xmlparse_SetParamEntityParsing(xmlparseobject *p, PyObject* args)

{

int flag;

if (!PyArg_ParseTuple(args, "i", &flag))

return NULL;

flag = XML_SetParamEntityParsing(p->itself, flag);

return PyInt_FromLong(flag);

}

static struct PyMethodDef xmlparse_methods[] = {

{"Parse", (PyCFunction)xmlparse_Parse,

METH_VARARGS, xmlparse_Parse__doc__},

{"ParseFile", (PyCFunction)xmlparse_ParseFile,

METH_VARARGS, xmlparse_ParseFile__doc__},

{"SetBase", (PyCFunction)xmlparse_SetBase,

METH_VARARGS, xmlparse_SetBase__doc__},

{"GetBase", (PyCFunction)xmlparse_GetBase,

METH_VARARGS, xmlparse_GetBase__doc__},

{"ExternalEntityParserCreate", (PyCFunction)xmlparse_ExternalEntityParserCreate,

METH_VARARGS, xmlparse_ExternalEntityParserCreate__doc__},

{"SetParamEntityParsing", (PyCFunction)xmlparse_SetParamEntityParsing,

METH_VARARGS, xmlparse_SetParamEntityParsing__doc__},

{"GetInputContext", (PyCFunction)xmlparse_GetInputContext,

METH_VARARGS, xmlparse_GetInputContext__doc__},

{NULL, NULL} /* sentinel */

};

/* ---------- */

#ifdef Py_USING_UNICODE

/*

pyexpat international encoding support.

Make it as simple as possible.

*/

static char template_buffer[257];

PyObject *template_string = NULL;

static void

init_template_buffer(void)

{

int i;

for (i = 0; i < 256; i++) {

template_buffer[i] = i;

}

template_buffer[256] = 0;

}

int

PyUnknownEncodingHandler(void *encodingHandlerData,

const XML_Char *name,

XML_Encoding * info)

{

PyUnicodeObject *_u_string = NULL;

int result = 0;

int i;

/* Yes, supports only 8bit encodings */

_u_string = (PyUnicodeObject *)

PyUnicode_Decode(template_buffer, 256, name, "replace");

if (_u_string == NULL)

return result;

for (i = 0; i < 256; i++) {

/* Stupid to access directly, but fast */

Py_UNICODE c = _u_string->str[i];

if (c == Py_UNICODE_REPLACEMENT_CHARACTER)

info->map[i] = -1;

else

info->map[i] = c;

}

info->data = NULL;

info->convert = NULL;

info->release = NULL;

result=1;

Py_DECREF(_u_string);

return result;

}

#endif

static PyObject *

newxmlparseobject(char *encoding, char *namespace_separator)

{

int i;

xmlparseobject *self;

#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6

self = PyObject_NEW(xmlparseobject, &Xmlparsetype);

if (self == NULL)

return NULL;