#include "Python.h"

#define VERSION "1.0.6"

#define USE_EXPAT

#define STATIC_CHILDREN 4

#if 0

static int memory = 0;

#define ALLOC(size, comment)\

do { memory += size; printf("%8d - %s\n", memory, comment); } while (0)

#define RELEASE(size, comment)\

do { memory -= size; printf("%8d - %s\n", memory, comment); } while (0)

#define ALLOC(size, comment)

#define RELEASE(size, comment)

#if defined(_MSC_VER)

#define LOCAL(type) static __inline type __fastcall

#define LOCAL(type) static type

#if (PY_VERSION_HEX < 0x02060000)

#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)

#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)

#if (PY_VERSION_HEX < 0x02050000)

typedef int Py_ssize_t;

#define lenfunc inquiry

#if (PY_VERSION_HEX < 0x02040000)

#define PyDict_CheckExact PyDict_Check

#if !defined(Py_RETURN_NONE)

#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None

#define JOIN_GET(p) ((Py_uintptr_t) (p) & 1)

#define JOIN_SET(p, flag) ((void*) ((Py_uintptr_t) (JOIN_OBJ(p)) | (flag)))

#define JOIN_OBJ(p) ((PyObject*) ((Py_uintptr_t) (p) & ~1))

static PyObject* elementtree_parseerror_obj;

static PyObject* elementtree_copyelement_obj;

static PyObject* elementtree_deepcopy_obj;

static PyObject* elementtree_iter_obj;

static PyObject* elementtree_itertext_obj;

static PyObject* elementpath_obj;

Py_LOCAL_INLINE(void)

_set_joined_ptr(PyObject **p, PyObject *new_joined_ptr)

{

PyObject *tmp = JOIN_OBJ(*p);

*p = new_joined_ptr;

Py_DECREF(tmp);

}

LOCAL(PyObject*)

deepcopy(PyObject* object, PyObject* memo)

{

/* do a deep copy of the given object */

PyObject* args;

PyObject* result;

if (!elementtree_deepcopy_obj) {

PyErr_SetString(

PyExc_RuntimeError,

"deepcopy helper not found"

);

return NULL;

}

args = PyTuple_New(2);

if (!args)

return NULL;

Py_INCREF(object); PyTuple_SET_ITEM(args, 0, (PyObject*) object);

Py_INCREF(memo); PyTuple_SET_ITEM(args, 1, (PyObject*) memo);

result = PyObject_CallObject(elementtree_deepcopy_obj, args);

Py_DECREF(args);

return result;

}

LOCAL(PyObject*)

list_join(PyObject* list)

{

/* join list elements */

PyObject* joiner;

PyObject* function;

PyObject* args;

PyObject* result;

switch (PyList_GET_SIZE(list)) {

case 0:

return PyString_FromString("");

case 1:

result = PyList_GET_ITEM(list, 0);

Py_INCREF(result);

return result;

}

/* two or more elements: slice out a suitable separator from the

joiner = PySequence_GetSlice(PyList_GET_ITEM(list, 0), 0, 0);

if (!joiner)

return NULL;

function = PyObject_GetAttrString(joiner, "join");

if (!function) {

Py_DECREF(joiner);

return NULL;

}

args = PyTuple_New(1);

if (!args) {

Py_DECREF(function);

Py_DECREF(joiner);

return NULL;

}

Py_INCREF(list);

PyTuple_SET_ITEM(args, 0, list);

result = PyObject_CallObject(function, args);

Py_DECREF(args); /* also removes list */

Py_DECREF(function);

Py_DECREF(joiner);

return result;

}

typedef struct {

/* attributes (a dictionary object), or None if no attributes */

PyObject* attrib;

/* child elements */

int length; /* actual number of items */

int allocated; /* allocated items */

/* this either points to _children or to a malloced buffer */

PyObject* *children;

PyObject* _children[STATIC_CHILDREN];

} ElementObjectExtra;

