#include "Python.h"

#include <ctype.h>

#include "compile.h"

#include "frameobject.h"

#ifdef HAVE_EXPAT_H

#include "expat.h"

#ifdef XML_MAJOR_VERSION

#define EXPAT_VERSION (0x10000 * XML_MAJOR_VERSION \

+ 0x100 * XML_MINOR_VERSION \

+ XML_MICRO_VERSION)

#else

/* Assume the oldest Expat that used expat.h and did not have version info */

#define EXPAT_VERSION 0x015f00

#endif

#else /* !defined(HAVE_EXPAT_H) */

#include "xmlparse.h"

/* Assume Expat 1.1 unless told otherwise */

#ifndef EXPAT_VERSION

#define EXPAT_VERSION 0x010100

#endif

#endif /* !defined(HAVE_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,

#if EXPAT_VERSION >= 0x010200

StartDoctypeDecl,

EndDoctypeDecl,

#endif

#if EXPAT_VERSION == 0x010200

ExternalParsedEntityDecl,

InternalParsedEntityDecl,

#endif

#if EXPAT_VERSION >= 0x015f00

EntityDecl,

XmlDecl,

ElementDecl,

AttlistDecl,

#endif

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

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

}

#if EXPAT_VERSION == 0x010200

/* Convert an array of attributes and their values into a Python dict */

static PyObject *

conv_atts_using_string(XML_Char **atts)

{

PyObject *attrs_obj = NULL;

XML_Char **attrs_p, **attrs_k = NULL;

int attrs_len;

PyObject *rv;

if ((attrs_obj = PyDict_New()) == NULL)

goto finally;

for (attrs_len = 0, attrs_p = atts;

*attrs_p;

attrs_p++, attrs_len++) {

if (attrs_len % 2) {

rv = PyString_FromString(*attrs_p);

if (!rv) {

Py_DECREF(attrs_obj);

attrs_obj = NULL;

goto finally;

}

if (PyDict_SetItemString(attrs_obj,

(char*)*attrs_k, rv) < 0) {

Py_DECREF(attrs_obj);

attrs_obj = NULL;

goto finally;

}

Py_DECREF(rv);

}

else

attrs_k = attrs_p;

}

finally:

return attrs_obj;

}

#endif

#ifdef Py_USING_UNICODE

#if EXPAT_VERSION == 0x010200

static PyObject *

conv_atts_using_unicode(XML_Char **atts)

{

PyObject *attrs_obj;

XML_Char **attrs_p, **attrs_k = NULL;

int attrs_len;

if ((attrs_obj = PyDict_New()) == NULL)

goto finally;

for (attrs_len = 0, attrs_p = atts;

*attrs_p;

attrs_p++, attrs_len++) {

if (attrs_len % 2) {

PyObject *attr_str, *value_str;

const char *p = (const char *) (*attrs_k);

attr_str = PyUnicode_DecodeUTF8(p, strlen(p), "strict");

if (!attr_str) {

Py_DECREF(attrs_obj);

attrs_obj = NULL;

goto finally;

}

p = (const char *) *attrs_p;

value_str = PyUnicode_DecodeUTF8(p, strlen(p), "strict");

if (!value_str) {

Py_DECREF(attrs_obj);

Py_DECREF(attr_str);

attrs_obj = NULL;

goto finally;

}

if (PyDict_SetItem(attrs_obj, attr_str, value_str) < 0) {

Py_DECREF(attrs_obj);

Py_DECREF(attr_str);

Py_DECREF(value_str);

attrs_obj = NULL;

goto finally;

}

Py_DECREF(attr_str);

Py_DECREF(value_str);

}

else

attrs_k = attrs_p;

}

finally:

return attrs_obj;

}

#endif

/* 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 decref);

static void

flag_error(xmlparseobject *self)

{

clear_handlers(self, 1);

}

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

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

#if EXPAT_VERSION >= 0x015f00

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

#endif

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 */

#if EXPAT_VERSION == 0x010200

VOID_HANDLER(StartDoctypeDecl,

(void *userData, const XML_Char *doctypeName),

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

Py_None, Py_None, -1))

#elif EXPAT_VERSION >= 0x015f00

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

#endif

#if EXPAT_VERSION >= 0x010200

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

#endif

#if EXPAT_VERSION == 0x010200

VOID_HANDLER(ExternalParsedEntityDecl,

(void *userData, const XML_Char *entityName,

const XML_Char *base, const XML_Char *systemId,

const XML_Char *publicId),

("(O&O&O&O&)", STRING_CONV_FUNC, entityName,

STRING_CONV_FUNC, base, STRING_CONV_FUNC, systemId,

STRING_CONV_FUNC, publicId))

VOID_HANDLER(InternalParsedEntityDecl,

(void *userData, const XML_Char *entityName,

const XML_Char *replacementText, int replacementTextLength),

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

STRING_CONV_FUNC, replacementText, replacementTextLength))

#endif /* Expat version 1.2 & better */

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

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

}

#if EXPAT_VERSION >= 0x015f00

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;

}

#endif

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