#include "Python.h"

#include "structmember.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

#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) & ~(Py_uintptr_t)1))

static PyObject* elementtree_parseerror_obj;

static PyObject* elementtree_deepcopy_obj;

static PyObject* elementtree_iter_obj;

static PyObject* elementtree_itertext_obj;

static PyObject* elementpath_obj;

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_Pack(2, object, memo);

if (!args)

return NULL;

result = PyObject_CallObject(elementtree_deepcopy_obj, args);

Py_DECREF(args);

return result;

}

LOCAL(PyObject*)

list_join(PyObject* list)

{

/* join list elements (destroying the list in the process) */

PyObject* joiner;

PyObject* result;

joiner = PyUnicode_FromStringAndSize("", 0);

if (!joiner)

return NULL;

result = PyUnicode_Join(joiner, list);

Py_DECREF(joiner);

if (result)

Py_DECREF(list);

return result;

}

static int

is_empty_dict(PyObject *obj)

{

return PyDict_CheckExact(obj) && PyDict_Size(obj) == 0;

}

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;

PyObject* localName; /* string */

PyObject* ns; /* string */

PyObject* start; /* tuple(line, col, bytePos) */

PyObject* end; /* tuple(line, col, bytePos) */

ElementObjectExtra* extra;

PyObject *weakreflist; /* For tp_weaklistoffset */

} ElementObject;

static PyTypeObject Element_Type;

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

LOCAL(int)

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

dealloc_extra(ElementObject* self)

{

ElementObjectExtra *myextra;

int i;

if (!self->extra)

return;

/* Avoid DECREFs calling into this code again (cycles, etc.)

myextra = self->extra;

self->extra = NULL;

Py_DECREF(myextra->attrib);

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

Py_DECREF(myextra->children[i]);

if (myextra->children != myextra->_children)

PyObject_Free(myextra->children);

PyObject_Free(myextra);

}

LOCAL(int)

feed_new_element(ElementObject* self, PyObject* tag, PyObject* attrib)

{

Py_UNICODE *string;

char *bytes;

int size, i;

self->extra = NULL;

if ((attrib != NULL && attrib != Py_None && !is_empty_dict(attrib))) {

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

PyObject_Del(self);

return -1;

}

}

Py_INCREF(tag);

self->tag = tag;

Py_INCREF(Py_None);

self->text = Py_None;

Py_INCREF(Py_None);

self->tail = Py_None;

self->localName = NULL;

self->ns = NULL;

#if defined(Py_USING_UNICODE)

if (PyUnicode_Check(tag)) {

string = PyUnicode_AS_UNICODE(tag);

size = PyUnicode_GET_SIZE(tag);

/* look for namespace separator */

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

if (string[i] == '}')

break;

}

if (i != size) {

/* convert from universal name */

self->ns = PyUnicode_FromUnicode(string+1, i-1);

Py_INCREF(self->ns);

if (size-i > 0) {

self->localName = PyUnicode_FromUnicode(string+i+1, size-i-1);

Py_INCREF(self->localName);

} else {

Py_INCREF(Py_None);

self->localName = Py_None;

}

}

} else

{

bytes = PyBytes_AS_STRING(tag);

size = strlen(bytes);

/* look for namespace separator */

for (i = 0; i < size; i++)

if (bytes[i] == '}')

break;

if (i != size) {

/* convert from universal name */

self->ns = PyUnicode_FromStringAndSize(bytes+1, i-1);

Py_INCREF(self->ns);

if (size-i > 0) {

self->localName = PyUnicode_FromStringAndSize(bytes+i+1, size-i-1);

Py_INCREF(self->localName);

} else {

Py_INCREF(Py_None);

self->localName = Py_None;

}

}

}

/* plain name; use key as tag */

if (self->localName == NULL) {

Py_INCREF(tag);

self->localName = tag;

}

if (self->ns == NULL) {

Py_INCREF(Py_None);

self->ns = Py_None;

}

Py_INCREF(Py_None);

self->start = Py_None;

Py_INCREF(Py_None);

self->end = Py_None;

self->weakreflist = NULL;

return 0;

}

LOCAL(PyObject*)

create_new_element(PyObject* tag, PyObject* attrib)

{

ElementObject* self;

self = PyObject_GC_New(ElementObject, &Element_Type);

if (self == NULL)

return NULL;

if (feed_new_element(self, tag, attrib) < 0)

return NULL;

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

PyObject_GC_Track(self);

return (PyObject*) self;

}

