#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#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) ((uintptr_t) (p) & 1)

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

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

static void _clear_joined_ptr(PyObject **p)

{

if (*p) {

PyObject *tmp = JOIN_OBJ(*p);

*p = NULL;

Py_DECREF(tmp);

}

}

static PyTypeObject Element_Type;

static PyTypeObject ElementIter_Type;

static PyTypeObject TreeBuilder_Type;

static PyTypeObject XMLParser_Type;

typedef struct {

PyObject *parseerror_obj;

PyObject *deepcopy_obj;

PyObject *elementpath_obj;

} elementtreestate;

static struct PyModuleDef elementtreemodule;

#define ET_STATE(mod) ((elementtreestate *) PyModule_GetState(mod))

#define ET_STATE_GLOBAL \

((elementtreestate *) PyModule_GetState(PyState_FindModule(&elementtreemodule)))

static int

elementtree_clear(PyObject *m)

{

elementtreestate *st = ET_STATE(m);

Py_CLEAR(st->parseerror_obj);

Py_CLEAR(st->deepcopy_obj);

Py_CLEAR(st->elementpath_obj);

return 0;

}

static int

elementtree_traverse(PyObject *m, visitproc visit, void *arg)

{

elementtreestate *st = ET_STATE(m);

Py_VISIT(st->parseerror_obj);

Py_VISIT(st->deepcopy_obj);

Py_VISIT(st->elementpath_obj);

return 0;

}

static void

elementtree_free(void *m)

{

elementtree_clear((PyObject *)m);

}

LOCAL(PyObject*)

list_join(PyObject* list)

{

/* join list elements */

PyObject* joiner;

PyObject* result;

joiner = PyUnicode_FromStringAndSize("", 0);

if (!joiner)

return NULL;

result = PyUnicode_Join(joiner, list);

Py_DECREF(joiner);

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

Py_ssize_t length; /* actual number of items */

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

PyObject *weakreflist; /* For tp_weaklistoffset */

} ElementObject;

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

PyErr_NoMemory();

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;

Py_ssize_t 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(PyObject*)

create_new_element(PyObject* tag, PyObject* attrib)

{

ElementObject* self;

self = PyObject_GC_New(ElementObject, &Element_Type);

if (self == NULL)

return NULL;

self->extra = NULL;

Py_INCREF(tag);

self->tag = tag;

Py_INCREF(Py_None);

self->text = Py_None;

Py_INCREF(Py_None);

self->tail = Py_None;

self->weakreflist = NULL;

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

PyObject_GC_Track(self);

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

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

Py_DECREF(self);

return NULL;

}

}

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;

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

/* attrib can be NULL if PyDict_New failed */

if (attrib)

if (PyDict_Update(attrib, kwds) < 0)

return NULL;

return attrib;

}

static int

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

{

PyObject *tag;

PyObject *tmp;

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 (attrib != NULL && !is_empty_dict(attrib)) {

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

Py_DECREF(attrib);

return -1;

}

}

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

Py_XDECREF(attrib);

/* Replace the objects already pointed to by tag, text and tail. */

Py_INCREF(tag);

Py_XSETREF(self_elem->tag, tag);

tmp = self_elem->text;

Py_INCREF(Py_None);

self_elem->text = Py_None;

Py_DECREF(JOIN_OBJ(tmp));

tmp = self_elem->tail;

Py_INCREF(Py_None);

self_elem->tail = Py_None;

Py_DECREF(JOIN_OBJ(tmp));

return 0;

}

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

if (create_extra(self, NULL) < 0)

return -1;

}

size = self->extra->length + extra; /* never overflows */

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

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*

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 (elem == NULL)

return NULL;

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

