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

* Licensed to PSF under a Contributor Agreement.

* See http://www.python.org/psf/license for licensing details.

*

* _elementtree - C accelerator for xml.etree.ElementTree

* Copyright (c) 1999-2009 by Secret Labs AB. All rights reserved.

* Copyright (c) 1999-2009 by Fredrik Lundh.

*

* info@pythonware.com

* http://www.pythonware.com

*--------------------------------------------------------------------

*/

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

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

/* configuration */

/* An element can hold this many children without extra memory

allocations. */

#define STATIC_CHILDREN 4

/* For best performance, chose a value so that 80-90% of all nodes

have no more than the given number of children. Set this to zero

to minimize the size of the element structure itself (this only

helps if you have lots of leaf nodes with attributes). */

/* Also note that pymalloc always allocates blocks in multiples of

eight bytes. For the current C version of ElementTree, this means

that the number of children should be an even number, at least on

32-bit platforms. */

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

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

#else

#define ALLOC(size, comment)

#define RELEASE(size, comment)

#endif

/* compiler tweaks */

#if defined(_MSC_VER)

#define LOCAL(type) static __inline type __fastcall

#else

#define LOCAL(type) static type

#endif

/* macros used to store 'join' flags in string object pointers. note

that all use of text and tail as object pointers must be wrapped in

JOIN_OBJ. see comments in the ElementObject definition for more

info. */

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

/* Py_SETREF for a PyObject* that uses a join flag. */

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

}

/* Py_CLEAR for a PyObject* that uses a join flag. Pass the pointer by

* reference since this function sets it to NULL.

*/

static void _clear_joined_ptr(PyObject **p)

{

if (*p) {

_set_joined_ptr(p, NULL);

}

}

/* Types defined by this extension */

static PyTypeObject Element_Type;

static PyTypeObject ElementIter_Type;

static PyTypeObject TreeBuilder_Type;

static PyTypeObject XMLParser_Type;

/* Per-module state; PEP 3121 */

typedef struct {

PyObject *parseerror_obj;

PyObject *deepcopy_obj;

PyObject *elementpath_obj;

PyObject *comment_factory;

PyObject *pi_factory;

} elementtreestate;

static struct PyModuleDef elementtreemodule;

/* Given a module object (assumed to be _elementtree), get its per-module

* state.

*/

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

/* Find the module instance imported in the currently running sub-interpreter

* and get its state.

*/

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

Py_CLEAR(st->comment_factory);

Py_CLEAR(st->pi_factory);

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

Py_VISIT(st->comment_factory);

Py_VISIT(st->pi_factory);

return 0;

}

static void

elementtree_free(void *m)

{

elementtree_clear((PyObject *)m);

}

/* helpers */

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;

}

/* Is the given object an empty dictionary?

*/

static int

is_empty_dict(PyObject *obj)

{

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

}

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

/* the Element type */

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;

use JOIN_OBJ to get the object pointer. the join flag is used

to distinguish lists created by the tree builder from lists

assigned to the attribute by application code; the former

should be joined before being returned to the user, the latter

should be left intact. */

PyObject* text;

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

pointer; use JOIN_OBJ to get the object pointer. */

PyObject* tail;

ElementObjectExtra* extra;

PyObject *weakreflist; /* For tp_weaklistoffset */

} ElementObject;

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

#define Element_Check(op) PyObject_TypeCheck(op, &Element_Type)

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

/* Element constructors and destructor */

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(ElementObjectExtra *extra)

{

Py_ssize_t i;

if (!extra)

return;

Py_DECREF(extra->attrib);

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

Py_DECREF(extra->children[i]);

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

PyObject_Free(extra->children);

PyObject_Free(extra);

}

LOCAL(void)

clear_extra(ElementObject* self)

{

ElementObjectExtra *myextra;

if (!self->extra)

return;

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

*/

myextra = self->extra;

self->extra = NULL;

dealloc_extra(myextra);

}

/* Convenience internal function to create new Element objects with the given

* tag and attributes.

*/

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;

}

/* Helper function for extracting the attrib dictionary from a keywords dict.

* This is required by some constructors/functions in this module that can

* either accept attrib as a keyword argument or all attributes splashed

* directly into *kwds.

*

* Return a dictionary with the content of kwds merged into the content of

* attrib. If there is no attrib keyword, return a copy of kwds.

*/

static PyObject*

get_attrib_from_keywords(PyObject *kwds)

{

PyObject *attrib_str = PyUnicode_FromString("attrib");

if (attrib_str == NULL) {

return NULL;

}

PyObject *attrib = PyDict_GetItemWithError(kwds, attrib_str);

if (attrib) {

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

* kwds

*/

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

if (attrib && PyDict_DelItem(kwds, attrib_str) < 0) {

Py_DECREF(attrib);

attrib = NULL;

}

}

else if (!PyErr_Occurred()) {

attrib = PyDict_New();

}

Py_DECREF(attrib_str);

if (attrib != NULL && PyDict_Update(attrib, kwds) < 0) {

Py_DECREF(attrib);

return NULL;

}

return attrib;

}

/*[clinic input]

module _elementtree

class _elementtree.Element "ElementObject *" "&Element_Type"

class _elementtree.TreeBuilder "TreeBuilderObject *" "&TreeBuilder_Type"

class _elementtree.XMLParser "XMLParserObject *" "&XMLParser_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=159aa50a54061c22]*/

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

Py_INCREF(Py_None);

_set_joined_ptr(&self_elem->text, Py_None);

Py_INCREF(Py_None);

