_elementtree.c

/*--------------------------------------------------------------------
 * Licensed to PSF under a Contributor Agreement.
 * See https://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
 *--------------------------------------------------------------------
 */

#ifndefPy_BUILD_CORE_BUILTIN
# definePy_BUILD_CORE_MODULE 1
#endif

#include"Python.h"
#include"pycore_pyhash.h"// _Py_HashSecret

#include<stddef.h>// offsetof()
#include"expat.h"
#include"pyexpat.h"

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

/* 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 C version of ElementTree, this means
 that the number of children should be an even number, at least on
 32-bit platforms. */

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

/* compiler tweaks */
#if defined(_MSC_VER)
#defineLOCAL(type) static __inline type __fastcall
#else
#defineLOCAL(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. */
#defineJOIN_GET(p) ((uintptr_t) (p) & 1)
#defineJOIN_SET(p, flag) ((void*) ((uintptr_t) (JOIN_OBJ(p)) | (flag)))
#defineJOIN_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.
*/
staticvoid_clear_joined_ptr(PyObject**p)
{
if (*p) {
_set_joined_ptr(p, NULL);
 }
}

/* Per-module state; PEP 3121 */
typedefstruct {
PyObject*parseerror_obj;
PyObject*deepcopy_obj;
PyObject*elementpath_obj;
PyObject*comment_factory;
PyObject*pi_factory;
/* Interned strings */
PyObject*str_text;
PyObject*str_tail;
PyObject*str_append;
PyObject*str_find;
PyObject*str_findtext;
PyObject*str_findall;
PyObject*str_iterfind;
PyObject*str_doctype;
/* Types defined by this extension */
PyTypeObject*Element_Type;
PyTypeObject*ElementIter_Type;
PyTypeObject*TreeBuilder_Type;
PyTypeObject*XMLParser_Type;

PyObject*expat_capsule;
structPyExpat_CAPI*expat_capi;
} elementtreestate;

staticstructPyModuleDefelementtreemodule;

/* Given a module object (assumed to be _elementtree), get its per-module
 * state.
 */
staticinlineelementtreestate*
get_elementtree_state(PyObject*module)
{
void*state=PyModule_GetState(module);
assert(state!=NULL);
return (elementtreestate*)state;
}

staticinlineelementtreestate*
get_elementtree_state_by_cls(PyTypeObject*cls)
{
void*state=PyType_GetModuleState(cls);
assert(state!=NULL);
return (elementtreestate*)state;
}

staticinlineelementtreestate*
get_elementtree_state_by_type(PyTypeObject*tp)
{
PyObject*mod=PyType_GetModuleByDef(tp, &elementtreemodule);
assert(mod!=NULL);
returnget_elementtree_state(mod);
}

staticint
elementtree_clear(PyObject*m)
{
elementtreestate*st=get_elementtree_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);

// Interned strings
Py_CLEAR(st->str_append);
Py_CLEAR(st->str_find);
Py_CLEAR(st->str_findall);
Py_CLEAR(st->str_findtext);
Py_CLEAR(st->str_iterfind);
Py_CLEAR(st->str_tail);
Py_CLEAR(st->str_text);
Py_CLEAR(st->str_doctype);

// Heap types
Py_CLEAR(st->Element_Type);
Py_CLEAR(st->ElementIter_Type);
Py_CLEAR(st->TreeBuilder_Type);
Py_CLEAR(st->XMLParser_Type);
Py_CLEAR(st->expat_capsule);

st->expat_capi=NULL;
return0;
}

staticint
elementtree_traverse(PyObject*m, visitprocvisit, void*arg)
{
elementtreestate*st=get_elementtree_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);

// Heap types
Py_VISIT(st->Element_Type);
Py_VISIT(st->ElementIter_Type);
Py_VISIT(st->TreeBuilder_Type);
Py_VISIT(st->XMLParser_Type);
Py_VISIT(st->expat_capsule);
return0;
}

staticvoid
elementtree_free(void*m)
{
 (void)elementtree_clear((PyObject*)m);
}

/* helpers */

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

joiner=Py_GetConstant(Py_CONSTANT_EMPTY_STR);
if (!joiner)
returnNULL;
result=PyUnicode_Join(joiner, list);
Py_DECREF(joiner);
returnresult;
}

/* Is the given object an empty dictionary?
*/
staticint
is_empty_dict(PyObject*obj)
{
returnPyDict_CheckExact(obj) &&PyDict_GET_SIZE(obj) ==0;
}