if (self->extra) {

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

_clear_joined_ptr(&self->text);

_clear_joined_ptr(&self->tail);

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

Py_TRASHCAN_SAFE_BEGIN(self)

if (self->weakreflist != NULL)

Py_DECREF(attrib);

if (!element)

return NULL;

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

if (!text)

goto error;

Py_DECREF(element->text);

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

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

if (!tail)

goto error;

Py_DECREF(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((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(PyObject *)

deepcopy(PyObject *object, PyObject *memo)

{

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

elementtreestate *st;

PyObject *stack[2];

/* Fast paths */

if (object == Py_None || PyUnicode_CheckExact(object)) {

Py_INCREF(object);

return object;

}

if (Py_REFCNT(object) == 1) {

if (PyDict_CheckExact(object)) {

PyObject *key, *value;

Py_ssize_t pos = 0;

int simple = 1;

while (PyDict_Next(object, &pos, &key, &value)) {

if (!PyUnicode_CheckExact(key) || !PyUnicode_CheckExact(value)) {

simple = 0;

break;

}

}

if (simple)

return PyDict_Copy(object);

/* Fall through to general case */

}

else if (Element_CheckExact(object)) {

return _elementtree_Element___deepcopy__((ElementObject *)object, memo);

}

}

/* General case */

st = ET_STATE_GLOBAL;

if (!st->deepcopy_obj) {

PyErr_SetString(PyExc_RuntimeError,

"deepcopy helper not found");

return NULL;

}

stack[0] = object;

stack[1] = memo;

return _PyObject_FastCall(st->deepcopy_obj, stack, 2);

}

static Py_ssize_t

_elementtree_Element___sizeof___impl(ElementObject *self)

{

Py_ssize_t result = _PyObject_SIZE(Py_TYPE(self));

if (self->extra) {

result += sizeof(ElementObjectExtra);

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

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

}

return result;

}

#define PICKLED_TAG "tag"

#define PICKLED_CHILDREN "_children"

#define PICKLED_ATTRIB "attrib"

#define PICKLED_TAIL "tail"

#define PICKLED_TEXT "text"

static PyObject *

_elementtree_Element___getstate___impl(ElementObject *self)

{

Py_ssize_t 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{}sOsO}",

PICKLED_TAG, self->tag,

PICKLED_CHILDREN, children,

PICKLED_ATTRIB,

PICKLED_TEXT, JOIN_OBJ(self->text),

PICKLED_TAIL, JOIN_OBJ(self->tail));

else

instancedict = Py_BuildValue("{sOsOsOsOsO}",

PICKLED_TAG, self->tag,

PICKLED_CHILDREN, children,

PICKLED_ATTRIB, self->extra->attrib,

PICKLED_TEXT, JOIN_OBJ(self->text),

PICKLED_TAIL, JOIN_OBJ(self->tail));

if (instancedict) {

Py_DECREF(children);

return instancedict;

}

else {

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

Py_DECREF(PyList_GET_ITEM(children, i));

Py_DECREF(children);

return NULL;

}

}

static PyObject *

element_setstate_from_attributes(ElementObject *self,

PyObject *children)

{

Py_ssize_t i, nchildren;

if (!tag) {

PyErr_SetString(PyExc_TypeError, "tag may not be NULL");

return NULL;

}

Py_INCREF(tag);

Py_XSETREF(self->tag, tag);

_clear_joined_ptr(&self->text);

self->text = text ? JOIN_SET(text, PyList_CheckExact(text)) : Py_None;

Py_INCREF(JOIN_OBJ(self->text));

_clear_joined_ptr(&self->tail);

self->tail = tail ? JOIN_SET(tail, PyList_CheckExact(tail)) : Py_None;

Py_INCREF(JOIN_OBJ(self->tail));

/* Handle ATTRIB and CHILDREN. */

if (!children && !attrib)

Py_RETURN_NONE;

/* Compute 'nchildren'. */

if (children) {

if (!PyList_Check(children)) {

PyErr_SetString(PyExc_TypeError, "'_children' is not a list");

return NULL;

}

nchildren = PyList_Size(children);

}

else {

nchildren = 0;

}

/* Allocate 'extra'. */

if (element_resize(self, nchildren)) {

return NULL;

}

assert(self->extra && self->extra->allocated >= nchildren);

/* Copy children */

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