return (elementtreestate *)state;
}
-/* Find the module instance imported in the currently running sub-interpreter
- * and get its state.
- */
-#define ET_STATE_GLOBAL \
- ((elementtreestate *) PyModule_GetState(PyState_FindModule(&elementtreemodule)))
+static inline elementtreestate *
+get_elementtree_state_by_cls(PyTypeObject *cls)
+{
+ void *state = PyType_GetModuleState(cls);
+ assert(state != NULL);
+ return (elementtreestate *)state;
+}
+
+static inline elementtreestate *
+get_elementtree_state_by_type(PyTypeObject *tp)
+{
+ PyObject *mod = PyType_GetModuleByDef(tp, &elementtreemodule);
+ assert(mod != NULL);
+ return get_elementtree_state(mod);
+}
static int
elementtree_clear(PyObject *m)
{
PyObject* elem;
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state(self);
ElementObject* parent;
PyObject* tag;
PyObject* attrib = NULL;
/*[clinic input]
_elementtree.Element.append
+ cls: defining_class
subelement: object(subclass_of='clinic_state()->Element_Type')
/
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement)
-/*[clinic end generated code: output=54a884b7cf2295f4 input=439f2bd777288fb6]*/
+_elementtree_Element_append_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *subelement)
+/*[clinic end generated code: output=d00923711ea317fc input=8baf92679f9717b8]*/
{
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
if (element_add_subelement(st, self, subelement) < 0)
return NULL;
/*[clinic input]
_elementtree.Element.__copy__
+ cls: defining_class
+ /
+
[clinic start generated code]*/
static PyObject *
-_elementtree_Element___copy___impl(ElementObject *self)
-/*[clinic end generated code: output=2c701ebff7247781 input=ad87aaebe95675bf]*/
+_elementtree_Element___copy___impl(ElementObject *self, PyTypeObject *cls)
+/*[clinic end generated code: output=da22894421ff2b36 input=91edb92d9f441213]*/
{
Py_ssize_t i;
ElementObject* element;
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
element = (ElementObject*) create_new_element(
st, self->tag, self->extra ? self->extra->attrib : NULL);
PyObject* tail;
PyObject* id;
- elementtreestate *st = ET_STATE_GLOBAL;
+ PyTypeObject *tp = Py_TYPE(self);
+ elementtreestate *st = get_elementtree_state_by_type(tp);
tag = deepcopy(st, self->tag, memo);
if (!tag)
return NULL;
/*[clinic input]
_elementtree.Element.__setstate__
+ cls: defining_class
state: object
/
[clinic start generated code]*/
static PyObject *
-_elementtree_Element___setstate__(ElementObject *self, PyObject *state)
-/*[clinic end generated code: output=ea28bf3491b1f75e input=aaf80abea7c1e3b9]*/
+_elementtree_Element___setstate___impl(ElementObject *self,
+ PyTypeObject *cls, PyObject *state)
+/*[clinic end generated code: output=598bfb5730f71509 input=13830488d35d51f7]*/
{
if (!PyDict_CheckExact(state)) {
PyErr_Format(PyExc_TypeError,
return NULL;
}
else {
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
return element_setstate_from_Python(st, self, state);
}
}
/*[clinic input]
_elementtree.Element.extend
+ cls: defining_class
elements: object
/
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_extend(ElementObject *self, PyObject *elements)
-/*[clinic end generated code: output=f6e67fc2ff529191 input=807bc4f31c69f7c0]*/
+_elementtree_Element_extend_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *elements)
+/*[clinic end generated code: output=3e86d37fac542216 input=6479b1b5379d09ae]*/
{
PyObject* seq;
Py_ssize_t i;
return NULL;
}
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
for (i = 0; i < PySequence_Fast_GET_SIZE(seq); i++) {
PyObject* element = Py_NewRef(PySequence_Fast_GET_ITEM(seq, i));
if (element_add_subelement(st, self, element) < 0) {
/*[clinic input]
_elementtree.Element.find
+ cls: defining_class
+ /
path: object
namespaces: object = None
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_find_impl(ElementObject *self, PyObject *path,
- PyObject *namespaces)
-/*[clinic end generated code: output=41b43f0f0becafae input=359b6985f6489d2e]*/
+_elementtree_Element_find_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *namespaces)
+/*[clinic end generated code: output=18f77d393c9fef1b input=94df8a83f956acc6]*/
{
Py_ssize_t i;
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
if (checkpath(path) || namespaces != Py_None) {
return PyObject_CallMethodObjArgs(
/*[clinic input]
_elementtree.Element.findtext
+ cls: defining_class
+ /
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,
+_elementtree_Element_findtext_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *default_value,
PyObject *namespaces)
-/*[clinic end generated code: output=83b3ba4535d308d2 input=b53a85aa5aa2a916]*/
+/*[clinic end generated code: output=6af7a2d96aac32cb input=32f252099f62a3d2]*/
{
Py_ssize_t i;
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
if (checkpath(path) || namespaces != Py_None)
return PyObject_CallMethodObjArgs(
/*[clinic input]
_elementtree.Element.findall
+ cls: defining_class
+ /
path: object
namespaces: object = None
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
- PyObject *namespaces)
-/*[clinic end generated code: output=1a0bd9f5541b711d input=4d9e6505a638550c]*/
+_elementtree_Element_findall_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *namespaces)
+/*[clinic end generated code: output=65e39a1208f3b59e input=7aa0db45673fc9a5]*/
{
Py_ssize_t i;
PyObject* out;
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
if (checkpath(path) || namespaces != Py_None) {
return PyObject_CallMethodObjArgs(
/*[clinic input]
_elementtree.Element.iterfind
+ cls: defining_class
+ /
path: object
namespaces: object = None
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
- PyObject *namespaces)
-/*[clinic end generated code: output=ecdd56d63b19d40f input=abb974e350fb65c7]*/
+_elementtree_Element_iterfind_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *namespaces)
+/*[clinic end generated code: output=be5c3f697a14e676 input=88766875a5c9a88b]*/
{
PyObject* tag = path;
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
return PyObject_CallMethodObjArgs(
st->elementpath_obj, st->str_iterfind, self, tag, namespaces, NULL);
/*[clinic input]
_elementtree.Element.iter
+ cls: defining_class
+ /
tag: object = None
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag)
-/*[clinic end generated code: output=3f49f9a862941cc5 input=774d5b12e573aedd]*/
+_elementtree_Element_iter_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *tag)
+/*[clinic end generated code: output=bff29dc5d4566c68 input=f6944c48d3f84c58]*/
{
if (PyUnicode_Check(tag)) {
if (PyUnicode_READY(tag) < 0)
tag = Py_None;
}
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
return create_elementiter(st, self, tag, 0);
}
/*[clinic input]
_elementtree.Element.itertext
+ cls: defining_class
+ /
+
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_itertext_impl(ElementObject *self)
-/*[clinic end generated code: output=5fa34b2fbcb65df6 input=af8f0e42cb239c89]*/
+_elementtree_Element_itertext_impl(ElementObject *self, PyTypeObject *cls)
+/*[clinic end generated code: output=fdeb2a3bca0ae063 input=a1ef1f0fc872a586]*/
{
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
return create_elementiter(st, self, Py_None, 1);
}
/*[clinic input]
_elementtree.Element.makeelement
+ cls: defining_class
tag: object
attrib: object(subclass_of='&PyDict_Type')
/
[clinic start generated code]*/
static PyObject *
-_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
- PyObject *attrib)
-/*[clinic end generated code: output=4109832d5bb789ef input=2279d974529c3861]*/
+_elementtree_Element_makeelement_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *tag, PyObject *attrib)
+/*[clinic end generated code: output=d50bb17a47077d47 input=589829dab92f26e8]*/
{
PyObject* elem;
if (!attrib)
return NULL;
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state_by_cls(cls);
elem = create_new_element(st, tag, attrib);
Py_DECREF(attrib);
old = self->extra->children[index];
if (item) {
- elementtreestate *st = ET_STATE_GLOBAL;
+ PyTypeObject *tp = Py_TYPE(self);
+ elementtreestate *st = get_elementtree_state_by_type(tp);
if (!Element_Check(st, item)) {
raise_type_error(item);
return -1;
}
}
- elementtreestate *st = ET_STATE_GLOBAL;
+ PyTypeObject *tp = Py_TYPE(self);
+ elementtreestate *st = get_elementtree_state_by_type(tp);
for (i = 0; i < newlen; i++) {
PyObject *element = PySequence_Fast_GET_ITEM(seq, i);
if (!Element_Check(st, element)) {
}
#ifndef NDEBUG
- elementtreestate *st = ET_STATE_GLOBAL;
+ PyTypeObject *tp = Py_TYPE(it);
+ elementtreestate *st = get_elementtree_state_by_type(tp);
assert(Element_Check(st, extra->children[child_index]));
#endif
elem = (ElementObject *)Py_NewRef(extra->children[child_index]);
t->start_ns_event_obj = t->end_ns_event_obj = NULL;
t->comment_event_obj = t->pi_event_obj = NULL;
t->insert_comments = t->insert_pis = 0;
- t->state = ET_STATE_GLOBAL;
+ t->state = get_elementtree_state_by_type(type);
}
return (PyObject *)t;
}
PyObject *pi_factory)
/*[clinic end generated code: output=813b408adee26535 input=99d17627aea7fb3b]*/
{
- elementtreestate *st = ET_STATE_GLOBAL;
+ elementtreestate *st = get_elementtree_state(module);
PyObject *old;
if (!PyCallable_Check(comment_factory) && comment_factory != Py_None) {
self->handle_start = self->handle_data = self->handle_end = NULL;
self->handle_comment = self->handle_pi = self->handle_close = NULL;
self->handle_doctype = NULL;
- self->state = ET_STATE_GLOBAL;
+ self->state = get_elementtree_state_by_type(type);
}
return (PyObject *)self;
}
{NULL},
};
-#define clinic_state() (ET_STATE_GLOBAL)
+#define clinic_state() (get_elementtree_state_by_type(Py_TYPE(self)))
#include "clinic/_elementtree.c.h"
#undef clinic_state
{NULL, NULL}
};
-
-static struct PyModuleDef elementtreemodule = {
- PyModuleDef_HEAD_INIT,
- "_elementtree",
- NULL,
- sizeof(elementtreestate),
- _functions,
- NULL,
- elementtree_traverse,
- elementtree_clear,
- elementtree_free
-};
-
#define CREATE_TYPE(module, type, spec) \
do { \
if (type != NULL) { \
} \
} while (0)
-PyMODINIT_FUNC
-PyInit__elementtree(void)
+static int
+module_exec(PyObject *m)
{
- PyObject *m = NULL;
- elementtreestate *st = NULL;
-
- m = PyState_FindModule(&elementtreemodule);
- if (m) {
- return Py_NewRef(m);
- }
-
- m = PyModule_Create(&elementtreemodule);
- if (!m)
- goto error;
- st = get_elementtree_state(m);
+ elementtreestate *st = get_elementtree_state(m);
/* Initialize object types */
CREATE_TYPE(m, st->ElementIter_Type, &elementiter_spec);
}
}
- return m;
+ return 0;
error:
- Py_XDECREF(m);
- return NULL;
+ return -1;
+}
+
+static struct PyModuleDef_Slot elementtree_slots[] = {
+ {Py_mod_exec, module_exec},
+ {0, NULL},
+};
+
+static struct PyModuleDef elementtreemodule = {
+ .m_base = PyModuleDef_HEAD_INIT,
+ .m_name = "_elementtree",
+ .m_size = sizeof(elementtreestate),
+ .m_methods = _functions,
+ .m_slots = elementtree_slots,
+ .m_traverse = elementtree_traverse,
+ .m_clear = elementtree_clear,
+ .m_free = elementtree_free,
+};
+
+PyMODINIT_FUNC
+PyInit__elementtree(void)
+{
+ return PyModuleDef_Init(&elementtreemodule);
}
"\n");
#define _ELEMENTTREE_ELEMENT_APPEND_METHODDEF \
- {"append", (PyCFunction)_elementtree_Element_append, METH_O, _elementtree_Element_append__doc__},
+ {"append", _PyCFunction_CAST(_elementtree_Element_append), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_append__doc__},
static PyObject *
-_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement);
+_elementtree_Element_append_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *subelement);
static PyObject *
-_elementtree_Element_append(ElementObject *self, PyObject *arg)
+_elementtree_Element_append(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "append",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[1];
PyObject *subelement;
- if (!PyObject_TypeCheck(arg, clinic_state()->Element_Type)) {
- _PyArg_BadArgument("append", "argument", (clinic_state()->Element_Type)->tp_name, arg);
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ if (!args) {
goto exit;
}
- subelement = arg;
- return_value = _elementtree_Element_append_impl(self, subelement);
+ if (!PyObject_TypeCheck(args[0], clinic_state()->Element_Type)) {
+ _PyArg_BadArgument("append", "argument 1", (clinic_state()->Element_Type)->tp_name, args[0]);
+ goto exit;
+ }
+ subelement = args[0];
+ return_value = _elementtree_Element_append_impl(self, cls, subelement);
exit:
return return_value;
"\n");
#define _ELEMENTTREE_ELEMENT___COPY___METHODDEF \
- {"__copy__", (PyCFunction)_elementtree_Element___copy__, METH_NOARGS, _elementtree_Element___copy____doc__},
+ {"__copy__", _PyCFunction_CAST(_elementtree_Element___copy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element___copy____doc__},
static PyObject *
-_elementtree_Element___copy___impl(ElementObject *self);
+_elementtree_Element___copy___impl(ElementObject *self, PyTypeObject *cls);
static PyObject *
-_elementtree_Element___copy__(ElementObject *self, PyObject *Py_UNUSED(ignored))
+_elementtree_Element___copy__(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
- return _elementtree_Element___copy___impl(self);
+ if (nargs) {
+ PyErr_SetString(PyExc_TypeError, "__copy__() takes no arguments");
+ return NULL;
+ }
+ return _elementtree_Element___copy___impl(self, cls);
}
PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__,
"\n");
#define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF \
- {"__setstate__", (PyCFunction)_elementtree_Element___setstate__, METH_O, _elementtree_Element___setstate____doc__},
+ {"__setstate__", _PyCFunction_CAST(_elementtree_Element___setstate__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element___setstate____doc__},
+
+static PyObject *
+_elementtree_Element___setstate___impl(ElementObject *self,
+ PyTypeObject *cls, PyObject *state);
+
+static PyObject *
+_elementtree_Element___setstate__(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "__setstate__",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[1];
+ PyObject *state;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ state = args[0];
+ return_value = _elementtree_Element___setstate___impl(self, cls, state);
+
+exit:
+ return return_value;
+}
PyDoc_STRVAR(_elementtree_Element_extend__doc__,
"extend($self, elements, /)\n"
"\n");
#define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF \
- {"extend", (PyCFunction)_elementtree_Element_extend, METH_O, _elementtree_Element_extend__doc__},
+ {"extend", _PyCFunction_CAST(_elementtree_Element_extend), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_extend__doc__},
+
+static PyObject *
+_elementtree_Element_extend_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *elements);
+
+static PyObject *
+_elementtree_Element_extend(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "extend",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[1];
+ PyObject *elements;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ elements = args[0];
+ return_value = _elementtree_Element_extend_impl(self, cls, elements);
+
+exit:
+ return return_value;
+}
PyDoc_STRVAR(_elementtree_Element_find__doc__,
"find($self, /, path, namespaces=None)\n"
"\n");
#define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \
- {"find", _PyCFunction_CAST(_elementtree_Element_find), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
+ {"find", _PyCFunction_CAST(_elementtree_Element_find), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
static PyObject *
-_elementtree_Element_find_impl(ElementObject *self, PyObject *path,
- PyObject *namespaces);
+_elementtree_Element_find_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *namespaces);
static PyObject *
-_elementtree_Element_find(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_elementtree_Element_find(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
}
namespaces = args[1];
skip_optional_pos:
- return_value = _elementtree_Element_find_impl(self, path, namespaces);
+ return_value = _elementtree_Element_find_impl(self, cls, path, namespaces);
exit:
return return_value;
"\n");
#define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \
- {"findtext", _PyCFunction_CAST(_elementtree_Element_findtext), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
+ {"findtext", _PyCFunction_CAST(_elementtree_Element_findtext), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
static PyObject *
-_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,
- PyObject *default_value,
+_elementtree_Element_findtext_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *default_value,
PyObject *namespaces);
static PyObject *
-_elementtree_Element_findtext(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_elementtree_Element_findtext(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
}
namespaces = args[2];
skip_optional_pos:
- return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces);
+ return_value = _elementtree_Element_findtext_impl(self, cls, path, default_value, namespaces);
exit:
return return_value;
"\n");
#define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \
- {"findall", _PyCFunction_CAST(_elementtree_Element_findall), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
+ {"findall", _PyCFunction_CAST(_elementtree_Element_findall), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
static PyObject *
-_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
- PyObject *namespaces);
+_elementtree_Element_findall_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *namespaces);
static PyObject *
-_elementtree_Element_findall(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_elementtree_Element_findall(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
}
namespaces = args[1];
skip_optional_pos:
- return_value = _elementtree_Element_findall_impl(self, path, namespaces);
+ return_value = _elementtree_Element_findall_impl(self, cls, path, namespaces);
exit:
return return_value;
"\n");
#define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \
- {"iterfind", _PyCFunction_CAST(_elementtree_Element_iterfind), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
+ {"iterfind", _PyCFunction_CAST(_elementtree_Element_iterfind), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
static PyObject *
-_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
- PyObject *namespaces);
+_elementtree_Element_iterfind_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *path, PyObject *namespaces);
static PyObject *
-_elementtree_Element_iterfind(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_elementtree_Element_iterfind(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
}
namespaces = args[1];
skip_optional_pos:
- return_value = _elementtree_Element_iterfind_impl(self, path, namespaces);
+ return_value = _elementtree_Element_iterfind_impl(self, cls, path, namespaces);
exit:
return return_value;
"\n");
#define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \
- {"iter", _PyCFunction_CAST(_elementtree_Element_iter), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
+ {"iter", _PyCFunction_CAST(_elementtree_Element_iter), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
static PyObject *
-_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag);
+_elementtree_Element_iter_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *tag);
static PyObject *
-_elementtree_Element_iter(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+_elementtree_Element_iter(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
}
tag = args[0];
skip_optional_pos:
- return_value = _elementtree_Element_iter_impl(self, tag);
+ return_value = _elementtree_Element_iter_impl(self, cls, tag);
exit:
return return_value;
"\n");
#define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF \
- {"itertext", (PyCFunction)_elementtree_Element_itertext, METH_NOARGS, _elementtree_Element_itertext__doc__},
+ {"itertext", _PyCFunction_CAST(_elementtree_Element_itertext), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_itertext__doc__},
static PyObject *
-_elementtree_Element_itertext_impl(ElementObject *self);
+_elementtree_Element_itertext_impl(ElementObject *self, PyTypeObject *cls);
static PyObject *
-_elementtree_Element_itertext(ElementObject *self, PyObject *Py_UNUSED(ignored))
+_elementtree_Element_itertext(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
- return _elementtree_Element_itertext_impl(self);
+ if (nargs) {
+ PyErr_SetString(PyExc_TypeError, "itertext() takes no arguments");
+ return NULL;
+ }
+ return _elementtree_Element_itertext_impl(self, cls);
}
PyDoc_STRVAR(_elementtree_Element_insert__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
- {"makeelement", _PyCFunction_CAST(_elementtree_Element_makeelement), METH_FASTCALL, _elementtree_Element_makeelement__doc__},
+ {"makeelement", _PyCFunction_CAST(_elementtree_Element_makeelement), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_makeelement__doc__},
static PyObject *
-_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
- PyObject *attrib);
+_elementtree_Element_makeelement_impl(ElementObject *self, PyTypeObject *cls,
+ PyObject *tag, PyObject *attrib);
static PyObject *
-_elementtree_Element_makeelement(ElementObject *self, PyObject *const *args, Py_ssize_t nargs)
+_elementtree_Element_makeelement(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", "", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "makeelement",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[2];
PyObject *tag;
PyObject *attrib;
- if (!_PyArg_CheckPositional("makeelement", nargs, 2, 2)) {
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ if (!args) {
goto exit;
}
tag = args[0];
goto exit;
}
attrib = args[1];
- return_value = _elementtree_Element_makeelement_impl(self, tag, attrib);
+ return_value = _elementtree_Element_makeelement_impl(self, cls, tag, attrib);
exit:
return return_value;
exit:
return return_value;
}
-/*[clinic end generated code: output=d380adb43d8f4a62 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=40767b1a98e54b60 input=a9049054013a1b77]*/
projects / thirdparty / Python / cpython.git / commitdiff