/* -------------------------------------------------------------------- */
/* the Element type */

typedefstruct {

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

/* child elements */
Py_ssize_tlength; /* actual number of items */
Py_ssize_tallocated; /* 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;

PyObject*weakreflist; /* For tp_weaklistoffset */

} ElementObject;


#define_Element_CAST(op) ((ElementObject *)(op))
#defineElement_CheckExact(st, op) Py_IS_TYPE(op, (st)->Element_Type)
#defineElement_Check(st, op) PyObject_TypeCheck(op, (st)->Element_Type)


/* -------------------------------------------------------------------- */
/* Element constructors and destructor */

LOCAL(int)
create_extra(ElementObject*self, PyObject*attrib)
{
self->extra=PyMem_Malloc(sizeof(ElementObjectExtra));
if (!self->extra) {
PyErr_NoMemory();
return-1;
 }

self->extra->attrib=Py_XNewRef(attrib);

self->extra->length=0;
self->extra->allocated=STATIC_CHILDREN;
self->extra->children=self->extra->_children;

return0;
}

LOCAL(void)
dealloc_extra(ElementObjectExtra*extra)
{
Py_ssize_ti;

if (!extra)
return;

Py_XDECREF(extra->attrib);

for (i=0; i<extra->length; i++)
Py_DECREF(extra->children[i]);

if (extra->children!=extra->_children) {
PyMem_Free(extra->children);
 }

PyMem_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(elementtreestate*st, PyObject*tag, PyObject*attrib)
{
ElementObject*self;

self=PyObject_GC_New(ElementObject, st->Element_Type);
if (self==NULL)
returnNULL;
self->extra=NULL;
self->tag=Py_NewRef(tag);
self->text=Py_NewRef(Py_None);
self->tail=Py_NewRef(Py_None);
self->weakreflist=NULL;

PyObject_GC_Track(self);

if (attrib!=NULL&& !is_empty_dict(attrib)) {
if (create_extra(self, attrib) <0) {
Py_DECREF(self);
returnNULL;
 }
 }

return (PyObject*) self;
}

staticPyObject*
element_new(PyTypeObject*type, PyObject*args, PyObject*kwds)
{
ElementObject*e= (ElementObject*)type->tp_alloc(type, 0);
if (e!=NULL) {
e->tag=Py_NewRef(Py_None);
e->text=Py_NewRef(Py_None);
e->tail=Py_NewRef(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.
 */
staticPyObject*
get_attrib_from_keywords(PyObject*kwds)
{
PyObject*attrib;
if (PyDict_PopString(kwds, "attrib", &attrib) <0) {
returnNULL;
 }

if (attrib) {
/* If attrib was found in kwds, copy its value and remove it from
 * kwds
 */
if (!PyDict_Check(attrib)) {
PyErr_Format(PyExc_TypeError, "attrib must be dict, not %.100s",
Py_TYPE(attrib)->tp_name);
Py_DECREF(attrib);
returnNULL;
 }
Py_SETREF(attrib, PyDict_Copy(attrib));
 }
else {
attrib=PyDict_New();
 }

if (attrib!=NULL&&PyDict_Update(attrib, kwds) <0) {
Py_DECREF(attrib);
returnNULL;
 }
returnattrib;
}

/*[clinic input]
module _elementtree
class _elementtree.Element "ElementObject *" "clinic_state()->Element_Type"
class _elementtree.TreeBuilder "TreeBuilderObject *" "clinic_state()->TreeBuilder_Type"
class _elementtree.XMLParser "XMLParserObject *" "clinic_state()->XMLParser_Type"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=6c83ea832d2b0ef1]*/

staticint
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;
 }
 }
 } elseif (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_XSETREF(self_elem->tag, Py_NewRef(tag));

_set_joined_ptr(&self_elem->text, Py_NewRef(Py_None));
_set_joined_ptr(&self_elem->tail, Py_NewRef(Py_None));

return0;
}

LOCAL(int)
element_resize(ElementObject*self, Py_ssize_textra)
{
Py_ssize_tsize;
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=PyMem_Realloc(self->extra->children,
size*sizeof(PyObject*));
if (!children) {
 goto nomemory;
 }
 } else {
children=PyMem_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(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(elementtreestate*st, ElementObject*self,
PyObject*element)
{
/* add a child element to a parent */
if (!Element_Check(st, element)) {
raise_type_error(element);
return-1;
 }

if (element_resize(self, 1) <0)
return-1;

self->extra->children[self->extra->length] =Py_NewRef(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) {
/* create missing dictionary */
res=self->extra->attrib=PyDict_New();
 }

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_SETREF(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_SETREF(res, tmp);
 }
 }

returnres;
}

staticPyObject*
subelement(PyObject*self, PyObject*args, PyObject*kwds)
{
PyObject*elem;

elementtreestate*st=get_elementtree_state(self);
ElementObject*parent;
PyObject*tag;
PyObject*attrib=NULL;
if (!PyArg_ParseTuple(args, "O!O|O!:SubElement",
st->Element_Type, &parent, &tag,
&PyDict_Type, &attrib)) {
returnNULL;
 }

if (attrib) {
/* attrib passed as positional arg */
attrib=PyDict_Copy(attrib);
if (!attrib)
returnNULL;
if (kwds!=NULL&&PyDict_Update(attrib, kwds) <0) {
Py_DECREF(attrib);
returnNULL;
 }
 } elseif (kwds) {
/* have keyword args */
attrib=get_attrib_from_keywords(kwds);
if (!attrib)
returnNULL;
 } else {
/* no attrib arg, no kwds, so no attribute */
 }

elem=create_new_element(st, tag, attrib);
Py_XDECREF(attrib);
if (elem==NULL)
returnNULL;

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

returnelem;
}

staticint
element_gc_traverse(PyObject*op, visitprocvisit, void*arg)
{
ElementObject*self=_Element_CAST(op);
Py_VISIT(Py_TYPE(self));
Py_VISIT(self->tag);
Py_VISIT(JOIN_OBJ(self->text));
Py_VISIT(JOIN_OBJ(self->tail));

if (self->extra) {
Py_ssize_ti;
Py_VISIT(self->extra->attrib);

for (i=0; i<self->extra->length; ++i)
Py_VISIT(self->extra->children[i]);
 }
return0;
}

staticint
element_gc_clear(PyObject*op)
{
ElementObject*self=_Element_CAST(op);
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);
return0;
}

staticvoid
element_dealloc(PyObject*op)
{
ElementObject*self=_Element_CAST(op);
PyTypeObject*tp=Py_TYPE(self);

/* bpo-31095: UnTrack is needed before calling any callbacks */
PyObject_GC_UnTrack(self);

if (self->weakreflist!=NULL)
PyObject_ClearWeakRefs(op);

/* element_gc_clear clears all references and deallocates extra
 */
 (void)element_gc_clear(op);

tp->tp_free(self);
Py_DECREF(tp);
}

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

/*[clinic input]
_elementtree.Element.append

 cls: defining_class
 subelement: object(subclass_of='clinic_state()->Element_Type')
 /

[clinic start generated code]*/

staticPyObject*
_elementtree_Element_append_impl(ElementObject*self, PyTypeObject*cls,
PyObject*subelement)
/*[clinic end generated code: output=d00923711ea317fc input=8baf92679f9717b8]*/
{
elementtreestate*st=get_elementtree_state_by_cls(cls);
if (element_add_subelement(st, self, subelement) <0)
returnNULL;

Py_RETURN_NONE;
}

/*[clinic input]
_elementtree.Element.clear

[clinic start generated code]*/

staticPyObject*
_elementtree_Element_clear_impl(ElementObject*self)
/*[clinic end generated code: output=8bcd7a51f94cfff6 input=3c719ff94bf45dd6]*/
{
clear_extra(self);

_set_joined_ptr(&self->text, Py_NewRef(Py_None));
_set_joined_ptr(&self->tail, Py_NewRef(Py_None));

Py_RETURN_NONE;
}

/*[clinic input]
_elementtree.Element.__copy__

 cls: defining_class
 /

[clinic start generated code]*/

staticPyObject*
_elementtree_Element___copy___impl(ElementObject*self, PyTypeObject*cls)
/*[clinic end generated code: output=da22894421ff2b36 input=91edb92d9f441213]*/
{
Py_ssize_ti;
ElementObject*element;
elementtreestate*st=get_elementtree_state_by_cls(cls);

element= (ElementObject*) create_new_element(
st, self->tag, self->extra ? self->extra->attrib : NULL);
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);

assert(!element->extra|| !element->extra->length);
if (self->extra) {
if (element_resize(element, self->extra->length) <0) {
Py_DECREF(element);
returnNULL;
 }

for (i=0; i<self->extra->length; i++) {
element->extra->children[i] =Py_NewRef(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(elementtreestate*, PyObject*, PyObject*);

/*[clinic input]
_elementtree.Element.__deepcopy__

 memo: object(subclass_of="&PyDict_Type")
 /

[clinic start generated code]*/

staticPyObject*
_elementtree_Element___deepcopy___impl(ElementObject*self, PyObject*memo)
/*[clinic end generated code: output=eefc3df50465b642 input=a2d40348c0aade10]*/
{
Py_ssize_ti;
ElementObject*element;
PyObject*tag;
PyObject*attrib;
PyObject*text;
PyObject*tail;
PyObject*id;

PyTypeObject*tp=Py_TYPE(self);
elementtreestate*st=get_elementtree_state_by_type(tp);
tag=deepcopy(st, self->tag, memo);
if (!tag)
returnNULL;

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

element= (ElementObject*) create_new_element(st, tag, attrib);

Py_DECREF(tag);
Py_XDECREF(attrib);

if (!element)
returnNULL;

text=deepcopy(st, JOIN_OBJ(self->text), memo);
if (!text)
 goto error;
_set_joined_ptr(&element->text, JOIN_SET(text, JOIN_GET(self->text)));

tail=deepcopy(st, 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;

// TODO(picnixz): check for an evil child's __deepcopy__ on 'self'
for (i=0; i<self->extra->length; i++) {
PyObject*child=deepcopy(st, self->extra->children[i], memo);
if (!child|| !Element_Check(st, 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);
returnNULL;
}

LOCAL(PyObject*)
deepcopy(elementtreestate*st, PyObject*object, PyObject*memo)
{
/* do a deep copy of the given object */

/* Fast paths */
if (object==Py_None||PyUnicode_CheckExact(object)) {
returnPy_NewRef(object);
 }

if (Py_REFCNT(object) ==1) {
if (PyDict_CheckExact(object)) {
PyObject*key, *value;
Py_ssize_tpos=0;
intsimple=1;
while (PyDict_Next(object, &pos, &key, &value)) {
if (!PyUnicode_CheckExact(key) || !PyUnicode_CheckExact(value)) {
simple=0;
break;
 }
 }
if (simple)
returnPyDict_Copy(object);
/* Fall through to general case */
 }
elseif (Element_CheckExact(st, object)) {
return_elementtree_Element___deepcopy___impl(
 (ElementObject*)object, memo);
 }
 }

/* General case */
if (!st->deepcopy_obj) {
PyErr_SetString(PyExc_RuntimeError,
"deepcopy helper not found");
returnNULL;
 }

PyObject*args[2] = {object, memo};
returnPyObject_Vectorcall(st->deepcopy_obj, args, 2, NULL);
}


/*[clinic input]
_elementtree.Element.__sizeof__ -> size_t

[clinic start generated code]*/

staticsize_t
_elementtree_Element___sizeof___impl(ElementObject*self)
/*[clinic end generated code: output=baae4e7ae9fe04ec input=54e298c501f3e0d0]*/
{
size_tresult=_PyObject_SIZE(Py_TYPE(self));
if (self->extra) {
result+=sizeof(ElementObjectExtra);
if (self->extra->children!=self->extra->_children) {
result+= (size_t)self->extra->allocated*sizeof(PyObject*);
 }
 }
returnresult;
}

/* dict keys for getstate/setstate. */
#definePICKLED_TAG "tag"
#definePICKLED_CHILDREN "_children"
#definePICKLED_ATTRIB "attrib"
#definePICKLED_TAIL "tail"
#definePICKLED_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]*/

staticPyObject*
_elementtree_Element___getstate___impl(ElementObject*self)
/*[clinic end generated code: output=37279aeeb6bb5b04 input=f0d16d7ec2f7adc1]*/
{
Py_ssize_ti;
PyObject*children, *attrib;

/* Build a list of children. */
children=PyList_New(self->extra ? self->extra->length : 0);
if (!children)
returnNULL;
for (i=0; i<PyList_GET_SIZE(children); i++) {
PyObject*child=Py_NewRef(self->extra->children[i]);
PyList_SET_ITEM(children, i, child);
 }

if (self->extra&&self->extra->attrib) {
attrib=Py_NewRef(self->extra->attrib);
 }
else {
attrib=PyDict_New();
if (!attrib) {
Py_DECREF(children);
returnNULL;
 }
 }

returnPy_BuildValue("{sOsNsNsOsO}",
PICKLED_TAG, self->tag,
PICKLED_CHILDREN, children,
PICKLED_ATTRIB, attrib,
PICKLED_TEXT, JOIN_OBJ(self->text),
PICKLED_TAIL, JOIN_OBJ(self->tail));