_elementtree.c

/*
 * ElementTree
 * $Id: _elementtree.c 3473 2009-01-11 22:53:55Z fredrik $
 *
 * elementtree accelerator
 *
 * History:
 * 1999-06-20 fl created (as part of sgmlop)
 * 2001-05-29 fl effdom edition
 * 2003-02-27 fl elementtree edition (alpha)
 * 2004-06-03 fl updates for elementtree 1.2
 * 2005-01-05 fl major optimization effort
 * 2005-01-11 fl first public release (cElementTree 0.8)
 * 2005-01-12 fl split element object into base and extras
 * 2005-01-13 fl use tagged pointers for tail/text (cElementTree 0.9)
 * 2005-01-17 fl added treebuilder close method
 * 2005-01-17 fl fixed crash in getchildren
 * 2005-01-18 fl removed observer api, added iterparse (cElementTree 0.9.3)
 * 2005-01-23 fl revised iterparse api; added namespace event support (0.9.8)
 * 2005-01-26 fl added VERSION module property (cElementTree 1.0)
 * 2005-01-28 fl added remove method (1.0.1)
 * 2005-03-01 fl added iselement function; fixed makeelement aliasing (1.0.2)
 * 2005-03-13 fl export Comment and ProcessingInstruction/PI helpers
 * 2005-03-26 fl added Comment and PI support to XMLParser
 * 2005-03-27 fl event optimizations; complain about bogus events
 * 2005-08-08 fl fixed read error handling in parse
 * 2005-08-11 fl added runtime test for copy workaround (1.0.3)
 * 2005-12-13 fl added expat_capi support (for xml.etree) (1.0.4)
 * 2005-12-16 fl added support for non-standard encodings
 * 2006-03-08 fl fixed a couple of potential null-refs and leaks
 * 2006-03-12 fl merge in 2.5 ssize_t changes
 * 2007-08-25 fl call custom builder's close method from XMLParser
 * 2007-08-31 fl added iter, extend from ET 1.3
 * 2007-09-01 fl fixed ParseError exception, setslice source type, etc
 * 2007-09-03 fl fixed handling of negative insert indexes
 * 2007-09-04 fl added itertext from ET 1.3
 * 2007-09-06 fl added position attribute to ParseError exception
 * 2008-06-06 fl delay error reporting in iterparse (from Hrvoje Niksic)
 *
 * 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
 */

/* Licensed to PSF under a Contributor Agreement. */
/* See http://www.python.org/psf/license for licensing details. */

#include"Python.h"

#defineVERSION "1.0.6"

/* -------------------------------------------------------------------- */
/* configuration */

/* Leave defined to include the expat-based XMLParser type */
#defineUSE_EXPAT

/* Define to do all expat calls via pyexpat's embedded expat library */
/* #define USE_PYEXPAT_CAPI */

/* An element can hold this many children without extra memory
 allocations. */
#defineSTATIC_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 version of cElementTree, this means
 that the number of children should be an even number, at least on
 32-bit platforms. */

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

#if0
staticintmemory=0;
#defineALLOC(size, comment)\
do { memory += size; printf("%8d - %s\n", memory, comment); } while (0)
#defineRELEASE(size, comment)\
do { memory -= size; printf("%8d - %s\n", memory, comment); } while (0)
#else
#defineALLOC(size, comment)
#defineRELEASE(size, comment)
#endif

/* compiler tweaks */
#if defined(_MSC_VER)
#defineLOCAL(type) static __inline type __fastcall
#else
#defineLOCAL(type) static type
#endif

/* compatibility macros */
#if (PY_VERSION_HEX<0x02060000)
#definePy_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)
#definePy_TYPE(ob) (((PyObject*)(ob))->ob_type)
#endif

#if (PY_VERSION_HEX<0x02050000)
typedefintPy_ssize_t;
#definelenfunc inquiry
#endif

#if (PY_VERSION_HEX<0x02040000)
#definePyDict_CheckExact PyDict_Check

#if !defined(Py_RETURN_NONE)
#definePy_RETURN_NONE return Py_INCREF(Py_None), Py_None
#endif
#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. */
#defineJOIN_GET(p) ((Py_uintptr_t) (p) & 1)
#defineJOIN_SET(p, flag) ((void*) ((Py_uintptr_t) (JOIN_OBJ(p)) | (flag)))
#defineJOIN_OBJ(p) ((PyObject*) ((Py_uintptr_t) (p) & ~1))

/* glue functions (see the init function for details) */
staticPyObject*elementtree_parseerror_obj;
staticPyObject*elementtree_copyelement_obj;
staticPyObject*elementtree_deepcopy_obj;
staticPyObject*elementtree_iter_obj;
staticPyObject*elementtree_itertext_obj;
staticPyObject*elementpath_obj;

/* helpers */

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

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"
 );
returnNULL;
 }

