#include "Python.h"

#include <ctype.h>

#include "frameobject.h"

#include "expat.h"

#include "pyexpat.h"

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

#define FIX_TRACE

enum HandlerTypes {

StartElement,

EndElement,

ProcessingInstruction,

CharacterData,

UnparsedEntityDecl,

NotationDecl,

StartNamespaceDecl,

EndNamespaceDecl,

Comment,

StartCdataSection,

EndCdataSection,

Default,

DefaultHandlerExpand,

NotStandalone,

ExternalEntityRef,

StartDoctypeDecl,

EndDoctypeDecl,

EntityDecl,

XmlDecl,

ElementDecl,

AttlistDecl,

#if XML_COMBINED_VERSION >= 19504

SkippedEntity,

#endif

_DummyDecl

};

static PyObject *ErrorObject;

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

/* Declarations for objects of type xmlparser */

typedef struct {

PyObject_HEAD

XML_Parser itself;

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

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

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

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

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

/* NULL if not enabled */

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

int buffer_used; /* Buffer units in use */

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

PyObject **handlers;

} xmlparseobject;

#define CHARACTER_DATA_BUFFER_SIZE 8192

static 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;

PyObject *nameobj;

};

static 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 = PyLong_FromLong(value);

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

Py_XDECREF(v);

return 0;

}

Py_DECREF(v);

return 1;

}

/* Build and set an Expat exception, including positioning

* information. Always returns NULL.

*/

static PyObject *

set_error(xmlparseobject *self, enum XML_Error code)

{

PyObject *err;

PyObject *buffer;

XML_Parser parser = self->itself;

int lineno = XML_GetErrorLineNumber(parser);

int column = XML_GetErrorColumnNumber(parser);

buffer = PyUnicode_FromFormat("%s: line %i, column %i",

XML_ErrorString(code), lineno, column);

if (buffer == NULL)

return NULL;

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

Py_DECREF(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);

}

Py_XDECREF(err);

return NULL;

}

static int

have_handler(xmlparseobject *self, int type)

{

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

return handler != NULL;

}

static PyObject *

get_handler_name(struct HandlerInfo *hinfo)

{

PyObject *name = hinfo->nameobj;

if (name == NULL) {

name = PyUnicode_FromString(hinfo->name);

hinfo->nameobj = name;

}

Py_XINCREF(name);

return name;

}

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

Returns None if str is a null pointer. */

static PyObject *

conv_string_to_unicode(const 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(str, strlen(str), "strict");

}

static PyObject *

conv_string_len_to_unicode(const XML_Char *str, int len)

{

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

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");

}

/* Callback routines */

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

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

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

if an external entity reference is encountered. */

static int

error_external_entity_ref_handler(XML_Parser parser,

const XML_Char *context,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId)

{

return 0;

}

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

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

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

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

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

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

static void

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

{

/* Do nothing. */

}

static void

flag_error(xmlparseobject *self)

{

clear_handlers(self, 0);

XML_SetExternalEntityRefHandler(self->itself,

error_external_entity_ref_handler);

}

static PyCodeObject*

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

{

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

handler_info[slot].tb_code =

PyCode_NewEmpty(__FILE__, func_name, lineno);

}

return handler_info[slot].tb_code;

}

#ifdef FIX_TRACE

static int

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

{

int result = 0;

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

return 0;

if (tstate->c_profilefunc != NULL) {

tstate->tracing++;

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

f, code , val);

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

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

tstate->tracing--;

if (result)

return result;

}

if (tstate->c_tracefunc != NULL) {

tstate->tracing++;

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

f, code , val);

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

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

tstate->tracing--;

}

return result;

}

static int

trace_frame_exc(PyThreadState *tstate, PyFrameObject *f)

{

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

int err;

if (tstate->c_tracefunc == NULL)

return 0;

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

if (value == NULL) {

value = Py_None;

Py_INCREF(value);

}

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

if (arg == NULL) {

PyErr_Restore(type, value, traceback);

return 0;

}

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

Py_DECREF(arg);

if (err == 0)

PyErr_Restore(type, value, traceback);

else {

Py_XDECREF(type);

Py_XDECREF(value);

Py_XDECREF(traceback);

}

return err;

}

#endif

static PyObject*

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

xmlparseobject *self)

{

PyThreadState *tstate = PyThreadState_GET();

PyFrameObject *f;

PyObject *res;

if (c == NULL)

return NULL;

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

if (f == NULL)

return NULL;

tstate->frame = f;

#ifdef FIX_TRACE

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

return NULL;

}

#endif

res = PyEval_CallObject(func, args);

if (res == NULL) {

if (tstate->curexc_traceback == NULL)

PyTraceBack_Here(f);

XML_StopParser(self->itself, XML_FALSE);

#ifdef FIX_TRACE

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

return NULL;

}

}

else {

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

Py_XDECREF(res);

res = NULL;

}

}

#else

}

#endif

tstate->frame = f->f_back;

Py_DECREF(f);

return res;

}

static PyObject*

string_intern(xmlparseobject *self, const char* str)