_set_joined_ptr(&self_elem->tail, Py_None);

return 0;

}

LOCAL(int)

element_resize(ElementObject* self, Py_ssize_t extra)

{

Py_ssize_t size;

PyObject* *children;

assert(extra >= 0);

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

elements. set an exception and return -1 if allocation failed */

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"

* which needs at least 4 bytes.

* Although it's a false alarm always assume at least one child to

* be safe.

*/

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", which needs at least 4 bytes. Although it's a

* false alarm always assume at least one child to be safe.

*/

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

raise_type_error(PyObject *element)

{

PyErr_Format(PyExc_TypeError,

"expected an Element, not \"%.200s\"",

Py_TYPE(element)->tp_name);

}

LOCAL(int)

element_add_subelement(ElementObject* self, PyObject* element)

{

/* add a child element to a parent */

if (!Element_Check(element)) {

raise_type_error(element);

return -1;

}

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 != NULL && PyDict_Update(attrib, kwds) < 0) {

Py_DECREF(attrib);

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,

* so fully deallocate it.

*/

clear_extra(self);

return 0;

}

static void

element_dealloc(ElementObject* self)

{

/* bpo-31095: UnTrack is needed before calling any callbacks */

PyObject_GC_UnTrack(self);

Py_TRASHCAN_BEGIN(self, element_dealloc)

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

Py_TRASHCAN_END

}

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

/*[clinic input]

_elementtree.Element.append

subelement: object(subclass_of='&Element_Type')

/

[clinic start generated code]*/

static PyObject *

_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement)

/*[clinic end generated code: output=54a884b7cf2295f4 input=3ed648beb5bfa22a]*/

{

if (element_add_subelement(self, subelement) < 0)

return NULL;

Py_RETURN_NONE;

}

/*[clinic input]

_elementtree.Element.clear

[clinic start generated code]*/

static PyObject *

_elementtree_Element_clear_impl(ElementObject *self)

/*[clinic end generated code: output=8bcd7a51f94cfff6 input=3c719ff94bf45dd6]*/

{

clear_extra(self);

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;

}

/*[clinic input]

_elementtree.Element.__copy__

[clinic start generated code]*/

static PyObject *

_elementtree_Element___copy___impl(ElementObject *self)

/*[clinic end generated code: output=2c701ebff7247781 input=ad87aaebe95675bf]*/

{

Py_ssize_t i;

ElementObject* element;

element = (ElementObject*) create_new_element(

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

assert(!element->extra || !element->extra->length);

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

}

assert(!element->extra->length);

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

}

return (PyObject*) element;

}

/* Helper for a deep copy. */

LOCAL(PyObject *) deepcopy(PyObject *, PyObject *);

/*[clinic input]

_elementtree.Element.__deepcopy__

memo: object(subclass_of="&PyDict_Type")

/

[clinic start generated code]*/

static PyObject *

_elementtree_Element___deepcopy___impl(ElementObject *self, PyObject *memo)

/*[clinic end generated code: output=eefc3df50465b642 input=a2d40348c0aade10]*/

{

Py_ssize_t i;

ElementObject* element;

PyObject* tag;

PyObject* attrib;

PyObject* text;

PyObject* tail;

PyObject* id;

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;

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

assert(!element->extra || !element->extra->length);

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

if (child) {

raise_type_error(child);

Py_DECREF(child);

}

element->extra->length = i;

goto error;

}

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

}

assert(!element->extra->length);

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___impl(

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

}

/*[clinic input]

_elementtree.Element.__sizeof__ -> Py_ssize_t

[clinic start generated code]*/

static Py_ssize_t

_elementtree_Element___sizeof___impl(ElementObject *self)

/*[clinic end generated code: output=bf73867721008000 input=70f4b323d55a17c1]*/

{

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;

}

/* dict keys for getstate/setstate. */

#define PICKLED_TAG "tag"

#define PICKLED_CHILDREN "_children"

#define PICKLED_ATTRIB "attrib"

#define PICKLED_TAIL "tail"

#define PICKLED_TEXT "text"

/* __getstate__ returns a fabricated instance dict as in the pure-Python

* Element implementation, for interoperability/interchangeability. This

* makes the pure-Python implementation details an API, but (a) there aren't

* any unnecessary structures there; and (b) it buys compatibility with 3.2

* pickles. See issue #16076.

*/

/*[clinic input]

_elementtree.Element.__getstate__

[clinic start generated code]*/

static PyObject *

_elementtree_Element___getstate___impl(ElementObject *self)

/*[clinic end generated code: output=37279aeeb6bb5b04 input=f0d16d7ec2f7adc1]*/

{

Py_ssize_t i;

PyObject *children, *attrib;

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

}

if (self->extra && self->extra->attrib != Py_None) {

attrib = self->extra->attrib;

Py_INCREF(attrib);

}

else {

attrib = PyDict_New();

if (!attrib) {

Py_DECREF(children);

return NULL;

}

}

return Py_BuildValue("{sOsNsNsOsO}",

PICKLED_TAG, self->tag,

PICKLED_CHILDREN, children,

PICKLED_ATTRIB, attrib,

PICKLED_TEXT, JOIN_OBJ(self->text),

PICKLED_TAIL, JOIN_OBJ(self->tail));

}

static PyObject *

element_setstate_from_attributes(ElementObject *self,

PyObject *tag,

PyObject *attrib,

PyObject *text,

PyObject *tail,

PyObject *children)

{

Py_ssize_t i, nchildren;

ElementObjectExtra *oldextra = NULL;

if (!tag) {

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

return NULL;

}