args=PyTuple_New(2);
if (!args)
returnNULL;

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

returnresult;
}

LOCAL(PyObject*)
list_join(PyObject*list)
{
/* join list elements */
PyObject*joiner;
PyObject*function;
PyObject*args;
PyObject*result;

switch (PyList_GET_SIZE(list)) {
case0:
returnPyString_FromString("");
case1:
result=PyList_GET_ITEM(list, 0);
Py_INCREF(result);
returnresult;
 }

/* two or more elements: slice out a suitable separator from the
 first member, and use that to join the entire list */

joiner=PySequence_GetSlice(PyList_GET_ITEM(list, 0), 0, 0);
if (!joiner)
returnNULL;

function=PyObject_GetAttrString(joiner, "join");
if (!function) {
Py_DECREF(joiner);
returnNULL;
 }

args=PyTuple_New(1);
if (!args) {
Py_DECREF(function);
Py_DECREF(joiner);
returnNULL;
 }

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

returnresult;
}

/* -------------------------------------------------------------------- */
/* the element type */

typedefstruct {

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

/* child elements */
intlength; /* actual number of items */
intallocated; /* allocated items */

/* this either points to _children or to a malloced buffer */
PyObject**children;

PyObject*_children[STATIC_CHILDREN];

} ElementObjectExtra;

typedefstruct {
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;

} ElementObject;

staticforwardPyTypeObjectElement_Type;

#defineElement_CheckExact(op) (Py_TYPE(op) == &Element_Type)

/* -------------------------------------------------------------------- */
/* element constructor and destructor */

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;

return0;
}

LOCAL(void)
element_dealloc_extra(ElementObject*self)
{
inti;

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

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

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_textra)
{
Py_ssize_tsize;
PyObject**children;

/* make sure self->children can hold the given number of extra
 elements. set an exception and return -1 if allocation failed */

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"
 * 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 (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", 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;
 }

return0;

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

return0;
}

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)
returnNULL;
self->extra->attrib=res;
 }

returnres;
}

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)
returnNULL;
self->text=tmp;
Py_DECREF(res);
res=tmp;
 }
 }

returnres;
}

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)
returnNULL;
self->tail=tmp;
Py_DECREF(res);
res=tmp;
 }
 }

returnres;
}

staticPyObject*
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))
returnNULL;

if (attrib||kw) {
attrib= (attrib) ? PyDict_Copy(attrib) : PyDict_New();
if (!attrib)
returnNULL;
if (kw!=NULL&&PyDict_Update(attrib, kw) <0) {
Py_DECREF(attrib);
returnNULL;
 }
 } else {
Py_INCREF(Py_None);
attrib=Py_None;
 }

elem=element_new(tag, attrib);

Py_DECREF(attrib);

returnelem;
}

staticPyObject*
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))
returnNULL;

if (attrib||kw) {
attrib= (attrib) ? PyDict_Copy(attrib) : PyDict_New();
if (!attrib)
returnNULL;
if (kw!=NULL&&PyDict_Update(attrib, kw) <0) {
Py_DECREF(attrib);
returnNULL;
 }
 } else {
Py_INCREF(Py_None);
attrib=Py_None;
 }

elem=element_new(tag, attrib);
Py_DECREF(attrib);
if (elem==NULL)
returnNULL;

if (element_add_subelement(parent, elem) <0) {
Py_DECREF(elem);
returnNULL;
 }

returnelem;
}

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

/* -------------------------------------------------------------------- */
/* methods (in alphabetical order) */

staticPyObject*
element_append(ElementObject*self, PyObject*args)
{
PyObject*element;
if (!PyArg_ParseTuple(args, "O!:append", &Element_Type, &element))
returnNULL;

if (element_add_subelement(self, element) <0)
returnNULL;

Py_RETURN_NONE;
}

