cpython: fea94f9cb5a0 (original) (raw)

--- a/Modules/_elementtree.c +++ b/Modules/_elementtree.c @@ -370,6 +370,14 @@ get_attrib_from_keywords(PyObject kwds) 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) { @@ -658,25 +666,33 @@ element_dealloc(ElementObject self) / -------------------------------------------------------------------- / -static PyObject -element_append(ElementObject self, PyObject* args) +/*[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]/ {

PyObject* element;
if (!PyArg_ParseTuple(args, "O!:append", &Element_Type, &element))
```
   return NULL;[](#l1.38)
```

if (element_add_subelement(self, element) < 0)

if (element_add_subelement(self, subelement) < 0) return NULL;

Py_RETURN_NONE; } -static PyObject* -element_clearmethod(ElementObject* self, PyObject* args) +/[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]/ {

if (!PyArg_ParseTuple(args, ":clear"))
```
   return NULL;[](#l1.59)
```

- dealloc_extra(self); Py_INCREF(Py_None); @@ -690,15 +706,18 @@ element_clearmethod(ElementObject* self, Py_RETURN_NONE; } -static PyObject* -element_copy(ElementObject* self, PyObject* args) +/[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;

if (!PyArg_ParseTuple(args, ":copy"))
```
   return NULL;[](#l1.83)
```

- element = (ElementObject*) create_new_element( self->tag, (self->extra) ? self->extra->attrib : Py_None); if (!element) @@ -729,8 +748,17 @@ element_copy(ElementObject* self, PyObje return (PyObject*) element; } -static PyObject* -element_deepcopy(ElementObject* self, PyObject* args) +/*[clinic input] +_elementtree.Element.deepcopy +

memo: object
/

+ +[clinic start generated code]/ + +static PyObject +elementtree_Element___deepcopy_(ElementObject self, PyObject memo) +/[clinic end generated code: output=d1f19851d17bf239 input=df24c2b602430b77]/ { Py_ssize_t i; ElementObject element; @@ -740,10 +768,6 @@ element_deepcopy(ElementObject self, Py PyObject* tail; PyObject* id;

PyObject* memo;
if (!PyArg_ParseTuple(args, "O:deepcopy", &memo))
```
   return NULL;[](#l1.114)
```

- tag = deepcopy(self->tag, memo); if (!tag) return NULL; @@ -814,17 +838,22 @@ element_deepcopy(ElementObject* self, Py return NULL; } -static PyObject* -element_sizeof(PyObject* myself, PyObject* args) +/[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]*/ {

ElementObject self = (ElementObject)myself; 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);

return result;

} /* dict keys for getstate/setstate. / @@ -840,8 +869,14 @@ element_sizeof(PyObject myself, PyObjec

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 * -element_getstate(ElementObject self) +_elementtree_Element___getstate___impl(ElementObject self) +/[clinic end generated code: output=37279aeeb6bb5b04 input=f0d16d7ec2f7adc1]/ { Py_ssize_t i, noattrib; PyObject *instancedict = NULL, children; @@ -956,6 +991,7 @@ element_setstate_from_attributes(Element / setstate for Element instance from the Python implementation.

'state' should be the instance dict. */ +