{

PyObject *result = conv_string_to_unicode(str);

PyObject *value;

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

if (!result)

return result;

if (!self->intern)

return result;

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

if (!value) {

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

return result;

else

return NULL;

}

Py_INCREF(value);

Py_DECREF(result);

return value;

}

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

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

*/

static int

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

{

PyObject *args;

PyObject *temp;

if (!have_handler(self, CharacterData))

return -1;

args = PyTuple_New(1);

if (args == NULL)

return -1;

temp = (conv_string_len_to_unicode(buffer, len));

if (temp == NULL) {

Py_DECREF(args);

flag_error(self);

XML_SetCharacterDataHandler(self->itself,

noop_character_data_handler);

return -1;

}

PyTuple_SET_ITEM(args, 0, temp);

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

self->in_callback = 1;

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

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

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

self->in_callback = 0;

Py_DECREF(args);

if (temp == NULL) {

flag_error(self);

XML_SetCharacterDataHandler(self->itself,

noop_character_data_handler);

return -1;

}

Py_DECREF(temp);

return 0;

}

static int

flush_character_buffer(xmlparseobject *self)

{

int rc;

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

return 0;

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

self->buffer_used = 0;

return rc;

}

static void

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

{

xmlparseobject *self = (xmlparseobject *) userData;

if (self->buffer == NULL)

call_character_handler(self, data, len);

else {

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

if (flush_character_buffer(self) < 0)

return;

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

* if there isn't a handler anymore

*/

if (!have_handler(self, CharacterData))

return;

}

if (len > self->buffer_size) {

call_character_handler(self, data, len);

self->buffer_used = 0;

}

else {

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

data, len * sizeof(XML_Char));

self->buffer_used += len;

}

}

}

static void