typedef struct {

PyObject_HEAD

/* element tag (a string). */

PyObject* tag;

/* text before first child. note that this is a tagged pointer;

PyObject* text;

/* text after this element, in parent. note that this is a tagged

PyObject* tail;

ElementObjectExtra* extra;

} ElementObject;

staticforward PyTypeObject Element_Type;

#define Element_CheckExact(op) (Py_TYPE(op) == &Element_Type)

LOCAL(int)

element_new_extra(ElementObject* self, PyObject* attrib)

{

self->extra = PyObject_Malloc(sizeof(ElementObjectExtra));

if (!self->extra)

return -1;

if (!attrib)

attrib = Py_None;

Py_INCREF(attrib);

self->extra->attrib = attrib;

self->extra->length = 0;

self->extra->allocated = STATIC_CHILDREN;

self->extra->children = self->extra->_children;

return 0;

}

LOCAL(void)

element_dealloc_extra(ElementObject* self)

{

int i;

Py_DECREF(self->extra->attrib);

for (i = 0; i < self->extra->length; i++)

Py_DECREF(self->extra->children[i]);

if (self->extra->children != self->extra->_children)

PyObject_Free(self->extra->children);

PyObject_Free(self->extra);

}

LOCAL(PyObject*)

element_new(PyObject* tag, PyObject* attrib)

{

ElementObject* self;

self = PyObject_New(ElementObject, &Element_Type);

if (self == NULL)

return NULL;

/* use None for empty dictionaries */

if (PyDict_CheckExact(attrib) && !PyDict_Size(attrib))

attrib = Py_None;

self->extra = NULL;

if (attrib != Py_None) {

if (element_new_extra(self, attrib) < 0) {

PyObject_Del(self);

return NULL;

}

self->extra->length = 0;

self->extra->allocated = STATIC_CHILDREN;

self->extra->children = self->extra->_children;

}

Py_INCREF(tag);

self->tag = tag;

Py_INCREF(Py_None);

self->text = Py_None;

Py_INCREF(Py_None);

self->tail = Py_None;

ALLOC(sizeof(ElementObject), "create element");

return (PyObject*) self;

}

LOCAL(int)

element_resize(ElementObject* self, Py_ssize_t extra)

{

Py_ssize_t size;

PyObject* *children;

/* make sure self->children can hold the given number of extra

if (!self->extra)

element_new_extra(self, NULL);

size = self->extra->length + extra;

if (size > self->extra->allocated) {

/* use Python 2.4's list growth strategy */

size = (size >> 3) + (size < 9 ? 3 : 6) + size;

/* Coverity CID #182 size_error: Allocating 1 bytes to pointer "children"

size = size ? size : 1;

if ((size_t)size > PY_SSIZE_T_MAX/sizeof(PyObject*))

goto nomemory;

if (size > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"too many children");

return -1;

}

if (self->extra->children != self->extra->_children) {

/* Coverity CID #182 size_error: Allocating 1 bytes to pointer

children = PyObject_Realloc(self->extra->children,

size * sizeof(PyObject*));

if (!children)

goto nomemory;

} else {

children = PyObject_Malloc(size * sizeof(PyObject*));

if (!children)

goto nomemory;

/* copy existing children from static area to malloc buffer */

memcpy(children, self->extra->children,

self->extra->length * sizeof(PyObject*));

}

self->extra->children = children;

self->extra->allocated = size;

}

return 0;

nomemory:

PyErr_NoMemory();

return -1;

}

LOCAL(int)

element_add_subelement(ElementObject* self, PyObject* element)

{

/* add a child element to a parent */

if (element_resize(self, 1) < 0)

return -1;

Py_INCREF(element);

self->extra->children[self->extra->length] = element;

self->extra->length++;

return 0;

}

LOCAL(PyObject*)

element_get_attrib(ElementObject* self)

{

/* return borrowed reference to attrib dictionary */

/* note: this function assumes that the extra section exists */

PyObject* res = self->extra->attrib;

if (res == Py_None) {

Py_DECREF(res);

/* create missing dictionary */

res = PyDict_New();

if (!res)

return NULL;

self->extra->attrib = res;

}

return res;

}

LOCAL(PyObject*)

element_get_text(ElementObject* self)

{

/* return borrowed reference to text attribute */

PyObject *res = self->text;

if (JOIN_GET(res)) {

res = JOIN_OBJ(res);

if (PyList_CheckExact(res)) {

PyObject *tmp = list_join(res);

if (!tmp)

return NULL;

self->text = tmp;

Py_DECREF(res);

res = tmp;

}

}

return res;

}