static PyObject *

element_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

ElementObject *e = (ElementObject *)type->tp_alloc(type, 0);

if (e != NULL) {

Py_INCREF(Py_None);

e->tag = Py_None;

Py_INCREF(Py_None);

e->text = Py_None;

Py_INCREF(Py_None);

e->tail = Py_None;

Py_INCREF(Py_None);

e->localName = Py_None;

Py_INCREF(Py_None);

e->ns = Py_None;

Py_INCREF(Py_None);

e->start = Py_None;

Py_INCREF(Py_None);

e->end = Py_None;

e->extra = NULL;

e->weakreflist = NULL;

}

return (PyObject *)e;

}

static PyObject*

get_attrib_from_keywords(PyObject *kwds)

{

PyObject *attrib_str = PyUnicode_FromString("attrib");

PyObject *attrib = PyDict_GetItem(kwds, attrib_str);

if (attrib) {

/* If attrib was found in kwds, copy its value and remove it from

if (!PyDict_Check(attrib)) {

Py_DECREF(attrib_str);

PyErr_Format(PyExc_TypeError, "attrib must be dict, not %.100s",

Py_TYPE(attrib)->tp_name);

return NULL;

}

attrib = PyDict_Copy(attrib);

PyDict_DelItem(kwds, attrib_str);

} else {

attrib = PyDict_New();

}

Py_DECREF(attrib_str);

if (attrib)

PyDict_Update(attrib, kwds);

return attrib;

}

static int

element_init(PyObject *self, PyObject *args, PyObject *kwds)

{

PyObject *tag;

PyObject *attrib = NULL;

ElementObject *self_elem;

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

return -1;

if (attrib) {

/* attrib passed as positional arg */

attrib = PyDict_Copy(attrib);

if (!attrib)

return -1;

if (kwds) {

if (PyDict_Update(attrib, kwds) < 0) {

Py_DECREF(attrib);

return -1;

}

}

} else if (kwds) {

/* have keywords args */

attrib = get_attrib_from_keywords(kwds);

if (!attrib)

return -1;

}

self_elem = (ElementObject *)self;

if (feed_new_element(self_elem, tag, attrib) < 0) {

Py_DECREF(attrib);

return -1;

}

/* We own a reference to attrib here and it's no longer needed. */

Py_XDECREF(attrib);

return 0;

}

LOCAL(void)

element_add_position(ElementObject* self, int end, long line, long col, long bytePos)

{

PyObject* position;

position = PyTuple_New(3);

PyTuple_SET_ITEM(position, 0, (PyObject*) PyLong_FromLong(line));

PyTuple_SET_ITEM(position, 1, (PyObject*) PyLong_FromLong(col));

PyTuple_SET_ITEM(position, 2, (PyObject*) PyLong_FromLong(bytePos));

if (end) {

self->end = position;

} else {

self->start = position;

}

}

LOCAL(int)

element_resize(ElementObject* self, int extra)

{

int size;

PyObject* *children;

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

if (!self->extra)

create_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 (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) {

/* create missing dictionary */

res = PyDict_New();

if (!res)

return NULL;

Py_DECREF(Py_None);

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

res = list_join(res);

if (!res)

return NULL;

self->text = res;

}

}

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

res = list_join(res);

if (!res)

return NULL;

self->tail = res;

}

}

return res;

}

static PyObject*

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

{

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

/* attrib passed as positional arg */

attrib = PyDict_Copy(attrib);

if (!attrib)

return NULL;

if (kwds) {

if (PyDict_Update(attrib, kwds) < 0) {

return NULL;

}

}

} else if (kwds) {

/* have keyword args */

attrib = get_attrib_from_keywords(kwds);

if (!attrib)

return NULL;

} else {

/* no attrib arg, no kwds, so no attribute */

Py_INCREF(Py_None);

attrib = Py_None;

}

elem = create_new_element(tag, attrib);

Py_DECREF(attrib);

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

Py_DECREF(elem);

return NULL;

}

return elem;

}

static int

element_gc_traverse(ElementObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->tag);

Py_VISIT(JOIN_OBJ(self->text));

Py_VISIT(JOIN_OBJ(self->tail));

Py_VISIT(self->localName);

Py_VISIT(self->ns);

Py_VISIT(self->start);

Py_VISIT(self->end);

if (self->extra) {

int i;

Py_VISIT(self->extra->attrib);

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

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

}

return 0;

}

static int

element_gc_clear(ElementObject *self)