my_StartElementHandler(void *userData,

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

{

xmlparseobject *self = (xmlparseobject *)userData;

if (have_handler(self, StartElement)) {

PyObject *container, *rv, *args;

int i, max;

if (flush_character_buffer(self) < 0)

return;

/* 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_intern(self, (XML_Char *) atts[i]);

PyObject *v;

if (n == NULL) {

flag_error(self);

Py_DECREF(container);

return;

}

v = conv_string_to_unicode((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 = string_intern(self, name);

if (args != NULL)

args = Py_BuildValue("(NN)", args, 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);

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 (have_handler(self, NAME)) { \

if (flush_character_buffer(self) < 0) \

return RETURN; \

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); \

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 = PyLong_AsLong(rv);, rc, \

(xmlparseobject *)userData)

VOID_HANDLER(EndElement,

(void *userData, const XML_Char *name),

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

VOID_HANDLER(ProcessingInstruction,

(void *userData,

const XML_Char *target,

const XML_Char *data),

("(NO&)", string_intern(self, target), conv_string_to_unicode ,data))

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),

("(NNNNN)",

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

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

string_intern(self, notationName)))

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),

("NiNNNNN",

string_intern(self, entityName), is_parameter_entity,

(conv_string_len_to_unicode(value, value_length)),

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

string_intern(self, publicId),

string_intern(self, notationName)))

VOID_HANDLER(XmlDecl,

(void *userData,

const XML_Char *version,

const XML_Char *encoding,

int standalone),

("(O&O&i)",

conv_string_to_unicode ,version, conv_string_to_unicode ,encoding,

standalone))

static PyObject *

conv_content_model(XML_Content * const model,

PyObject *(*conv_string)(const 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 void

my_ElementDeclHandler(void *userData,

const XML_Char *name,

XML_Content *model)

{

xmlparseobject *self = (xmlparseobject *)userData;

PyObject *args = NULL;

if (have_handler(self, ElementDecl)) {

PyObject *rv = NULL;

PyObject *modelobj, *nameobj;

if (flush_character_buffer(self) < 0)

goto finally;

modelobj = conv_content_model(model, (conv_string_to_unicode));

if (modelobj == NULL) {

flag_error(self);

goto finally;

}

nameobj = string_intern(self, name);

if (nameobj == NULL) {

Py_DECREF(modelobj);

flag_error(self);

goto finally;

}

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

if (args == NULL) {

Py_DECREF(modelobj);

flag_error(self);

goto finally;

}

self->in_callback = 1;

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

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

self->in_callback = 0;

if (rv == NULL) {

flag_error(self);

goto finally;

}

Py_DECREF(rv);

}

finally:

Py_XDECREF(args);

XML_FreeContentModel(self->itself, model);

return;

}

VOID_HANDLER(AttlistDecl,

(void *userData,

const XML_Char *elname,

const XML_Char *attname,

const XML_Char *att_type,

const XML_Char *dflt,

int isrequired),

("(NNO&O&i)",

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

conv_string_to_unicode ,att_type, conv_string_to_unicode ,dflt,

isrequired))

#if XML_COMBINED_VERSION >= 19504

VOID_HANDLER(SkippedEntity,

(void *userData,

const XML_Char *entityName,

int is_parameter_entity),

("Ni",

string_intern(self, entityName), is_parameter_entity))

#endif

VOID_HANDLER(NotationDecl,

(void *userData,

const XML_Char *notationName,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId),

("(NNNN)",

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

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

VOID_HANDLER(StartNamespaceDecl,

(void *userData,

const XML_Char *prefix,

const XML_Char *uri),

("(NN)",

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

VOID_HANDLER(EndNamespaceDecl,

(void *userData,

const XML_Char *prefix),

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

VOID_HANDLER(Comment,

(void *userData, const XML_Char *data),

("(O&)", conv_string_to_unicode ,data))

VOID_HANDLER(StartCdataSection,

(void *userData),

("()"))

VOID_HANDLER(EndCdataSection,

(void *userData),

("()"))

VOID_HANDLER(Default,

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

("(N)", (conv_string_len_to_unicode(s,len))))

VOID_HANDLER(DefaultHandlerExpand,

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

("(N)", (conv_string_len_to_unicode(s,len))))

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&NNN)",

conv_string_to_unicode ,context, string_intern(self, base),

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

rc = PyLong_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),

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

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

has_internal_subset))

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

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

static PyObject *

get_parse_result(xmlparseobject *self, int rv)

{

if (PyErr_Occurred()) {

return NULL;

}

if (rv == 0) {

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

}

if (flush_character_buffer(self) < 0) {

return NULL;

}

return PyLong_FromLong(rv);

}

PyDoc_STRVAR(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;

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

return NULL;

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

}

/* File reading copied from cPickle */

#define BUF_SIZE 2048

static int

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

{

PyObject *str;

Py_ssize_t len;

char *ptr;

str = PyObject_CallFunction(meth, "n", buf_size);

if (str == NULL)

goto error;

if (PyBytes_Check(str))

ptr = PyBytes_AS_STRING(str);

else if (PyByteArray_Check(str))

ptr = PyByteArray_AS_STRING(str);

else {

PyErr_Format(PyExc_TypeError,

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

Py_TYPE(str)->tp_name);

goto error;

}

len = Py_SIZE(str);

if (len > buf_size) {

PyErr_Format(PyExc_ValueError,

"read() returned too much data: "

"%i bytes requested, %zd returned",

buf_size, len);

goto error;

}

memcpy(buf, ptr, len);

Py_DECREF(str);

/* len <= buf_size <= INT_MAX */

return (int)len;

error:

Py_XDECREF(str);

return -1;

}

PyDoc_STRVAR(xmlparse_ParseFile__doc__,

"ParseFile(file)\n\

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

static PyObject *

xmlparse_ParseFile(xmlparseobject *self, PyObject *f)

{

int rv = 1;

PyObject *readmethod = NULL;

_Py_identifier(read);

readmethod = _PyObject_GetAttrId(f, &PyId_read);

if (readmethod == NULL) {

PyErr_SetString(PyExc_TypeError,

"argument must have 'read' attribute");

return NULL;

}

for (;;) {

int bytes_read;

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

if (buf == NULL) {

Py_XDECREF(readmethod);

return PyErr_NoMemory();

}

bytes_read = readinst(buf, BUF_SIZE, readmethod);

if (bytes_read < 0) {

Py_DECREF(readmethod);

return NULL;

}

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

if (PyErr_Occurred()) {

Py_XDECREF(readmethod);

return NULL;

}

if (!rv || bytes_read == 0)

break;

}

Py_XDECREF(readmethod);

return get_parse_result(self, rv);

}

PyDoc_STRVAR(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;

}

PyDoc_STRVAR(xmlparse_GetBase__doc__,

"GetBase() -> url\n\

Return base URL string for the parser.");

static PyObject *

xmlparse_GetBase(xmlparseobject *self, PyObject *unused)

{

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

}

PyDoc_STRVAR(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 *unused)

{

if (self->in_callback) {

int offset, size;

const char *buffer

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

if (buffer != NULL)

return PyBytes_FromStringAndSize(buffer + offset,

size - offset);

else

Py_RETURN_NONE;

}

else

Py_RETURN_NONE;

}

PyDoc_STRVAR(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;

}

new_parser = PyObject_GC_New(xmlparseobject, &Xmlparsetype);

if (new_parser == NULL)

return NULL;

new_parser->buffer_size = self->buffer_size;

new_parser->buffer_used = 0;

new_parser->buffer = NULL;

new_parser->ordered_attributes = self->ordered_attributes;

new_parser->specified_attributes = self->specified_attributes;

new_parser->in_callback = 0;

new_parser->ns_prefixes = self->ns_prefixes;

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

encoding);

new_parser->handlers = 0;

new_parser->intern = self->intern;

Py_XINCREF(new_parser->intern);

PyObject_GC_Track(new_parser);

if (self->buffer != NULL) {

new_parser->buffer = malloc(new_parser->buffer_size);

if (new_parser->buffer == NULL) {

Py_DECREF(new_parser);

return PyErr_NoMemory();

}

}

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++) {

PyObject *handler = self->handlers[i];

if (handler != NULL) {

Py_INCREF(handler);

new_parser->handlers[i] = handler;

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

handler_info[i].handler);

}