static PyObject * element_setstate_from_Python(ElementObject *self, PyObject state) { @@ -981,8 +1017,17 @@ element_setstate_from_Python(ElementObje return retval; } +/[clinic input] +_elementtree.Element.setstate +

state: object
/

+ +[clinic start generated code]/ + static PyObject -element_setstate(ElementObject self, PyObject state) +elementtree_Element___setstate_(ElementObject self, PyObject state) +/[clinic end generated code: output=ea28bf3491b1f75e input=aaf80abea7c1e3b9]/ { if (!PyDict_CheckExact(state)) { PyErr_Format(PyExc_TypeError, @@ -1036,21 +1081,26 @@ checkpath(PyObject tag) return 1; / unknown type; might be path expression / } -static PyObject -element_extend(ElementObject self, PyObject args) +/*[clinic input] +_elementtree.Element.extend +

elements: object
/

+ +[clinic start generated code]*/ + +static PyObject +_elementtree_Element_extend(ElementObject self, PyObject elements) +/[clinic end generated code: output=f6e67fc2ff529191 input=807bc4f31c69f7c0]/ { PyObject seq; Py_ssize_t i, seqlen = 0;

PyObject* seq_in;
if (!PyArg_ParseTuple(args, "O:extend", &seq_in))
```
   return NULL;[](#l1.212)
```

seq = PySequence_Fast(seq_in, "");

seq = PySequence_Fast(elements, ""); if (!seq) { PyErr_Format( PyExc_TypeError,

       "expected sequence, not \"%.200s\"", Py_TYPE(seq_in)->tp_name[](#l1.219)

```
       "expected sequence, not \"%.200s\"", Py_TYPE(elements)->tp_name[](#l1.220)
       );[](#l1.221)
   return NULL;[](#l1.222)
```
} @@ -1078,23 +1128,26 @@ element_extend(ElementObject* self, PyOb Py_RETURN_NONE; } -static PyObject* -element_find(ElementObject *self, PyObject *args, PyObject kwds) +/[clinic input] +_elementtree.Element.find +
path: object
namespaces: object = None

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_find_impl(ElementObject *self, PyObject *path,

                          PyObject *namespaces)[](#l1.240)

+/[clinic end generated code: output=41b43f0f0becafae input=359b6985f6489d2e]/ { Py_ssize_t i;

PyObject* tag;
PyObject* namespaces = Py_None;
static char *kwlist[] = {"path", "namespaces", 0}; elementtreestate *st = ET_STATE_GLOBAL;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:find", kwlist,

                                &tag, &namespaces))[](#l1.250)

```
   return NULL;[](#l1.251)
```

if (checkpath(tag) || namespaces != Py_None) {

if (checkpath(path) || namespaces != Py_None) { _Py_IDENTIFIER(find); return _PyObject_CallMethodId(

       st->elementpath_obj, &PyId_find, "OOO", self, tag, namespaces[](#l1.257)

```
       st->elementpath_obj, &PyId_find, "OOO", self, path, namespaces[](#l1.258)
       );[](#l1.259)
```
} @@ -1104,7 +1157,7 @@ element_find(ElementObject self, PyObje for (i = 0; i < self->extra->length; i++) { PyObject item = self->extra->children[i]; if (Element_CheckExact(item) &&

       PyObject_RichCompareBool(((ElementObject*)item)->tag, tag, Py_EQ) == 1) {[](#l1.266)

       PyObject_RichCompareBool(((ElementObject*)item)->tag, path, Py_EQ) == 1) {[](#l1.267)
       Py_INCREF(item);[](#l1.268)
       return item;[](#l1.269)
   }[](#l1.270)

@@ -1113,24 +1166,28 @@ element_find(ElementObject self, PyObje Py_RETURN_NONE; } -static PyObject -element_findtext(ElementObject *self, PyObject *args, PyObject kwds) +/[clinic input] +_elementtree.Element.findtext +

path: object
default: object = None
namespaces: object = None

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,

                              PyObject *default_value,[](#l1.288)

                              PyObject *namespaces)[](#l1.289)

+/[clinic end generated code: output=83b3ba4535d308d2 input=b53a85aa5aa2a916]/ { Py_ssize_t i;

PyObject* tag;
PyObject* default_value = Py_None;
PyObject* namespaces = Py_None; _Py_IDENTIFIER(findtext);
static char *kwlist[] = {"path", "default", "namespaces", 0}; elementtreestate *st = ET_STATE_GLOBAL;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:findtext", kwlist,

                                &tag, &default_value, &namespaces))[](#l1.301)

```
   return NULL;[](#l1.302)
```

if (checkpath(tag) || namespaces != Py_None)

if (checkpath(path) || namespaces != Py_None) return _PyObject_CallMethodId(

       st->elementpath_obj, &PyId_findtext, "OOOO", self, tag, default_value, namespaces[](#l1.307)

       st->elementpath_obj, &PyId_findtext, "OOOO", self, path, default_value, namespaces[](#l1.308)
       );[](#l1.309)

if (!self->extra) { @@ -1141,7 +1198,7 @@ element_findtext(ElementObject self, Py for (i = 0; i < self->extra->length; i++) { ElementObject item = (ElementObject*) self->extra->children[i]; if (Element_CheckExact(item) &&

       (PyObject_RichCompareBool(item->tag, tag, Py_EQ) == 1)) {[](#l1.316)

       (PyObject_RichCompareBool(item->tag, path, Py_EQ) == 1)) {[](#l1.317)
       PyObject* text = element_get_text(item);[](#l1.318)
       if (text == Py_None)[](#l1.319)
           return PyUnicode_New(0, 0);[](#l1.320)

@@ -1154,20 +1211,24 @@ element_findtext(ElementObject self, Py return default_value; } -static PyObject -element_findall(ElementObject *self, PyObject *args, PyObject kwds) +/[clinic input] +_elementtree.Element.findall +

path: object
namespaces: object = None

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,

                             PyObject *namespaces)[](#l1.337)

+/[clinic end generated code: output=1a0bd9f5541b711d input=4d9e6505a638550c]/ { Py_ssize_t i; PyObject* out;

PyObject* tag;
PyObject* namespaces = Py_None;
static char *kwlist[] = {"path", "namespaces", 0};

PyObject* tag = path; elementtreestate *st = ET_STATE_GLOBAL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:findall", kwlist,

                                &tag, &namespaces))[](#l1.349)

```
   return NULL;[](#l1.350)
```

- if (checkpath(tag) || namespaces != Py_None) { _Py_IDENTIFIER(findall); return _PyObject_CallMethodId( @@ -1196,36 +1257,41 @@ element_findall(ElementObject self, PyO return out; } -static PyObject -element_iterfind(ElementObject *self, PyObject *args, PyObject kwds) +/[clinic input] +_elementtree.Element.iterfind +

path: object
namespaces: object = None

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,

                              PyObject *namespaces)[](#l1.371)

+/[clinic end generated code: output=ecdd56d63b19d40f input=abb974e350fb65c7]/ {

PyObject* tag;
PyObject* namespaces = Py_None;

PyObject* tag = path; _Py_IDENTIFIER(iterfind);

static char *kwlist[] = {"path", "namespaces", 0}; elementtreestate *st = ET_STATE_GLOBAL;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:iterfind", kwlist,

                                &tag, &namespaces)) {[](#l1.382)

```
   return NULL;[](#l1.383)
```
}

- return _PyObject_CallMethodId( st->elementpath_obj, &PyId_iterfind, "OOO", self, tag, namespaces); } -static PyObject* -element_get(ElementObject* self, PyObject* args, PyObject* kwds) +/*[clinic input] +_elementtree.Element.get +

key: object
default: object = None

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_get_impl(ElementObject *self, PyObject *key,

                         PyObject *default_value)[](#l1.402)

+/[clinic end generated code: output=523c614142595d75 input=ee153bbf8cdb246e]/ { PyObject* value;

static char* kwlist[] = {"key", "default", 0};

PyObject* key;
PyObject* default_value = Py_None;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:get", kwlist, &key,

                                &default_value))[](#l1.412)

```
   return NULL;[](#l1.413)
```

if (!self->extra || self->extra->attrib == Py_None) value = default_value; @@ -1239,17 +1305,20 @@ element_get(ElementObject* self, PyObjec return value; } -static PyObject* -element_getchildren(ElementObject* self, PyObject* args) +/[clinic input] +_elementtree.Element.getchildren + +[clinic start generated code]/ + +static PyObject +_elementtree_Element_getchildren_impl(ElementObject self) +/[clinic end generated code: output=e50ffe118637b14f input=0f754dfded150d5f]/ { Py_ssize_t i; PyObject* list; /* FIXME: report as deprecated? */

if (!PyArg_ParseTuple(args, ":getchildren"))
```
   return NULL;[](#l1.438)
```

- if (!self->extra) return PyList_New(0); @@ -1271,25 +1340,30 @@ static PyObject * create_elementiter(ElementObject *self, PyObject tag, int gettext); +/[clinic input] +_elementtree.Element.iter +

tag: object = None

+ +[clinic start generated code]*/ + static PyObject * -element_iter(ElementObject *self, PyObject *args, PyObject *kwds) +_elementtree_Element_iter_impl(ElementObject self, PyObject tag) +/[clinic end generated code: output=3f49f9a862941cc5 input=774d5b12e573aedd]/ {

PyObject* tag = Py_None;
static char* kwlist[] = {"tag", 0};

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:iter", kwlist, &tag))
```
   return NULL;[](#l1.463)
```

- return create_elementiter(self, tag, 0); } -static PyObject* -element_itertext(ElementObject* self, PyObject* args) +/[clinic input] +_elementtree.Element.itertext + +[clinic start generated code]/ + +static PyObject +_elementtree_Element_itertext_impl(ElementObject self) +/[clinic end generated code: output=5fa34b2fbcb65df6 input=af8f0e42cb239c89]/ {

if (!PyArg_ParseTuple(args, ":itertext"))
```
   return NULL;[](#l1.481)
```

- return create_elementiter(self, Py_None, 1); } @@ -1311,14 +1385,21 @@ element_getitem(PyObject* self_, Py_ssiz return self->extra->children[index]; } -static PyObject* -element_insert(ElementObject* self, PyObject* args) +/*[clinic input] +_elementtree.Element.insert +

index: Py_ssize_t
subelement: object(subclass_of='&Element_Type')
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,

                            PyObject *subelement)[](#l1.503)

+/[clinic end generated code: output=990adfef4d424c0b input=cd6fbfcdab52d7a8]/ {

Py_ssize_t index, i;
PyObject* element;
if (!PyArg_ParseTuple(args, "nO!:insert", &index,

                     &Element_Type, &element))[](#l1.509)

```
   return NULL;[](#l1.510)
```

Py_ssize_t i;

if (!self->extra) { if (create_extra(self, NULL) < 0) @@ -1339,32 +1420,38 @@ element_insert(ElementObject* self, PyOb for (i = self->extra->length; i > index; i--) self->extra->children[i] = self->extra->children[i-1];

Py_INCREF(element);
self->extra->children[index] = element;

Py_INCREF(subelement);
self->extra->children[index] = subelement;

self->extra->length++; Py_RETURN_NONE; } -static PyObject* -element_items(ElementObject* self, PyObject* args) +/[clinic input] +_elementtree.Element.items + +[clinic start generated code]/ + +static PyObject +_elementtree_Element_items_impl(ElementObject self) +/[clinic end generated code: output=6db2c778ce3f5a4d input=adbe09aaea474447]/ {

if (!PyArg_ParseTuple(args, ":items"))
```
   return NULL;[](#l1.541)
```

- if (!self->extra || self->extra->attrib == Py_None) return PyList_New(0); return PyDict_Items(self->extra->attrib); } -static PyObject* -element_keys(ElementObject* self, PyObject* args) +/[clinic input] +_elementtree.Element.keys + +[clinic start generated code]/ + +static PyObject +_elementtree_Element_keys_impl(ElementObject self) +/[clinic end generated code: output=bc5bfabbf20eeb3c input=f02caf5b496b5b0b]/ {

if (!PyArg_ParseTuple(args, ":keys"))
```
   return NULL;[](#l1.561)
```

- if (!self->extra || self->extra->attrib == Py_None) return PyList_New(0); @@ -1380,16 +1467,22 @@ element_length(ElementObject* self) return self->extra->length; } -static PyObject* -element_makeelement(PyObject* self, PyObject* args, PyObject* kw) +/*[clinic input] +_elementtree.Element.makeelement +

tag: object
attrib: object
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,

                                 PyObject *attrib)[](#l1.583)

+/[clinic end generated code: output=4109832d5bb789ef input=9480d1d2e3e68235]/ { PyObject* elem;

PyObject* tag;
PyObject* attrib;
if (!PyArg_ParseTuple(args, "OO:makeelement", &tag, &attrib))
```
   return NULL;[](#l1.591)
```

- attrib = PyDict_Copy(attrib); if (!attrib) return NULL; @@ -1401,15 +1494,20 @@ element_makeelement(PyObject* self, PyOb return elem; } -static PyObject* -element_remove(ElementObject* self, PyObject* args) +/*[clinic input] +_elementtree.Element.remove +

subelement: object(subclass_of='&Element_Type')
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_remove_impl(ElementObject self, PyObject subelement) +/[clinic end generated code: output=38fe6c07d6d87d1f input=d52fc28ededc0bd8]/ { Py_ssize_t i;

PyObject* element;
if (!PyArg_ParseTuple(args, "O!:remove", &Element_Type, &element))
```
   return NULL;[](#l1.618)
```

- if (!self->extra) { /* element has no children, so raise exception / PyErr_SetString( @@ -1420,14 +1518,14 @@ element_remove(ElementObject self, PyOb } for (i = 0; i < self->extra->length; i++) {

   if (self->extra->children[i] == element)[](#l1.627)

   if (self->extra->children[i] == subelement)[](#l1.628)
       break;[](#l1.629)

   if (PyObject_RichCompareBool(self->extra->children[i], element, Py_EQ) == 1)[](#l1.630)

   if (PyObject_RichCompareBool(self->extra->children[i], subelement, Py_EQ) == 1)[](#l1.631)
       break;[](#l1.632)

} if (i == self->extra->length) {

   /* element is not in children, so raise exception */[](#l1.636)

   /* subelement is not in children, so raise exception */[](#l1.637)
   PyErr_SetString([](#l1.638)
       PyExc_ValueError,[](#l1.639)
       "list.remove(x): x not in list"[](#l1.640)

@@ -1454,16 +1552,22 @@ element_repr(ElementObject* self) return PyUnicode_FromFormat("<Element at %p>", self); } -static PyObject* -element_set(ElementObject* self, PyObject* args) +/*[clinic input] +_elementtree.Element.set +

key: object
value: object
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_Element_set_impl(ElementObject *self, PyObject *key,

                         PyObject *value)[](#l1.658)

+/[clinic end generated code: output=fb938806be3c5656 input=1efe90f7d82b3fe9]/ { PyObject* attrib;

PyObject* key;
PyObject* value;
if (!PyArg_ParseTuple(args, "OO:set", &key, &value))
```
   return NULL;[](#l1.666)
```

- if (!self->extra) { if (create_extra(self, NULL) < 0) return NULL; @@ -1744,43 +1848,6 @@ element_ass_subscr(PyObject* self_, PyOb } } -static PyMethodDef element_methods[] = { -

{"clear", (PyCFunction) element_clearmethod, METH_VARARGS},

{"get", (PyCFunction) element_get, METH_VARARGS | METH_KEYWORDS},
{"set", (PyCFunction) element_set, METH_VARARGS},

{"find", (PyCFunction) element_find, METH_VARARGS | METH_KEYWORDS},
{"findtext", (PyCFunction) element_findtext, METH_VARARGS | METH_KEYWORDS},
{"findall", (PyCFunction) element_findall, METH_VARARGS | METH_KEYWORDS},

{"append", (PyCFunction) element_append, METH_VARARGS},
{"extend", (PyCFunction) element_extend, METH_VARARGS},
{"insert", (PyCFunction) element_insert, METH_VARARGS},
{"remove", (PyCFunction) element_remove, METH_VARARGS},

{"iter", (PyCFunction) element_iter, METH_VARARGS | METH_KEYWORDS},
{"itertext", (PyCFunction) element_itertext, METH_VARARGS},
{"iterfind", (PyCFunction) element_iterfind, METH_VARARGS | METH_KEYWORDS},

{"getiterator", (PyCFunction) element_iter, METH_VARARGS | METH_KEYWORDS},
{"getchildren", (PyCFunction) element_getchildren, METH_VARARGS},

{"items", (PyCFunction) element_items, METH_VARARGS},
{"keys", (PyCFunction) element_keys, METH_VARARGS},

{"makeelement", (PyCFunction) element_makeelement, METH_VARARGS},

{"copy", (PyCFunction) element_copy, METH_VARARGS},
{"deepcopy", (PyCFunction) element_deepcopy, METH_VARARGS},
{"sizeof", element_sizeof, METH_NOARGS},
{"getstate", (PyCFunction)element_getstate, METH_NOARGS},
{"setstate", (PyCFunction)element_setstate, METH_O},

{NULL, NULL}

-}; - static PyObject* element_getattro(ElementObject* self, PyObject* nameobj) { @@ -1877,54 +1944,6 @@ static PySequenceMethods element_as_sequ 0, }; -static PyMappingMethods element_as_mapping = {

(lenfunc) element_length,
(binaryfunc) element_subscr,
(objobjargproc) element_ass_subscr,

-}; - -static PyTypeObject Element_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
"xml.etree.ElementTree.Element", sizeof(ElementObject), 0,
/* methods */
(destructor)element_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
(reprfunc)element_repr, /* tp_repr */
0, /* tp_as_number */
&element_as_sequence, /* tp_as_sequence */
&element_as_mapping, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
(getattrofunc)element_getattro, /* tp_getattro */
(setattrofunc)element_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

                                               /* tp_flags */[](#l1.745)

0, /* tp_doc */
(traverseproc)element_gc_traverse, /* tp_traverse */
(inquiry)element_gc_clear, /* tp_clear */
0, /* tp_richcompare */
offsetof(ElementObject, weakreflist), /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
element_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)element_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
element_new, /* tp_new */
0, /* tp_free */

-}; - /******************************* Element iterator ****************************/ /* ElementIterObject represents the iteration state over an XML element in @@ -2264,23 +2283,24 @@ treebuilder_new(PyTypeObject *type, PyOb return (PyObject )t; } +/[clinic input] +_elementtree.TreeBuilder.init +

element_factory: object = NULL

+ +[clinic start generated code]*/ + static int -treebuilder_init(PyObject *self, PyObject *args, PyObject *kwds) +_elementtree_TreeBuilder___init___impl(TreeBuilderObject *self,

                                  PyObject *element_factory)[](#l1.784)

+/[clinic end generated code: output=91cfa7558970ee96 input=1b424eeefc35249c]/ {

static char *kwlist[] = {"element_factory", 0};
PyObject *element_factory = NULL;
TreeBuilderObject *self_tb = (TreeBuilderObject *)self; PyObject *tmp;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:TreeBuilder", kwlist,

                                &element_factory)) {[](#l1.793)

```
   return -1;[](#l1.794)
```
}

- if (element_factory) { Py_INCREF(element_factory);

   tmp = self_tb->element_factory;[](#l1.799)

   self_tb->element_factory = element_factory;[](#l1.800)

   tmp = self->element_factory;[](#l1.801)

```
   self->element_factory = element_factory;[](#l1.802)
   Py_XDECREF(tmp);[](#l1.803)
```
} @@ -2600,23 +2620,33 @@ treebuilder_handle_namespace(TreeBuilder /* -------------------------------------------------------------------- / / methods (in alphabetical order) / -static PyObject -treebuilder_data(TreeBuilderObject* self, PyObject* args) +/*[clinic input] +_elementtree.TreeBuilder.data +
data: object
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_TreeBuilder_data(TreeBuilderObject self, PyObject data) +/[clinic end generated code: output=69144c7100795bb2 input=a0540c532b284d29]/ {

PyObject* data;
if (!PyArg_ParseTuple(args, "O:data", &data))
```
   return NULL;[](#l1.826)
```

- return treebuilder_handle_data(self, data); } -static PyObject* -treebuilder_end(TreeBuilderObject* self, PyObject* args) +/*[clinic input] +_elementtree.TreeBuilder.end +

tag: object
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_TreeBuilder_end(TreeBuilderObject self, PyObject tag) +/[clinic end generated code: output=9a98727cc691cd9d input=22dc3674236f5745]/ {

PyObject* tag;
if (!PyArg_ParseTuple(args, "O:end", &tag))
```
   return NULL;[](#l1.847)
```

- return treebuilder_handle_end(self, tag); } @@ -2636,76 +2666,35 @@ treebuilder_done(TreeBuilderObject* self return res; } -static PyObject* -treebuilder_close(TreeBuilderObject* self, PyObject* args) +/[clinic input] +_elementtree.TreeBuilder.close + +[clinic start generated code]/ + +static PyObject +_elementtree_TreeBuilder_close_impl(TreeBuilderObject self) +/[clinic end generated code: output=b441fee3202f61ee input=f7c9c65dc718de14]/ {

if (!PyArg_ParseTuple(args, ":close"))
```
   return NULL;[](#l1.868)
```

- return treebuilder_done(self); } -static PyObject* -treebuilder_start(TreeBuilderObject* self, PyObject* args) +/*[clinic input] +_elementtree.TreeBuilder.start +

tag: object
attrs: object = None
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,

                               PyObject *attrs)[](#l1.886)

+/[clinic end generated code: output=e7e9dc2861349411 input=95fc1758dd042c65]/ {

PyObject* tag;
PyObject* attrib = Py_None;
if (!PyArg_ParseTuple(args, "O|O:start", &tag, &attrib))
```
   return NULL;[](#l1.892)
```

return treebuilder_handle_start(self, tag, attrib);

return treebuilder_handle_start(self, tag, attrs);

} -static PyMethodDef treebuilder_methods[] = {

{"data", (PyCFunction) treebuilder_data, METH_VARARGS},
{"start", (PyCFunction) treebuilder_start, METH_VARARGS},
{"end", (PyCFunction) treebuilder_end, METH_VARARGS},
{"close", (PyCFunction) treebuilder_close, METH_VARARGS},
{NULL, NULL}

-}; - -static PyTypeObject TreeBuilder_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
"xml.etree.ElementTree.TreeBuilder", sizeof(TreeBuilderObject), 0,
/* methods */
(destructor)treebuilder_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

                                               /* tp_flags */[](#l1.926)

0, /* tp_doc */
(traverseproc)treebuilder_gc_traverse, /* tp_traverse */
(inquiry)treebuilder_gc_clear, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
treebuilder_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)treebuilder_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
treebuilder_new, /* tp_new */
0, /* tp_free */

-}; - /* ==================================================================== / / the expat interface */ @@ -3212,33 +3201,34 @@ xmlparser_new(PyTypeObject *type, PyObje return (PyObject )self; } +/[clinic input] +_elementtree.XMLParser.init +

html: object = NULL
target: object = NULL
encoding: str(nullable=True) = NULL

+ +[clinic start generated code]*/ + static int -xmlparser_init(PyObject *self, PyObject *args, PyObject *kwds) +_elementtree_XMLParser___init___impl(XMLParserObject *self, PyObject *html,

                                PyObject *target, const char *encoding)[](#l1.967)

+/[clinic end generated code: output=d6a16c63dda54441 input=a870da39c80d7d68]/ {

XMLParserObject *self_xp = (XMLParserObject *)self;
PyObject *target = NULL, *html = NULL;
char *encoding = NULL;
static char *kwlist[] = {"html", "target", "encoding", 0};

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOz:XMLParser", kwlist,

                                &html, &target, &encoding)) {[](#l1.976)

self->entity = PyDict_New();
if (!self->entity)
```
   return -1;[](#l1.979)
```

self->names = PyDict_New();
if (!self->names) {

   Py_CLEAR(self->entity);[](#l1.983)
   return -1;[](#l1.984)

}

self_xp->entity = PyDict_New();
if (!self_xp->entity)
```
   return -1;[](#l1.989)
```

self_xp->names = PyDict_New();
if (!self_xp->names) {

   Py_CLEAR(self_xp->entity);[](#l1.993)

```
   return -1;[](#l1.994)
```
}

self_xp->parser = EXPAT(ParserCreate_MM)(encoding, &ExpatMemoryHandler, "}");
if (!self_xp->parser) {

   Py_CLEAR(self_xp->entity);[](#l1.999)

   Py_CLEAR(self_xp->names);[](#l1.1000)

self->parser = EXPAT(ParserCreate_MM)(encoding, &ExpatMemoryHandler, "}");
if (!self->parser) {
```
   Py_CLEAR(self->entity);[](#l1.1003)
```
```
   Py_CLEAR(self->names);[](#l1.1004)
   PyErr_NoMemory();[](#l1.1005)
   return -1;[](#l1.1006)
```
} @@ -3248,55 +3238,55 @@ xmlparser_init(PyObject *self, PyObject } else { target = treebuilder_new(&TreeBuilder_Type, NULL, NULL); if (!target) {

       Py_CLEAR(self_xp->entity);[](#l1.1012)

       Py_CLEAR(self_xp->names);[](#l1.1013)

       EXPAT(ParserFree)(self_xp->parser);[](#l1.1014)

       Py_CLEAR(self->entity);[](#l1.1015)

       Py_CLEAR(self->names);[](#l1.1016)

       EXPAT(ParserFree)(self->parser);[](#l1.1017)
       return -1;[](#l1.1018)
   }[](#l1.1019)

}

self_xp->target = target;

self_xp->handle_start = PyObject_GetAttrString(target, "start");
self_xp->handle_data = PyObject_GetAttrString(target, "data");
self_xp->handle_end = PyObject_GetAttrString(target, "end");
self_xp->handle_comment = PyObject_GetAttrString(target, "comment");
self_xp->handle_pi = PyObject_GetAttrString(target, "pi");
self_xp->handle_close = PyObject_GetAttrString(target, "close");
self_xp->handle_doctype = PyObject_GetAttrString(target, "doctype");

self->target = target;

self->handle_start = PyObject_GetAttrString(target, "start");
self->handle_data = PyObject_GetAttrString(target, "data");
self->handle_end = PyObject_GetAttrString(target, "end");
self->handle_comment = PyObject_GetAttrString(target, "comment");
self->handle_pi = PyObject_GetAttrString(target, "pi");
self->handle_close = PyObject_GetAttrString(target, "close");
self->handle_doctype = PyObject_GetAttrString(target, "doctype");

PyErr_Clear(); /* configure parser */

EXPAT(SetUserData)(self_xp->parser, self_xp);

EXPAT(SetUserData)(self->parser, self); EXPAT(SetElementHandler)(

```
   self_xp->parser,[](#l1.1046)
```

   self->parser,[](#l1.1047)
   (XML_StartElementHandler) expat_start_handler,[](#l1.1048)
   (XML_EndElementHandler) expat_end_handler[](#l1.1049)
   );[](#l1.1050)

EXPAT(SetDefaultHandlerExpand)(

```
   self_xp->parser,[](#l1.1052)
```

   self->parser,[](#l1.1053)
   (XML_DefaultHandler) expat_default_handler[](#l1.1054)
   );[](#l1.1055)

EXPAT(SetCharacterDataHandler)(

```
   self_xp->parser,[](#l1.1057)
```

   self->parser,[](#l1.1058)
   (XML_CharacterDataHandler) expat_data_handler[](#l1.1059)
   );[](#l1.1060)

if (self_xp->handle_comment)

if (self->handle_comment) EXPAT(SetCommentHandler)(

```
       self_xp->parser,[](#l1.1064)
```

       self->parser,[](#l1.1065)
       (XML_CommentHandler) expat_comment_handler[](#l1.1066)
       );[](#l1.1067)

if (self_xp->handle_pi)

if (self->handle_pi) EXPAT(SetProcessingInstructionHandler)(

```
       self_xp->parser,[](#l1.1071)
```

       self->parser,[](#l1.1072)
       (XML_ProcessingInstructionHandler) expat_pi_handler[](#l1.1073)
       );[](#l1.1074)

EXPAT(SetStartDoctypeDeclHandler)(

```
   self_xp->parser,[](#l1.1076)
```

   self->parser,[](#l1.1077)
   (XML_StartDoctypeDeclHandler) expat_start_doctype_handler[](#l1.1078)
   );[](#l1.1079)

EXPAT(SetUnknownEncodingHandler)(

```
   self_xp->parser,[](#l1.1081)
```

   self->parser,[](#l1.1082)
   EXPAT(DefaultUnknownEncodingHandler), NULL[](#l1.1083)
   );[](#l1.1084)

@@ -3372,15 +3362,18 @@ expat_parse(XMLParserObject* self, const Py_RETURN_NONE; } -static PyObject* -xmlparser_close(XMLParserObject* self, PyObject* args) +/[clinic input] +_elementtree.XMLParser.close + +[clinic start generated code]/ + +static PyObject +_elementtree_XMLParser_close_impl(XMLParserObject self) +/[clinic end generated code: output=d68d375dd23bc7fb input=ca7909ca78c3abfe]/ { /* end feeding data to parser / PyObject res;

if (!PyArg_ParseTuple(args, ":close"))
```
   return NULL;[](#l1.1105)
```

- res = expat_parse(self, "", 0, 1); if (!res) return NULL; @@ -3398,15 +3391,24 @@ xmlparser_close(XMLParserObject* self, P } } -static PyObject* -xmlparser_feed(XMLParserObject* self, PyObject* arg) +/*[clinic input] +_elementtree.XMLParser.feed +

data: object
/

+ +[clinic start generated code]*/ + +static PyObject +_elementtree_XMLParser_feed(XMLParserObject self, PyObject data) +/[clinic end generated code: output=e42b6a78eec7446d input=fe231b6b8de3ce1f]/ { / feed data to parser */

if (PyUnicode_Check(arg)) {

if (PyUnicode_Check(data)) { Py_ssize_t data_len;

   const char *data = PyUnicode_AsUTF8AndSize(arg, &data_len);[](#l1.1133)

```
   if (data == NULL)[](#l1.1134)
```

   const char *data_ptr = PyUnicode_AsUTF8AndSize(data, &data_len);[](#l1.1135)

   if (data_ptr == NULL)[](#l1.1136)
       return NULL;[](#l1.1137)
   if (data_len > INT_MAX) {[](#l1.1138)
       PyErr_SetString(PyExc_OverflowError, "size does not fit in an int");[](#l1.1139)

@@ -3414,12 +3416,12 @@ xmlparser_feed(XMLParserObject* self, Py } /* Explicitly set UTF-8 encoding. Return code ignored. */ (void)EXPAT(SetEncoding)(self->parser, "utf-8");

   return expat_parse(self, data, (int)data_len, 0);[](#l1.1144)

   return expat_parse(self, data_ptr, (int)data_len, 0);[](#l1.1145)

} else { Py_buffer view; PyObject *res;

   if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) < 0)[](#l1.1150)

   if (PyObject_GetBuffer(data, &view, PyBUF_SIMPLE) < 0)[](#l1.1151)
       return NULL;[](#l1.1152)
   if (view.len > INT_MAX) {[](#l1.1153)
       PyBuffer_Release(&view);[](#l1.1154)

@@ -3432,8 +3434,17 @@ xmlparser_feed(XMLParserObject* self, Py } } -static PyObject* -xmlparser_parse_whole(XMLParserObject* self, PyObject* args) +/*[clinic input] +_elementtree.XMLParser._parse_whole +

file: object
/

+ +[clinic start generated code]/ + +static PyObject +_elementtree_XMLParser__parse_whole(XMLParserObject self, PyObject file) +/[clinic end generated code: output=f797197bb818dda3 input=19ecc893b6f3e752]/ { / (internal) parse the whole input, until end of stream / PyObject reader; @@ -3441,11 +3452,7 @@ xmlparser_parse_whole(XMLParserObject s PyObject* temp; PyObject* res;

PyObject* fileobj;
if (!PyArg_ParseTuple(args, "O:_parse", &fileobj))
```
   return NULL;[](#l1.1181)
```

reader = PyObject_GetAttrString(fileobj, "read");

reader = PyObject_GetAttrString(file, "read"); if (!reader) return NULL;

@@ -3512,25 +3519,37 @@ xmlparser_parse_whole(XMLParserObject* s return res; } -static PyObject* -xmlparser_doctype(XMLParserObject self, PyObject args) +/[clinic input] +_elementtree.XMLParser.doctype + +[clinic start generated code]/ + +static PyObject +_elementtree_XMLParser_doctype_impl(XMLParserObject self) +/[clinic end generated code: output=d09fdb9c45f3a602 input=20d5e0febf902a2f]/ { Py_RETURN_NONE; } -static PyObject* -xmlparser_setevents(XMLParserObject self, PyObject args) +/*[clinic input] +_elementtree.XMLParser._setevents +

events_queue: object(subclass_of='&PyList_Type')
events_to_report: object = None
/

+ +[clinic start generated code]*/ + +static PyObject * +_elementtree_XMLParser__setevents_impl(XMLParserObject *self,

                                  PyObject *events_queue,[](#l1.1219)

                                  PyObject *events_to_report)[](#l1.1220)

+/[clinic end generated code: output=1440092922b13ed1 input=59db9742910c6174]/ { /* activate element event reporting */ Py_ssize_t i, seqlen; TreeBuilderObject *target; -

PyObject *events_queue;
PyObject *events_to_report = Py_None; PyObject *events_seq;
if (!PyArg_ParseTuple(args, "O!|O:_setevents", &PyList_Type, &events_queue,

                     &events_to_report))[](#l1.1231)

```
   return NULL;[](#l1.1232)
```

if (!TreeBuilder_CheckExact(self->target)) { PyErr_SetString( @@ -3614,15 +3633,6 @@ xmlparser_setevents(XMLParserObject *sel Py_RETURN_NONE; } -static PyMethodDef xmlparser_methods[] = {

{"feed", (PyCFunction) xmlparser_feed, METH_O},
{"close", (PyCFunction) xmlparser_close, METH_VARARGS},
{"_parse_whole", (PyCFunction) xmlparser_parse_whole, METH_VARARGS},
{"_setevents", (PyCFunction) xmlparser_setevents, METH_VARARGS},
{"doctype", (PyCFunction) xmlparser_doctype, METH_VARARGS},
{NULL, NULL}

-}; - static PyObject* xmlparser_getattro(XMLParserObject* self, PyObject* nameobj) { @@ -3647,6 +3657,152 @@ xmlparser_getattro(XMLParserObject* self return PyObject_GenericGetAttr((PyObject*) self, nameobj); } +#include "clinic/_elementtree.c.h" + +static PyMethodDef element_methods[] = { +

_ELEMENTTREE_ELEMENT_CLEAR_METHODDEF

_ELEMENTTREE_ELEMENT_GET_METHODDEF
_ELEMENTTREE_ELEMENT_SET_METHODDEF

_ELEMENTTREE_ELEMENT_FIND_METHODDEF
_ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF
_ELEMENTTREE_ELEMENT_FINDALL_METHODDEF

_ELEMENTTREE_ELEMENT_APPEND_METHODDEF
_ELEMENTTREE_ELEMENT_EXTEND_METHODDEF
_ELEMENTTREE_ELEMENT_INSERT_METHODDEF
_ELEMENTTREE_ELEMENT_REMOVE_METHODDEF

_ELEMENTTREE_ELEMENT_ITER_METHODDEF
_ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF
_ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF

{"getiterator", (PyCFunction)elementtree_Element_iter, METH_VARARGS|METH_KEYWORDS, elementtree_Element_iter__doc},
_ELEMENTTREE_ELEMENT_GETCHILDREN_METHODDEF

_ELEMENTTREE_ELEMENT_ITEMS_METHODDEF
_ELEMENTTREE_ELEMENT_KEYS_METHODDEF

_ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF

_ELEMENTTREE_ELEMENT___COPY___METHODDEF
_ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF
_ELEMENTTREE_ELEMENT___SIZEOF___METHODDEF
_ELEMENTTREE_ELEMENT___GETSTATE___METHODDEF
_ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF

{NULL, NULL}

+}; + +static PyMappingMethods element_as_mapping = {

(lenfunc) element_length,
(binaryfunc) element_subscr,
(objobjargproc) element_ass_subscr,

+}; + +static PyTypeObject Element_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
"xml.etree.ElementTree.Element", sizeof(ElementObject), 0,
/* methods */
(destructor)element_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
(reprfunc)element_repr, /* tp_repr */
0, /* tp_as_number */
&element_as_sequence, /* tp_as_sequence */
&element_as_mapping, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
(getattrofunc)element_getattro, /* tp_getattro */
(setattrofunc)element_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

                                               /* tp_flags */[](#l1.1321)

0, /* tp_doc */
(traverseproc)element_gc_traverse, /* tp_traverse */
(inquiry)element_gc_clear, /* tp_clear */
0, /* tp_richcompare */
offsetof(ElementObject, weakreflist), /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
element_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)element_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
element_new, /* tp_new */
0, /* tp_free */

+}; + +static PyMethodDef treebuilder_methods[] = {

_ELEMENTTREE_TREEBUILDER_DATA_METHODDEF
_ELEMENTTREE_TREEBUILDER_START_METHODDEF
_ELEMENTTREE_TREEBUILDER_END_METHODDEF
_ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF
{NULL, NULL}

+}; + +static PyTypeObject TreeBuilder_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
"xml.etree.ElementTree.TreeBuilder", sizeof(TreeBuilderObject), 0,
/* methods */
(destructor)treebuilder_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

                                               /* tp_flags */[](#l1.1371)

0, /* tp_doc */
(traverseproc)treebuilder_gc_traverse, /* tp_traverse */
(inquiry)treebuilder_gc_clear, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
treebuilder_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
elementtree_TreeBuilder___init_, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
treebuilder_new, /* tp_new */
0, /* tp_free */

+}; + +static PyMethodDef xmlparser_methods[] = {

_ELEMENTTREE_XMLPARSER_FEED_METHODDEF
_ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF
_ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF
_ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF
_ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF
{NULL, NULL}

+}; + static PyTypeObject XMLParser_Type = { PyVarObject_HEAD_INIT(NULL, 0) "xml.etree.ElementTree.XMLParser", sizeof(XMLParserObject), 0, @@ -3683,7 +3839,7 @@ static PyTypeObject XMLParser_Type = { 0, /* tp_descr_get / 0, / tp_descr_set / 0, / tp_dictoffset */

(initproc)xmlparser_init, /* tp_init */

elementtree_XMLParser___init_, /* tp_init / PyType_GenericAlloc, / tp_alloc / xmlparser_new, / tp_new / 0, / tp_free */

copy from Modules/_elementtree.c copy to Modules/clinic/_elementtree.c.h --- a/Modules/_elementtree.c +++ b/Modules/clinic/_elementtree.c.h @@ -1,3781 +1,666 @@ -/*--------------------------------------------------------------------

- 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[](#l2.15)
*--------------------------------------------------------------------
/ - -#define PY_SSIZE_T_CLEAN - -#include "Python.h" -#include "structmember.h" +/[clinic input] +preserve +[clinic start generated code]/ -/ -------------------------------------------------------------------- / -/ configuration / - -/ An element can hold this many children without extra memory
allocations. */ -#define STATIC_CHILDREN 4 +PyDoc_STRVAR(elementtree_Element_append__doc_, +"append($self, subelement, /)\n" +"--\n" +"\n");

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

-/* -------------------------------------------------------------------- */ +#define _ELEMENTTREE_ELEMENT_APPEND_METHODDEF [](#l2.49)

{"append", (PyCFunction)elementtree_Element_append, METH_O, elementtree_Element_append__doc},

-#if 0 -static int memory = 0; -#define ALLOC(size, comment)[](#l2.54) -do { memory += size; printf("%8d - %s\n", memory, comment); } while (0) -#define RELEASE(size, comment)[](#l2.56) -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 +static PyObject * +_elementtree_Element_append_impl(ElementObject *self, PyObject subelement); -/ 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) ((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_Element_append(ElementObject *self, PyObject *arg) +{

PyObject *return_value = NULL;
PyObject *subelement;

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

   PyObject *tmp = JOIN_OBJ(*p);[](#l2.91)

```
   *p = NULL;[](#l2.92)
```
```
   Py_DECREF(tmp);[](#l2.93)
```
}

if (!PyArg_Parse(arg, "O!:append", &Element_Type, &subelement))
```
   goto exit;[](#l2.96)
```
return_value = _elementtree_Element_append_impl(self, subelement);

+ +exit:

return return_value;

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

-} 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)) +PyDoc_STRVAR(elementtree_Element_clear__doc_, +"clear($self, /)\n" +"--\n" +"\n"); -/ Find the module instance imported in the currently running sub-interpreter
- and get its state.
*/ -#define ET_STATE_GLOBAL [](#l2.131)
((elementtreestate *) PyModule_GetState(PyState_FindModule(&elementtreemodule)))

+#define _ELEMENTTREE_ELEMENT_CLEAR_METHODDEF [](#l2.133)

{"clear", (PyCFunction)elementtree_Element_clear, METH_NOARGS, elementtree_Element_clear__doc},

-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 PyObject * +_elementtree_Element_clear_impl(ElementObject *self); -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) +static PyObject * +_elementtree_Element_clear(ElementObject *self, PyObject *Py_UNUSED(ignored)) {

elementtree_clear((PyObject *)m);

-} - -/* helpers / - -LOCAL(PyObject) -deepcopy(PyObject* object, PyObject* memo) -{

/* do a deep copy of the given object */
PyObject* args;
PyObject* result;
elementtreestate *st = ET_STATE_GLOBAL;

if (!st->deepcopy_obj) {
```
   PyErr_SetString([](#l2.177)
```
```
       PyExc_RuntimeError,[](#l2.178)
```

       "deepcopy helper not found"[](#l2.179)

```
       );[](#l2.180)
```
```
   return NULL;[](#l2.181)
```
}

args = PyTuple_Pack(2, object, memo);
if (!args)
```
   return NULL;[](#l2.186)
```
result = PyObject_CallObject(st->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;[](#l2.201)
```
result = PyUnicode_Join(joiner, list);
Py_DECREF(joiner);
if (result)
```
   Py_DECREF(list);[](#l2.205)
```
return result;

-} - -/* Is the given object an empty dictionary? -*/ -static int -is_empty_dict(PyObject *obj) -{

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

return _elementtree_Element_clear_impl(self);

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

+PyDoc_STRVAR(elementtree_Element___copy____doc_, +"copy($self, /)\n" +"--\n" +"\n");

/* 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[](#l2.249)

  to distinguish lists created by the tree builder from lists[](#l2.250)

  assigned to the attribute by application code; the former[](#l2.251)

  should be joined before being returned to the user, the latter[](#l2.252)

```
  should be left intact. */[](#l2.253)
```
PyObject* text;

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

  pointer; use JOIN_OBJ to get the object pointer. */[](#l2.257)

PyObject* tail;

ElementObjectExtra* extra;

PyObject weakreflist; / For tp_weaklistoffset */

- -} ElementObject; - - -#define Element_CheckExact(op) (Py_TYPE(op) == &Element_Type) +#define _ELEMENTTREE_ELEMENT___COPY___METHODDEF [](#l2.268)

{"copy", (PyCFunction)elementtree_Element___copy, METH_NOARGS, elementtree_Element___copy____doc},

-/* -------------------------------------------------------------------- / -/ Element constructors and destructor / - -LOCAL(int) -create_extra(ElementObject self, PyObject* attrib) -{

self->extra = PyObject_Malloc(sizeof(ElementObjectExtra));
if (!self->extra) {
```
   PyErr_NoMemory();[](#l2.279)
```
```
   return -1;[](#l2.280)
```
}

if (!attrib)
```
   attrib = Py_None;[](#l2.284)
```

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

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

+static PyObject * +_elementtree_Element___copy___impl(ElementObject *self);

return 0;

-} - -LOCAL(void) -dealloc_extra(ElementObject* self) +static PyObject * +elementtree_Element___copy_(ElementObject *self, PyObject *Py_UNUSED(ignored)) {

ElementObjectExtra *myextra;
Py_ssize_t i;

if (!self->extra)
```
   return;[](#l2.307)
```

/* 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]);[](#l2.317)

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

   PyObject_Free(myextra->children);[](#l2.320)

PyObject_Free(myextra);

return _elementtree_Element___copy___impl(self);

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

+PyDoc_STRVAR(elementtree_Element___deepcopy____doc_, +"deepcopy($self, memo, /)\n" +"--\n" +"\n");

self = PyObject_GC_New(ElementObject, &Element_Type);
if (self == NULL)
```
   return NULL;[](#l2.340)
```
self->extra = NULL;

Py_INCREF(tag);
self->tag = tag;

+#define _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF [](#l2.345)

{"deepcopy", (PyCFunction)elementtree_Element___deepcopy, METH_O, elementtree_Element___deepcopy____doc},

Py_INCREF(Py_None);
self->text = Py_None;

Py_INCREF(Py_None);
self->tail = Py_None;

self->weakreflist = NULL;

+PyDoc_STRVAR(elementtree_Element___sizeof____doc_, +"sizeof($self, /)\n" +"--\n" +"\n");

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

+#define _ELEMENTTREE_ELEMENT___SIZEOF___METHODDEF [](#l2.362)

{"sizeof", (PyCFunction)elementtree_Element___sizeof, METH_NOARGS, elementtree_Element___sizeof____doc},

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

   if (create_extra(self, attrib) < 0) {[](#l2.366)

```
       Py_DECREF(self);[](#l2.367)
```
```
       return NULL;[](#l2.368)
```
```
   }[](#l2.369)
```
}

return (PyObject*) self;

-} +static Py_ssize_t +elementtree_Element___sizeof___impl(ElementObject *self); static PyObject * -element_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +elementtree_Element___sizeof(ElementObject *self, PyObject *Py_UNUSED(ignored)) {

ElementObject *e = (ElementObject *)type->tp_alloc(type, 0);
if (e != NULL) {
```
   Py_INCREF(Py_None);[](#l2.383)
```
```
   e->tag = Py_None;[](#l2.384)
```

PyObject *return_value = NULL;
Py_ssize_t _return_value;

```
   Py_INCREF(Py_None);[](#l2.388)
```
```
   e->text = Py_None;[](#l2.389)
```

_return_value = _elementtree_Element___sizeof___impl(self);
if ((_return_value == -1) && PyErr_Occurred())
```
   goto exit;[](#l2.392)
```
return_value = PyLong_FromSsize_t(_return_value);

```
   Py_INCREF(Py_None);[](#l2.395)
```
```
   e->tail = Py_None;[](#l2.396)
```

```
   e->extra = NULL;[](#l2.398)
```
```
   e->weakreflist = NULL;[](#l2.399)
```
}
return (PyObject *)e;

+exit:

return return_value;

} -/* 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");
PyObject *attrib = PyDict_GetItem(kwds, attrib_str);

+PyDoc_STRVAR(elementtree_Element___getstate____doc_, +"getstate($self, /)\n" +"--\n" +"\n");

if (attrib) {

   /* If attrib was found in kwds, copy its value and remove it from[](#l2.425)

```
    * kwds[](#l2.426)
```
```
    */[](#l2.427)
```

   if (!PyDict_Check(attrib)) {[](#l2.428)

       Py_DECREF(attrib_str);[](#l2.429)

       PyErr_Format(PyExc_TypeError, "attrib must be dict, not %.100s",[](#l2.430)

                    Py_TYPE(attrib)->tp_name);[](#l2.431)

```
       return NULL;[](#l2.432)
```
```
   }[](#l2.433)
```

   attrib = PyDict_Copy(attrib);[](#l2.434)

   PyDict_DelItem(kwds, attrib_str);[](#l2.435)

} else {
```
   attrib = PyDict_New();[](#l2.437)
```
}

Py_DECREF(attrib_str);

/* attrib can be NULL if PyDict_New failed */
if (attrib)

   if (PyDict_Update(attrib, kwds) < 0)[](#l2.444)

```
       return NULL;[](#l2.445)
```
return attrib;

-} - -static int -element_init(PyObject *self, PyObject *args, PyObject *kwds) -{

PyObject *tag;
PyObject *tmp;
PyObject *attrib = NULL;
ElementObject *self_elem;

+#define _ELEMENTTREE_ELEMENT___GETSTATE___METHODDEF [](#l2.456)

{"getstate", (PyCFunction)elementtree_Element___getstate, METH_NOARGS, elementtree_Element___getstate____doc},

if (!PyArg_ParseTuple(args, "O|O!:Element", &tag, &PyDict_Type, &attrib))
```
   return -1;[](#l2.460)
```

if (attrib) {

   /* attrib passed as positional arg */[](#l2.463)

   attrib = PyDict_Copy(attrib);[](#l2.464)

```
   if (!attrib)[](#l2.465)
```
```
       return -1;[](#l2.466)
```
```
   if (kwds) {[](#l2.467)
```

       if (PyDict_Update(attrib, kwds) < 0) {[](#l2.468)

           Py_DECREF(attrib);[](#l2.469)

```
           return -1;[](#l2.470)
```
```
       }[](#l2.471)
```
```
   }[](#l2.472)
```
} else if (kwds) {
```
   /* have keywords args */[](#l2.474)
```

   attrib = get_attrib_from_keywords(kwds);[](#l2.475)

```
   if (!attrib)[](#l2.476)
```
```
       return -1;[](#l2.477)
```
}

self_elem = (ElementObject *)self;

+static PyObject * +_elementtree_Element___getstate___impl(ElementObject *self);

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

   if (create_extra(self_elem, attrib) < 0) {[](#l2.485)

```
       Py_DECREF(attrib);[](#l2.486)
```
```
       return -1;[](#l2.487)
```
```
   }[](#l2.488)
```
}

/* 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. */
tmp = self_elem->tag;
Py_INCREF(tag);
self_elem->tag = tag;
Py_DECREF(tmp);

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;

+static PyObject * +elementtree_Element___getstate_(ElementObject *self, PyObject *Py_UNUSED(ignored)) +{

return _elementtree_Element___getstate___impl(self);

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

  elements.  set an exception and return -1 if allocation failed */[](#l2.524)

if (!self->extra) {

   if (create_extra(self, NULL) < 0)[](#l2.527)

```
       return -1;[](#l2.528)
```
}

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

+PyDoc_STRVAR(elementtree_Element___setstate____doc_, +"setstate($self, state, /)\n" +"--\n" +"\n");

if (size > self->extra->allocated) {

   /* use Python 2.4's list growth strategy */[](#l2.538)

   size = (size >> 3) + (size < 9 ? 3 : 6) + size;[](#l2.539)

   /* Coverity CID #182 size_error: Allocating 1 bytes to pointer "children"[](#l2.540)

    * which needs at least 4 bytes.[](#l2.541)

    * Although it's a false alarm always assume at least one child to[](#l2.542)

```
    * be safe.[](#l2.543)
```
```
    */[](#l2.544)
```
```
   size = size ? size : 1;[](#l2.545)
```

   if ((size_t)size > PY_SSIZE_T_MAX/sizeof(PyObject*))[](#l2.546)

```
       goto nomemory;[](#l2.547)
```

   if (self->extra->children != self->extra->_children) {[](#l2.548)

       /* Coverity CID #182 size_error: Allocating 1 bytes to pointer[](#l2.549)

        * "children", which needs at least 4 bytes. Although it's a[](#l2.550)

        * false alarm always assume at least one child to be safe.[](#l2.551)

```
        */[](#l2.552)
```

       children = PyObject_Realloc(self->extra->children,[](#l2.553)

                                   size * sizeof(PyObject*));[](#l2.554)

```
       if (!children)[](#l2.555)
```
```
           goto nomemory;[](#l2.556)
```
```
   } else {[](#l2.557)
```

       children = PyObject_Malloc(size * sizeof(PyObject*));[](#l2.558)

```
       if (!children)[](#l2.559)
```
```
           goto nomemory;[](#l2.560)
```

       /* copy existing children from static area to malloc buffer */[](#l2.561)

       memcpy(children, self->extra->children,[](#l2.562)

              self->extra->length * sizeof(PyObject*));[](#l2.563)

```
   }[](#l2.564)
```

   self->extra->children = children;[](#l2.565)

   self->extra->allocated = size;[](#l2.566)

}

return 0;

nomemory:
PyErr_NoMemory();
return -1;

-} +#define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF [](#l2.575)

{"setstate", (PyCFunction)elementtree_Element___setstate, METH_O, elementtree_Element___setstate____doc},

-LOCAL(int) -element_add_subelement(ElementObject* self, PyObject* element) -{

/* add a child element to a parent */

if (element_resize(self, 1) < 0)
```
   return -1;[](#l2.584)
```

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;

+PyDoc_STRVAR(elementtree_Element_extend__doc_, +"extend($self, elements, /)\n" +"--\n" +"\n");

if (res == Py_None) {

   /* create missing dictionary */[](#l2.607)

```
   res = PyDict_New();[](#l2.608)
```
```
   if (!res)[](#l2.609)
```
```
       return NULL;[](#l2.610)
```
```
   Py_DECREF(Py_None);[](#l2.611)
```

   self->extra->attrib = res;[](#l2.612)

}

return res;

-} +#define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF [](#l2.617)

{"extend", (PyCFunction)elementtree_Element_extend, METH_O, elementtree_Element_extend__doc},

-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);[](#l2.628)
```

   if (PyList_CheckExact(res)) {[](#l2.629)

```
       res = list_join(res);[](#l2.630)
```
```
       if (!res)[](#l2.631)
```
```
           return NULL;[](#l2.632)
```
```
       self->text = res;[](#l2.633)
```
```
   }[](#l2.634)
```
}

return res;

-} +PyDoc_STRVAR(elementtree_Element_find__doc_, +"find($self, /, path, namespaces=None)\n" +"--\n" +"\n"); -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);[](#l2.652)
```

   if (PyList_CheckExact(res)) {[](#l2.653)

```
       res = list_join(res);[](#l2.654)
```
```
       if (!res)[](#l2.655)
```
```
           return NULL;[](#l2.656)
```
```
       self->tail = res;[](#l2.657)
```
```
   }[](#l2.658)
```
}

return res;

-} - -static PyObject* -subelement(PyObject *self, PyObject *args, PyObject *kwds) -{

PyObject* elem;

+#define _ELEMENTTREE_ELEMENT_FIND_METHODDEF [](#l2.668)

{"find", (PyCFunction)elementtree_Element_find, METH_VARARGS|METH_KEYWORDS, elementtree_Element_find__doc},

ElementObject* parent;
PyObject* tag;
PyObject* attrib = NULL;
if (!PyArg_ParseTuple(args, "O!O|O!:SubElement",

                     &Element_Type, &parent, &tag,[](#l2.675)

                     &PyDict_Type, &attrib)) {[](#l2.676)

```
   return NULL;[](#l2.677)
```
}

if (attrib) {

   /* attrib passed as positional arg */[](#l2.681)

   attrib = PyDict_Copy(attrib);[](#l2.682)

```
   if (!attrib)[](#l2.683)
```
```
       return NULL;[](#l2.684)
```
```
   if (kwds) {[](#l2.685)
```

       if (PyDict_Update(attrib, kwds) < 0) {[](#l2.686)

```
           return NULL;[](#l2.687)
```
```
       }[](#l2.688)
```
```
   }[](#l2.689)
```
} else if (kwds) {
```
   /* have keyword args */[](#l2.691)
```

   attrib = get_attrib_from_keywords(kwds);[](#l2.692)

```
   if (!attrib)[](#l2.693)
```
```
       return NULL;[](#l2.694)
```
} else {

   /* no attrib arg, no kwds, so no attribute */[](#l2.696)

```
   Py_INCREF(Py_None);[](#l2.697)
```
```
   attrib = Py_None;[](#l2.698)
```
}

+static PyObject * +_elementtree_Element_find_impl(ElementObject *self, PyObject *path,

                          PyObject *namespaces);[](#l2.702)

elem = create_new_element(tag, attrib);
Py_DECREF(attrib);
if (elem == NULL)
```
   return NULL;[](#l2.707)
```

if (element_add_subelement(parent, elem) < 0) {
```
   Py_DECREF(elem);[](#l2.710)
```
```
   return NULL;[](#l2.711)
```
}

return elem;

-} - -static int -element_gc_traverse(ElementObject *self, visitproc visit, void *arg) +static PyObject * +_elementtree_Element_find(ElementObject *self, PyObject *args, PyObject *kwargs) {

Py_VISIT(self->tag);
Py_VISIT(JOIN_OBJ(self->text));
Py_VISIT(JOIN_OBJ(self->tail));

if (self->extra) {
```
   Py_ssize_t i;[](#l2.727)
```

   Py_VISIT(self->extra->attrib);[](#l2.728)

PyObject *return_value = NULL;
static char *_keywords[] = {"path", "namespaces", NULL};
PyObject *path;
PyObject *namespaces = Py_None;

   for (i = 0; i < self->extra->length; ++i)[](#l2.734)

       Py_VISIT(self->extra->children[i]);[](#l2.735)

}
return 0;

-} - -static int -element_gc_clear(ElementObject *self) -{

Py_CLEAR(self->tag);
_clear_joined_ptr(&self->text);
_clear_joined_ptr(&self->tail);

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:find", _keywords,
```
   &path, &namespaces))[](#l2.747)
```
```
   goto exit;[](#l2.748)
```
return_value = _elementtree_Element_find_impl(self, path, namespaces);

/* After dropping all references from extra, it's no longer valid anyway,
```
* so fully deallocate it.[](#l2.752)
```
*/
dealloc_extra(self);
return 0;

-} - -static void -element_dealloc(ElementObject* self) -{

PyObject_GC_UnTrack(self);

if (self->weakreflist != NULL)

   PyObject_ClearWeakRefs((PyObject *) self);[](#l2.764)

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

+exit:

return return_value;

} -/* -------------------------------------------------------------------- / - -static PyObject -element_append(ElementObject* self, PyObject* args) -{

PyObject* element;
if (!PyArg_ParseTuple(args, "O!:append", &Element_Type, &element))
```
   return NULL;[](#l2.783)
```

if (element_add_subelement(self, element) < 0)
```
   return NULL;[](#l2.786)
```

Py_RETURN_NONE;

-} +PyDoc_STRVAR(elementtree_Element_findtext__doc_, +"findtext($self, /, path, default=None, namespaces=None)\n" +"--\n" +"\n"); -static PyObject* -element_clearmethod(ElementObject* self, PyObject* args) -{

if (!PyArg_ParseTuple(args, ":clear"))
```
   return NULL;[](#l2.799)
```

dealloc_extra(self);

+#define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF [](#l2.802)

{"findtext", (PyCFunction)elementtree_Element_findtext, METH_VARARGS|METH_KEYWORDS, elementtree_Element_findtext__doc},

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

-} +static PyObject * +_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,

                              PyObject *default_value,[](#l2.817)

                              PyObject *namespaces);[](#l2.818)

-static PyObject* -element_copy(ElementObject* self, PyObject* args) +static PyObject * +_elementtree_Element_findtext(ElementObject *self, PyObject *args, PyObject *kwargs) {

Py_ssize_t i;
ElementObject* element;

if (!PyArg_ParseTuple(args, ":copy"))
```
   return NULL;[](#l2.829)
```

element = (ElementObject*) create_new_element(

   self->tag, (self->extra) ? self->extra->attrib : Py_None);[](#l2.832)

if (!element)
```
   return NULL;[](#l2.834)
```

Py_DECREF(JOIN_OBJ(element->text));
element->text = self->text;
Py_INCREF(JOIN_OBJ(element->text));

PyObject *return_value = NULL;
static char *_keywords[] = {"path", "default", "namespaces", NULL};
PyObject *path;
PyObject *default_value = Py_None;
PyObject *namespaces = Py_None;

Py_DECREF(JOIN_OBJ(element->tail));
element->tail = self->tail;
Py_INCREF(JOIN_OBJ(element->tail));

if (self->extra) {

   if (element_resize(element, self->extra->length) < 0) {[](#l2.850)

```
       Py_DECREF(element);[](#l2.851)
```
```
       return NULL;[](#l2.852)
```
```
   }[](#l2.853)
```

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:findtext", _keywords,

   &path, &default_value, &namespaces))[](#l2.855)

```
   goto exit;[](#l2.856)
```
return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces);

   for (i = 0; i < self->extra->length; i++) {[](#l2.859)

       Py_INCREF(self->extra->children[i]);[](#l2.860)

       element->extra->children[i] = self->extra->children[i];[](#l2.861)

```
   }[](#l2.862)
```

   element->extra->length = self->extra->length;[](#l2.864)

}

return (PyObject*) element;

+exit:

return return_value;

} -static PyObject* -element_deepcopy(ElementObject* self, PyObject* args) -{

Py_ssize_t i;
ElementObject* element;
PyObject* tag;
PyObject* attrib;
PyObject* text;
PyObject* tail;
PyObject* id;

PyObject* memo;
if (!PyArg_ParseTuple(args, "O:deepcopy", &memo))
```
   return NULL;[](#l2.885)
```

tag = deepcopy(self->tag, memo);
if (!tag)
```
   return NULL;[](#l2.889)
```

+PyDoc_STRVAR(elementtree_Element_findall__doc_, +"findall($self, /, path, namespaces=None)\n" +"--\n" +"\n");

if (self->extra) {

   attrib = deepcopy(self->extra->attrib, memo);[](#l2.896)

```
   if (!attrib) {[](#l2.897)
```
```
       Py_DECREF(tag);[](#l2.898)
```
```
       return NULL;[](#l2.899)
```
```
   }[](#l2.900)
```
} else {
```
   Py_INCREF(Py_None);[](#l2.902)
```
```
   attrib = Py_None;[](#l2.903)
```
}

+#define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF [](#l2.905)

{"findall", (PyCFunction)elementtree_Element_findall, METH_VARARGS|METH_KEYWORDS, elementtree_Element_findall__doc},

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

Py_DECREF(tag);
Py_DECREF(attrib);

if (!element)
```
   return NULL;[](#l2.914)
```

+static PyObject * +_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,

                             PyObject *namespaces);[](#l2.917)

text = deepcopy(JOIN_OBJ(self->text), memo);
if (!text)
```
   goto error;[](#l2.921)
```
Py_DECREF(element->text);
element->text = JOIN_SET(text, JOIN_GET(self->text));

tail = deepcopy(JOIN_OBJ(self->tail), memo);
if (!tail)
```
   goto error;[](#l2.927)
```
Py_DECREF(element->tail);
element->tail = JOIN_SET(tail, JOIN_GET(self->tail));

if (self->extra) {

   if (element_resize(element, self->extra->length) < 0)[](#l2.932)

```
       goto error;[](#l2.933)
```

+static PyObject * +_elementtree_Element_findall(ElementObject *self, PyObject *args, PyObject *kwargs) +{

PyObject *return_value = NULL;
static char *_keywords[] = {"path", "namespaces", NULL};
PyObject *path;
PyObject *namespaces = Py_None;

   for (i = 0; i < self->extra->length; i++) {[](#l2.942)

       PyObject* child = deepcopy(self->extra->children[i], memo);[](#l2.943)

```
       if (!child) {[](#l2.944)
```

           element->extra->length = i;[](#l2.945)

```
           goto error;[](#l2.946)
```
```
       }[](#l2.947)
```

       element->extra->children[i] = child;[](#l2.948)

```
   }[](#l2.949)
```

   element->extra->length = self->extra->length;[](#l2.951)

}

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:findall", _keywords,
```
   &path, &namespaces))[](#l2.954)
```
```
   goto exit;[](#l2.955)
```
return_value = _elementtree_Element_findall_impl(self, path, namespaces);

/* add object to memo dictionary (so deepcopy won't visit it again) */
id = PyLong_FromSsize_t((Py_uintptr_t) self);
if (!id)
```
   goto error;[](#l2.961)
```

i = PyDict_SetItem(memo, id, (PyObject*) element);

Py_DECREF(id);

if (i < 0)
```
   goto error;[](#l2.968)
```

return (PyObject*) element;

error:
Py_DECREF(element);
return NULL;

+exit:

return return_value;

} -static PyObject* -element_sizeof(PyObject* myself, PyObject* args) -{

ElementObject self = (ElementObject)myself;
Py_ssize_t result = sizeof(ElementObject);
if (self->extra) {

   result += sizeof(ElementObjectExtra);[](#l2.985)

   if (self->extra->children != self->extra->_children)[](#l2.986)

       result += sizeof(PyObject*) * self->extra->allocated;[](#l2.987)

}
return PyLong_FromSsize_t(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.
*/ -static PyObject * -element_getstate(ElementObject *self) -{
Py_ssize_t i, noattrib;
PyObject *instancedict = NULL, *children;

+PyDoc_STRVAR(elementtree_Element_iterfind__doc_, +"iterfind($self, /, path, namespaces=None)\n" +"--\n" +"\n");

/* Build a list of children. */
children = PyList_New(self->extra ? self->extra->length : 0);
if (!children)
```
   return NULL;[](#l2.1018)
```
for (i = 0; i < PyList_GET_SIZE(children); i++) {

   PyObject *child = self->extra->children[i];[](#l2.1020)

```
   Py_INCREF(child);[](#l2.1021)
```

   PyList_SET_ITEM(children, i, child);[](#l2.1022)

}

+#define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF [](#l2.1024)

{"iterfind", (PyCFunction)elementtree_Element_iterfind, METH_VARARGS|METH_KEYWORDS, elementtree_Element_iterfind__doc},

/* Construct the state object. */
noattrib = (self->extra == NULL || self->extra->attrib == Py_None);
if (noattrib)

   instancedict = Py_BuildValue("{sOsOs{}sOsO}",[](#l2.1030)

                                PICKLED_TAG, self->tag,[](#l2.1031)

                                PICKLED_CHILDREN, children,[](#l2.1032)

                                PICKLED_ATTRIB,[](#l2.1033)

                                PICKLED_TEXT, JOIN_OBJ(self->text),[](#l2.1034)

                                PICKLED_TAIL, JOIN_OBJ(self->tail));[](#l2.1035)

else

   instancedict = Py_BuildValue("{sOsOsOsOsO}",[](#l2.1037)

                                PICKLED_TAG, self->tag,[](#l2.1038)

                                PICKLED_CHILDREN, children,[](#l2.1039)

                                PICKLED_ATTRIB, self->extra->attrib,[](#l2.1040)

                                PICKLED_TEXT, JOIN_OBJ(self->text),[](#l2.1041)

                                PICKLED_TAIL, JOIN_OBJ(self->tail));[](#l2.1042)

if (instancedict) {
```
   Py_DECREF(children);[](#l2.1044)
```
```
   return instancedict;[](#l2.1045)
```
}
else {

   for (i = 0; i < PyList_GET_SIZE(children); i++)[](#l2.1048)

       Py_DECREF(PyList_GET_ITEM(children, i));[](#l2.1049)

```
   Py_DECREF(children);[](#l2.1050)
```

```
   return NULL;[](#l2.1052)
```
}

-} +static PyObject * +_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,

                              PyObject *namespaces);[](#l2.1057)

static PyObject * -element_setstate_from_attributes(ElementObject *self,

                            PyObject *tag,[](#l2.1061)

                            PyObject *attrib,[](#l2.1062)

                            PyObject *text,[](#l2.1063)

                            PyObject *tail,[](#l2.1064)

                            PyObject *children)[](#l2.1065)

+_elementtree_Element_iterfind(ElementObject *self, PyObject *args, PyObject *kwargs) {

Py_ssize_t i, nchildren;

if (!tag) {

   PyErr_SetString(PyExc_TypeError, "tag may not be NULL");[](#l2.1071)

```
   return NULL;[](#l2.1072)
```
}

Py_CLEAR(self->tag);
self->tag = tag;
Py_INCREF(self->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;[](#l2.1089)
```

/* Compute 'nchildren'. */
if (children) {

   if (!PyList_Check(children)) {[](#l2.1093)

       PyErr_SetString(PyExc_TypeError, "'_children' is not a list");[](#l2.1094)

```
       return NULL;[](#l2.1095)
```
```
   }[](#l2.1096)
```

   nchildren = PyList_Size(children);[](#l2.1097)

}
else {
```
   nchildren = 0;[](#l2.1100)
```
}

/* Allocate 'extra'. */
if (element_resize(self, nchildren)) {
```
   return NULL;[](#l2.1105)
```
}
assert(self->extra && self->extra->allocated >= nchildren);

PyObject *return_value = NULL;
static char *_keywords[] = {"path", "namespaces", NULL};
PyObject *path;
PyObject *namespaces = Py_None;

/* Copy children */
for (i = 0; i < nchildren; i++) {

   self->extra->children[i] = PyList_GET_ITEM(children, i);[](#l2.1115)

   Py_INCREF(self->extra->children[i]);[](#l2.1116)

}

self->extra->length = nchildren;
self->extra->allocated = nchildren;

/* Stash attrib. */
if (attrib) {

   Py_CLEAR(self->extra->attrib);[](#l2.1124)

   self->extra->attrib = attrib;[](#l2.1125)

```
   Py_INCREF(attrib);[](#l2.1126)
```
}

Py_RETURN_NONE;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:iterfind", _keywords,
```
   &path, &namespaces))[](#l2.1132)
```
```
   goto exit;[](#l2.1133)
```
return_value = _elementtree_Element_iterfind_impl(self, path, namespaces);

-/* setstate for Element instance from the Python implementation.

- 'state' should be the instance dict.
*/ -static PyObject * -element_setstate_from_Python(ElementObject *self, PyObject *state) -{
static char *kwlist[] = {PICKLED_TAG, PICKLED_ATTRIB, PICKLED_TEXT,

                        PICKLED_TAIL, PICKLED_CHILDREN, 0};[](#l2.1143)

PyObject *args;
PyObject *tag, *attrib, *text, *tail, *children;
PyObject *retval;

tag = attrib = text = tail = children = NULL;
args = PyTuple_New(0);
if (!args)
```
   return NULL;[](#l2.1151)
```

if (PyArg_ParseTupleAndKeywords(args, state, "|$OOOOO", kwlist, &tag,

                               &attrib, &text, &tail, &children))[](#l2.1154)

   retval = element_setstate_from_attributes(self, tag, attrib, text,[](#l2.1155)

                                             tail, children);[](#l2.1156)

else
```
   retval = NULL;[](#l2.1158)
```

Py_DECREF(args);
return retval;

-} - -static PyObject * -element_setstate(ElementObject *self, PyObject *state) -{

if (!PyDict_CheckExact(state)) {

   PyErr_Format(PyExc_TypeError,[](#l2.1168)

                "Don't know how to unpickle \"%.200R\" as an Element",[](#l2.1169)

```
                state);[](#l2.1170)
```
```
   return NULL;[](#l2.1171)
```
}
else

   return element_setstate_from_Python(self, state);[](#l2.1174)

+exit:

return return_value;

} -LOCAL(int) -checkpath(PyObject* tag) -{

Py_ssize_t i;
int check = 1;

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

- -#define PATHCHAR(ch) [](#l2.1187)

(ch == '/' || ch == '*' || ch == '[' || ch == '@' || ch == '.')

+PyDoc_STRVAR(elementtree_Element_get__doc_, +"get($self, /, key, default=None)\n" +"--\n" +"\n");

if (PyUnicode_Check(tag)) {

   const Py_ssize_t len = PyUnicode_GET_LENGTH(tag);[](#l2.1195)

   void *data = PyUnicode_DATA(tag);[](#l2.1196)

   unsigned int kind = PyUnicode_KIND(tag);[](#l2.1197)

   for (i = 0; i < len; i++) {[](#l2.1198)

       Py_UCS4 ch = PyUnicode_READ(kind, data, i);[](#l2.1199)

```
       if (ch == '{')[](#l2.1200)
```
```
           check = 0;[](#l2.1201)
```
```
       else if (ch == '}')[](#l2.1202)
```
```
           check = 1;[](#l2.1203)
```

       else if (check && PATHCHAR(ch))[](#l2.1204)

```
           return 1;[](#l2.1205)
```
```
   }[](#l2.1206)
```
```
   return 0;[](#l2.1207)
```
}
if (PyBytes_Check(tag)) {

   char *p = PyBytes_AS_STRING(tag);[](#l2.1210)

   for (i = 0; i < PyBytes_GET_SIZE(tag); i++) {[](#l2.1211)

```
       if (p[i] == '{')[](#l2.1212)
```
```
           check = 0;[](#l2.1213)
```

       else if (p[i] == '}')[](#l2.1214)

```
           check = 1;[](#l2.1215)
```

       else if (check && PATHCHAR(p[i]))[](#l2.1216)

```
           return 1;[](#l2.1217)
```
```
   }[](#l2.1218)
```
```
   return 0;[](#l2.1219)
```
}

+#define _ELEMENTTREE_ELEMENT_GET_METHODDEF [](#l2.1221)

{"get", (PyCFunction)elementtree_Element_get, METH_VARARGS|METH_KEYWORDS, elementtree_Element_get__doc},

return 1; /* unknown type; might be path expression */

-} - -static PyObject* -element_extend(ElementObject* self, PyObject* args) -{

PyObject* seq;
Py_ssize_t i, seqlen = 0;

PyObject* seq_in;
if (!PyArg_ParseTuple(args, "O:extend", &seq_in))
```
   return NULL;[](#l2.1235)
```

+static PyObject * +_elementtree_Element_get_impl(ElementObject *self, PyObject *key,

                         PyObject *default_value);[](#l2.1238)

seq = PySequence_Fast(seq_in, "");
if (!seq) {
```
   PyErr_Format([](#l2.1242)
```
```
       PyExc_TypeError,[](#l2.1243)
```

       "expected sequence, not \"%.200s\"", Py_TYPE(seq_in)->tp_name[](#l2.1244)

```
       );[](#l2.1245)
```
```
   return NULL;[](#l2.1246)
```
}

seqlen = PySequence_Size(seq);
for (i = 0; i < seqlen; i++) {

   PyObject* element = PySequence_Fast_GET_ITEM(seq, i);[](#l2.1251)

   if (!PyObject_IsInstance(element, (PyObject *)&Element_Type)) {[](#l2.1252)

```
       Py_DECREF(seq);[](#l2.1253)
```
```
       PyErr_Format([](#l2.1254)
```
```
           PyExc_TypeError,[](#l2.1255)
```

           "expected an Element, not \"%.200s\"",[](#l2.1256)

           Py_TYPE(element)->tp_name);[](#l2.1257)

```
       return NULL;[](#l2.1258)
```
```
   }[](#l2.1259)
```

   if (element_add_subelement(self, element) < 0) {[](#l2.1261)

```
       Py_DECREF(seq);[](#l2.1262)
```
```
       return NULL;[](#l2.1263)
```
```
   }[](#l2.1264)
```
}

Py_DECREF(seq);

Py_RETURN_NONE;

-} +static PyObject * +_elementtree_Element_get(ElementObject *self, PyObject *args, PyObject *kwargs) +{

PyObject *return_value = NULL;
static char *_keywords[] = {"key", "default", NULL};
PyObject *key;
PyObject *default_value = Py_None;

-static PyObject* -element_find(ElementObject *self, PyObject *args, PyObject *kwds) -{

Py_ssize_t i;
PyObject* tag;
PyObject* namespaces = Py_None;
static char *kwlist[] = {"path", "namespaces", 0};
elementtreestate *st = ET_STATE_GLOBAL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:find", kwlist,

                                &tag, &namespaces))[](#l2.1289)

```
   return NULL;[](#l2.1290)
```

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:get", _keywords,
```
   &key, &default_value))[](#l2.1292)
```
```
   goto exit;[](#l2.1293)
```
return_value = _elementtree_Element_get_impl(self, key, default_value);

if (checkpath(tag) || namespaces != Py_None) {
```
   _Py_IDENTIFIER(find);[](#l2.1297)
```

   return _PyObject_CallMethodId([](#l2.1298)

       st->elementpath_obj, &PyId_find, "OOO", self, tag, namespaces[](#l2.1299)

```
       );[](#l2.1300)
```
}

if (!self->extra)
```
   Py_RETURN_NONE;[](#l2.1304)
```

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

   PyObject* item = self->extra->children[i];[](#l2.1307)

   if (Element_CheckExact(item) &&[](#l2.1308)

       PyObject_RichCompareBool(((ElementObject*)item)->tag, tag, Py_EQ) == 1) {[](#l2.1309)

```
       Py_INCREF(item);[](#l2.1310)
```
```
       return item;[](#l2.1311)
```
```
   }[](#l2.1312)
```
}

Py_RETURN_NONE;

+exit:

return return_value;

} -static PyObject* -element_findtext(ElementObject *self, PyObject *args, PyObject *kwds) -{

Py_ssize_t i;
PyObject* tag;
PyObject* default_value = Py_None;
PyObject* namespaces = Py_None;
_Py_IDENTIFIER(findtext);
static char *kwlist[] = {"path", "default", "namespaces", 0};
elementtreestate *st = ET_STATE_GLOBAL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:findtext", kwlist,

                                &tag, &default_value, &namespaces))[](#l2.1332)

```
   return NULL;[](#l2.1333)
```

if (checkpath(tag) || namespaces != Py_None)

   return _PyObject_CallMethodId([](#l2.1336)

       st->elementpath_obj, &PyId_findtext, "OOOO", self, tag, default_value, namespaces[](#l2.1337)

```
       );[](#l2.1338)
```

+PyDoc_STRVAR(elementtree_Element_getchildren__doc_, +"getchildren($self, /)\n" +"--\n" +"\n");

if (!self->extra) {

   Py_INCREF(default_value);[](#l2.1345)

```
   return default_value;[](#l2.1346)
```
}

+#define _ELEMENTTREE_ELEMENT_GETCHILDREN_METHODDEF [](#l2.1348)

{"getchildren", (PyCFunction)elementtree_Element_getchildren, METH_NOARGS, elementtree_Element_getchildren__doc},

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

   ElementObject* item = (ElementObject*) self->extra->children[i];[](#l2.1352)

   if (Element_CheckExact(item) &&[](#l2.1353)

       (PyObject_RichCompareBool(item->tag, tag, Py_EQ) == 1)) {[](#l2.1354)

       PyObject* text = element_get_text(item);[](#l2.1355)

```
       if (text == Py_None)[](#l2.1356)
```

           return PyUnicode_New(0, 0);[](#l2.1357)

```
       Py_XINCREF(text);[](#l2.1358)
```
```
       return text;[](#l2.1359)
```
```
   }[](#l2.1360)
```
}

+static PyObject * +_elementtree_Element_getchildren_impl(ElementObject *self);

Py_INCREF(default_value);
return default_value;

-} - -static PyObject* -element_findall(ElementObject *self, PyObject *args, PyObject *kwds) +static PyObject * +_elementtree_Element_getchildren(ElementObject *self, PyObject *Py_UNUSED(ignored)) {

Py_ssize_t i;
PyObject* out;
PyObject* tag;
PyObject* namespaces = Py_None;
static char *kwlist[] = {"path", "namespaces", 0};
elementtreestate *st = ET_STATE_GLOBAL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:findall", kwlist,

                                &tag, &namespaces))[](#l2.1382)

```
   return NULL;[](#l2.1383)
```

if (checkpath(tag) || namespaces != Py_None) {
```
   _Py_IDENTIFIER(findall);[](#l2.1386)
```

   return _PyObject_CallMethodId([](#l2.1387)

       st->elementpath_obj, &PyId_findall, "OOO", self, tag, namespaces[](#l2.1388)

```
       );[](#l2.1389)
```
}

out = PyList_New(0);
if (!out)
```
   return NULL;[](#l2.1394)
```

if (!self->extra)
```
   return out;[](#l2.1397)
```

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

   PyObject* item = self->extra->children[i];[](#l2.1400)

   if (Element_CheckExact(item) &&[](#l2.1401)

       PyObject_RichCompareBool(((ElementObject*)item)->tag, tag, Py_EQ) == 1) {[](#l2.1402)

       if (PyList_Append(out, item) < 0) {[](#l2.1403)

```
           Py_DECREF(out);[](#l2.1404)
```
```
           return NULL;[](#l2.1405)
```
```
       }[](#l2.1406)
```
```
   }[](#l2.1407)
```
}

return out;

-} - -static PyObject* -element_iterfind(ElementObject *self, PyObject *args, PyObject *kwds) -{

PyObject* tag;
PyObject* namespaces = Py_None;
_Py_IDENTIFIER(iterfind);
static char *kwlist[] = {"path", "namespaces", 0};
elementtreestate *st = ET_STATE_GLOBAL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:iterfind", kwlist,

                                &tag, &namespaces)) {[](#l2.1423)

```
   return NULL;[](#l2.1424)
```
}

return _PyObject_CallMethodId(

   st->elementpath_obj, &PyId_iterfind, "OOO", self, tag, namespaces);[](#l2.1428)

return _elementtree_Element_getchildren_impl(self);

} -static PyObject* -element_get(ElementObject* self, PyObject* args, PyObject* kwds) -{

PyObject* value;
static char* kwlist[] = {"key", "default", 0};

PyObject* key;
PyObject* default_value = Py_None;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:get", kwlist, &key,

                                &default_value))[](#l2.1442)

```
   return NULL;[](#l2.1443)
```

if (!self->extra || self->extra->attrib == Py_None)
```
   value = default_value;[](#l2.1446)
```
else {

   value = PyDict_GetItem(self->extra->attrib, key);[](#l2.1448)

```
   if (!value)[](#l2.1449)
```

       value = default_value;[](#l2.1450)

}

Py_INCREF(value);
return value;

-} +PyDoc_STRVAR(elementtree_Element_iter__doc_, +"iter($self, /, tag=None)\n" +"--\n" +"\n"); -static PyObject* -element_getchildren(ElementObject* self, PyObject* args) -{

Py_ssize_t i;
PyObject* list;

/* FIXME: report as deprecated? */

if (!PyArg_ParseTuple(args, ":getchildren"))
```
   return NULL;[](#l2.1470)
```

if (!self->extra)
```
   return PyList_New(0);[](#l2.1473)
```

list = PyList_New(self->extra->length);
if (!list)
```
   return NULL;[](#l2.1477)
```

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

   PyObject* item = self->extra->children[i];[](#l2.1480)

```
   Py_INCREF(item);[](#l2.1481)
```

   PyList_SET_ITEM(list, i, item);[](#l2.1482)

}

return list;

-} - +#define _ELEMENTTREE_ELEMENT_ITER_METHODDEF [](#l2.1488)

{"iter", (PyCFunction)elementtree_Element_iter, METH_VARARGS|METH_KEYWORDS, elementtree_Element_iter__doc},

static PyObject * -create_elementiter(ElementObject *self, PyObject *tag, int gettext); - +_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag); static PyObject * -element_iter(ElementObject *self, PyObject *args, PyObject *kwds) +_elementtree_Element_iter(ElementObject *self, PyObject *args, PyObject *kwargs) {

PyObject* tag = Py_None;
static char* kwlist[] = {"tag", 0};

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:iter", kwlist, &tag))
```
   return NULL;[](#l2.1504)
```

PyObject *return_value = NULL;
static char *_keywords[] = {"tag", NULL};
PyObject *tag = Py_None;

return create_elementiter(self, tag, 0);

-} -

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:iter", _keywords,
```
   &tag))[](#l2.1513)
```
```
   goto exit;[](#l2.1514)
```
return_value = _elementtree_Element_iter_impl(self, tag);

-static PyObject* -element_itertext(ElementObject* self, PyObject* args) -{

if (!PyArg_ParseTuple(args, ":itertext"))
```
   return NULL;[](#l2.1521)
```

return create_elementiter(self, Py_None, 1);

+exit:

return return_value;

} - -static PyObject* -element_getitem(PyObject* self_, Py_ssize_t index) -{

ElementObject* self = (ElementObject*) self_;

+PyDoc_STRVAR(elementtree_Element_itertext__doc_, +"itertext($self, /)\n" +"--\n" +"\n");

if (!self->extra || index < 0 || index >= self->extra->length) {
```
   PyErr_SetString([](#l2.1539)
```
```
       PyExc_IndexError,[](#l2.1540)
```

       "child index out of range"[](#l2.1541)

```
       );[](#l2.1542)
```
```
   return NULL;[](#l2.1543)
```
}

+#define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF [](#l2.1545)

{"itertext", (PyCFunction)elementtree_Element_itertext, METH_NOARGS, elementtree_Element_itertext__doc},

Py_INCREF(self->extra->children[index]);
return self->extra->children[index];

-} +static PyObject +_elementtree_Element_itertext_impl(ElementObject self); -static PyObject -element_insert(ElementObject self, PyObject* args) +static PyObject * +_elementtree_Element_itertext(ElementObject *self, PyObject *Py_UNUSED(ignored)) {

Py_ssize_t index, i;
PyObject* element;
if (!PyArg_ParseTuple(args, "nO!:insert", &index,

                     &Element_Type, &element))[](#l2.1562)

```
   return NULL;[](#l2.1563)
```

if (!self->extra) {

   if (create_extra(self, NULL) < 0)[](#l2.1566)

```
       return NULL;[](#l2.1567)
```
}

if (index < 0) {

   index += self->extra->length;[](#l2.1571)

```
   if (index < 0)[](#l2.1572)
```
```
       index = 0;[](#l2.1573)
```
}
if (index > self->extra->length)

   index = self->extra->length;[](#l2.1576)

if (element_resize(self, 1) < 0)
```
   return NULL;[](#l2.1579)
```

for (i = self->extra->length; i > index; i--)

   self->extra->children[i] = self->extra->children[i-1];[](#l2.1582)

Py_INCREF(element);
self->extra->children[index] = element;

self->extra->length++;

Py_RETURN_NONE;

return _elementtree_Element_itertext_impl(self);

} -static PyObject* -element_items(ElementObject* self, PyObject* args) -{

if (!PyArg_ParseTuple(args, ":items"))
```
   return NULL;[](#l2.1597)
```

if (!self->extra || self->extra->attrib == Py_None)
```
   return PyList_New(0);[](#l2.1600)
```

return PyDict_Items(self->extra->attrib);

-} - -static PyObject* -element_keys(ElementObject* self, PyObject* args) -{

if (!PyArg_ParseTuple(args, ":keys"))
```
   return NULL;[](#l2.1609)
```

if (!self->extra || self->extra->attrib == Py_None)
```
   return PyList_New(0);[](#l2.1612)
```

+PyDoc_STRVAR(elementtree_Element_insert__doc_, +"insert($self, index, subelement, /)\n" +"--\n" +"\n");

return PyDict_Keys(self->extra->attrib);

-} - -static Py_ssize_t -element_length(ElementObject* self) -{

if (!self->extra)
```
   return 0;[](#l2.1625)
```

return self->extra->length;

-} +#define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF [](#l2.1629)

{"insert", (PyCFunction)elementtree_Element_insert, METH_VARARGS, elementtree_Element_insert__doc},

-static PyObject* -element_makeelement(PyObject* self, PyObject* args, PyObject* kw) -{

PyObject* elem;

PyObject* tag;
PyObject* attrib;
if (!PyArg_ParseTuple(args, "OO:makeelement", &tag, &attrib))
```
   return NULL;[](#l2.1640)
```

attrib = PyDict_Copy(attrib);
if (!attrib)
```
   return NULL;[](#l2.1644)
```

+static PyObject * +_elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,

                            PyObject *subelement);[](#l2.1647)

elem = create_new_element(tag, attrib);

Py_DECREF(attrib);

return elem;

-} - -static PyObject* -element_remove(ElementObject* self, PyObject* args) +static PyObject * +_elementtree_Element_insert(ElementObject *self, PyObject *args) {

Py_ssize_t i;

PyObject* element;
if (!PyArg_ParseTuple(args, "O!:remove", &Element_Type, &element))
```
   return NULL;[](#l2.1665)
```

if (!self->extra) {

   /* element has no children, so raise exception */[](#l2.1668)

```
   PyErr_SetString([](#l2.1669)
```
```
       PyExc_ValueError,[](#l2.1670)
```

       "list.remove(x): x not in list"[](#l2.1671)

```
       );[](#l2.1672)
```
```
   return NULL;[](#l2.1673)
```
}

PyObject *return_value = NULL;
Py_ssize_t index;
PyObject *subelement;

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

   if (self->extra->children[i] == element)[](#l2.1680)

```
       break;[](#l2.1681)
```

   if (PyObject_RichCompareBool(self->extra->children[i], element, Py_EQ) == 1)[](#l2.1682)

```
       break;[](#l2.1683)
```
}

if (!PyArg_ParseTuple(args, "nO!:insert",

   &index, &Element_Type, &subelement))[](#l2.1686)

```
   goto exit;[](#l2.1687)
```
return_value = _elementtree_Element_insert_impl(self, index, subelement);

if (i == self->extra->length) {

   /* element is not in children, so raise exception */[](#l2.1691)

```
   PyErr_SetString([](#l2.1692)
```
```
       PyExc_ValueError,[](#l2.1693)
```

       "list.remove(x): x not in list"[](#l2.1694)

```
       );[](#l2.1695)
```
```
   return NULL;[](#l2.1696)
```
}

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

self->extra->length--;

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

   self->extra->children[i] = self->extra->children[i+1];[](#l2.1704)

Py_RETURN_NONE;

+exit:

return return_value;

} -static PyObject* -element_repr(ElementObject* self) -{

if (self->tag)

   return PyUnicode_FromFormat("<Element %R at %p>", self->tag, self);[](#l2.1715)

else

   return PyUnicode_FromFormat("<Element at %p>", self);[](#l2.1717)

-} +PyDoc_STRVAR(elementtree_Element_items__doc_, +"items($self, /)\n" +"--\n" +"\n"); -static PyObject* -element_set(ElementObject* self, PyObject* args) -{

PyObject* attrib;

+#define _ELEMENTTREE_ELEMENT_ITEMS_METHODDEF [](#l2.1728)

{"items", (PyCFunction)elementtree_Element_items, METH_NOARGS, elementtree_Element_items__doc},

PyObject* key;
PyObject* value;
if (!PyArg_ParseTuple(args, "OO:set", &key, &value))
```
   return NULL;[](#l2.1734)
```

+static PyObject * +_elementtree_Element_items_impl(ElementObject *self);

if (!self->extra) {

   if (create_extra(self, NULL) < 0)[](#l2.1739)

```
       return NULL;[](#l2.1740)
```
}

attrib = element_get_attrib(self);
if (!attrib)
```
   return NULL;[](#l2.1745)
```

if (PyDict_SetItem(attrib, key, value) < 0)
```
   return NULL;[](#l2.1748)
```

Py_RETURN_NONE;

+static PyObject * +_elementtree_Element_items(ElementObject *self, PyObject *Py_UNUSED(ignored)) +{

return _elementtree_Element_items_impl(self);

} -static int -element_setitem(PyObject* self_, Py_ssize_t index, PyObject* item) -{

ElementObject* self = (ElementObject*) self_;
Py_ssize_t i;
PyObject* old;

if (!self->extra || index < 0 || index >= self->extra->length) {
```
   PyErr_SetString([](#l2.1765)
```
```
       PyExc_IndexError,[](#l2.1766)
```

       "child assignment index out of range");[](#l2.1767)

```
   return -1;[](#l2.1768)
```
}

old = self->extra->children[index];

+PyDoc_STRVAR(elementtree_Element_keys__doc_, +"keys($self, /)\n" +"--\n" +"\n");

if (item) {
```
   Py_INCREF(item);[](#l2.1778)
```

   self->extra->children[index] = item;[](#l2.1779)

} else {
```
   self->extra->length--;[](#l2.1781)
```

   for (i = index; i < self->extra->length; i++)[](#l2.1782)

       self->extra->children[i] = self->extra->children[i+1];[](#l2.1783)

}

Py_DECREF(old);

return 0;

-} - -static PyObject* -element_subscr(PyObject* self_, PyObject* item) -{

ElementObject* self = (ElementObject*) self_;

if (PyIndex_Check(item)) {

   Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);[](#l2.1797)

+#define _ELEMENTTREE_ELEMENT_KEYS_METHODDEF [](#l2.1798)

{"keys", (PyCFunction)elementtree_Element_keys, METH_NOARGS, elementtree_Element_keys__doc},

   if (i == -1 && PyErr_Occurred()) {[](#l2.1801)

```
       return NULL;[](#l2.1802)
```
```
   }[](#l2.1803)
```

   if (i < 0 && self->extra)[](#l2.1804)

       i += self->extra->length;[](#l2.1805)

   return element_getitem(self_, i);[](#l2.1806)

}
else if (PySlice_Check(item)) {

   Py_ssize_t start, stop, step, slicelen, cur, i;[](#l2.1809)

```
   PyObject* list;[](#l2.1810)
```

```
   if (!self->extra)[](#l2.1812)
```

       return PyList_New(0);[](#l2.1813)

   if (PySlice_GetIndicesEx(item,[](#l2.1815)

           self->extra->length,[](#l2.1816)

           &start, &stop, &step, &slicelen) < 0) {[](#l2.1817)

```
       return NULL;[](#l2.1818)
```
```
   }[](#l2.1819)
```

+static PyObject * +_elementtree_Element_keys_impl(ElementObject *self);

```
   if (slicelen <= 0)[](#l2.1823)
```

       return PyList_New(0);[](#l2.1824)

```
   else {[](#l2.1825)
```

       list = PyList_New(slicelen);[](#l2.1826)

```
       if (!list)[](#l2.1827)
```
```
           return NULL;[](#l2.1828)
```

       for (cur = start, i = 0; i < slicelen;[](#l2.1830)

            cur += step, i++) {[](#l2.1831)

           PyObject* item = self->extra->children[cur];[](#l2.1832)

```
           Py_INCREF(item);[](#l2.1833)
```

           PyList_SET_ITEM(list, i, item);[](#l2.1834)

```
       }[](#l2.1835)
```

```
       return list;[](#l2.1837)
```
```
   }[](#l2.1838)
```
}
else {

   PyErr_SetString(PyExc_TypeError,[](#l2.1841)

           "element indices must be integers");[](#l2.1842)

```
   return NULL;[](#l2.1843)
```
}

+static PyObject * +_elementtree_Element_keys(ElementObject *self, PyObject *Py_UNUSED(ignored)) +{

return _elementtree_Element_keys_impl(self);

} -static int -element_ass_subscr(PyObject* self_, PyObject* item, PyObject* value) -{

ElementObject* self = (ElementObject*) self_;

if (PyIndex_Check(item)) {

   Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);[](#l2.1857)

   if (i == -1 && PyErr_Occurred()) {[](#l2.1859)

```
       return -1;[](#l2.1860)
```
```
   }[](#l2.1861)
```

   if (i < 0 && self->extra)[](#l2.1862)

       i += self->extra->length;[](#l2.1863)

   return element_setitem(self_, i, value);[](#l2.1864)

}
else if (PySlice_Check(item)) {

   Py_ssize_t start, stop, step, slicelen, newlen, cur, i;[](#l2.1867)

   PyObject* recycle = NULL;[](#l2.1869)

```
   PyObject* seq = NULL;[](#l2.1870)
```

```
   if (!self->extra) {[](#l2.1872)
```

       if (create_extra(self, NULL) < 0)[](#l2.1873)

```
           return -1;[](#l2.1874)
```
```
   }[](#l2.1875)
```

   if (PySlice_GetIndicesEx(item,[](#l2.1877)

           self->extra->length,[](#l2.1878)

           &start, &stop, &step, &slicelen) < 0) {[](#l2.1879)

```
       return -1;[](#l2.1880)
```
```
   }[](#l2.1881)
```

```
   if (value == NULL) {[](#l2.1883)
```
```
       /* Delete slice */[](#l2.1884)
```
```
       size_t cur;[](#l2.1885)
```
```
       Py_ssize_t i;[](#l2.1886)
```

```
       if (slicelen <= 0)[](#l2.1888)
```
```
           return 0;[](#l2.1889)
```

+PyDoc_STRVAR(elementtree_Element_makeelement__doc_, +"makeelement($self, tag, attrib, /)\n" +"--\n" +"\n");

       /* Since we're deleting, the direction of the range doesn't matter,[](#l2.1895)

        * so for simplicity make it always ascending.[](#l2.1896)

```
       */[](#l2.1897)
```
```
       if (step < 0) {[](#l2.1898)
```

           stop = start + 1;[](#l2.1899)

           start = stop + step * (slicelen - 1) - 1;[](#l2.1900)

```
           step = -step;[](#l2.1901)
```
```
       }[](#l2.1902)
```

       assert((size_t)slicelen <= PY_SIZE_MAX / sizeof(PyObject *));[](#l2.1904)

       /* recycle is a list that will contain all the children[](#l2.1906)

        * scheduled for removal.[](#l2.1907)

```
       */[](#l2.1908)
```

       if (!(recycle = PyList_New(slicelen))) {[](#l2.1909)

           PyErr_NoMemory();[](#l2.1910)

```
           return -1;[](#l2.1911)
```
```
       }[](#l2.1912)
```

+#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF [](#l2.1913)

{"makeelement", (PyCFunction)elementtree_Element_makeelement, METH_VARARGS, elementtree_Element_makeelement__doc},

       /* This loop walks over all the children that have to be deleted,[](#l2.1916)

        * with cur pointing at them. num_moved is the amount of children[](#l2.1917)

        * until the next deleted child that have to be "shifted down" to[](#l2.1918)

        * occupy the deleted's places.[](#l2.1919)

        * Note that in the ith iteration, shifting is done i+i places down[](#l2.1920)

        * because i children were already removed.[](#l2.1921)

```
       */[](#l2.1922)
```

       for (cur = start, i = 0; cur < (size_t)stop; cur += step, ++i) {[](#l2.1923)

           /* Compute how many children have to be moved, clipping at the[](#l2.1924)

```
            * list end.[](#l2.1925)
```
```
           */[](#l2.1926)
```

           Py_ssize_t num_moved = step - 1;[](#l2.1927)

           if (cur + step >= (size_t)self->extra->length) {[](#l2.1928)

               num_moved = self->extra->length - cur - 1;[](#l2.1929)

```
           }[](#l2.1930)
```

           PyList_SET_ITEM(recycle, i, self->extra->children[cur]);[](#l2.1932)

```
           memmove([](#l2.1934)
```

               self->extra->children + cur - i,[](#l2.1935)

               self->extra->children + cur + 1,[](#l2.1936)

               num_moved * sizeof(PyObject *));[](#l2.1937)

```
       }[](#l2.1938)
```

+static PyObject * +_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,

                                 PyObject *attrib);[](#l2.1941)

       /* Leftover "tail" after the last removed child */[](#l2.1943)

       cur = start + (size_t)slicelen * step;[](#l2.1944)

       if (cur < (size_t)self->extra->length) {[](#l2.1945)

```
           memmove([](#l2.1946)
```

               self->extra->children + cur - slicelen,[](#l2.1947)

               self->extra->children + cur,[](#l2.1948)

               (self->extra->length - cur) * sizeof(PyObject *));[](#l2.1949)

```
       }[](#l2.1950)
```

       self->extra->length -= slicelen;[](#l2.1952)

       /* Discard the recycle list with all the deleted sub-elements */[](#l2.1954)

```
       Py_XDECREF(recycle);[](#l2.1955)
```
```
       return 0;[](#l2.1956)
```
```
   }[](#l2.1957)
```
```
   else {[](#l2.1958)
```

       /* A new slice is actually being assigned */[](#l2.1959)

       seq = PySequence_Fast(value, "");[](#l2.1960)

```
       if (!seq) {[](#l2.1961)
```
```
           PyErr_Format([](#l2.1962)
```

               PyExc_TypeError,[](#l2.1963)

               "expected sequence, not \"%.200s\"", Py_TYPE(value)->tp_name[](#l2.1964)

```
               );[](#l2.1965)
```
```
           return -1;[](#l2.1966)
```
```
       }[](#l2.1967)
```

       newlen = PySequence_Size(seq);[](#l2.1968)

```
   }[](#l2.1969)
```

   if (step !=  1 && newlen != slicelen)[](#l2.1971)

```
   {[](#l2.1972)
```

       PyErr_Format(PyExc_ValueError,[](#l2.1973)

           "attempt to assign sequence of size %zd "[](#l2.1974)

           "to extended slice of size %zd",[](#l2.1975)

```
           newlen, slicelen[](#l2.1976)
```
```
           );[](#l2.1977)
```
```
       return -1;[](#l2.1978)
```
```
   }[](#l2.1979)
```

   /* Resize before creating the recycle bin, to prevent refleaks. */[](#l2.1981)

```
   if (newlen > slicelen) {[](#l2.1982)
```

       if (element_resize(self, newlen - slicelen) < 0) {[](#l2.1983)

```
           if (seq) {[](#l2.1984)
```

               Py_DECREF(seq);[](#l2.1985)

```
           }[](#l2.1986)
```
```
           return -1;[](#l2.1987)
```
```
       }[](#l2.1988)
```
```
   }[](#l2.1989)
```

+static PyObject * +_elementtree_Element_makeelement(ElementObject *self, PyObject *args) +{

PyObject *return_value = NULL;
PyObject *tag;
PyObject *attrib;

```
   if (slicelen > 0) {[](#l2.1997)
```

       /* to avoid recursive calls to this method (via decref), move[](#l2.1998)

          old items to the recycle bin here, and get rid of them when[](#l2.1999)

          we're done modifying the element */[](#l2.2000)

       recycle = PyList_New(slicelen);[](#l2.2001)

```
       if (!recycle) {[](#l2.2002)
```
```
           if (seq) {[](#l2.2003)
```

               Py_DECREF(seq);[](#l2.2004)

```
           }[](#l2.2005)
```
```
           return -1;[](#l2.2006)
```
```
       }[](#l2.2007)
```

       for (cur = start, i = 0; i < slicelen;[](#l2.2008)

            cur += step, i++)[](#l2.2009)

           PyList_SET_ITEM(recycle, i, self->extra->children[cur]);[](#l2.2010)

```
   }[](#l2.2011)
```

if (!PyArg_UnpackTuple(args, "makeelement",
```
   2, 2,[](#l2.2013)
```
```
   &tag, &attrib))[](#l2.2014)
```
```
   goto exit;[](#l2.2015)
```
return_value = _elementtree_Element_makeelement_impl(self, tag, attrib);

```
   if (newlen < slicelen) {[](#l2.2018)
```
```
       /* delete slice */[](#l2.2019)
```

       for (i = stop; i < self->extra->length; i++)[](#l2.2020)

           self->extra->children[i + newlen - slicelen] = self->extra->children[i];[](#l2.2021)

   } else if (newlen > slicelen) {[](#l2.2022)

```
       /* insert slice */[](#l2.2023)
```

       for (i = self->extra->length-1; i >= stop; i--)[](#l2.2024)

           self->extra->children[i + newlen - slicelen] = self->extra->children[i];[](#l2.2025)

```
   }[](#l2.2026)
```

```
   /* replace the slice */[](#l2.2028)
```

   for (cur = start, i = 0; i < newlen;[](#l2.2029)

```
        cur += step, i++) {[](#l2.2030)
```

       PyObject* element = PySequence_Fast_GET_ITEM(seq, i);[](#l2.2031)

```
       Py_INCREF(element);[](#l2.2032)
```

       self->extra->children[cur] = element;[](#l2.2033)

```
   }[](#l2.2034)
```

   self->extra->length += newlen - slicelen;[](#l2.2036)

```
   if (seq) {[](#l2.2038)
```
```
       Py_DECREF(seq);[](#l2.2039)
```
```
   }[](#l2.2040)
```

   /* discard the recycle bin, and everything in it */[](#l2.2042)

```
   Py_XDECREF(recycle);[](#l2.2043)
```

```
   return 0;[](#l2.2045)
```
}
else {

   PyErr_SetString(PyExc_TypeError,[](#l2.2048)

           "element indices must be integers");[](#l2.2049)

```
   return -1;[](#l2.2050)
```
}

+exit:

return return_value;

} -static PyMethodDef element_methods[] = { -

{"clear", (PyCFunction) element_clearmethod, METH_VARARGS},

{"get", (PyCFunction) element_get, METH_VARARGS | METH_KEYWORDS},
{"set", (PyCFunction) element_set, METH_VARARGS},

{"find", (PyCFunction) element_find, METH_VARARGS | METH_KEYWORDS},
{"findtext", (PyCFunction) element_findtext, METH_VARARGS | METH_KEYWORDS},
{"findall", (PyCFunction) element_findall, METH_VARARGS | METH_KEYWORDS},

{"append", (PyCFunction) element_append, METH_VARARGS},
{"extend", (PyCFunction) element_extend, METH_VARARGS},
{"insert", (PyCFunction) element_insert, METH_VARARGS},
{"remove", (PyCFunction) element_remove, METH_VARARGS},

{"iter", (PyCFunction) element_iter, METH_VARARGS | METH_KEYWORDS},
{"itertext", (PyCFunction) element_itertext, METH_VARARGS},
{"iterfind", (PyCFunction) element_iterfind, METH_VARARGS | METH_KEYWORDS},

+PyDoc_STRVAR(elementtree_Element_remove__doc_, +"remove($self, subelement, /)\n" +"--\n" +"\n");

{"getiterator", (PyCFunction) element_iter, METH_VARARGS | METH_KEYWORDS},
{"getchildren", (PyCFunction) element_getchildren, METH_VARARGS},

{"items", (PyCFunction) element_items, METH_VARARGS},
{"keys", (PyCFunction) element_keys, METH_VARARGS},

{"makeelement", (PyCFunction) element_makeelement, METH_VARARGS},

+#define _ELEMENTTREE_ELEMENT_REMOVE_METHODDEF [](#l2.2087)

{"remove", (PyCFunction)elementtree_Element_remove, METH_O, elementtree_Element_remove__doc},

{"copy", (PyCFunction) element_copy, METH_VARARGS},
{"deepcopy", (PyCFunction) element_deepcopy, METH_VARARGS},
{"sizeof", element_sizeof, METH_NOARGS},
{"getstate", (PyCFunction)element_getstate, METH_NOARGS},
{"setstate", (PyCFunction)element_setstate, METH_O},

+static PyObject * +_elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement);

{NULL, NULL}

-}; - -static PyObject* -element_getattro(ElementObject* self, PyObject* nameobj) +static PyObject * +_elementtree_Element_remove(ElementObject *self, PyObject *arg) {

PyObject* res;
char *name = "";

PyObject *return_value = NULL;
PyObject *subelement;

if (PyUnicode_Check(nameobj))

   name = _PyUnicode_AsString(nameobj);[](#l2.2112)

if (name == NULL)
```
   return NULL;[](#l2.2115)
```

if (!PyArg_Parse(arg, "O!:remove", &Element_Type, &subelement))
```
   goto exit;[](#l2.2117)
```
return_value = _elementtree_Element_remove_impl(self, subelement);

/* handle common attributes first */
if (strcmp(name, "tag") == 0) {
```
   res = self->tag;[](#l2.2122)
```
```
   Py_INCREF(res);[](#l2.2123)
```
```
   return res;[](#l2.2124)
```
} else if (strcmp(name, "text") == 0) {

   res = element_get_text(self);[](#l2.2126)

```
   Py_XINCREF(res);[](#l2.2127)
```
```
   return res;[](#l2.2128)
```
}

+exit:

return return_value;

+} + +PyDoc_STRVAR(elementtree_Element_set__doc_, +"set($self, key, value, /)\n" +"--\n" +"\n"); + +#define _ELEMENTTREE_ELEMENT_SET_METHODDEF [](#l2.2139)

{"set", (PyCFunction)elementtree_Element_set, METH_VARARGS, elementtree_Element_set__doc},

/* methods */
res = PyObject_GenericGetAttr((PyObject*) self, nameobj);
if (res)
```
   return res;[](#l2.2145)
```

+static PyObject * +_elementtree_Element_set_impl(ElementObject *self, PyObject *key,

                         PyObject *value);[](#l2.2148)

/* less common attributes */
if (strcmp(name, "tail") == 0) {
```
   PyErr_Clear();[](#l2.2152)
```

   res = element_get_tail(self);[](#l2.2153)

} else if (strcmp(name, "attrib") == 0) {
```
   PyErr_Clear();[](#l2.2155)
```
```
   if (!self->extra) {[](#l2.2156)
```

       if (create_extra(self, NULL) < 0)[](#l2.2157)

```
           return NULL;[](#l2.2158)
```
```
   }[](#l2.2159)
```

   res = element_get_attrib(self);[](#l2.2160)

}

+static PyObject * +_elementtree_Element_set(ElementObject *self, PyObject *args) +{

PyObject *return_value = NULL;
PyObject *key;
PyObject *value;

if (!res)
```
   return NULL;[](#l2.2170)
```

if (!PyArg_UnpackTuple(args, "set",
```
   2, 2,[](#l2.2172)
```
```
   &key, &value))[](#l2.2173)
```
```
   goto exit;[](#l2.2174)
```
return_value = _elementtree_Element_set_impl(self, key, value);

Py_INCREF(res);
return res;

+exit:

return return_value;

} static int -element_setattro(ElementObject* self, PyObject* nameobj, PyObject* value) -{

char *name = "";
if (PyUnicode_Check(nameobj))

   name = _PyUnicode_AsString(nameobj);[](#l2.2188)

if (name == NULL)
```
   return -1;[](#l2.2190)
```

+_elementtree_TreeBuilder___init___impl(TreeBuilderObject *self,

                                  PyObject *element_factory);[](#l2.2192)

if (strcmp(name, "tag") == 0) {
```
   Py_DECREF(self->tag);[](#l2.2195)
```
```
   self->tag = value;[](#l2.2196)
```
```
   Py_INCREF(self->tag);[](#l2.2197)
```
} else if (strcmp(name, "text") == 0) {

   Py_DECREF(JOIN_OBJ(self->text));[](#l2.2199)

```
   self->text = value;[](#l2.2200)
```
```
   Py_INCREF(self->text);[](#l2.2201)
```
} else if (strcmp(name, "tail") == 0) {

   Py_DECREF(JOIN_OBJ(self->tail));[](#l2.2203)

```
   self->tail = value;[](#l2.2204)
```
```
   Py_INCREF(self->tail);[](#l2.2205)
```
} else if (strcmp(name, "attrib") == 0) {
```
   if (!self->extra) {[](#l2.2207)
```

       if (create_extra(self, NULL) < 0)[](#l2.2208)

```
           return -1;[](#l2.2209)
```
```
   }[](#l2.2210)
```

   Py_DECREF(self->extra->attrib);[](#l2.2211)

   self->extra->attrib = value;[](#l2.2212)

   Py_INCREF(self->extra->attrib);[](#l2.2213)

} else {

   PyErr_SetString(PyExc_AttributeError,[](#l2.2215)

       "Can't set arbitrary attributes on Element");[](#l2.2216)

```
   return -1;[](#l2.2217)
```
}

+static int +elementtree_TreeBuilder___init_(PyObject *self, PyObject *args, PyObject *kwargs) +{

int return_value = -1;
static char *_keywords[] = {"element_factory", NULL};
PyObject *element_factory = NULL;

return 0;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:TreeBuilder", _keywords,
```
   &element_factory))[](#l2.2228)
```
```
   goto exit;[](#l2.2229)
```
return_value = _elementtree_TreeBuilder___init___impl((TreeBuilderObject *)self, element_factory);

+ +exit:

return return_value;

} -static PySequenceMethods element_as_sequence = {

(lenfunc) element_length,
0, /* sq_concat */
0, /* sq_repeat */
element_getitem,
0,
element_setitem,
0,

-}; - -static PyMappingMethods element_as_mapping = {

(lenfunc) element_length,
(binaryfunc) element_subscr,
(objobjargproc) element_ass_subscr,

-}; +PyDoc_STRVAR(elementtree_TreeBuilder_data__doc_, +"data($self, data, /)\n" +"--\n" +"\n"); -static PyTypeObject Element_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
"xml.etree.ElementTree.Element", sizeof(ElementObject), 0,
/* methods */
(destructor)element_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
(reprfunc)element_repr, /* tp_repr */
0, /* tp_as_number */
&element_as_sequence, /* tp_as_sequence */
&element_as_mapping, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
(getattrofunc)element_getattro, /* tp_getattro */
(setattrofunc)element_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

                                               /* tp_flags */[](#l2.2276)

0, /* tp_doc */
(traverseproc)element_gc_traverse, /* tp_traverse */
(inquiry)element_gc_clear, /* tp_clear */
0, /* tp_richcompare */
offsetof(ElementObject, weakreflist), /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
element_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)element_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
element_new, /* tp_new */
0, /* tp_free */

-}; - -/******************************* Element iterator ****************************/ +#define _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF [](#l2.2299)

{"data", (PyCFunction)elementtree_TreeBuilder_data, METH_O, elementtree_TreeBuilder_data__doc},

-/* ElementIterObject represents the iteration state over an XML element in

- pre-order traversal. To keep track of which sub-element should be returned
- next, a stack of parents is maintained. This is a standard stack-based
- iterative pre-order traversal of a tree.
- The stack is managed using a single-linked list starting at parent_stack.
- Each stack node contains the saved parent to which we should return after
- the current one is exhausted, and the next child to examine in that parent.
*/ -typedef struct ParentLocator_t {
ElementObject *parent;
Py_ssize_t child_index;
struct ParentLocator_t *next;

-} ParentLocator; +PyDoc_STRVAR(elementtree_TreeBuilder_end__doc_, +"end($self, tag, /)\n" +"--\n" +"\n"); -typedef struct {

PyObject_HEAD
ParentLocator *parent_stack;
ElementObject *root_element;
PyObject *sought_tag;
int root_done;
int gettext;

-} ElementIterObject; - - -static void -elementiter_dealloc(ElementIterObject *it) -{

ParentLocator *p = it->parent_stack;
while (p) {
```
   ParentLocator *temp = p;[](#l2.2335)
```
```
   Py_XDECREF(p->parent);[](#l2.2336)
```
```
   p = p->next;[](#l2.2337)
```
```
   PyObject_Free(temp);[](#l2.2338)
```
}

+#define _ELEMENTTREE_TREEBUILDER_END_METHODDEF [](#l2.2340)

{"end", (PyCFunction)elementtree_TreeBuilder_end, METH_O, elementtree_TreeBuilder_end__doc},

Py_XDECREF(it->sought_tag);
Py_XDECREF(it->root_element);

PyObject_GC_UnTrack(it);
PyObject_GC_Del(it);

-} - -static int -elementiter_traverse(ElementIterObject *it, visitproc visit, void *arg) -{

ParentLocator *p = it->parent_stack;
while (p) {
```
   Py_VISIT(p->parent);[](#l2.2355)
```
```
   p = p->next;[](#l2.2356)
```
}

+PyDoc_STRVAR(elementtree_TreeBuilder_close__doc_, +"close($self, /)\n" +"--\n" +"\n");

Py_VISIT(it->root_element);
Py_VISIT(it->sought_tag);
return 0;

-} - -/* Helper function for elementiter_next. Add a new parent to the parent stack.

*/ -static ParentLocator * -parent_stack_push_new(ParentLocator *stack, ElementObject *parent) -{
ParentLocator *new_node = PyObject_Malloc(sizeof(ParentLocator));
if (new_node) {

   new_node->parent = parent;[](#l2.2375)

```
   Py_INCREF(parent);[](#l2.2376)
```

   new_node->child_index = 0;[](#l2.2377)

```
   new_node->next = stack;[](#l2.2378)
```
}
return new_node;

-} +#define _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF [](#l2.2382)

{"close", (PyCFunction)elementtree_TreeBuilder_close, METH_NOARGS, elementtree_TreeBuilder_close__doc},

static PyObject * -elementiter_next(ElementIterObject *it) -{

/* Sub-element iterator.
```
*[](#l2.2389)
```

* A short note on gettext: this function serves both the iter() and[](#l2.2390)

* itertext() methods to avoid code duplication. However, there are a few[](#l2.2391)

* small differences in the way these iterations work. Namely:[](#l2.2392)

*   - itertext() only yields text from nodes that have it, and continues[](#l2.2393)

*     iterating when a node doesn't have text (so it doesn't return any[](#l2.2394)

```
*     node like iter())[](#l2.2395)
```

*   - itertext() also has to handle tail, after finishing with all the[](#l2.2396)

```
*     children of a node.[](#l2.2397)
```
```
*/[](#l2.2398)
```
ElementObject *cur_parent;
Py_ssize_t child_index;

while (1) {

   /* Handle the case reached in the beginning and end of iteration, where[](#l2.2403)

    * the parent stack is empty. The root_done flag gives us indication[](#l2.2404)

    * whether we've just started iterating (so root_done is 0), in which[](#l2.2405)

    * case the root is returned. If root_done is 1 and we're here, the[](#l2.2406)

    * iterator is exhausted.[](#l2.2407)

```
    */[](#l2.2408)
```

   if (!it->parent_stack->parent) {[](#l2.2409)

```
       if (it->root_done) {[](#l2.2410)
```

           PyErr_SetNone(PyExc_StopIteration);[](#l2.2411)

```
           return NULL;[](#l2.2412)
```
```
       } else {[](#l2.2413)
```

           it->parent_stack = parent_stack_push_new(it->parent_stack,[](#l2.2414)

                                                    it->root_element);[](#l2.2415)

           if (!it->parent_stack) {[](#l2.2416)

               PyErr_NoMemory();[](#l2.2417)

```
               return NULL;[](#l2.2418)
```
```
           }[](#l2.2419)
```

           it->root_done = 1;[](#l2.2421)

           if (it->sought_tag == Py_None ||[](#l2.2422)

               PyObject_RichCompareBool(it->root_element->tag,[](#l2.2423)

                                        it->sought_tag, Py_EQ) == 1) {[](#l2.2424)

               if (it->gettext) {[](#l2.2425)

                   PyObject *text = element_get_text(it->root_element);[](#l2.2426)

                   if (!text)[](#l2.2427)

                       return NULL;[](#l2.2428)

                   if (PyObject_IsTrue(text)) {[](#l2.2429)

                       Py_INCREF(text);[](#l2.2430)

                       return text;[](#l2.2431)

```
                   }[](#l2.2432)
```
```
               } else {[](#l2.2433)
```

                   Py_INCREF(it->root_element);[](#l2.2434)

                   return (PyObject *)it->root_element;[](#l2.2435)

```
               }[](#l2.2436)
```
```
           }[](#l2.2437)
```
```
       }[](#l2.2438)
```
```
   }[](#l2.2439)
```

+_elementtree_TreeBuilder_close_impl(TreeBuilderObject *self);

   /* See if there are children left to traverse in the current parent. If[](#l2.2442)

    * yes, visit the next child. If not, pop the stack and try again.[](#l2.2443)

```
    */[](#l2.2444)
```

   cur_parent = it->parent_stack->parent;[](#l2.2445)

   child_index = it->parent_stack->child_index;[](#l2.2446)

   if (cur_parent->extra && child_index < cur_parent->extra->length) {[](#l2.2447)

       ElementObject *child = (ElementObject *)[](#l2.2448)

           cur_parent->extra->children[child_index];[](#l2.2449)

       it->parent_stack->child_index++;[](#l2.2450)

       it->parent_stack = parent_stack_push_new(it->parent_stack,[](#l2.2451)

                                                child);[](#l2.2452)

       if (!it->parent_stack) {[](#l2.2453)

           PyErr_NoMemory();[](#l2.2454)

```
           return NULL;[](#l2.2455)
```
```
       }[](#l2.2456)
```

```
       if (it->gettext) {[](#l2.2458)
```

           PyObject *text = element_get_text(child);[](#l2.2459)

```
           if (!text)[](#l2.2460)
```
```
               return NULL;[](#l2.2461)
```

           if (PyObject_IsTrue(text)) {[](#l2.2462)

               Py_INCREF(text);[](#l2.2463)

```
               return text;[](#l2.2464)
```
```
           }[](#l2.2465)
```

       } else if (it->sought_tag == Py_None ||[](#l2.2466)

           PyObject_RichCompareBool(child->tag,[](#l2.2467)

                                    it->sought_tag, Py_EQ) == 1) {[](#l2.2468)

           Py_INCREF(child);[](#l2.2469)

           return (PyObject *)child;[](#l2.2470)

```
       }[](#l2.2471)
```
```
       else[](#l2.2472)
```
```
           continue;[](#l2.2473)
```
```
   }[](#l2.2474)
```
```
   else {[](#l2.2475)
```
```
       PyObject *tail;[](#l2.2476)
```

       ParentLocator *next = it->parent_stack->next;[](#l2.2477)

```
       if (it->gettext) {[](#l2.2478)
```

           tail = element_get_tail(cur_parent);[](#l2.2479)

```
           if (!tail)[](#l2.2480)
```
```
               return NULL;[](#l2.2481)
```
```
       }[](#l2.2482)
```
```
       else[](#l2.2483)
```
```
           tail = Py_None;[](#l2.2484)
```

       Py_XDECREF(it->parent_stack->parent);[](#l2.2485)

       PyObject_Free(it->parent_stack);[](#l2.2486)

       it->parent_stack = next;[](#l2.2487)

       /* Note that extra condition on it->parent_stack->parent here;[](#l2.2489)

        * this is because itertext() is supposed to only return *inner*[](#l2.2490)

        * text, not text following the element it began iteration with.[](#l2.2491)

```
        */[](#l2.2492)
```

       if (it->parent_stack->parent && PyObject_IsTrue(tail)) {[](#l2.2493)

```
           Py_INCREF(tail);[](#l2.2494)
```
```
           return tail;[](#l2.2495)
```
```
       }[](#l2.2496)
```
```
   }[](#l2.2497)
```
}

return NULL;

+static PyObject * +_elementtree_TreeBuilder_close(TreeBuilderObject *self, PyObject *Py_UNUSED(ignored)) +{

return _elementtree_TreeBuilder_close_impl(self);

} +PyDoc_STRVAR(elementtree_TreeBuilder_start__doc_, +"start($self, tag, attrs=None, /)\n" +"--\n" +"\n"); -static PyTypeObject ElementIter_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
/* Using the module's name since the pure-Python implementation does not
```
  have such a type. */[](#l2.2515)
```
"_elementtree._element_iterator", /* tp_name */
sizeof(ElementIterObject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)elementiter_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
0, /* tp_doc */
(traverseproc)elementiter_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
PyObject_SelfIter, /* tp_iter */
(iternextfunc)elementiter_next, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */

-}; - +#define _ELEMENTTREE_TREEBUILDER_START_METHODDEF [](#l2.2556)

{"start", (PyCFunction)elementtree_TreeBuilder_start, METH_VARARGS, elementtree_TreeBuilder_start__doc},

static PyObject * -create_elementiter(ElementObject *self, PyObject *tag, int gettext) -{

ElementIterObject *it;
PyObject *star = NULL;

it = PyObject_GC_New(ElementIterObject, &ElementIter_Type);
if (!it)
```
   return NULL;[](#l2.2567)
```

if (PyUnicode_Check(tag))

   star = PyUnicode_FromString("*");[](#l2.2570)

else if (PyBytes_Check(tag))

   star = PyBytes_FromString("*");[](#l2.2572)

if (star && PyObject_RichCompareBool(tag, star, Py_EQ) == 1)
```
   tag = Py_None;[](#l2.2575)
```
Py_XDECREF(star);

Py_INCREF(tag);
it->sought_tag = tag;
it->root_done = 0;
it->gettext = gettext;
Py_INCREF(self);
it->root_element = self;

PyObject_GC_Track(it);

it->parent_stack = PyObject_Malloc(sizeof(ParentLocator));
if (it->parent_stack == NULL) {
```
   Py_DECREF(it);[](#l2.2589)
```
```
   PyErr_NoMemory();[](#l2.2590)
```
```
   return NULL;[](#l2.2591)
```
}
it->parent_stack->parent = NULL;
it->parent_stack->child_index = 0;
it->parent_stack->next = NULL;

return (PyObject *)it;

-} - - -/* ==================================================================== / -/ the tree builder type */ - -typedef struct {

PyObject_HEAD

PyObject root; / root node (first created node) */

PyObject this; / current node */
PyObject last; / most recently created node */

PyObject data; / data collector (string or list), or NULL */

PyObject stack; / element stack */
Py_ssize_t index; /* current stack size (0 means empty) */

PyObject *element_factory;

/* element tracing */
PyObject events; / list of events, or NULL if not collecting */
PyObject start_event_obj; / event objects (NULL to ignore) */
PyObject *end_event_obj;
PyObject *start_ns_event_obj;
PyObject *end_ns_event_obj;

-} TreeBuilderObject; - -#define TreeBuilder_CheckExact(op) (Py_TYPE(op) == &TreeBuilder_Type) - -/* -------------------------------------------------------------------- / -/ constructor and destructor */ +_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,

                               PyObject *attrs);[](#l2.2632)

static PyObject * -treebuilder_new(PyTypeObject *type, PyObject *args, PyObject *kwds) -{

TreeBuilderObject *t = (TreeBuilderObject *)type->tp_alloc(type, 0);
if (t != NULL) {
```
   t->root = NULL;[](#l2.2639)
```

```
   Py_INCREF(Py_None);[](#l2.2641)
```
```
   t->this = Py_None;[](#l2.2642)
```
```
   Py_INCREF(Py_None);[](#l2.2643)
```
```
   t->last = Py_None;[](#l2.2644)
```

```
   t->data = NULL;[](#l2.2646)
```

   t->element_factory = NULL;[](#l2.2647)

   t->stack = PyList_New(20);[](#l2.2648)

```
   if (!t->stack) {[](#l2.2649)
```
```
       Py_DECREF(t->this);[](#l2.2650)
```
```
       Py_DECREF(t->last);[](#l2.2651)
```

       Py_DECREF((PyObject *) t);[](#l2.2652)

```
       return NULL;[](#l2.2653)
```
```
   }[](#l2.2654)
```
```
   t->index = 0;[](#l2.2655)
```

```
   t->events = NULL;[](#l2.2657)
```

   t->start_event_obj = t->end_event_obj = NULL;[](#l2.2658)

   t->start_ns_event_obj = t->end_ns_event_obj = NULL;[](#l2.2659)

}
return (PyObject *)t;

-} - -static int -treebuilder_init(PyObject *self, PyObject *args, PyObject *kwds) +_elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject *args) {

static char *kwlist[] = {"element_factory", 0};
PyObject *element_factory = NULL;
TreeBuilderObject *self_tb = (TreeBuilderObject *)self;
PyObject *tmp;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:TreeBuilder", kwlist,

                                &element_factory)) {[](#l2.2674)

```
   return -1;[](#l2.2675)
```
}

if (element_factory) {

   Py_INCREF(element_factory);[](#l2.2679)

   tmp = self_tb->element_factory;[](#l2.2680)

   self_tb->element_factory = element_factory;[](#l2.2681)

```
   Py_XDECREF(tmp);[](#l2.2682)
```
}

return 0;

-} - -static int -treebuilder_gc_traverse(TreeBuilderObject *self, visitproc visit, void *arg) -{

Py_VISIT(self->root);
Py_VISIT(self->this);
Py_VISIT(self->last);
Py_VISIT(self->data);
Py_VISIT(self->stack);
Py_VISIT(self->element_factory);
return 0;

PyObject *return_value = NULL;
PyObject *tag;
PyObject *attrs = Py_None;

-static int -treebuilder_gc_clear(TreeBuilderObject *self) -{

Py_CLEAR(self->end_ns_event_obj);
Py_CLEAR(self->start_ns_event_obj);
Py_CLEAR(self->end_event_obj);
Py_CLEAR(self->start_event_obj);
Py_CLEAR(self->events);
Py_CLEAR(self->stack);
Py_CLEAR(self->data);
Py_CLEAR(self->last);
Py_CLEAR(self->this);
Py_CLEAR(self->element_factory);
Py_CLEAR(self->root);
return 0;

-} - -static void -treebuilder_dealloc(TreeBuilderObject *self) -{

PyObject_GC_UnTrack(self);
treebuilder_gc_clear(self);
Py_TYPE(self)->tp_free((PyObject *)self);

-} - -/* -------------------------------------------------------------------- / -/ helpers for handling of arbitrary element-like objects */

if (!PyArg_UnpackTuple(args, "start",
```
   1, 2,[](#l2.2731)
```
```
   &tag, &attrs))[](#l2.2732)
```
```
   goto exit;[](#l2.2733)
```
return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs);

-static int -treebuilder_set_element_text_or_tail(PyObject *element, PyObject *data,

                                PyObject **dest, _Py_Identifier *name)[](#l2.2738)

if (Element_CheckExact(element)) {

   Py_DECREF(JOIN_OBJ(*dest));[](#l2.2741)

   *dest = JOIN_SET(data, PyList_CheckExact(data));[](#l2.2742)

```
   return 0;[](#l2.2743)
```
}
else {

   PyObject *joined = list_join(data);[](#l2.2746)

```
   int r;[](#l2.2747)
```
```
   if (joined == NULL)[](#l2.2748)
```
```
       return -1;[](#l2.2749)
```

   r = _PyObject_SetAttrId(element, name, joined);[](#l2.2750)

```
   Py_DECREF(joined);[](#l2.2751)
```
```
   return r;[](#l2.2752)
```
}

-} - -/* These two functions steal a reference to data */ -static int -treebuilder_set_element_text(PyObject *element, PyObject *data) -{

_Py_IDENTIFIER(text);
return treebuilder_set_element_text_or_tail(

   element, data, &((ElementObject *) element)->text, &PyId_text);[](#l2.2762)

-} - -static int -treebuilder_set_element_tail(PyObject *element, PyObject *data) -{

_Py_IDENTIFIER(tail);
return treebuilder_set_element_text_or_tail(

   element, data, &((ElementObject *) element)->tail, &PyId_tail);[](#l2.2770)

+exit:

return return_value;

} static int -treebuilder_add_subelement(PyObject *element, PyObject *child) -{

_Py_IDENTIFIER(append);
if (Element_CheckExact(element)) {

   ElementObject *elem = (ElementObject *) element;[](#l2.2780)

   return element_add_subelement(elem, child);[](#l2.2781)

}
else {
```
   PyObject *res;[](#l2.2784)
```

   res = _PyObject_CallMethodId(element, &PyId_append, "O", child);[](#l2.2785)

```
   if (res == NULL)[](#l2.2786)
```
```
       return -1;[](#l2.2787)
```
```
   Py_DECREF(res);[](#l2.2788)
```
```
   return 0;[](#l2.2789)
```
}

-} - -/* -------------------------------------------------------------------- / -/ handlers / - -LOCAL(PyObject) -treebuilder_handle_start(TreeBuilderObject* self, PyObject* tag,

                    PyObject* attrib)[](#l2.2798)

PyObject* node;
PyObject* this;
elementtreestate *st = ET_STATE_GLOBAL;

if (self->data) {

   if (self->this == self->last) {[](#l2.2805)

       if (treebuilder_set_element_text(self->last, self->data))[](#l2.2806)

```
           return NULL;[](#l2.2807)
```
```
   }[](#l2.2808)
```
```
   else {[](#l2.2809)
```

       if (treebuilder_set_element_tail(self->last, self->data))[](#l2.2810)

```
           return NULL;[](#l2.2811)
```
```
   }[](#l2.2812)
```
```
   self->data = NULL;[](#l2.2813)
```
}

if (self->element_factory && self->element_factory != Py_None) {

   node = PyObject_CallFunction(self->element_factory, "OO", tag, attrib);[](#l2.2817)

} else {

   node = create_new_element(tag, attrib);[](#l2.2819)

}
if (!node) {
```
   return NULL;[](#l2.2822)
```
}

this = self->this;

if (this != Py_None) {

   if (treebuilder_add_subelement(this, node) < 0)[](#l2.2828)

```
       goto error;[](#l2.2829)
```
} else {
```
   if (self->root) {[](#l2.2831)
```
```
       PyErr_SetString([](#l2.2832)
```

           st->parseerror_obj,[](#l2.2833)

           "multiple elements on top level"[](#l2.2834)

```
           );[](#l2.2835)
```
```
       goto error;[](#l2.2836)
```
```
   }[](#l2.2837)
```
```
   Py_INCREF(node);[](#l2.2838)
```
```
   self->root = node;[](#l2.2839)
```
}

if (self->index < PyList_GET_SIZE(self->stack)) {

   if (PyList_SetItem(self->stack, self->index, this) < 0)[](#l2.2843)

```
       goto error;[](#l2.2844)
```
```
   Py_INCREF(this);[](#l2.2845)
```
} else {

   if (PyList_Append(self->stack, this) < 0)[](#l2.2847)

```
       goto error;[](#l2.2848)
```
}
self->index++;

Py_DECREF(this);
Py_INCREF(node);
self->this = node;

Py_DECREF(self->last);
Py_INCREF(node);
self->last = node;

if (self->start_event_obj) {
```
   PyObject* res;[](#l2.2861)
```

   PyObject* action = self->start_event_obj;[](#l2.2862)

   res = PyTuple_Pack(2, action, node);[](#l2.2863)

```
   if (res) {[](#l2.2864)
```

       PyList_Append(self->events, res);[](#l2.2865)

```
       Py_DECREF(res);[](#l2.2866)
```
```
   } else[](#l2.2867)
```

       PyErr_Clear(); /* FIXME: propagate error */[](#l2.2868)

}

return node;

error:
Py_DECREF(node);
return NULL;

-} - -LOCAL(PyObject*) -treebuilder_handle_data(TreeBuilderObject* self, PyObject* data) -{

if (!self->data) {

   if (self->last == Py_None) {[](#l2.2882)

       /* ignore calls to data before the first call to start */[](#l2.2883)

```
       Py_RETURN_NONE;[](#l2.2884)
```
```
   }[](#l2.2885)
```

   /* store the first item as is */[](#l2.2886)

   Py_INCREF(data); self->data = data;[](#l2.2887)

} else {

   /* more than one item; use a list to collect items */[](#l2.2889)

   if (PyBytes_CheckExact(self->data) && Py_REFCNT(self->data) == 1 &&[](#l2.2890)

       PyBytes_CheckExact(data) && PyBytes_GET_SIZE(data) == 1) {[](#l2.2891)

       /* XXX this code path unused in Python 3? */[](#l2.2892)

       /* expat often generates single character data sections; handle[](#l2.2893)

          the most common case by resizing the existing string... */[](#l2.2894)

       Py_ssize_t size = PyBytes_GET_SIZE(self->data);[](#l2.2895)

       if (_PyBytes_Resize(&self->data, size + 1) < 0)[](#l2.2896)

```
           return NULL;[](#l2.2897)
```

       PyBytes_AS_STRING(self->data)[size] = PyBytes_AS_STRING(data)[0];[](#l2.2898)

   } else if (PyList_CheckExact(self->data)) {[](#l2.2899)

       if (PyList_Append(self->data, data) < 0)[](#l2.2900)

```
           return NULL;[](#l2.2901)
```
```
   } else {[](#l2.2902)
```

       PyObject* list = PyList_New(2);[](#l2.2903)

```
       if (!list)[](#l2.2904)
```
```
           return NULL;[](#l2.2905)
```

       PyList_SET_ITEM(list, 0, self->data);[](#l2.2906)

       Py_INCREF(data); PyList_SET_ITEM(list, 1, data);[](#l2.2907)

```
       self->data = list;[](#l2.2908)
```
```
   }[](#l2.2909)
```
}

Py_RETURN_NONE;

-} - -LOCAL(PyObject*) -treebuilder_handle_end(TreeBuilderObject* self, PyObject* tag) -{

PyObject* item;

+_elementtree_XMLParser___init___impl(XMLParserObject *self, PyObject *html,

                                PyObject *target, const char *encoding);[](#l2.2920)

if (self->data) {

   if (self->this == self->last) {[](#l2.2923)

       if (treebuilder_set_element_text(self->last, self->data))[](#l2.2924)

```
           return NULL;[](#l2.2925)
```
```
   } else {[](#l2.2926)
```

       if (treebuilder_set_element_tail(self->last, self->data))[](#l2.2927)

```
           return NULL;[](#l2.2928)
```
```
   }[](#l2.2929)
```
```
   self->data = NULL;[](#l2.2930)
```
}

if (self->index == 0) {
```
   PyErr_SetString([](#l2.2934)
```
```
       PyExc_IndexError,[](#l2.2935)
```

       "pop from empty stack"[](#l2.2936)

```
       );[](#l2.2937)
```
```
   return NULL;[](#l2.2938)
```
}

self->index--;

item = PyList_GET_ITEM(self->stack, self->index);
Py_INCREF(item);

Py_DECREF(self->last);

self->last = self->this;
self->this = item;

if (self->end_event_obj) {
```
   PyObject* res;[](#l2.2952)
```

   PyObject* action = self->end_event_obj;[](#l2.2953)

   PyObject* node = (PyObject*) self->last;[](#l2.2954)

   res = PyTuple_Pack(2, action, node);[](#l2.2955)

```
   if (res) {[](#l2.2956)
```

       PyList_Append(self->events, res);[](#l2.2957)

```
       Py_DECREF(res);[](#l2.2958)
```
```
   } else[](#l2.2959)
```

       PyErr_Clear(); /* FIXME: propagate error */[](#l2.2960)

}

Py_INCREF(self->last);
return (PyObject*) self->last;

-} - -LOCAL(void) -treebuilder_handle_namespace(TreeBuilderObject* self, int start,

                        PyObject *prefix, PyObject *uri)[](#l2.2969)

+static int +elementtree_XMLParser___init_(PyObject *self, PyObject *args, PyObject *kwargs) {

PyObject* res;
PyObject* action;
PyObject* parcel;

if (!self->events)
```
   return;[](#l2.2978)
```

if (start) {

   if (!self->start_ns_event_obj)[](#l2.2981)

```
       return;[](#l2.2982)
```

   action = self->start_ns_event_obj;[](#l2.2983)

   parcel = Py_BuildValue("OO", prefix, uri);[](#l2.2984)

```
   if (!parcel)[](#l2.2985)
```
```
       return;[](#l2.2986)
```
```
   Py_INCREF(action);[](#l2.2987)
```
} else {

   if (!self->end_ns_event_obj)[](#l2.2989)

```
       return;[](#l2.2990)
```

   action = self->end_ns_event_obj;[](#l2.2991)

```
   Py_INCREF(action);[](#l2.2992)
```
```
   parcel = Py_None;[](#l2.2993)
```
```
   Py_INCREF(parcel);[](#l2.2994)
```
}

int return_value = -1;
static char *_keywords[] = {"html", "target", "encoding", NULL};
PyObject *html = NULL;
PyObject *target = NULL;
const char *encoding = NULL;

res = PyTuple_New(2);

if (res) {

   PyTuple_SET_ITEM(res, 0, action);[](#l2.3005)

   PyTuple_SET_ITEM(res, 1, parcel);[](#l2.3006)

   PyList_Append(self->events, res);[](#l2.3007)

```
   Py_DECREF(res);[](#l2.3008)
```
}
else {
```
   Py_DECREF(action);[](#l2.3011)
```
```
   Py_DECREF(parcel);[](#l2.3012)
```

   PyErr_Clear(); /* FIXME: propagate error */[](#l2.3013)

}

-} - -/* -------------------------------------------------------------------- / -/ methods (in alphabetical order) / - -static PyObject -treebuilder_data(TreeBuilderObject* self, PyObject* args) -{

PyObject* data;
if (!PyArg_ParseTuple(args, "O:data", &data))
```
   return NULL;[](#l2.3025)
```

return treebuilder_handle_data(self, data);

-} - -static PyObject* -treebuilder_end(TreeBuilderObject* self, PyObject* args) -{

PyObject* tag;
if (!PyArg_ParseTuple(args, "O:end", &tag))
```
   return NULL;[](#l2.3035)
```

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOz:XMLParser", _keywords,

   &html, &target, &encoding))[](#l2.3037)

```
   goto exit;[](#l2.3038)
```
return_value = _elementtree_XMLParser___init___impl((XMLParserObject *)self, html, target, encoding);

return treebuilder_handle_end(self, tag);

-} - -LOCAL(PyObject*) -treebuilder_done(TreeBuilderObject* self) -{

PyObject* res;

/* FIXME: check stack size? */

if (self->root)
```
   res = self->root;[](#l2.3052)
```
else
```
   res = Py_None;[](#l2.3054)
```

Py_INCREF(res);
return res;

-} - -static PyObject* -treebuilder_close(TreeBuilderObject* self, PyObject* args) -{

if (!PyArg_ParseTuple(args, ":close"))
```
   return NULL;[](#l2.3064)
```

return treebuilder_done(self);

-} - -static PyObject* -treebuilder_start(TreeBuilderObject* self, PyObject* args) -{

PyObject* tag;
PyObject* attrib = Py_None;
if (!PyArg_ParseTuple(args, "O|O:start", &tag, &attrib))
```
   return NULL;[](#l2.3075)
```

return treebuilder_handle_start(self, tag, attrib);

+exit:

return return_value;

} -static PyMethodDef treebuilder_methods[] = {

{"data", (PyCFunction) treebuilder_data, METH_VARARGS},
{"start", (PyCFunction) treebuilder_start, METH_VARARGS},
{"end", (PyCFunction) treebuilder_end, METH_VARARGS},
{"close", (PyCFunction) treebuilder_close, METH_VARARGS},
{NULL, NULL}

-}; - -static PyTypeObject TreeBuilder_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
"xml.etree.ElementTree.TreeBuilder", sizeof(TreeBuilderObject), 0,
/* methods */
(destructor)treebuilder_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

                                               /* tp_flags */[](#l2.3110)

0, /* tp_doc */
(traverseproc)treebuilder_gc_traverse, /* tp_traverse */
(inquiry)treebuilder_gc_clear, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
treebuilder_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)treebuilder_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
treebuilder_new, /* tp_new */
0, /* tp_free */

-}; - -/* ==================================================================== / -/ the expat interface / - -#include "expat.h" -#include "pyexpat.h" - -/ The PyExpat_CAPI structure is an immutable dispatch table, so it can be

- cached globally without being in per-module state.
*/ -static struct PyExpat_CAPI *expat_capi; -#define EXPAT(func) (expat_capi->func) - -static XML_Memory_Handling_Suite ExpatMemoryHandler = {
PyObject_Malloc, PyObject_Realloc, PyObject_Free};

- -typedef struct {

PyObject_HEAD

XML_Parser parser;

PyObject *target;
PyObject *entity;

PyObject *names;

PyObject *handle_start;
PyObject *handle_data;
PyObject *handle_end;

PyObject *handle_comment;
PyObject *handle_pi;
PyObject *handle_doctype;

PyObject *handle_close;

- -} XMLParserObject; - -#define XMLParser_CheckExact(op) (Py_TYPE(op) == &XMLParser_Type) - -/* helpers / - -LOCAL(PyObject) -makeuniversal(XMLParserObject* self, const char* string) -{

/* convert a UTF-8 tag/attribute name from the expat parser

  to a universal name string */[](#l2.3177)

+PyDoc_STRVAR(elementtree_XMLParser_close__doc_, +"close($self, /)\n" +"--\n" +"\n");

Py_ssize_t size = (Py_ssize_t) strlen(string);
PyObject* key;
PyObject* value;

/* look the 'raw' name up in the names dictionary */
key = PyBytes_FromStringAndSize(string, size);
if (!key)
```
   return NULL;[](#l2.3190)
```

value = PyDict_GetItem(self->names, key);

if (value) {
```
   Py_INCREF(value);[](#l2.3195)
```
} else {

   /* new name.  convert to universal name, and decode as[](#l2.3197)

```
      necessary */[](#l2.3198)
```

```
   PyObject* tag;[](#l2.3200)
```
```
   char* p;[](#l2.3201)
```
```
   Py_ssize_t i;[](#l2.3202)
```

   /* look for namespace separator */[](#l2.3204)

   for (i = 0; i < size; i++)[](#l2.3205)

       if (string[i] == '}')[](#l2.3206)

```
           break;[](#l2.3207)
```
```
   if (i != size) {[](#l2.3208)
```

       /* convert to universal name */[](#l2.3209)

       tag = PyBytes_FromStringAndSize(NULL, size+1);[](#l2.3210)

```
       if (tag == NULL) {[](#l2.3211)
```
```
           Py_DECREF(key);[](#l2.3212)
```
```
           return NULL;[](#l2.3213)
```
```
       }[](#l2.3214)
```

       p = PyBytes_AS_STRING(tag);[](#l2.3215)

```
       p[0] = '{';[](#l2.3216)
```

       memcpy(p+1, string, size);[](#l2.3217)

```
       size++;[](#l2.3218)
```
```
   } else {[](#l2.3219)
```

       /* plain name; use key as tag */[](#l2.3220)

```
       Py_INCREF(key);[](#l2.3221)
```
```
       tag = key;[](#l2.3222)
```
```
   }[](#l2.3223)
```

   /* decode universal name */[](#l2.3225)

   p = PyBytes_AS_STRING(tag);[](#l2.3226)

   value = PyUnicode_DecodeUTF8(p, size, "strict");[](#l2.3227)

```
   Py_DECREF(tag);[](#l2.3228)
```
```
   if (!value) {[](#l2.3229)
```
```
       Py_DECREF(key);[](#l2.3230)
```
```
       return NULL;[](#l2.3231)
```
```
   }[](#l2.3232)
```

   /* add to names dictionary */[](#l2.3234)

   if (PyDict_SetItem(self->names, key, value) < 0) {[](#l2.3235)

```
       Py_DECREF(key);[](#l2.3236)
```
```
       Py_DECREF(value);[](#l2.3237)
```
```
       return NULL;[](#l2.3238)
```
```
   }[](#l2.3239)
```
}

Py_DECREF(key);
return value;

-} - -/* Set the ParseError exception with the given parameters.

- If message is not NULL, it's used as the error string. Otherwise, the
- message string is the default for the given error_code. -*/ -static void -expat_set_error(enum XML_Error error_code, Py_ssize_t line, Py_ssize_t column,

           const char *message)[](#l2.3252)

PyObject *errmsg, *error, *position, *code;
elementtreestate *st = ET_STATE_GLOBAL;

errmsg = PyUnicode_FromFormat("%s: line %zd, column %zd",

           message ? message : EXPAT(ErrorString)(error_code),[](#l2.3258)

```
           line, column);[](#l2.3259)
```
if (errmsg == NULL)
```
   return;[](#l2.3261)
```

error = PyObject_CallFunction(st->parseerror_obj, "O", errmsg);
Py_DECREF(errmsg);
if (!error)
```
   return;[](#l2.3266)
```

/* Add code and position attributes */
code = PyLong_FromLong((long)error_code);
if (!code) {
```
   Py_DECREF(error);[](#l2.3271)
```
```
   return;[](#l2.3272)
```
}
if (PyObject_SetAttrString(error, "code", code) == -1) {
```
   Py_DECREF(error);[](#l2.3275)
```
```
   Py_DECREF(code);[](#l2.3276)
```
```
   return;[](#l2.3277)
```
}
Py_DECREF(code);

+#define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF [](#l2.3280)

{"close", (PyCFunction)elementtree_XMLParser_close, METH_NOARGS, elementtree_XMLParser_close__doc},

position = Py_BuildValue("(nn)", line, column);
if (!position) {
```
   Py_DECREF(error);[](#l2.3285)
```
```
   return;[](#l2.3286)
```
}
if (PyObject_SetAttrString(error, "position", position) == -1) {
```
   Py_DECREF(error);[](#l2.3289)
```
```
   Py_DECREF(position);[](#l2.3290)
```
```
   return;[](#l2.3291)
```
}
Py_DECREF(position);

PyErr_SetObject(st->parseerror_obj, error);
Py_DECREF(error);

-} - -/* -------------------------------------------------------------------- / -/ handlers / - -static void -expat_default_handler(XMLParserObject self, const XML_Char* data_in,

                 int data_len)[](#l2.3304)

PyObject* key;
PyObject* value;
PyObject* res;

if (data_len < 2 || data_in[0] != '&')
```
   return;[](#l2.3311)
```

if (PyErr_Occurred())
```
   return;[](#l2.3314)
```

key = PyUnicode_DecodeUTF8(data_in + 1, data_len - 2, "strict");
if (!key)
```
   return;[](#l2.3318)
```

value = PyDict_GetItem(self->entity, key);

if (value) {

   if (TreeBuilder_CheckExact(self->target))[](#l2.3323)

       res = treebuilder_handle_data([](#l2.3324)

           (TreeBuilderObject*) self->target, value[](#l2.3325)

```
           );[](#l2.3326)
```

   else if (self->handle_data)[](#l2.3327)

       res = PyObject_CallFunction(self->handle_data, "O", value);[](#l2.3328)

```
   else[](#l2.3329)
```
```
       res = NULL;[](#l2.3330)
```
```
   Py_XDECREF(res);[](#l2.3331)
```
} else if (!PyErr_Occurred()) {

   /* Report the first error, not the last */[](#l2.3333)

   char message[128] = "undefined entity ";[](#l2.3334)

   strncat(message, data_in, data_len < 100?data_len:100);[](#l2.3335)

```
   expat_set_error([](#l2.3336)
```

       XML_ERROR_UNDEFINED_ENTITY,[](#l2.3337)

       EXPAT(GetErrorLineNumber)(self->parser),[](#l2.3338)

       EXPAT(GetErrorColumnNumber)(self->parser),[](#l2.3339)

```
       message[](#l2.3340)
```
```
       );[](#l2.3341)
```
}

Py_DECREF(key);

-} - -static void -expat_start_handler(XMLParserObject* self, const XML_Char* tag_in,

               const XML_Char **attrib_in)[](#l2.3349)

PyObject* res;
PyObject* tag;
PyObject* attrib;
int ok;

if (PyErr_Occurred())
```
   return;[](#l2.3357)
```

/* tag name */
tag = makeuniversal(self, tag_in);
if (!tag)

   return; /* parser will look for errors */[](#l2.3362)

+static PyObject * +_elementtree_XMLParser_close_impl(XMLParserObject *self);

/* attributes */
if (attrib_in[0]) {
```
   attrib = PyDict_New();[](#l2.3368)
```
```
   if (!attrib)[](#l2.3369)
```
```
       return;[](#l2.3370)
```

   while (attrib_in[0] && attrib_in[1]) {[](#l2.3371)

       PyObject* key = makeuniversal(self, attrib_in[0]);[](#l2.3372)

       PyObject* value = PyUnicode_DecodeUTF8(attrib_in[1], strlen(attrib_in[1]), "strict");[](#l2.3373)

       if (!key || !value) {[](#l2.3374)

           Py_XDECREF(value);[](#l2.3375)

```
           Py_XDECREF(key);[](#l2.3376)
```

           Py_DECREF(attrib);[](#l2.3377)

```
           return;[](#l2.3378)
```
```
       }[](#l2.3379)
```

       ok = PyDict_SetItem(attrib, key, value);[](#l2.3380)

```
       Py_DECREF(value);[](#l2.3381)
```
```
       Py_DECREF(key);[](#l2.3382)
```
```
       if (ok < 0) {[](#l2.3383)
```

           Py_DECREF(attrib);[](#l2.3384)

```
           return;[](#l2.3385)
```
```
       }[](#l2.3386)
```
```
       attrib_in += 2;[](#l2.3387)
```
```
   }[](#l2.3388)
```
} else {

   /* Pass an empty dictionary on */[](#l2.3390)

```
   attrib = PyDict_New();[](#l2.3391)
```
```
   if (!attrib)[](#l2.3392)
```
```
       return;[](#l2.3393)
```
}

if (TreeBuilder_CheckExact(self->target)) {
```
   /* shortcut */[](#l2.3397)
```

   res = treebuilder_handle_start((TreeBuilderObject*) self->target,[](#l2.3398)

                                  tag, attrib);[](#l2.3399)

}
else if (self->handle_start) {

   res = PyObject_CallFunction(self->handle_start, "OO", tag, attrib);[](#l2.3402)

} else
```
   res = NULL;[](#l2.3404)
```

Py_DECREF(tag);
Py_DECREF(attrib);

Py_XDECREF(res);

-} - -static void -expat_data_handler(XMLParserObject* self, const XML_Char* data_in,

```
              int data_len)[](#l2.3414)
```

+static PyObject * +_elementtree_XMLParser_close(XMLParserObject *self, PyObject *Py_UNUSED(ignored)) {

PyObject* data;
PyObject* res;

if (PyErr_Occurred())
```
   return;[](#l2.3422)
```

data = PyUnicode_DecodeUTF8(data_in, data_len, "strict");
if (!data)

   return; /* parser will look for errors */[](#l2.3426)

if (TreeBuilder_CheckExact(self->target))
```
   /* shortcut */[](#l2.3429)
```

   res = treebuilder_handle_data((TreeBuilderObject*) self->target, data);[](#l2.3430)

else if (self->handle_data)

   res = PyObject_CallFunction(self->handle_data, "O", data);[](#l2.3432)

else
```
   res = NULL;[](#l2.3434)
```

Py_DECREF(data);

Py_XDECREF(res);

-} - -static void -expat_end_handler(XMLParserObject* self, const XML_Char* tag_in) -{

PyObject* tag;
PyObject* res = NULL;

if (PyErr_Occurred())
```
   return;[](#l2.3448)
```

if (TreeBuilder_CheckExact(self->target))
```
   /* shortcut */[](#l2.3451)
```

   /* the standard tree builder doesn't look at the end tag */[](#l2.3452)

   res = treebuilder_handle_end([](#l2.3453)

       (TreeBuilderObject*) self->target, Py_None[](#l2.3454)

```
       );[](#l2.3455)
```
else if (self->handle_end) {

   tag = makeuniversal(self, tag_in);[](#l2.3457)

```
   if (tag) {[](#l2.3458)
```

       res = PyObject_CallFunction(self->handle_end, "O", tag);[](#l2.3459)

```
       Py_DECREF(tag);[](#l2.3460)
```
```
   }[](#l2.3461)
```
}

Py_XDECREF(res);

-} - -static void -expat_start_ns_handler(XMLParserObject* self, const XML_Char* prefix,

                  const XML_Char *uri)[](#l2.3469)

PyObject* sprefix = NULL;
PyObject* suri = NULL;

if (PyErr_Occurred())
```
   return;[](#l2.3475)
```

if (uri)

   suri = PyUnicode_DecodeUTF8(uri, strlen(uri), "strict");[](#l2.3478)

else

   suri = PyUnicode_FromString("");[](#l2.3480)

if (!suri)
```
   return;[](#l2.3482)
```

if (prefix)

   sprefix = PyUnicode_DecodeUTF8(prefix, strlen(prefix), "strict");[](#l2.3485)

else

   sprefix = PyUnicode_FromString("");[](#l2.3487)

if (!sprefix) {
```
   Py_DECREF(suri);[](#l2.3489)
```
```
   return;[](#l2.3490)
```
}

treebuilder_handle_namespace(

   (TreeBuilderObject*) self->target, 1, sprefix, suri[](#l2.3494)

```
   );[](#l2.3495)
```

Py_DECREF(sprefix);
Py_DECREF(suri);

return _elementtree_XMLParser_close_impl(self);

} -static void -expat_end_ns_handler(XMLParserObject* self, const XML_Char* prefix_in) -{

if (PyErr_Occurred())
```
   return;[](#l2.3506)
```

treebuilder_handle_namespace(

   (TreeBuilderObject*) self->target, 0, NULL, NULL[](#l2.3509)

```
   );[](#l2.3510)
```

-} - -static void -expat_comment_handler(XMLParserObject* self, const XML_Char* comment_in) -{

PyObject* comment;
PyObject* res;

if (PyErr_Occurred())
```
   return;[](#l2.3520)
```

if (self->handle_comment) {

   comment = PyUnicode_DecodeUTF8(comment_in, strlen(comment_in), "strict");[](#l2.3523)

```
   if (comment) {[](#l2.3524)
```

       res = PyObject_CallFunction(self->handle_comment, "O", comment);[](#l2.3525)

```
       Py_XDECREF(res);[](#l2.3526)
```
```
       Py_DECREF(comment);[](#l2.3527)
```
```
   }[](#l2.3528)
```
}

-} +PyDoc_STRVAR(elementtree_XMLParser_feed__doc_, +"feed($self, data, /)\n" +"--\n" +"\n"); -static void -expat_start_doctype_handler(XMLParserObject *self,

                       const XML_Char *doctype_name,[](#l2.3538)

                       const XML_Char *sysid,[](#l2.3539)

                       const XML_Char *pubid,[](#l2.3540)

                       int has_internal_subset)[](#l2.3541)

PyObject *self_pyobj = (PyObject *)self;
PyObject *doctype_name_obj, *sysid_obj, *pubid_obj;
PyObject *parser_doctype = NULL;
PyObject *res = NULL;

if (PyErr_Occurred())
```
   return;[](#l2.3549)
```

doctype_name_obj = makeuniversal(self, doctype_name);
if (!doctype_name_obj)
```
   return;[](#l2.3553)
```

if (sysid) {

   sysid_obj = makeuniversal(self, sysid);[](#l2.3556)

```
   if (!sysid_obj) {[](#l2.3557)
```

       Py_DECREF(doctype_name_obj);[](#l2.3558)

```
       return;[](#l2.3559)
```
```
   }[](#l2.3560)
```
} else {
```
   Py_INCREF(Py_None);[](#l2.3562)
```
```
   sysid_obj = Py_None;[](#l2.3563)
```
}

+#define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF [](#l2.3565)

{"feed", (PyCFunction)elementtree_XMLParser_feed, METH_O, elementtree_XMLParser_feed__doc},

if (pubid) {

   pubid_obj = makeuniversal(self, pubid);[](#l2.3569)

```
   if (!pubid_obj) {[](#l2.3570)
```

       Py_DECREF(doctype_name_obj);[](#l2.3571)

       Py_DECREF(sysid_obj);[](#l2.3572)

```
       return;[](#l2.3573)
```
```
   }[](#l2.3574)
```
} else {
```
   Py_INCREF(Py_None);[](#l2.3576)
```
```
   pubid_obj = Py_None;[](#l2.3577)
```
}

+PyDoc_STRVAR(elementtree_XMLParser__parse_whole__doc_, +"_parse_whole($self, file, /)\n" +"--\n" +"\n");

/* If the target has a handler for doctype, call it. */
if (self->handle_doctype) {

   res = PyObject_CallFunction(self->handle_doctype, "OOO",[](#l2.3586)

                               doctype_name_obj, pubid_obj, sysid_obj);[](#l2.3587)

```
   Py_CLEAR(res);[](#l2.3588)
```
}

+#define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF [](#l2.3590)

{"_parse_whole", (PyCFunction)elementtree_XMLParser__parse_whole, METH_O, elementtree_XMLParser__parse_whole__doc},

/* Now see if the parser itself has a doctype method. If yes and it's

* a subclass, call it but warn about deprecation. If it's not a subclass[](#l2.3594)

* (i.e. vanilla XMLParser), do nothing.[](#l2.3595)

```
*/[](#l2.3596)
```
parser_doctype = PyObject_GetAttrString(self_pyobj, "doctype");
if (parser_doctype) {

   if (!XMLParser_CheckExact(self_pyobj)) {[](#l2.3599)

       if (PyErr_WarnEx(PyExc_DeprecationWarning,[](#l2.3600)

                       "This method of XMLParser is deprecated.  Define"[](#l2.3601)

                       " doctype() method on the TreeBuilder target.",[](#l2.3602)

                       1) < 0) {[](#l2.3603)

```
           goto clear;[](#l2.3604)
```
```
       }[](#l2.3605)
```

       res = PyObject_CallFunction(parser_doctype, "OOO",[](#l2.3606)

                                   doctype_name_obj, pubid_obj, sysid_obj);[](#l2.3607)

```
       Py_CLEAR(res);[](#l2.3608)
```
```
   }[](#l2.3609)
```
}

- -clear:

Py_XDECREF(parser_doctype);
Py_DECREF(doctype_name_obj);
Py_DECREF(pubid_obj);
Py_DECREF(sysid_obj);

-} +PyDoc_STRVAR(elementtree_XMLParser_doctype__doc_, +"doctype($self, /)\n" +"--\n" +"\n"); -static void -expat_pi_handler(XMLParserObject* self, const XML_Char* target_in,

            const XML_Char* data_in)[](#l2.3625)

PyObject* target;
PyObject* data;
PyObject* res;

if (PyErr_Occurred())
```
   return;[](#l2.3632)
```

if (self->handle_pi) {

   target = PyUnicode_DecodeUTF8(target_in, strlen(target_in), "strict");[](#l2.3635)

   data = PyUnicode_DecodeUTF8(data_in, strlen(data_in), "strict");[](#l2.3636)

```
   if (target && data) {[](#l2.3637)
```

       res = PyObject_CallFunction(self->handle_pi, "OO", target, data);[](#l2.3638)

```
       Py_XDECREF(res);[](#l2.3639)
```
```
       Py_DECREF(data);[](#l2.3640)
```
```
       Py_DECREF(target);[](#l2.3641)
```
```
   } else {[](#l2.3642)
```
```
       Py_XDECREF(data);[](#l2.3643)
```
```
       Py_XDECREF(target);[](#l2.3644)
```
```
   }[](#l2.3645)
```
}

-} - -/* -------------------------------------------------------------------- */ +#define _ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF [](#l2.3650)

{"doctype", (PyCFunction)elementtree_XMLParser_doctype, METH_NOARGS, elementtree_XMLParser_doctype__doc},

static PyObject * -xmlparser_new(PyTypeObject *type, PyObject *args, PyObject *kwds) -{

XMLParserObject *self = (XMLParserObject *)type->tp_alloc(type, 0);
if (self) {
```
   self->parser = NULL;[](#l2.3658)
```

   self->target = self->entity = self->names = NULL;[](#l2.3659)

   self->handle_start = self->handle_data = self->handle_end = NULL;[](#l2.3660)

   self->handle_comment = self->handle_pi = self->handle_close = NULL;[](#l2.3661)

   self->handle_doctype = NULL;[](#l2.3662)

}
return (PyObject *)self;

-} - -static int -xmlparser_init(PyObject *self, PyObject *args, PyObject *kwds) -{

XMLParserObject *self_xp = (XMLParserObject *)self;
PyObject *target = NULL, *html = NULL;
char *encoding = NULL;
static char *kwlist[] = {"html", "target", "encoding", 0};

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOz:XMLParser", kwlist,

                                &html, &target, &encoding)) {[](#l2.3676)

```
   return -1;[](#l2.3677)
```
}

self_xp->entity = PyDict_New();
if (!self_xp->entity)
```
   return -1;[](#l2.3682)
```

self_xp->names = PyDict_New();
if (!self_xp->names) {

   Py_CLEAR(self_xp->entity);[](#l2.3686)

```
   return -1;[](#l2.3687)
```
}

self_xp->parser = EXPAT(ParserCreate_MM)(encoding, &ExpatMemoryHandler, "}");
if (!self_xp->parser) {

   Py_CLEAR(self_xp->entity);[](#l2.3692)

   Py_CLEAR(self_xp->names);[](#l2.3693)

```
   PyErr_NoMemory();[](#l2.3694)
```
```
   return -1;[](#l2.3695)
```
}

if (target) {
```
   Py_INCREF(target);[](#l2.3699)
```
} else {

   target = treebuilder_new(&TreeBuilder_Type, NULL, NULL);[](#l2.3701)

```
   if (!target) {[](#l2.3702)
```

       Py_CLEAR(self_xp->entity);[](#l2.3703)

       Py_CLEAR(self_xp->names);[](#l2.3704)

       EXPAT(ParserFree)(self_xp->parser);[](#l2.3705)

```
       return -1;[](#l2.3706)
```
```
   }[](#l2.3707)
```
}
self_xp->target = target;

self_xp->handle_start = PyObject_GetAttrString(target, "start");
self_xp->handle_data = PyObject_GetAttrString(target, "data");
self_xp->handle_end = PyObject_GetAttrString(target, "end");
self_xp->handle_comment = PyObject_GetAttrString(target, "comment");
self_xp->handle_pi = PyObject_GetAttrString(target, "pi");
self_xp->handle_close = PyObject_GetAttrString(target, "close");
self_xp->handle_doctype = PyObject_GetAttrString(target, "doctype");

PyErr_Clear();

+_elementtree_XMLParser_doctype_impl(XMLParserObject *self);

/* configure parser */
EXPAT(SetUserData)(self_xp->parser, self_xp);
EXPAT(SetElementHandler)(
```
   self_xp->parser,[](#l2.3725)
```

   (XML_StartElementHandler) expat_start_handler,[](#l2.3726)

   (XML_EndElementHandler) expat_end_handler[](#l2.3727)

```
   );[](#l2.3728)
```
EXPAT(SetDefaultHandlerExpand)(
```
   self_xp->parser,[](#l2.3730)
```

   (XML_DefaultHandler) expat_default_handler[](#l2.3731)

```
   );[](#l2.3732)
```
EXPAT(SetCharacterDataHandler)(
```
   self_xp->parser,[](#l2.3734)
```

   (XML_CharacterDataHandler) expat_data_handler[](#l2.3735)

```
   );[](#l2.3736)
```
if (self_xp->handle_comment)

   EXPAT(SetCommentHandler)([](#l2.3738)

```
       self_xp->parser,[](#l2.3739)
```

       (XML_CommentHandler) expat_comment_handler[](#l2.3740)

```
       );[](#l2.3741)
```
if (self_xp->handle_pi)

   EXPAT(SetProcessingInstructionHandler)([](#l2.3743)

```
       self_xp->parser,[](#l2.3744)
```

       (XML_ProcessingInstructionHandler) expat_pi_handler[](#l2.3745)

```
       );[](#l2.3746)
```
EXPAT(SetStartDoctypeDeclHandler)(
```
   self_xp->parser,[](#l2.3748)
```

   (XML_StartDoctypeDeclHandler) expat_start_doctype_handler[](#l2.3749)

```
   );[](#l2.3750)
```
EXPAT(SetUnknownEncodingHandler)(
```
   self_xp->parser,[](#l2.3752)
```

   EXPAT(DefaultUnknownEncodingHandler), NULL[](#l2.3753)

```
   );[](#l2.3754)
```

return 0;

-} - -static int -xmlparser_gc_traverse(XMLParserObject *self, visitproc visit, void *arg) -{

Py_VISIT(self->handle_close);
Py_VISIT(self->handle_pi);
Py_VISIT(self->handle_comment);
Py_VISIT(self->handle_end);
Py_VISIT(self->handle_data);
Py_VISIT(self->handle_start);

Py_VISIT(self->target);
Py_VISIT(self->entity);
Py_VISIT(self->names);

return 0;

-} - -static int -xmlparser_gc_clear(XMLParserObject *self) +static PyObject * +_elementtree_XMLParser_doctype(XMLParserObject *self, PyObject *Py_UNUSED(ignored)) {

EXPAT(ParserFree)(self->parser);

Py_CLEAR(self->handle_close);
Py_CLEAR(self->handle_pi);
Py_CLEAR(self->handle_comment);
Py_CLEAR(self->handle_end);
Py_CLEAR(self->handle_data);
Py_CLEAR(self->handle_start);
Py_CLEAR(self->handle_doctype);

Py_CLEAR(self->target);
Py_CLEAR(self->entity);
Py_CLEAR(self->names);

return 0;

-} - -static void -xmlparser_dealloc(XMLParserObject* self) -{

PyObject_GC_UnTrack(self);
xmlparser_gc_clear(self);
Py_TYPE(self)->tp_free((PyObject *)self);

-} - -LOCAL(PyObject*) -expat_parse(XMLParserObject* self, const char* data, int data_len, int final) -{

int ok;

assert(!PyErr_Occurred());
ok = EXPAT(Parse)(self->parser, data, data_len, final);

if (PyErr_Occurred())
```
   return NULL;[](#l2.3815)
```

if (!ok) {
```
   expat_set_error([](#l2.3818)
```

       EXPAT(GetErrorCode)(self->parser),[](#l2.3819)

       EXPAT(GetErrorLineNumber)(self->parser),[](#l2.3820)

       EXPAT(GetErrorColumnNumber)(self->parser),[](#l2.3821)

```
       NULL[](#l2.3822)
```
```
       );[](#l2.3823)
```
```
   return NULL;[](#l2.3824)
```
}

Py_RETURN_NONE;

-} - -static PyObject* -xmlparser_close(XMLParserObject* self, PyObject* args) -{

/* end feeding data to parser */

PyObject* res;
if (!PyArg_ParseTuple(args, ":close"))
```
   return NULL;[](#l2.3837)
```

res = expat_parse(self, "", 0, 1);
if (!res)
```
   return NULL;[](#l2.3841)
```

if (TreeBuilder_CheckExact(self->target)) {
```
   Py_DECREF(res);[](#l2.3844)
```

   return treebuilder_done((TreeBuilderObject*) self->target);[](#l2.3845)

}
else if (self->handle_close) {
```
   Py_DECREF(res);[](#l2.3848)
```

   return PyObject_CallFunction(self->handle_close, "");[](#l2.3849)

}
else {
```
   return res;[](#l2.3852)
```
}

return _elementtree_XMLParser_doctype_impl(self);

} -static PyObject* -xmlparser_feed(XMLParserObject* self, PyObject* arg) -{

/* feed data to parser */

+PyDoc_STRVAR(elementtree_XMLParser__setevents__doc_, +"_setevents($self, events_queue, events_to_report=None, /)\n" +"--\n" +"\n");

if (PyUnicode_Check(arg)) {
```
   Py_ssize_t data_len;[](#l2.3867)
```

   const char *data = PyUnicode_AsUTF8AndSize(arg, &data_len);[](#l2.3868)

```
   if (data == NULL)[](#l2.3869)
```
```
       return NULL;[](#l2.3870)
```

   if (data_len > INT_MAX) {[](#l2.3871)

       PyErr_SetString(PyExc_OverflowError, "size does not fit in an int");[](#l2.3872)

```
       return NULL;[](#l2.3873)
```
```
   }[](#l2.3874)
```

   /* Explicitly set UTF-8 encoding. Return code ignored. */[](#l2.3875)

   (void)EXPAT(SetEncoding)(self->parser, "utf-8");[](#l2.3876)

   return expat_parse(self, data, (int)data_len, 0);[](#l2.3877)

}
else {
```
   Py_buffer view;[](#l2.3880)
```
```
   PyObject *res;[](#l2.3881)
```

   if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) < 0)[](#l2.3882)

```
       return NULL;[](#l2.3883)
```

   if (view.len > INT_MAX) {[](#l2.3884)

       PyBuffer_Release(&view);[](#l2.3885)

       PyErr_SetString(PyExc_OverflowError, "size does not fit in an int");[](#l2.3886)

```
       return NULL;[](#l2.3887)
```
```
   }[](#l2.3888)
```

   res = expat_parse(self, view.buf, (int)view.len, 0);[](#l2.3889)

```
   PyBuffer_Release(&view);[](#l2.3890)
```
```
   return res;[](#l2.3891)
```
}

-} - -static PyObject* -xmlparser_parse_whole(XMLParserObject* self, PyObject* args) -{

/* (internal) parse the whole input, until end of stream */
PyObject* reader;
PyObject* buffer;
PyObject* temp;
PyObject* res;

PyObject* fileobj;
if (!PyArg_ParseTuple(args, "O:_parse", &fileobj))
```
   return NULL;[](#l2.3906)
```

reader = PyObject_GetAttrString(fileobj, "read");
if (!reader)
```
   return NULL;[](#l2.3910)
```

/* read from open file object */
for (;;) {

   buffer = PyObject_CallFunction(reader, "i", 64*1024);[](#l2.3915)

```
   if (!buffer) {[](#l2.3917)
```

       /* read failed (e.g. due to KeyboardInterrupt) */[](#l2.3918)

```
       Py_DECREF(reader);[](#l2.3919)
```
```
       return NULL;[](#l2.3920)
```
```
   }[](#l2.3921)
```

+#define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF [](#l2.3922)

{"_setevents", (PyCFunction)elementtree_XMLParser__setevents, METH_VARARGS, elementtree_XMLParser__setevents__doc},

   if (PyUnicode_CheckExact(buffer)) {[](#l2.3925)

       /* A unicode object is encoded into bytes using UTF-8 */[](#l2.3926)

       if (PyUnicode_GET_LENGTH(buffer) == 0) {[](#l2.3927)

           Py_DECREF(buffer);[](#l2.3928)

```
           break;[](#l2.3929)
```
```
       }[](#l2.3930)
```

       temp = PyUnicode_AsEncodedString(buffer, "utf-8", "surrogatepass");[](#l2.3931)

```
       Py_DECREF(buffer);[](#l2.3932)
```
```
       if (!temp) {[](#l2.3933)
```

           /* Propagate exception from PyUnicode_AsEncodedString */[](#l2.3934)

           Py_DECREF(reader);[](#l2.3935)

```
           return NULL;[](#l2.3936)
```
```
       }[](#l2.3937)
```
```
       buffer = temp;[](#l2.3938)
```
```
   }[](#l2.3939)
```

   else if (!PyBytes_CheckExact(buffer) || PyBytes_GET_SIZE(buffer) == 0) {[](#l2.3940)

```
       Py_DECREF(buffer);[](#l2.3941)
```
```
       break;[](#l2.3942)
```
```
   }[](#l2.3943)
```

   if (PyBytes_GET_SIZE(buffer) > INT_MAX) {[](#l2.3945)

```
       Py_DECREF(buffer);[](#l2.3946)
```
```
       Py_DECREF(reader);[](#l2.3947)
```

       PyErr_SetString(PyExc_OverflowError, "size does not fit in an int");[](#l2.3948)

```
       return NULL;[](#l2.3949)
```
```
   }[](#l2.3950)
```
```
   res = expat_parse([](#l2.3951)
```

       self, PyBytes_AS_STRING(buffer), (int)PyBytes_GET_SIZE(buffer), 0[](#l2.3952)

```
       );[](#l2.3953)
```

```
   Py_DECREF(buffer);[](#l2.3955)
```

+static PyObject * +_elementtree_XMLParser__setevents_impl(XMLParserObject *self,

                                  PyObject *events_queue,[](#l2.3958)

                                  PyObject *events_to_report);[](#l2.3959)

```
   if (!res) {[](#l2.3961)
```
```
       Py_DECREF(reader);[](#l2.3962)
```
```
       return NULL;[](#l2.3963)
```
```
   }[](#l2.3964)
```
```
   Py_DECREF(res);[](#l2.3965)
```

}

Py_DECREF(reader);

res = expat_parse(self, "", 0, 1);

if (res && TreeBuilder_CheckExact(self->target)) {
```
   Py_DECREF(res);[](#l2.3974)
```

   return treebuilder_done((TreeBuilderObject*) self->target);[](#l2.3975)

}

return res;

-} - -static PyObject* -xmlparser_doctype(XMLParserObject *self, PyObject *args) +static PyObject * +_elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *args) {

Py_RETURN_NONE;

-} - -static PyObject* -xmlparser_setevents(XMLParserObject self, PyObject args) -{

/* activate element event reporting */
Py_ssize_t i, seqlen;
TreeBuilderObject *target;

PyObject *return_value = NULL; PyObject *events_queue; PyObject *events_to_report = Py_None;

PyObject *events_seq;
if (!PyArg_ParseTuple(args, "O!|O:_setevents", &PyList_Type, &events_queue,

                     &events_to_report))[](#l2.4001)

```
   return NULL;[](#l2.4002)
```

if (!TreeBuilder_CheckExact(self->target)) {
```
   PyErr_SetString([](#l2.4005)
```
```
       PyExc_TypeError,[](#l2.4006)
```

       "event handling only supported for ElementTree.TreeBuilder "[](#l2.4007)

```
       "targets"[](#l2.4008)
```
```
       );[](#l2.4009)
```
```
   return NULL;[](#l2.4010)
```
}

target = (TreeBuilderObject*) self->target;

Py_INCREF(events_queue);
Py_XDECREF(target->events);
target->events = events_queue;

/* clear out existing events */
Py_CLEAR(target->start_event_obj);
Py_CLEAR(target->end_event_obj);
Py_CLEAR(target->start_ns_event_obj);
Py_CLEAR(target->end_ns_event_obj);

if (events_to_report == Py_None) {

   /* default is "end" only */[](#l2.4026)

   target->end_event_obj = PyUnicode_FromString("end");[](#l2.4027)

```
   Py_RETURN_NONE;[](#l2.4028)
```
}

if (!(events_seq = PySequence_Fast(events_to_report,

                                  "events must be a sequence"))) {[](#l2.4032)

```
   return NULL;[](#l2.4033)
```
}

seqlen = PySequence_Size(events_seq);
for (i = 0; i < seqlen; ++i) {

   PyObject *event_name_obj = PySequence_Fast_GET_ITEM(events_seq, i);[](#l2.4038)

```
   char *event_name = NULL;[](#l2.4039)
```

   if (PyUnicode_Check(event_name_obj)) {[](#l2.4040)

       event_name = _PyUnicode_AsString(event_name_obj);[](#l2.4041)

   } else if (PyBytes_Check(event_name_obj)) {[](#l2.4042)

       event_name = PyBytes_AS_STRING(event_name_obj);[](#l2.4043)

```
   }[](#l2.4044)
```

   if (event_name == NULL) {[](#l2.4046)

       Py_DECREF(events_seq);[](#l2.4047)

       PyErr_Format(PyExc_ValueError, "invalid events sequence");[](#l2.4048)

```
       return NULL;[](#l2.4049)
```

   } else if (strcmp(event_name, "start") == 0) {[](#l2.4050)

       Py_INCREF(event_name_obj);[](#l2.4051)

       target->start_event_obj = event_name_obj;[](#l2.4052)

   } else if (strcmp(event_name, "end") == 0) {[](#l2.4053)

       Py_INCREF(event_name_obj);[](#l2.4054)

       Py_XDECREF(target->end_event_obj);[](#l2.4055)

       target->end_event_obj = event_name_obj;[](#l2.4056)

   } else if (strcmp(event_name, "start-ns") == 0) {[](#l2.4057)

       Py_INCREF(event_name_obj);[](#l2.4058)

       Py_XDECREF(target->start_ns_event_obj);[](#l2.4059)

       target->start_ns_event_obj = event_name_obj;[](#l2.4060)

       EXPAT(SetNamespaceDeclHandler)([](#l2.4061)

```
           self->parser,[](#l2.4062)
```

           (XML_StartNamespaceDeclHandler) expat_start_ns_handler,[](#l2.4063)

           (XML_EndNamespaceDeclHandler) expat_end_ns_handler[](#l2.4064)

```
           );[](#l2.4065)
```

   } else if (strcmp(event_name, "end-ns") == 0) {[](#l2.4066)

       Py_INCREF(event_name_obj);[](#l2.4067)

       Py_XDECREF(target->end_ns_event_obj);[](#l2.4068)

       target->end_ns_event_obj = event_name_obj;[](#l2.4069)

       EXPAT(SetNamespaceDeclHandler)([](#l2.4070)

```
           self->parser,[](#l2.4071)
```

           (XML_StartNamespaceDeclHandler) expat_start_ns_handler,[](#l2.4072)

           (XML_EndNamespaceDeclHandler) expat_end_ns_handler[](#l2.4073)

```
           );[](#l2.4074)
```
```
   } else {[](#l2.4075)
```

       Py_DECREF(events_seq);[](#l2.4076)

       PyErr_Format(PyExc_ValueError, "unknown event '%s'", event_name);[](#l2.4077)

```
       return NULL;[](#l2.4078)
```
```
   }[](#l2.4079)
```
}

Py_DECREF(events_seq);
Py_RETURN_NONE;

-} - -static PyMethodDef xmlparser_methods[] = {

{"feed", (PyCFunction) xmlparser_feed, METH_O},
{"close", (PyCFunction) xmlparser_close, METH_VARARGS},
{"_parse_whole", (PyCFunction) xmlparser_parse_whole, METH_VARARGS},
{"_setevents", (PyCFunction) xmlparser_setevents, METH_VARARGS},
{"doctype", (PyCFunction) xmlparser_doctype, METH_VARARGS},
{NULL, NULL}

-}; - -static PyObject* -xmlparser_getattro(XMLParserObject* self, PyObject* nameobj) -{

if (PyUnicode_Check(nameobj)) {
```
   PyObject* res;[](#l2.4099)
```

   if (PyUnicode_CompareWithASCIIString(nameobj, "entity") == 0)[](#l2.4100)

```
       res = self->entity;[](#l2.4101)
```

   else if (PyUnicode_CompareWithASCIIString(nameobj, "target") == 0)[](#l2.4102)

```
       res = self->target;[](#l2.4103)
```

   else if (PyUnicode_CompareWithASCIIString(nameobj, "version") == 0) {[](#l2.4104)

       return PyUnicode_FromFormat([](#l2.4105)

           "Expat %d.%d.%d", XML_MAJOR_VERSION,[](#l2.4106)

           XML_MINOR_VERSION, XML_MICRO_VERSION);[](#l2.4107)

```
   }[](#l2.4108)
```
```
   else[](#l2.4109)
```
```
       goto generic;[](#l2.4110)
```

```
   Py_INCREF(res);[](#l2.4112)
```
```
   return res;[](#l2.4113)
```
}
generic:
return PyObject_GenericGetAttr((PyObject*) self, nameobj);

-} -static PyTypeObject XMLParser_Type = {

PyVarObject_HEAD_INIT(NULL, 0)
"xml.etree.ElementTree.XMLParser", sizeof(XMLParserObject), 0,
/* methods */
(destructor)xmlparser_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
(getattrofunc)xmlparser_getattro, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

                                               /* tp_flags */[](#l2.4139)

0, /* tp_doc */
(traverseproc)xmlparser_gc_traverse, /* tp_traverse */
(inquiry)xmlparser_gc_clear, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
xmlparser_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)xmlparser_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
xmlparser_new, /* tp_new */
0, /* tp_free */

-}; - -/* ==================================================================== / -/ python module interface */ - -static PyMethodDef _functions[] = {

{"SubElement", (PyCFunction) subelement, METH_VARARGS | METH_KEYWORDS},
{NULL, NULL}

-}; - - -static struct PyModuleDef elementtreemodule = {

PyModuleDef_HEAD_INIT,
"_elementtree",
NULL,
sizeof(elementtreestate),
_functions,
NULL,
elementtree_traverse,
elementtree_clear,
elementtree_free

-};

if (!PyArg_ParseTuple(args, "O!|O:_setevents",

   &PyList_Type, &events_queue, &events_to_report))[](#l2.4182)

```
   goto exit;[](#l2.4183)
```
return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report);

-PyMODINIT_FUNC -PyInit__elementtree(void) -{

PyObject *m, *temp;
elementtreestate *st;

m = PyState_FindModule(&elementtreemodule);
if (m) {
```
   Py_INCREF(m);[](#l2.4194)
```
```
   return m;[](#l2.4195)
```
}

/* Initialize object types */
if (PyType_Ready(&ElementIter_Type) < 0)
```
   return NULL;[](#l2.4200)
```
if (PyType_Ready(&TreeBuilder_Type) < 0)
```
   return NULL;[](#l2.4202)
```
if (PyType_Ready(&Element_Type) < 0)
```
   return NULL;[](#l2.4204)
```
if (PyType_Ready(&XMLParser_Type) < 0)
```
   return NULL;[](#l2.4206)
```

m = PyModule_Create(&elementtreemodule);
if (!m)
```
   return NULL;[](#l2.4210)
```
st = ET_STATE(m);

if (!(temp = PyImport_ImportModule("copy")))
```
   return NULL;[](#l2.4214)
```
st->deepcopy_obj = PyObject_GetAttrString(temp, "deepcopy");
Py_XDECREF(temp);

if (!(st->elementpath_obj = PyImport_ImportModule("xml.etree.ElementPath")))
```
   return NULL;[](#l2.4219)
```

/* link against pyexpat */
expat_capi = PyCapsule_Import(PyExpat_CAPSULE_NAME, 0);
if (expat_capi) {

   /* check that it's usable */[](#l2.4224)

   if (strcmp(expat_capi->magic, PyExpat_CAPI_MAGIC) != 0 ||[](#l2.4225)

       (size_t)expat_capi->size < sizeof(struct PyExpat_CAPI) ||[](#l2.4226)

       expat_capi->MAJOR_VERSION != XML_MAJOR_VERSION ||[](#l2.4227)

       expat_capi->MINOR_VERSION != XML_MINOR_VERSION ||[](#l2.4228)

       expat_capi->MICRO_VERSION != XML_MICRO_VERSION) {[](#l2.4229)

       PyErr_SetString(PyExc_ImportError,[](#l2.4230)

                       "pyexpat version is incompatible");[](#l2.4231)

```
       return NULL;[](#l2.4232)
```
```
   }[](#l2.4233)
```
} else {
```
   return NULL;[](#l2.4235)
```
}

st->parseerror_obj = PyErr_NewException(

   "xml.etree.ElementTree.ParseError", PyExc_SyntaxError, NULL[](#l2.4239)

```
   );[](#l2.4240)
```
Py_INCREF(st->parseerror_obj);
PyModule_AddObject(m, "ParseError", st->parseerror_obj);

Py_INCREF((PyObject *)&Element_Type);
PyModule_AddObject(m, "Element", (PyObject *)&Element_Type);

Py_INCREF((PyObject *)&TreeBuilder_Type);
PyModule_AddObject(m, "TreeBuilder", (PyObject *)&TreeBuilder_Type);

Py_INCREF((PyObject *)&XMLParser_Type);
PyModule_AddObject(m, "XMLParser", (PyObject *)&XMLParser_Type);

return m;

+exit:

return return_value;

} +/[clinic end generated code: output=119aed84c1545187 input=a9049054013a1b77]/