staticPyObject*
element_clear(ElementObject*self, PyObject*args)
{
if (!PyArg_ParseTuple(args, ":clear"))
returnNULL;

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

staticPyObject*
element_copy(ElementObject*self, PyObject*args)
{
inti;
ElementObject*element;

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

element= (ElementObject*) element_new(
self->tag, (self->extra) ? self->extra->attrib : Py_None
 );
if (!element)
returnNULL;

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

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

staticPyObject*
element_deepcopy(ElementObject*self, PyObject*args)
{
inti;
ElementObject*element;
PyObject*tag;
PyObject*attrib;
PyObject*text;
PyObject*tail;
PyObject*id;

PyObject*memo;
if (!PyArg_ParseTuple(args, "O:__deepcopy__", &memo))
returnNULL;

tag=deepcopy(self->tag, memo);
if (!tag)
returnNULL;

if (self->extra) {
attrib=deepcopy(self->extra->attrib, memo);
if (!attrib) {
Py_DECREF(tag);
returnNULL;
 }
 } else {
Py_INCREF(Py_None);
attrib=Py_None;
 }

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

Py_DECREF(tag);
Py_DECREF(attrib);

if (!element)
returnNULL;

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

LOCAL(int)
checkpath(PyObject*tag)
{
Py_ssize_ti;
intcheck=1;

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

#definePATHCHAR(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;
elseif (p[i] =='}')
check=1;
elseif (check&&PATHCHAR(p[i]))
return1;
 }
return0;
 }
#endif
if (PyString_Check(tag)) {
char*p=PyString_AS_STRING(tag);
for (i=0; i<PyString_GET_SIZE(tag); i++) {
if (p[i] =='{')
check=0;
elseif (p[i] =='}')
check=1;
elseif (check&&PATHCHAR(p[i]))
return1;
 }
return0;
 }

return1; /* unknown type; might be path expression */
}

staticPyObject*
element_extend(ElementObject*self, PyObject*args)
{
PyObject*seq;
Py_ssize_ti;

PyObject*seq_in;
if (!PyArg_ParseTuple(args, "O:extend", &seq_in))
returnNULL;

seq=PySequence_Fast(seq_in, "");
if (!seq) {
PyErr_Format(
PyExc_TypeError,
"expected sequence, not \"%.200s\"", Py_TYPE(seq_in)->tp_name
 );
returnNULL;
 }

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

Py_DECREF(seq);

Py_RETURN_NONE;
}

staticPyObject*
element_find(ElementObject*self, PyObject*args)
{
inti;

PyObject*tag;
PyObject*namespaces=Py_None;
if (!PyArg_ParseTuple(args, "O|O:find", &tag, &namespaces))
returnNULL;

if (checkpath(tag) ||namespaces!=Py_None)
returnPyObject_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];
intrc;
if (!Element_CheckExact(item))
continue;
Py_INCREF(item);
rc=PyObject_Compare(((ElementObject*)item)->tag, tag);
if (rc==0)
returnitem;
Py_DECREF(item);
if (rc<0&&PyErr_Occurred())
returnNULL;
 }

Py_RETURN_NONE;
}

staticPyObject*
element_findtext(ElementObject*self, PyObject*args)
{
inti;

PyObject*tag;
PyObject*default_value=Py_None;
PyObject*namespaces=Py_None;
if (!PyArg_ParseTuple(args, "O|OO:findtext", &tag, &default_value, &namespaces))
returnNULL;

if (checkpath(tag) ||namespaces!=Py_None)
returnPyObject_CallMethod(
elementpath_obj, "findtext", "OOOO", self, tag, default_value, namespaces
 );

if (!self->extra) {
Py_INCREF(default_value);
returndefault_value;
 }

for (i=0; i<self->extra->length; i++) {
ElementObject*item= (ElementObject*) self->extra->children[i];
intrc;
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);
returnPyString_FromString("");
 }
Py_XINCREF(text);
Py_DECREF(item);
returntext;
 }
Py_DECREF(item);
if (rc<0&&PyErr_Occurred())
returnNULL;
 }

Py_INCREF(default_value);
returndefault_value;
}

staticPyObject*
element_findall(ElementObject*self, PyObject*args)
{
inti;
PyObject*out;

PyObject*tag;
PyObject*namespaces=Py_None;
if (!PyArg_ParseTuple(args, "O|O:findall", &tag, &namespaces))
returnNULL;

if (checkpath(tag) ||namespaces!=Py_None)
returnPyObject_CallMethod(
elementpath_obj, "findall", "OOO", self, tag, namespaces
 );

out=PyList_New(0);
if (!out)
returnNULL;

if (!self->extra)
returnout;

for (i=0; i<self->extra->length; i++) {
PyObject*item=self->extra->children[i];
intrc;
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);
returnNULL;
 }
 }

returnout;
}

staticPyObject*
element_iterfind(ElementObject*self, PyObject*args)
{
PyObject*tag;
PyObject*namespaces=Py_None;
if (!PyArg_ParseTuple(args, "O|O:iterfind", &tag, &namespaces))
returnNULL;

returnPyObject_CallMethod(
elementpath_obj, "iterfind", "OOO", self, tag, namespaces
 );
}

staticPyObject*
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))
returnNULL;

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

staticPyObject*
element_getchildren(ElementObject*self, PyObject*args)
{
inti;
PyObject*list;

if (PyErr_WarnPy3k("This method will be removed in future versions. "
"Use 'list(elem)' or iteration over elem instead.",
1) <0) {
returnNULL;
 }

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

if (!self->extra)
returnPyList_New(0);

list=PyList_New(self->extra->length);
if (!list)
returnNULL;

for (i=0; i<self->extra->length; i++) {
PyObject*item=self->extra->children[i];
Py_INCREF(item);
PyList_SET_ITEM(list, i, item);
 }

returnlist;
}

staticPyObject*
element_iter_impl(ElementObject*self, PyObject*tag)
{
PyObject*args;