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

#ifndef PyDoc_STRVAR

/*

 * fdrake says:

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

 * '''the parentheses cause compile failures

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

 * on some platforms (Irix?)'''

 */

#define PyDoc_STR(str)         str

#define PyDoc_VAR(name)        static char name[]

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

#endif

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

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

#define Py_USING_UNICODE

#else

#define FIX_TRACE

#endif

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

    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 = PyInt_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;

    char buffer[256];

    XML_Parser parser = self->itself;

    int lineno = XML_GetErrorLineNumber(parser);

    int column = XML_GetErrorColumnNumber(parser);

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

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

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

    }

    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 = PyString_FromString(hinfo->name);

        hinfo->nameobj = name;

    }

    Py_XINCREF(name);

    return name;

}

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

}

#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(const 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(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);

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

{

    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;

}

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

    }

#if PY_VERSION_HEX < 0x02040000

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

#else

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

#endif

    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;

}

#ifndef Py_USING_UNICODE

#define STRING_CONV_FUNC conv_string_to_utf8

#else

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

#define STRING_CONV_FUNC (self->returns_unicode \

                          ? conv_string_to_unicode : conv_string_to_utf8)

#endif

static PyObject*

string_intern(xmlparseobject *self, const char* str)

{

    PyObject *result = STRING_CONV_FUNC(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;

    args = PyTuple_New(1);

    if (args == NULL)

        return -1;

#ifdef Py_USING_UNICODE

    temp = (self->returns_unicode 

            ? conv_string_len_to_unicode(buffer, len) 

            : conv_string_len_to_utf8(buffer, len));

#else

    temp = conv_string_len_to_utf8(buffer, len);

#endif

    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;