Serhiy Storchaka added the comment:
Here is refreshed patch.
----------
title: Derby #7: Convert 51 sites to Argument Clinic across 3 files -> Derby:
Convert the ElementTree module to use Argument Clinic
Added file: http://bugs.python.org/file33355/etree_clinic.patch
_______________________________________
Python tracker <rep...@bugs.python.org>
<http://bugs.python.org/issue20159>
_______________________________________
diff -r e634b377d5cc Modules/_elementtree.c
--- a/Modules/_elementtree.c Tue Jan 07 14:25:26 2014 -0800
+++ b/Modules/_elementtree.c Wed Jan 08 01:42:50 2014 +0200
@@ -368,6 +368,12 @@
return attrib;
}
+/*[clinic input]
+module _elementtree
+class _elementtree.Element
+[clinic start generated code]*/
+/*[clinic end generated code:
checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+
static int
element_init(PyObject *self, PyObject *args, PyObject *kwds)
{
@@ -654,25 +660,80 @@
/* -------------------------------------------------------------------- */
-static PyObject*
-element_append(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.append
+
+ self: self(type='ElementObject *')
+ subelement: object(subclass_of='&Element_Type')
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_append__doc__,
+"append(subelement)");
+
+#define _ELEMENTTREE_ELEMENT_APPEND_METHODDEF \
+ {"append", (PyCFunction)_elementtree_Element_append, METH_VARARGS,
_elementtree_Element_append__doc__},
+
+static PyObject *
+_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement);
+
+static PyObject *
+_elementtree_Element_append(PyObject *self, PyObject *args)
{
- PyObject* element;
- if (!PyArg_ParseTuple(args, "O!:append", &Element_Type, &element))
- return NULL;
-
- if (element_add_subelement(self, element) < 0)
+ PyObject *return_value = NULL;
+ PyObject *subelement;
+
+ if (!PyArg_ParseTuple(args,
+ "O!:append",
+ &Element_Type, &subelement))
+ goto exit;
+ return_value = _elementtree_Element_append_impl((ElementObject *)self,
subelement);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement)
+/*[clinic end generated code:
checksum=2657014068bf9a52d383c72699454858243643a6]*/
+{
+ 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
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_clear__doc__,
+"clear()");
+
+#define _ELEMENTTREE_ELEMENT_CLEAR_METHODDEF \
+ {"clear", (PyCFunction)_elementtree_Element_clear, METH_NOARGS,
_elementtree_Element_clear__doc__},
+
+static PyObject *
+_elementtree_Element_clear_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_clear(PyObject *self, PyObject *Py_UNUSED(ignored))
{
- if (!PyArg_ParseTuple(args, ":clear"))
- return NULL;
-
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_Element_clear_impl((ElementObject *)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_clear_impl(ElementObject *self)
+/*[clinic end generated code:
checksum=b112605d2110394281eaabbf17b7458fc1037828]*/
+{
dealloc_extra(self);
Py_INCREF(Py_None);
@@ -686,15 +747,39 @@
Py_RETURN_NONE;
}
-static PyObject*
-element_copy(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.__copy__
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element___copy____doc__,
+"__copy__()");
+
+#define _ELEMENTTREE_ELEMENT___COPY___METHODDEF \
+ {"__copy__", (PyCFunction)_elementtree_Element___copy__, METH_NOARGS,
_elementtree_Element___copy____doc__},
+
+static PyObject *
+_elementtree_Element___copy___impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element___copy__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_Element___copy___impl((ElementObject *)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element___copy___impl(ElementObject *self)
+/*[clinic end generated code:
checksum=7a0523cd605533c0e69293b9a4fcbecc6e072ba2]*/
{
int i;
ElementObject* element;
- if (!PyArg_ParseTuple(args, ":__copy__"))
- return NULL;
-
element = (ElementObject*) create_new_element(
self->tag, (self->extra) ? self->extra->attrib : Py_None);
if (!element)
@@ -725,8 +810,24 @@
return (PyObject*) element;
}
-static PyObject*
-element_deepcopy(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.__deepcopy__
+
+ self: self(type='ElementObject *')
+ memo: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__,
+"__deepcopy__(memo)");
+
+#define _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF \
+ {"__deepcopy__", (PyCFunction)_elementtree_Element___deepcopy__, METH_O,
_elementtree_Element___deepcopy____doc__},
+
+static PyObject *
+_elementtree_Element___deepcopy__(ElementObject *self, PyObject *memo)
+/*[clinic end generated code:
checksum=f337046f0f00f6dc0dfc3dbf45553e310672f56b]*/
{
int i;
ElementObject* element;
@@ -736,10 +837,6 @@
PyObject* tail;
PyObject* id;
- PyObject* memo;
- if (!PyArg_ParseTuple(args, "O:__deepcopy__", &memo))
- return NULL;
-
tag = deepcopy(self->tag, memo);
if (!tag)
return NULL;
@@ -810,17 +907,48 @@
return NULL;
}
-static PyObject*
-element_sizeof(PyObject* myself, PyObject* args)
+/*[clinic input]
+_elementtree.Element.__sizeof__ -> Py_ssize_t
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element___sizeof____doc__,
+"__sizeof__()");
+
+#define _ELEMENTTREE_ELEMENT___SIZEOF___METHODDEF \
+ {"__sizeof__", (PyCFunction)_elementtree_Element___sizeof__, METH_NOARGS,
_elementtree_Element___sizeof____doc__},
+
+static Py_ssize_t
+_elementtree_Element___sizeof___impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element___sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))
{
- ElementObject *self = (ElementObject*)myself;
+ PyObject *return_value = NULL;
+ Py_ssize_t _return_value;
+
+ _return_value = _elementtree_Element___sizeof___impl((ElementObject
*)self);
+ if ((_return_value == -1) && PyErr_Occurred())
+ goto exit;
+ return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+ return return_value;
+}
+
+static Py_ssize_t
+_elementtree_Element___sizeof___impl(ElementObject *self)
+/*[clinic end generated code:
checksum=5e3e8a02ed3a3c73c99467e90f8b840277286cb7]*/
+{
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. */
@@ -836,8 +964,35 @@
* any unnecessary structures there; and (b) it buys compatibility with 3.2
* pickles. See issue #16076.
*/
+/*[clinic input]
+_elementtree.Element.__getstate__
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element___getstate____doc__,
+"__getstate__()");
+
+#define _ELEMENTTREE_ELEMENT___GETSTATE___METHODDEF \
+ {"__getstate__", (PyCFunction)_elementtree_Element___getstate__,
METH_NOARGS, _elementtree_Element___getstate____doc__},
+
static PyObject *
-element_getstate(ElementObject *self)
+_elementtree_Element___getstate___impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element___getstate__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_Element___getstate___impl((ElementObject
*)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element___getstate___impl(ElementObject *self)
+/*[clinic end generated code:
checksum=54ff075281a1ea36af223e690490204bc27748fb]*/
{
int i, noattrib;
PyObject *instancedict = NULL, *children;
@@ -952,6 +1107,7 @@
/* __setstate__ for Element instance from the Python implementation.
* 'state' should be the instance dict.
*/
+
static PyObject *
element_setstate_from_Python(ElementObject *self, PyObject *state)
{
@@ -977,8 +1133,24 @@
return retval;
}
+/*[clinic input]
+_elementtree.Element.__setstate__
+
+ self: self(type='ElementObject *')
+ state: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element___setstate____doc__,
+"__setstate__(state)");
+
+#define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF \
+ {"__setstate__", (PyCFunction)_elementtree_Element___setstate__, METH_O,
_elementtree_Element___setstate____doc__},
+
static PyObject *
-element_setstate(ElementObject *self, PyObject *state)
+_elementtree_Element___setstate__(ElementObject *self, PyObject *state)
+/*[clinic end generated code:
checksum=bd75aec0601d95cfd4ada7d5aa4b6597f7209422]*/
{
if (!PyDict_CheckExact(state)) {
PyErr_Format(PyExc_TypeError,
@@ -1032,21 +1204,33 @@
return 1; /* unknown type; might be path expression */
}
-static PyObject*
-element_extend(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.extend
+
+ self: self(type='ElementObject *')
+ elements: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_extend__doc__,
+"extend(elements)");
+
+#define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF \
+ {"extend", (PyCFunction)_elementtree_Element_extend, METH_O,
_elementtree_Element_extend__doc__},
+
+static PyObject *
+_elementtree_Element_extend(ElementObject *self, PyObject *elements)
+/*[clinic end generated code:
checksum=a5102ac72eb6ab1d742a8c6c06f5ee4c5e219580]*/
{
PyObject* seq;
Py_ssize_t i, seqlen = 0;
- PyObject* seq_in;
- if (!PyArg_ParseTuple(args, "O:extend", &seq_in))
- return NULL;
-
- 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
+ "expected sequence, not \"%.200s\"", Py_TYPE(elements)->tp_name
);
return NULL;
}
@@ -1074,23 +1258,53 @@
Py_RETURN_NONE;
}
-static PyObject*
-element_find(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic input]
+_elementtree.Element.find
+
+ self: self(type='ElementObject *')
+ path: object
+ namespaces: object = None
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_find__doc__,
+"find(path, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \
+ {"find", (PyCFunction)_elementtree_Element_find,
METH_VARARGS|METH_KEYWORDS, _elementtree_Element_find__doc__},
+
+static PyObject *
+_elementtree_Element_find_impl(ElementObject *self, PyObject *path, PyObject
*namespaces);
+
+static PyObject *
+_elementtree_Element_find(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"path", "namespaces", NULL};
+ PyObject *path;
+ PyObject *namespaces = Py_None;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O|O:find", _keywords,
+ &path, &namespaces))
+ goto exit;
+ return_value = _elementtree_Element_find_impl((ElementObject *)self, path,
namespaces);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_find_impl(ElementObject *self, PyObject *path, PyObject
*namespaces)
+/*[clinic end generated code:
checksum=636eddffd045f4ff6d3538514285824437eabde6]*/
{
int 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))
- return NULL;
-
- 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
+ st->elementpath_obj, &PyId_find, "OOO", self, path, namespaces
);
}
@@ -1100,7 +1314,7 @@
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) {
+ PyObject_RichCompareBool(((ElementObject*)item)->tag, path, Py_EQ)
== 1) {
Py_INCREF(item);
return item;
}
@@ -1109,24 +1323,55 @@
Py_RETURN_NONE;
}
-static PyObject*
-element_findtext(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic input]
+_elementtree.Element.findtext
+
+ self: self(type='ElementObject *')
+ path: object
+ default: object = None
+ namespaces: object = None
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_findtext__doc__,
+"findtext(path, default=None, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \
+ {"findtext", (PyCFunction)_elementtree_Element_findtext,
METH_VARARGS|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
+
+static PyObject *
+_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,
PyObject *default_value, PyObject *namespaces);
+
+static PyObject *
+_elementtree_Element_findtext(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"path", "default", "namespaces", NULL};
+ PyObject *path;
+ PyObject *default_value = Py_None;
+ PyObject *namespaces = Py_None;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O|OO:findtext", _keywords,
+ &path, &default_value, &namespaces))
+ goto exit;
+ return_value = _elementtree_Element_findtext_impl((ElementObject *)self,
path, default_value, namespaces);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,
PyObject *default_value, PyObject *namespaces)
+/*[clinic end generated code:
checksum=1bdd762f714aef8cee0f62faa4afc4eb8f21b58c]*/
{
int 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))
- return NULL;
-
- 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
+ st->elementpath_obj, &PyId_findtext, "OOOO", self, path,
default_value, namespaces
);
if (!self->extra) {
@@ -1137,7 +1382,7 @@
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)) {
+ (PyObject_RichCompareBool(item->tag, path, Py_EQ) == 1)) {
PyObject* text = element_get_text(item);
if (text == Py_None)
return PyUnicode_New(0, 0);
@@ -1150,20 +1395,51 @@
return default_value;
}
-static PyObject*
-element_findall(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic input]
+_elementtree.Element.findall
+
+ self: self(type='ElementObject *')
+ path: object
+ namespaces: object = None
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_findall__doc__,
+"findall(path, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \
+ {"findall", (PyCFunction)_elementtree_Element_findall,
METH_VARARGS|METH_KEYWORDS, _elementtree_Element_findall__doc__},
+
+static PyObject *
+_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
PyObject *namespaces);
+
+static PyObject *
+_elementtree_Element_findall(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"path", "namespaces", NULL};
+ PyObject *path;
+ PyObject *namespaces = Py_None;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O|O:findall", _keywords,
+ &path, &namespaces))
+ goto exit;
+ return_value = _elementtree_Element_findall_impl((ElementObject *)self,
path, namespaces);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
PyObject *namespaces)
+/*[clinic end generated code:
checksum=e126482bd3635e7ccfb83ba5bfb12c282b509e44]*/
{
int 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))
- return NULL;
-
if (checkpath(tag) || namespaces != Py_None) {
_Py_IDENTIFIER(findall);
return _PyObject_CallMethodId(
@@ -1192,36 +1468,95 @@
return out;
}
-static PyObject*
-element_iterfind(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic input]
+_elementtree.Element.iterfind
+
+ self: self(type='ElementObject *')
+ path: object
+ namespaces: object = None
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_iterfind__doc__,
+"iterfind(path, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \
+ {"iterfind", (PyCFunction)_elementtree_Element_iterfind,
METH_VARARGS|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
+
+static PyObject *
+_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
PyObject *namespaces);
+
+static PyObject *
+_elementtree_Element_iterfind(PyObject *self, PyObject *args, PyObject *kwargs)
{
- PyObject* tag;
- PyObject* namespaces = Py_None;
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"path", "namespaces", NULL};
+ PyObject *path;
+ PyObject *namespaces = Py_None;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O|O:iterfind", _keywords,
+ &path, &namespaces))
+ goto exit;
+ return_value = _elementtree_Element_iterfind_impl((ElementObject *)self,
path, namespaces);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
PyObject *namespaces)
+/*[clinic end generated code:
checksum=15f071c02d939b097f57c37132904e5bd19efa4c]*/
+{
+ 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)) {
- return NULL;
- }
-
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
+
+ self: self(type='ElementObject *')
+ key: object
+ default: object = None
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_get__doc__,
+"get(key, default=None)");
+
+#define _ELEMENTTREE_ELEMENT_GET_METHODDEF \
+ {"get", (PyCFunction)_elementtree_Element_get, METH_VARARGS|METH_KEYWORDS,
_elementtree_Element_get__doc__},
+
+static PyObject *
+_elementtree_Element_get_impl(ElementObject *self, PyObject *key, PyObject
*default_value);
+
+static PyObject *
+_elementtree_Element_get(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"key", "default", NULL};
+ PyObject *key;
+ PyObject *default_value = Py_None;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O|O:get", _keywords,
+ &key, &default_value))
+ goto exit;
+ return_value = _elementtree_Element_get_impl((ElementObject *)self, key,
default_value);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_get_impl(ElementObject *self, PyObject *key, PyObject
*default_value)
+/*[clinic end generated code:
checksum=91ae50e2b73068eefe8fbfa7c3fd15df298b0e98]*/
{
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))
- return NULL;
if (!self->extra || self->extra->attrib == Py_None)
value = default_value;
@@ -1235,17 +1570,41 @@
return value;
}
-static PyObject*
-element_getchildren(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.getchildren
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_getchildren__doc__,
+"getchildren()");
+
+#define _ELEMENTTREE_ELEMENT_GETCHILDREN_METHODDEF \
+ {"getchildren", (PyCFunction)_elementtree_Element_getchildren,
METH_NOARGS, _elementtree_Element_getchildren__doc__},
+
+static PyObject *
+_elementtree_Element_getchildren_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_getchildren(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_Element_getchildren_impl((ElementObject
*)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_getchildren_impl(ElementObject *self)
+/*[clinic end generated code:
checksum=afae4354dc5231ba76ce51be3fcf6146fa327d58]*/
{
int i;
PyObject* list;
/* FIXME: report as deprecated? */
- if (!PyArg_ParseTuple(args, ":getchildren"))
- return NULL;
-
if (!self->extra)
return PyList_New(0);
@@ -1267,25 +1626,78 @@
create_elementiter(ElementObject *self, PyObject *tag, int gettext);
+/*[clinic input]
+_elementtree.Element.iter
+
+ self: self(type='ElementObject *')
+ tag: object = None
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_iter__doc__,
+"iter(tag=None)");
+
+#define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \
+ {"iter", (PyCFunction)_elementtree_Element_iter,
METH_VARARGS|METH_KEYWORDS, _elementtree_Element_iter__doc__},
+
static PyObject *
-element_iter(ElementObject *self, PyObject *args, PyObject *kwds)
+_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag);
+
+static PyObject *
+_elementtree_Element_iter(PyObject *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;
-
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"tag", NULL};
+ PyObject *tag = Py_None;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "|O:iter", _keywords,
+ &tag))
+ goto exit;
+ return_value = _elementtree_Element_iter_impl((ElementObject *)self, tag);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag)
+/*[clinic end generated code:
checksum=996b1537be06ed54b57c9ee79cf05219dced62e3]*/
+{
return create_elementiter(self, tag, 0);
}
-static PyObject*
-element_itertext(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.itertext
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_itertext__doc__,
+"itertext()");
+
+#define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF \
+ {"itertext", (PyCFunction)_elementtree_Element_itertext, METH_NOARGS,
_elementtree_Element_itertext__doc__},
+
+static PyObject *
+_elementtree_Element_itertext_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_itertext(PyObject *self, PyObject *Py_UNUSED(ignored))
{
- if (!PyArg_ParseTuple(args, ":itertext"))
- return NULL;
-
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_Element_itertext_impl((ElementObject *)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_itertext_impl(ElementObject *self)
+/*[clinic end generated code:
checksum=46ee60dbf63f1c07205dc267333aef4d47cec1c9]*/
+{
return create_elementiter(self, Py_None, 1);
}
@@ -1307,17 +1719,48 @@
return self->extra->children[index];
}
-static PyObject*
-element_insert(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.insert
+
+ self: self(type='ElementObject *')
+ index: int
+ subelement: object(subclass_of='&Element_Type')
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_insert__doc__,
+"insert(index, subelement)");
+
+#define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF \
+ {"insert", (PyCFunction)_elementtree_Element_insert, METH_VARARGS,
_elementtree_Element_insert__doc__},
+
+static PyObject *
+_elementtree_Element_insert_impl(ElementObject *self, int index, PyObject
*subelement);
+
+static PyObject *
+_elementtree_Element_insert(PyObject *self, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ int index;
+ PyObject *subelement;
+
+ if (!PyArg_ParseTuple(args,
+ "iO!:insert",
+ &index, &Element_Type, &subelement))
+ goto exit;
+ return_value = _elementtree_Element_insert_impl((ElementObject *)self,
index, subelement);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_insert_impl(ElementObject *self, int index, PyObject
*subelement)
+/*[clinic end generated code:
checksum=7ad6a209044ad042f2487c42f7c7c5627d9c7a37]*/
{
int i;
- int index;
- PyObject* element;
- if (!PyArg_ParseTuple(args, "iO!:insert", &index,
- &Element_Type, &element))
- return NULL;
-
if (!self->extra) {
if (create_extra(self, NULL) < 0)
return NULL;
@@ -1337,32 +1780,80 @@
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
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_items__doc__,
+"items()");
+
+#define _ELEMENTTREE_ELEMENT_ITEMS_METHODDEF \
+ {"items", (PyCFunction)_elementtree_Element_items, METH_NOARGS,
_elementtree_Element_items__doc__},
+
+static PyObject *
+_elementtree_Element_items_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_items(PyObject *self, PyObject *Py_UNUSED(ignored))
{
- if (!PyArg_ParseTuple(args, ":items"))
- return NULL;
-
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_Element_items_impl((ElementObject *)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_items_impl(ElementObject *self)
+/*[clinic end generated code:
checksum=6da79e8ab42972f525e6e861b7c4a484f276355a]*/
+{
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
+
+ self: self(type='ElementObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_keys__doc__,
+"keys()");
+
+#define _ELEMENTTREE_ELEMENT_KEYS_METHODDEF \
+ {"keys", (PyCFunction)_elementtree_Element_keys, METH_NOARGS,
_elementtree_Element_keys__doc__},
+
+static PyObject *
+_elementtree_Element_keys_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_keys(PyObject *self, PyObject *Py_UNUSED(ignored))
{
- if (!PyArg_ParseTuple(args, ":keys"))
- return NULL;
-
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_Element_keys_impl((ElementObject *)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_keys_impl(ElementObject *self)
+/*[clinic end generated code:
checksum=793f43a3dac2f01b7666d889f093e3f512d482f3]*/
+{
if (!self->extra || self->extra->attrib == Py_None)
return PyList_New(0);
@@ -1378,16 +1869,48 @@
return self->extra->length;
}
-static PyObject*
-element_makeelement(PyObject* self, PyObject* args, PyObject* kw)
+/*[clinic input]
+_elementtree.Element.makeelement
+
+ self: self(type='ElementObject *')
+ tag: object
+ attrib: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
+"makeelement(tag, attrib)");
+
+#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
+ {"makeelement", (PyCFunction)_elementtree_Element_makeelement,
METH_VARARGS, _elementtree_Element_makeelement__doc__},
+
+static PyObject *
+_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
PyObject *attrib);
+
+static PyObject *
+_elementtree_Element_makeelement(PyObject *self, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *tag;
+ PyObject *attrib;
+
+ if (!PyArg_ParseTuple(args,
+ "OO:makeelement",
+ &tag, &attrib))
+ goto exit;
+ return_value = _elementtree_Element_makeelement_impl((ElementObject
*)self, tag, attrib);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
PyObject *attrib)
+/*[clinic end generated code:
checksum=a6361094d69138417544cf031f3df2d669510053]*/
{
PyObject* elem;
- PyObject* tag;
- PyObject* attrib;
- if (!PyArg_ParseTuple(args, "OO:makeelement", &tag, &attrib))
- return NULL;
-
attrib = PyDict_Copy(attrib);
if (!attrib)
return NULL;
@@ -1399,15 +1922,46 @@
return elem;
}
-static PyObject*
-element_remove(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.remove
+
+ self: self(type='ElementObject *')
+ subelement: object(subclass_of='&Element_Type')
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_remove__doc__,
+"remove(subelement)");
+
+#define _ELEMENTTREE_ELEMENT_REMOVE_METHODDEF \
+ {"remove", (PyCFunction)_elementtree_Element_remove, METH_VARARGS,
_elementtree_Element_remove__doc__},
+
+static PyObject *
+_elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement);
+
+static PyObject *
+_elementtree_Element_remove(PyObject *self, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *subelement;
+
+ if (!PyArg_ParseTuple(args,
+ "O!:remove",
+ &Element_Type, &subelement))
+ goto exit;
+ return_value = _elementtree_Element_remove_impl((ElementObject *)self,
subelement);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement)
+/*[clinic end generated code:
checksum=461762446933dbcaf0dd5f2bddd5075ee6594a10]*/
{
int i;
- PyObject* element;
- if (!PyArg_ParseTuple(args, "O!:remove", &Element_Type, &element))
- return NULL;
-
if (!self->extra) {
/* element has no children, so raise exception */
PyErr_SetString(
@@ -1418,14 +1972,14 @@
}
for (i = 0; i < self->extra->length; i++) {
- if (self->extra->children[i] == element)
+ if (self->extra->children[i] == subelement)
break;
- if (PyObject_RichCompareBool(self->extra->children[i], element, Py_EQ)
== 1)
+ if (PyObject_RichCompareBool(self->extra->children[i], subelement,
Py_EQ) == 1)
break;
}
if (i == self->extra->length) {
- /* element is not in children, so raise exception */
+ /* subelement is not in children, so raise exception */
PyErr_SetString(
PyExc_ValueError,
"list.remove(x): x not in list"
@@ -1452,16 +2006,48 @@
return PyUnicode_FromFormat("<Element at %p>", self);
}
-static PyObject*
-element_set(ElementObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.Element.set
+
+ self: self(type='ElementObject *')
+ key: object
+ value: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_Element_set__doc__,
+"set(key, value)");
+
+#define _ELEMENTTREE_ELEMENT_SET_METHODDEF \
+ {"set", (PyCFunction)_elementtree_Element_set, METH_VARARGS,
_elementtree_Element_set__doc__},
+
+static PyObject *
+_elementtree_Element_set_impl(ElementObject *self, PyObject *key, PyObject
*value);
+
+static PyObject *
+_elementtree_Element_set(PyObject *self, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *key;
+ PyObject *value;
+
+ if (!PyArg_ParseTuple(args,
+ "OO:set",
+ &key, &value))
+ goto exit;
+ return_value = _elementtree_Element_set_impl((ElementObject *)self, key,
value);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_Element_set_impl(ElementObject *self, PyObject *key, PyObject
*value)
+/*[clinic end generated code:
checksum=bff41191c04d8ebb5ca002101771cc54575ef34c]*/
{
PyObject* attrib;
- PyObject* key;
- PyObject* value;
- if (!PyArg_ParseTuple(args, "OO:set", &key, &value))
- return NULL;
-
if (!self->extra) {
if (create_extra(self, NULL) < 0)
return NULL;
@@ -1744,37 +2330,37 @@
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},
+ _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}
};
@@ -2262,6 +2848,11 @@
return (PyObject *)t;
}
+/*[clinic input]
+class _elementtree.TreeBuilder
+[clinic start generated code]*/
+/*[clinic end generated code:
checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+
static int
treebuilder_init(PyObject *self, PyObject *args, PyObject *kwds)
{
@@ -2598,23 +3189,47 @@
/* -------------------------------------------------------------------- */
/* methods (in alphabetical order) */
-static PyObject*
-treebuilder_data(TreeBuilderObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.TreeBuilder.data
+
+ self: self(type='TreeBuilderObject *')
+ data: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_data__doc__,
+"data(data)");
+
+#define _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF \
+ {"data", (PyCFunction)_elementtree_TreeBuilder_data, METH_O,
_elementtree_TreeBuilder_data__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_data(TreeBuilderObject *self, PyObject *data)
+/*[clinic end generated code:
checksum=c8bc9ede07a4b79d1f937c442d6990ebc8b180db]*/
{
- PyObject* data;
- if (!PyArg_ParseTuple(args, "O:data", &data))
- return NULL;
-
return treebuilder_handle_data(self, data);
}
-static PyObject*
-treebuilder_end(TreeBuilderObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.TreeBuilder.end
+
+ self: self(type='TreeBuilderObject *')
+ tag: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_end__doc__,
+"end(tag)");
+
+#define _ELEMENTTREE_TREEBUILDER_END_METHODDEF \
+ {"end", (PyCFunction)_elementtree_TreeBuilder_end, METH_O,
_elementtree_TreeBuilder_end__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_end(TreeBuilderObject *self, PyObject *tag)
+/*[clinic end generated code:
checksum=82bee0547d56fa6b029f8732b4d3c7f15f5d011c]*/
{
- PyObject* tag;
- if (!PyArg_ParseTuple(args, "O:end", &tag))
- return NULL;
-
return treebuilder_handle_end(self, tag);
}
@@ -2634,31 +3249,87 @@
return res;
}
-static PyObject*
-treebuilder_close(TreeBuilderObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.TreeBuilder.close
+
+ self: self(type='TreeBuilderObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_close__doc__,
+"close()");
+
+#define _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF \
+ {"close", (PyCFunction)_elementtree_TreeBuilder_close, METH_NOARGS,
_elementtree_TreeBuilder_close__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_close_impl(TreeBuilderObject *self);
+
+static PyObject *
+_elementtree_TreeBuilder_close(PyObject *self, PyObject *Py_UNUSED(ignored))
{
- if (!PyArg_ParseTuple(args, ":close"))
- return NULL;
-
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_TreeBuilder_close_impl((TreeBuilderObject
*)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_TreeBuilder_close_impl(TreeBuilderObject *self)
+/*[clinic end generated code:
checksum=04499971c07c3de69d131ca3885664749c4a48b7]*/
+{
return treebuilder_done(self);
}
-static PyObject*
-treebuilder_start(TreeBuilderObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.TreeBuilder.start
+
+ self: self(type='TreeBuilderObject *')
+ tag: object
+ attrs: object = None
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
+"start(tag, attrs=None)");
+
+#define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \
+ {"start", (PyCFunction)_elementtree_TreeBuilder_start, METH_VARARGS,
_elementtree_TreeBuilder_start__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
PyObject *attrs);
+
+static PyObject *
+_elementtree_TreeBuilder_start(PyObject *self, PyObject *args)
{
- PyObject* tag;
- PyObject* attrib = Py_None;
- if (!PyArg_ParseTuple(args, "O|O:start", &tag, &attrib))
- return NULL;
-
- return treebuilder_handle_start(self, tag, attrib);
+ PyObject *return_value = NULL;
+ PyObject *tag;
+ PyObject *attrs = Py_None;
+
+ if (!PyArg_ParseTuple(args,
+ "O|O:start",
+ &tag, &attrs))
+ goto exit;
+ return_value = _elementtree_TreeBuilder_start_impl((TreeBuilderObject
*)self, tag, attrs);
+
+exit:
+ return return_value;
}
+static PyObject *
+_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
PyObject *attrs)
+/*[clinic end generated code:
checksum=e1c32bce2ff2880e4756348b489e1eace4b7c442]*/
+{
+ 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},
+ _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF
+ _ELEMENTTREE_TREEBUILDER_START_METHODDEF
+ _ELEMENTTREE_TREEBUILDER_END_METHODDEF
+ _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF
{NULL, NULL}
};
@@ -3209,6 +3880,11 @@
return (PyObject *)self;
}
+/*[clinic input]
+class _elementtree.XMLParser
+[clinic start generated code]*/
+/*[clinic end generated code:
checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+
static int
xmlparser_init(PyObject *self, PyObject *args, PyObject *kwds)
{
@@ -3369,15 +4045,39 @@
Py_RETURN_NONE;
}
-static PyObject*
-xmlparser_close(XMLParserObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.XMLParser.close
+
+ self: self(type='XMLParserObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser_close__doc__,
+"close()");
+
+#define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF \
+ {"close", (PyCFunction)_elementtree_XMLParser_close, METH_NOARGS,
_elementtree_XMLParser_close__doc__},
+
+static PyObject *
+_elementtree_XMLParser_close_impl(XMLParserObject *self);
+
+static PyObject *
+_elementtree_XMLParser_close(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_XMLParser_close_impl((XMLParserObject *)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_XMLParser_close_impl(XMLParserObject *self)
+/*[clinic end generated code:
checksum=e559a2ddc0d5eb10cd73b4af4eef751d3f266757]*/
{
/* end feeding data to parser */
PyObject* res;
- if (!PyArg_ParseTuple(args, ":close"))
- return NULL;
-
res = expat_parse(self, "", 0, 1);
if (!res)
return NULL;
@@ -3395,15 +4095,31 @@
}
}
-static PyObject*
-xmlparser_feed(XMLParserObject* self, PyObject* arg)
+/*[clinic input]
+_elementtree.XMLParser.feed
+
+ self: self(type='XMLParserObject *')
+ data: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__,
+"feed(data)");
+
+#define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF \
+ {"feed", (PyCFunction)_elementtree_XMLParser_feed, METH_O,
_elementtree_XMLParser_feed__doc__},
+
+static PyObject *
+_elementtree_XMLParser_feed(XMLParserObject *self, PyObject *data)
+/*[clinic end generated code:
checksum=4946fd63df292c934b8f4d4a4c4d1e5d46330d61]*/
{
/* 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);
- if (data == NULL)
+ const char *data_ptr = PyUnicode_AsUTF8AndSize(data, &data_len);
+ if (data_ptr == NULL)
return NULL;
if (data_len > INT_MAX) {
PyErr_SetString(PyExc_OverflowError, "size does not fit in an
int");
@@ -3411,12 +4127,12 @@
}
/* Explicitly set UTF-8 encoding. Return code ignored. */
(void)EXPAT(SetEncoding)(self->parser, "utf-8");
- return expat_parse(self, data, (int)data_len, 0);
+ return expat_parse(self, data_ptr, (int)data_len, 0);
}
else {
Py_buffer view;
PyObject *res;
- if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) < 0)
+ if (PyObject_GetBuffer(data, &view, PyBUF_SIMPLE) < 0)
return NULL;
if (view.len > INT_MAX) {
PyBuffer_Release(&view);
@@ -3429,8 +4145,24 @@
}
}
-static PyObject*
-xmlparser_parse_whole(XMLParserObject* self, PyObject* args)
+/*[clinic input]
+_elementtree.XMLParser._parse_whole
+
+ self: self(type='XMLParserObject *')
+ file: object
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__,
+"_parse_whole(file)");
+
+#define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF \
+ {"_parse_whole", (PyCFunction)_elementtree_XMLParser__parse_whole, METH_O,
_elementtree_XMLParser__parse_whole__doc__},
+
+static PyObject *
+_elementtree_XMLParser__parse_whole(XMLParserObject *self, PyObject *file)
+/*[clinic end generated code:
checksum=1de535f1ffda36f6063de9c643d867d05a7fabe4]*/
{
/* (internal) parse the whole input, until end of stream */
PyObject* reader;
@@ -3438,11 +4170,7 @@
PyObject* temp;
PyObject* res;
- PyObject* fileobj;
- if (!PyArg_ParseTuple(args, "O:_parse", &fileobj))
- return NULL;
-
- reader = PyObject_GetAttrString(fileobj, "read");
+ reader = PyObject_GetAttrString(file, "read");
if (!reader)
return NULL;
@@ -3503,25 +4231,83 @@
return res;
}
-static PyObject*
-xmlparser_doctype(XMLParserObject *self, PyObject *args)
+/*[clinic input]
+_elementtree.XMLParser.doctype
+
+ self: self(type='XMLParserObject *')
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser_doctype__doc__,
+"doctype()");
+
+#define _ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF \
+ {"doctype", (PyCFunction)_elementtree_XMLParser_doctype, METH_NOARGS,
_elementtree_XMLParser_doctype__doc__},
+
+static PyObject *
+_elementtree_XMLParser_doctype_impl(XMLParserObject *self);
+
+static PyObject *
+_elementtree_XMLParser_doctype(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ PyObject *return_value = NULL;
+
+ return_value = _elementtree_XMLParser_doctype_impl((XMLParserObject
*)self);
+
+ return return_value;
+}
+
+static PyObject *
+_elementtree_XMLParser_doctype_impl(XMLParserObject *self)
+/*[clinic end generated code:
checksum=a4be49db2c4827ccbee8f4511468d05d0dec0281]*/
{
Py_RETURN_NONE;
}
-static PyObject*
-xmlparser_setevents(XMLParserObject *self, PyObject* args)
+/*[clinic input]
+_elementtree.XMLParser._setevents
+
+ self: self(type='XMLParserObject *')
+ events_queue: object(subclass_of='&PyList_Type')
+ events_to_report: object = None
+ /
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
+"_setevents(events_queue, events_to_report=None)");
+
+#define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \
+ {"_setevents", (PyCFunction)_elementtree_XMLParser__setevents,
METH_VARARGS, _elementtree_XMLParser__setevents__doc__},
+
+static PyObject *
+_elementtree_XMLParser__setevents_impl(XMLParserObject *self, PyObject
*events_queue, PyObject *events_to_report);
+
+static PyObject *
+_elementtree_XMLParser__setevents(PyObject *self, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *events_queue;
+ PyObject *events_to_report = Py_None;
+
+ if (!PyArg_ParseTuple(args,
+ "O!|O:_setevents",
+ &PyList_Type, &events_queue, &events_to_report))
+ goto exit;
+ return_value = _elementtree_XMLParser__setevents_impl((XMLParserObject
*)self, events_queue, events_to_report);
+
+exit:
+ return return_value;
+}
+
+static PyObject *
+_elementtree_XMLParser__setevents_impl(XMLParserObject *self, PyObject
*events_queue, PyObject *events_to_report)
+/*[clinic end generated code:
checksum=fb035b7fbf8a08b852467eecd664d0058ce56344]*/
{
/* 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))
- return NULL;
if (!TreeBuilder_CheckExact(self->target)) {
PyErr_SetString(
@@ -3606,11 +4392,11 @@
}
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},
+ _ELEMENTTREE_XMLPARSER_FEED_METHODDEF
+ _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF
+ _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF
+ _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF
+ _ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF
{NULL, NULL}
};
_______________________________________________
Python-bugs-list mailing list
Unsubscribe:
https://mail.python.org/mailman/options/python-bugs-list/archive%40mail-archive.com