{

Py_CLEAR(self->tag);

/* The following is like Py_CLEAR for self->text and self->tail, but

if (self->text) {

PyObject *tmp = JOIN_OBJ(self->text);

self->text = NULL;

Py_DECREF(tmp);

}

if (self->tail) {

PyObject *tmp = JOIN_OBJ(self->tail);

self->tail = NULL;

Py_DECREF(tmp);

}

Py_CLEAR(self->localName);

Py_CLEAR(self->ns);

Py_CLEAR(self->start);

Py_CLEAR(self->end);

/* After dropping all references from extra, it's no longer valid anyway,

dealloc_extra(self);

return 0;

}

static void

element_dealloc(ElementObject* self)

{

PyObject_GC_UnTrack(self);

if (self->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) self);

/* element_gc_clear clears all references and deallocates extra

element_gc_clear(self);

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

Py_TYPE(self)->tp_free((PyObject *)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_clearmethod(ElementObject* self, PyObject* args)

{

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

return NULL;

dealloc_extra(self);

Py_INCREF(Py_None);

Py_DECREF(JOIN_OBJ(self->text));

self->text = Py_None;

Py_INCREF(Py_None);

Py_DECREF(JOIN_OBJ(self->tail));

self->tail = Py_None;

Py_INCREF(Py_None);

Py_DECREF(self->localName);

self->localName = Py_None;

Py_INCREF(Py_None);

Py_DECREF(self->ns);

self->ns = Py_None;

Py_INCREF(Py_None);

Py_DECREF(self->start);

self->start = Py_None;

Py_INCREF(Py_None);

Py_DECREF(self->end);

self->end = 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*) create_new_element(

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

if (!element)

return NULL;

Py_DECREF(JOIN_OBJ(element->text));

element->text = self->text;

Py_INCREF(JOIN_OBJ(element->text));

Py_DECREF(JOIN_OBJ(element->tail));

element->tail = self->tail;

Py_INCREF(JOIN_OBJ(element->tail));

Py_DECREF(element->localName);

element->localName = self->localName;

Py_INCREF(element->localName);

Py_DECREF(element->ns);

element->ns = self->ns;

Py_INCREF(element->ns);

Py_DECREF(element->start);

element->start = self->start;

Py_INCREF(element->start);

Py_DECREF(element->end);

element->end = self->end;

Py_INCREF(element->end);

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*) create_new_element(tag, attrib);

Py_DECREF(tag);

Py_DECREF(attrib);

if (!element)

return NULL;

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

if (!text)

goto error;

Py_DECREF(JOIN_OBJ(element->text));

element->text = JOIN_SET(text, JOIN_GET(self->text));

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

if (!tail)

goto error;

Py_DECREF(JOIN_OBJ(element->tail));

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 = PyLong_FromSsize_t((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;

}

static PyObject*

element_sizeof(PyObject* _self, PyObject* args)

{

ElementObject *self = (ElementObject*)_self;

Py_ssize_t result = sizeof(ElementObject);

if (self->extra) {

result += sizeof(ElementObjectExtra);

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

result += sizeof(PyObject*) * self->extra->allocated;

}

return PyLong_FromSsize_t(result);

}

#define PICKLED_TAG "tag"

#define PICKLED_CHILDREN "_children"

#define PICKLED_ATTRIB "attrib"

#define PICKLED_TAIL "tail"

#define PICKLED_TEXT "text"

#define PICKLED_LOCALNAME "localName"

#define PICKLED_NS "ns"

#define PICKLED_START "start"

#define PICKLED_END "end"

static PyObject *

element_getstate(ElementObject *self)

{

int i, noattrib;

PyObject *instancedict = NULL, *children;

/* Build a list of children. */

children = PyList_New(self->extra ? self->extra->length : 0);

if (!children)

return NULL;

for (i = 0; i < PyList_GET_SIZE(children); i++) {

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

Py_INCREF(child);

PyList_SET_ITEM(children, i, child);

}

/* Construct the state object. */

noattrib = (self->extra == NULL || self->extra->attrib == Py_None);

if (noattrib)

instancedict = Py_BuildValue("{sOsOs{}sOsOsOsOsOsOsOsO}",

PICKLED_TAG, self->tag,

PICKLED_CHILDREN, children,

PICKLED_ATTRIB,

PICKLED_LOCALNAME, self->localName,

PICKLED_NS, self->ns,

PICKLED_START, self->start,

PICKLED_END, self->end,