LOCAL(PyObject*)

element_get_tail(ElementObject* self)

{

/* return borrowed reference to text attribute */

PyObject *res = self->tail;

if (JOIN_GET(res)) {

res = JOIN_OBJ(res);

if (PyList_CheckExact(res)) {

PyObject *tmp = list_join(res);

if (!tmp)

return NULL;

self->tail = tmp;

Py_DECREF(res);

res = tmp;

}

}

return res;

}

static PyObject*

element(PyObject* self, PyObject* args, PyObject* kw)

{

PyObject* elem;

PyObject* tag;

PyObject* attrib = NULL;

if (!PyArg_ParseTuple(args, "O|O!:Element", &tag,

&PyDict_Type, &attrib))

return NULL;

if (attrib || kw) {

attrib = (attrib) ? PyDict_Copy(attrib) : PyDict_New();

if (!attrib)

return NULL;

if (kw)

PyDict_Update(attrib, kw);

} else {

Py_INCREF(Py_None);

attrib = Py_None;

}

elem = element_new(tag, attrib);

Py_DECREF(attrib);

return elem;

}

static PyObject*

subelement(PyObject* self, PyObject* args, PyObject* kw)

{

PyObject* elem;

ElementObject* parent;

PyObject* tag;

PyObject* attrib = NULL;

if (!PyArg_ParseTuple(args, "O!O|O!:SubElement",

&Element_Type, &parent, &tag,

&PyDict_Type, &attrib))

return NULL;

if (attrib || kw) {

attrib = (attrib) ? PyDict_Copy(attrib) : PyDict_New();

if (!attrib)

return NULL;

if (kw)

PyDict_Update(attrib, kw);

} else {

Py_INCREF(Py_None);

attrib = Py_None;

}

elem = element_new(tag, attrib);

Py_DECREF(attrib);

if (elem == NULL)

return NULL;

if (element_add_subelement(parent, elem) < 0) {

Py_DECREF(elem);

return NULL;

}

return elem;

}

static void

element_dealloc(ElementObject* self)

{

if (self->extra)

element_dealloc_extra(self);

/* discard attributes */

Py_DECREF(self->tag);

Py_DECREF(JOIN_OBJ(self->text));

Py_DECREF(JOIN_OBJ(self->tail));

RELEASE(sizeof(ElementObject), "destroy element");

PyObject_Del(self);

}

static PyObject*

element_append(ElementObject* self, PyObject* args)

{

PyObject* element;

if (!PyArg_ParseTuple(args, "O!:append", &Element_Type, &element))

return NULL;

if (element_add_subelement(self, element) < 0)

return NULL;

Py_RETURN_NONE;

}

static PyObject*

element_clear(ElementObject* self, PyObject* args)

{

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

return NULL;

if (self->extra) {

element_dealloc_extra(self);

self->extra = NULL;

}

Py_INCREF(Py_None);

_set_joined_ptr(&self->text, Py_None);

Py_INCREF(Py_None);

_set_joined_ptr(&self->tail, Py_None);

Py_RETURN_NONE;

}

static PyObject*

element_copy(ElementObject* self, PyObject* args)

{

int i;

ElementObject* element;

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

return NULL;

element = (ElementObject*) element_new(

self->tag, (self->extra) ? self->extra->attrib : Py_None

);

if (!element)

return NULL;

Py_INCREF(JOIN_OBJ(self->text));

_set_joined_ptr(&element->text, self->text);

Py_INCREF(JOIN_OBJ(self->tail));

_set_joined_ptr(&element->tail, self->tail);

if (self->extra) {

if (element_resize(element, self->extra->length) < 0) {

Py_DECREF(element);

return NULL;

}

for (i = 0; i < self->extra->length; i++) {

Py_INCREF(self->extra->children[i]);

element->extra->children[i] = self->extra->children[i];

}

element->extra->length = self->extra->length;

}

return (PyObject*) element;

}

static PyObject*

element_deepcopy(ElementObject* self, PyObject* args)

{

int i;

ElementObject* element;

PyObject* tag;

PyObject* attrib;

PyObject* text;

PyObject* tail;

PyObject* id;

PyObject* memo;

if (!PyArg_ParseTuple(args, "O:__deepcopy__", &memo))

return NULL;

tag = deepcopy(self->tag, memo);

if (!tag)

return NULL;

if (self->extra) {

attrib = deepcopy(self->extra->attrib, memo);

if (!attrib) {

Py_DECREF(tag);

return NULL;

}

} else {

Py_INCREF(Py_None);

attrib = Py_None;

}

element = (ElementObject*) element_new(tag, attrib);

Py_DECREF(tag);

Py_DECREF(attrib);

if (!element)

return NULL;

text = deepcopy(JOIN_OBJ(self->text), memo);

if (!text)

goto error;

_set_joined_ptr(&element->text, JOIN_SET(text, JOIN_GET(self->text)));

tail = deepcopy(JOIN_OBJ(self->tail), memo);

if (!tail)

goto error;

_set_joined_ptr(&element->tail, JOIN_SET(tail, JOIN_GET(self->tail)));

if (self->extra) {

if (element_resize(element, self->extra->length) < 0)

goto error;

for (i = 0; i < self->extra->length; i++) {

PyObject* child = deepcopy(self->extra->children[i], memo);

if (!child) {

element->extra->length = i;

goto error;

}

element->extra->children[i] = child;

}

element->extra->length = self->extra->length;

}

/* add object to memo dictionary (so deepcopy won't visit it again) */

id = PyInt_FromLong((Py_uintptr_t) self);

if (!id)

goto error;

i = PyDict_SetItem(memo, id, (PyObject*) element);

Py_DECREF(id);

if (i < 0)

goto error;

return (PyObject*) element;

error:

Py_DECREF(element);

return NULL;

}

LOCAL(int)

checkpath(PyObject* tag)

{

Py_ssize_t i;

int check = 1;

/* check if a tag contains an xpath character */

#define PATHCHAR(ch) \

(ch == '/' || ch == '*' || ch == '[' || ch == '@' || ch == '.')

#if defined(Py_USING_UNICODE)

if (PyUnicode_Check(tag)) {

Py_UNICODE *p = PyUnicode_AS_UNICODE(tag);

for (i = 0; i < PyUnicode_GET_SIZE(tag); i++) {

if (p[i] == '{')

check = 0;

else if (p[i] == '}')

check = 1;

else if (check && PATHCHAR(p[i]))

return 1;

}

return 0;

}

if (PyString_Check(tag)) {

char *p = PyString_AS_STRING(tag);

for (i = 0; i < PyString_GET_SIZE(tag); i++) {

if (p[i] == '{')

check = 0;

else if (p[i] == '}')

check = 1;

else if (check && PATHCHAR(p[i]))

return 1;

}

return 0;

}

return 1; /* unknown type; might be path expression */

}

static PyObject*

element_extend(ElementObject* self, PyObject* args)

{

PyObject* seq;

Py_ssize_t i;

PyObject* seq_in;

if (!PyArg_ParseTuple(args, "O:extend", &seq_in))

return NULL;

seq = PySequence_Fast(seq_in, "");

if (!seq) {

PyErr_Format(

PyExc_TypeError,

"expected sequence, not \"%.200s\"", Py_TYPE(seq_in)->tp_name

);

return NULL;

}

for (i = 0; i < PySequence_Fast_GET_SIZE(seq); i++) {

PyObject* element = PySequence_Fast_GET_ITEM(seq, i);

if (element_add_subelement(self, element) < 0) {

Py_DECREF(seq);

return NULL;

}

}

Py_DECREF(seq);

Py_RETURN_NONE;

}

static PyObject*

element_find(ElementObject* self, PyObject* args)

{

int i;

PyObject* tag;

PyObject* namespaces = Py_None;

if (!PyArg_ParseTuple(args, "O|O:find", &tag, &namespaces))

return NULL;

if (checkpath(tag) || namespaces != Py_None)

return PyObject_CallMethod(

elementpath_obj, "find", "OOO", self, tag, namespaces

);

if (!self->extra)

Py_RETURN_NONE;

for (i = 0; i < self->extra->length; i++) {

PyObject* item = self->extra->children[i];

int rc;

if (!Element_CheckExact(item))

continue;

Py_INCREF(item);

rc = PyObject_Compare(((ElementObject*)item)->tag, tag);

if (rc == 0)

return item;

Py_DECREF(item);

if (rc < 0 && PyErr_Occurred())

return NULL;

}

Py_RETURN_NONE;

}

static PyObject*

element_findtext(ElementObject* self, PyObject* args)

{

int i;

PyObject* tag;

PyObject* default_value = Py_None;

PyObject* namespaces = Py_None;

if (!PyArg_ParseTuple(args, "O|OO:findtext", &tag, &default_value, &namespaces))

return NULL;

if (checkpath(tag) || namespaces != Py_None)

return PyObject_CallMethod(

elementpath_obj, "findtext", "OOOO", self, tag, default_value, namespaces

);

if (!self->extra) {

Py_INCREF(default_value);

return default_value;

}

for (i = 0; i < self->extra->length; i++) {

ElementObject* item = (ElementObject*) self->extra->children[i];

int rc;

if (!Element_CheckExact(item))

continue;

Py_INCREF(item);

rc = PyObject_Compare(item->tag, tag);

if (rc == 0) {

PyObject* text = element_get_text(item);

if (text == Py_None) {

Py_DECREF(item);

return PyString_FromString("");

}

Py_XINCREF(text);

Py_DECREF(item);

return text;

}

Py_DECREF(item);

if (rc < 0 && PyErr_Occurred())

return NULL;

}

Py_INCREF(default_value);

return default_value;

}

static PyObject*

element_findall(ElementObject* self, PyObject* args)

{

int i;

PyObject* out;

PyObject* tag;

PyObject* namespaces = Py_None;

if (!PyArg_ParseTuple(args, "O|O:findall", &tag, &namespaces))

return NULL;

if (checkpath(tag) || namespaces != Py_None)

return PyObject_CallMethod(

elementpath_obj, "findall", "OOO", self, tag, namespaces

);

out = PyList_New(0);

if (!out)

return NULL;

if (!self->extra)

return out;

for (i = 0; i < self->extra->length; i++) {

PyObject* item = self->extra->children[i];

int rc;

if (!Element_CheckExact(item))

continue;

Py_INCREF(item);

rc = PyObject_Compare(((ElementObject*)item)->tag, tag);

if (rc == 0)

rc = PyList_Append(out, item);

Py_DECREF(item);

if (rc < 0 && PyErr_Occurred()) {

Py_DECREF(out);

return NULL;

}

}

return out;

}

static PyObject*

element_iterfind(ElementObject* self, PyObject* args)

{

PyObject* tag;

PyObject* namespaces = Py_None;

if (!PyArg_ParseTuple(args, "O|O:iterfind", &tag, &namespaces))

return NULL;

return PyObject_CallMethod(

elementpath_obj, "iterfind", "OOO", self, tag, namespaces

);

}

static PyObject*

element_get(ElementObject* self, PyObject* args)

{

PyObject* value;

PyObject* key;

PyObject* default_value = Py_None;

if (!PyArg_ParseTuple(args, "O|O:get", &key, &default_value))

return NULL;

if (!self->extra || self->extra->attrib == Py_None)

value = default_value;

else {

value = PyDict_GetItem(self->extra->attrib, key);

if (!value)

value = default_value;

}

Py_INCREF(value);

return value;

}

static PyObject*

element_getchildren(ElementObject* self, PyObject* args)

{

int i;

PyObject* list;

if (PyErr_WarnPy3k("This method will be removed in future versions. "

"Use 'list(elem)' or iteration over elem instead.",

1) < 0) {

return NULL;

}

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

return NULL;

if (!self->extra)

return PyList_New(0);

list = PyList_New(self->extra->length);

if (!list)

return NULL;

for (i = 0; i < self->extra->length; i++) {

PyObject* item = self->extra->children[i];

Py_INCREF(item);

PyList_SET_ITEM(list, i, item);

}

return list;

}

static PyObject*

element_iter_impl(ElementObject* self, PyObject* tag)

{

PyObject* args;

PyObject* result;

if (!elementtree_iter_obj) {

PyErr_SetString(