traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

post _elementtree to multi-phase init

This commit is contained in:
Mohamed Koubaa 2020-11-27 19:34:26 -06:00
parent a26215db11
commit d5b1fb6ae9
3 changed files with 782 additions and 617 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Misc/NEWS.d/next/Core and Builtins/2020-11-27-19-33-46.bpo-1635741.dC6qv8.rst Normal file
View File

@ -0,0 +1,2 @@
Port the :mod:`_elementtree` extension module to multi-phase initialization
(:pep:`489`).

950
Modules/_elementtree.c
View File

File diff suppressed because it is too large Load Diff

447
Modules/clinic/_elementtree.c.h generated
View File

@ -8,23 +8,25 @@ PyDoc_STRVAR(_elementtree_Element_append__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_APPEND_METHODDEF \ #define _ELEMENTTREE_ELEMENT_APPEND_METHODDEF \
{"append", (PyCFunction)_elementtree_Element_append, METH_O, _elementtree_Element_append__doc__}, {"append", (PyCFunction)(void(*)(void))_elementtree_Element_append, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_append__doc__},
static PyObject * static PyObject *
_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement); _elementtree_Element_append_impl(ElementObject *self, PyTypeObject *cls,
PyObject *subelement);
static PyObject * 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; PyObject *return_value = NULL;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O!:append", _keywords, 0};
PyObject *subelement; PyObject *subelement;
if (!PyObject_TypeCheck(arg, &Element_Type)) { if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
_PyArg_BadArgument("append", "argument", (&Element_Type)->tp_name, arg); get_elementtree_module_state_by_object(self)->element_type, &subelement)) {
goto exit; goto exit;
} }
subelement = arg; return_value = _elementtree_Element_append_impl(self, cls, subelement);
return_value = _elementtree_Element_append_impl(self, subelement);
exit: exit:
return return_value; return return_value;
@ -53,15 +55,26 @@ PyDoc_STRVAR(_elementtree_Element___copy____doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT___COPY___METHODDEF \ #define _ELEMENTTREE_ELEMENT___COPY___METHODDEF \
{"__copy__", (PyCFunction)_elementtree_Element___copy__, METH_NOARGS, _elementtree_Element___copy____doc__}, {"__copy__", (PyCFunction)(void(*)(void))_elementtree_Element___copy__, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element___copy____doc__},
static PyObject * static PyObject *
_elementtree_Element___copy___impl(ElementObject *self); _elementtree_Element___copy___impl(ElementObject *self, PyTypeObject *cls);
static PyObject * 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); PyObject *return_value = NULL;
static const char * const _keywords[] = { NULL};
static _PyArg_Parser _parser = {":__copy__", _keywords, 0};
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser
)) {
goto exit;
}
return_value = _elementtree_Element___copy___impl(self, cls);
exit:
return return_value;
} }
PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__, PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__,
@ -70,23 +83,25 @@ PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF \ #define _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF \
{"__deepcopy__", (PyCFunction)_elementtree_Element___deepcopy__, METH_O, _elementtree_Element___deepcopy____doc__}, {"__deepcopy__", (PyCFunction)(void(*)(void))_elementtree_Element___deepcopy__, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element___deepcopy____doc__},
static PyObject * static PyObject *
_elementtree_Element___deepcopy___impl(ElementObject *self, PyObject *memo); _elementtree_Element___deepcopy___impl(ElementObject *self,
PyTypeObject *cls, PyObject *memo);
static PyObject * static PyObject *
_elementtree_Element___deepcopy__(ElementObject *self, PyObject *arg) _elementtree_Element___deepcopy__(ElementObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{ {
PyObject *return_value = NULL; PyObject *return_value = NULL;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O!:__deepcopy__", _keywords, 0};
PyObject *memo; PyObject *memo;
if (!PyDict_Check(arg)) { if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
_PyArg_BadArgument("__deepcopy__", "argument", "dict", arg); &PyDict_Type, &memo)) {
goto exit; goto exit;
} }
memo = arg; return_value = _elementtree_Element___deepcopy___impl(self, cls, memo);
return_value = _elementtree_Element___deepcopy___impl(self, memo);
exit: exit:
return return_value; return return_value;
@ -142,7 +157,29 @@ PyDoc_STRVAR(_elementtree_Element___setstate____doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF \ #define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF \
{"__setstate__", (PyCFunction)_elementtree_Element___setstate__, METH_O, _elementtree_Element___setstate____doc__}, {"__setstate__", (PyCFunction)(void(*)(void))_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;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O:__setstate__", _keywords, 0};
PyObject *state;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&state)) {
goto exit;
}
return_value = _elementtree_Element___setstate___impl(self, cls, state);
exit:
return return_value;
}
PyDoc_STRVAR(_elementtree_Element_extend__doc__, PyDoc_STRVAR(_elementtree_Element_extend__doc__,
"extend($self, elements, /)\n" "extend($self, elements, /)\n"
@ -150,7 +187,29 @@ PyDoc_STRVAR(_elementtree_Element_extend__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF \ #define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF \
{"extend", (PyCFunction)_elementtree_Element_extend, METH_O, _elementtree_Element_extend__doc__}, {"extend", (PyCFunction)(void(*)(void))_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;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O:extend", _keywords, 0};
PyObject *elements;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&elements)) {
goto exit;
}
return_value = _elementtree_Element_extend_impl(self, cls, elements);
exit:
return return_value;
}
PyDoc_STRVAR(_elementtree_Element_find__doc__, PyDoc_STRVAR(_elementtree_Element_find__doc__,
"find($self, /, path, namespaces=None)\n" "find($self, /, path, namespaces=None)\n"
@ -158,34 +217,26 @@ PyDoc_STRVAR(_elementtree_Element_find__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \ #define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \
{"find", (PyCFunction)(void(*)(void))_elementtree_Element_find, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__}, {"find", (PyCFunction)(void(*)(void))_elementtree_Element_find, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
static PyObject * static PyObject *
_elementtree_Element_find_impl(ElementObject *self, PyObject *path, _elementtree_Element_find_impl(ElementObject *self, PyTypeObject *cls,
PyObject *namespaces); PyObject *path, PyObject *namespaces);
static PyObject * 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; PyObject *return_value = NULL;
static const char * const _keywords[] = {"path", "namespaces", NULL}; static const char * const _keywords[] = {"path", "namespaces", NULL};
static _PyArg_Parser _parser = {NULL, _keywords, "find", 0}; static _PyArg_Parser _parser = {"O|O:find", _keywords, 0};
PyObject *argsbuf[2];
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
PyObject *path; PyObject *path;
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf); if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
if (!args) { &path, &namespaces)) {
goto exit; goto exit;
} }
path = args[0]; return_value = _elementtree_Element_find_impl(self, cls, path, namespaces);
if (!noptargs) {
goto skip_optional_pos;
}
namespaces = args[1];
skip_optional_pos:
return_value = _elementtree_Element_find_impl(self, path, namespaces);
exit: exit:
return return_value; return return_value;
@ -197,42 +248,28 @@ PyDoc_STRVAR(_elementtree_Element_findtext__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \ #define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \
{"findtext", (PyCFunction)(void(*)(void))_elementtree_Element_findtext, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__}, {"findtext", (PyCFunction)(void(*)(void))_elementtree_Element_findtext, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
static PyObject * static PyObject *
_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path, _elementtree_Element_findtext_impl(ElementObject *self, PyTypeObject *cls,
PyObject *default_value, PyObject *path, PyObject *default_value,
PyObject *namespaces); PyObject *namespaces);
static PyObject * 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; PyObject *return_value = NULL;
static const char * const _keywords[] = {"path", "default", "namespaces", NULL}; static const char * const _keywords[] = {"path", "default", "namespaces", NULL};
static _PyArg_Parser _parser = {NULL, _keywords, "findtext", 0}; static _PyArg_Parser _parser = {"O|OO:findtext", _keywords, 0};
PyObject *argsbuf[3];
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
PyObject *path; PyObject *path;
PyObject *default_value = Py_None; PyObject *default_value = Py_None;
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
if (!args) { &path, &default_value, &namespaces)) {
goto exit; goto exit;
} }
path = args[0]; return_value = _elementtree_Element_findtext_impl(self, cls, path, default_value, namespaces);
if (!noptargs) {
goto skip_optional_pos;
}
if (args[1]) {
default_value = args[1];
if (!--noptargs) {
goto skip_optional_pos;
}
}
namespaces = args[2];
skip_optional_pos:
return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces);
exit: exit:
return return_value; return return_value;
@ -244,34 +281,26 @@ PyDoc_STRVAR(_elementtree_Element_findall__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \ #define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \
{"findall", (PyCFunction)(void(*)(void))_elementtree_Element_findall, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__}, {"findall", (PyCFunction)(void(*)(void))_elementtree_Element_findall, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
static PyObject * static PyObject *
_elementtree_Element_findall_impl(ElementObject *self, PyObject *path, _elementtree_Element_findall_impl(ElementObject *self, PyTypeObject *cls,
PyObject *namespaces); PyObject *path, PyObject *namespaces);
static PyObject * 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; PyObject *return_value = NULL;
static const char * const _keywords[] = {"path", "namespaces", NULL}; static const char * const _keywords[] = {"path", "namespaces", NULL};
static _PyArg_Parser _parser = {NULL, _keywords, "findall", 0}; static _PyArg_Parser _parser = {"O|O:findall", _keywords, 0};
PyObject *argsbuf[2];
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
PyObject *path; PyObject *path;
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf); if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
if (!args) { &path, &namespaces)) {
goto exit; goto exit;
} }
path = args[0]; return_value = _elementtree_Element_findall_impl(self, cls, path, namespaces);
if (!noptargs) {
goto skip_optional_pos;
}
namespaces = args[1];
skip_optional_pos:
return_value = _elementtree_Element_findall_impl(self, path, namespaces);
exit: exit:
return return_value; return return_value;
@ -283,34 +312,26 @@ PyDoc_STRVAR(_elementtree_Element_iterfind__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \ #define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \
{"iterfind", (PyCFunction)(void(*)(void))_elementtree_Element_iterfind, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__}, {"iterfind", (PyCFunction)(void(*)(void))_elementtree_Element_iterfind, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
static PyObject * static PyObject *
_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path, _elementtree_Element_iterfind_impl(ElementObject *self, PyTypeObject *cls,
PyObject *namespaces); PyObject *path, PyObject *namespaces);
static PyObject * 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; PyObject *return_value = NULL;
static const char * const _keywords[] = {"path", "namespaces", NULL}; static const char * const _keywords[] = {"path", "namespaces", NULL};
static _PyArg_Parser _parser = {NULL, _keywords, "iterfind", 0}; static _PyArg_Parser _parser = {"O|O:iterfind", _keywords, 0};
PyObject *argsbuf[2];
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
PyObject *path; PyObject *path;
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf); if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
if (!args) { &path, &namespaces)) {
goto exit; goto exit;
} }
path = args[0]; return_value = _elementtree_Element_iterfind_impl(self, cls, path, namespaces);
if (!noptargs) {
goto skip_optional_pos;
}
namespaces = args[1];
skip_optional_pos:
return_value = _elementtree_Element_iterfind_impl(self, path, namespaces);
exit: exit:
return return_value; return return_value;
@ -361,31 +382,25 @@ PyDoc_STRVAR(_elementtree_Element_iter__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \ #define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \
{"iter", (PyCFunction)(void(*)(void))_elementtree_Element_iter, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__}, {"iter", (PyCFunction)(void(*)(void))_elementtree_Element_iter, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
static PyObject * static PyObject *
_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag); _elementtree_Element_iter_impl(ElementObject *self, PyTypeObject *cls,
PyObject *tag);
static PyObject * 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; PyObject *return_value = NULL;
static const char * const _keywords[] = {"tag", NULL}; static const char * const _keywords[] = {"tag", NULL};
static _PyArg_Parser _parser = {NULL, _keywords, "iter", 0}; static _PyArg_Parser _parser = {"|O:iter", _keywords, 0};
PyObject *argsbuf[1];
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
PyObject *tag = Py_None; PyObject *tag = Py_None;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
if (!args) { &tag)) {
goto exit; goto exit;
} }
if (!noptargs) { return_value = _elementtree_Element_iter_impl(self, cls, tag);
goto skip_optional_pos;
}
tag = args[0];
skip_optional_pos:
return_value = _elementtree_Element_iter_impl(self, tag);
exit: exit:
return return_value; return return_value;
@ -397,15 +412,26 @@ PyDoc_STRVAR(_elementtree_Element_itertext__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF \ #define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF \
{"itertext", (PyCFunction)_elementtree_Element_itertext, METH_NOARGS, _elementtree_Element_itertext__doc__}, {"itertext", (PyCFunction)(void(*)(void))_elementtree_Element_itertext, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_itertext__doc__},
static PyObject * static PyObject *
_elementtree_Element_itertext_impl(ElementObject *self); _elementtree_Element_itertext_impl(ElementObject *self, PyTypeObject *cls);
static PyObject * 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); PyObject *return_value = NULL;
static const char * const _keywords[] = { NULL};
static _PyArg_Parser _parser = {":itertext", _keywords, 0};
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser
)) {
goto exit;
}
return_value = _elementtree_Element_itertext_impl(self, cls);
exit:
return return_value;
} }
PyDoc_STRVAR(_elementtree_Element_insert__doc__, PyDoc_STRVAR(_elementtree_Element_insert__doc__,
@ -442,8 +468,8 @@ _elementtree_Element_insert(ElementObject *self, PyObject *const *args, Py_ssize
} }
index = ival; index = ival;
} }
if (!PyObject_TypeCheck(args[1], &Element_Type)) { if (!PyObject_TypeCheck(args[1], get_elementtree_module_state_by_object(self)->element_type)) {
_PyArg_BadArgument("insert", "argument 2", (&Element_Type)->tp_name, args[1]); _PyArg_BadArgument("insert", "argument 2", (get_elementtree_module_state_by_object(self)->element_type)->tp_name, args[1]);
goto exit; goto exit;
} }
subelement = args[1]; subelement = args[1];
@ -493,29 +519,26 @@ PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
"\n"); "\n");
#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \ #define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
{"makeelement", (PyCFunction)(void(*)(void))_elementtree_Element_makeelement, METH_FASTCALL, _elementtree_Element_makeelement__doc__}, {"makeelement", (PyCFunction)(void(*)(void))_elementtree_Element_makeelement, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_makeelement__doc__},
static PyObject * static PyObject *
_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag, _elementtree_Element_makeelement_impl(ElementObject *self, PyTypeObject *cls,
PyObject *attrib); PyObject *tag, PyObject *attrib);
static PyObject * 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; PyObject *return_value = NULL;
static const char * const _keywords[] = {"", "", NULL};
static _PyArg_Parser _parser = {"OO!:makeelement", _keywords, 0};
PyObject *tag; PyObject *tag;
PyObject *attrib; PyObject *attrib;
if (!_PyArg_CheckPositional("makeelement", nargs, 2, 2)) { if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&tag, &PyDict_Type, &attrib)) {
goto exit; goto exit;
} }
tag = args[0]; return_value = _elementtree_Element_makeelement_impl(self, cls, tag, attrib);
if (!PyDict_Check(args[1])) {
_PyArg_BadArgument("makeelement", "argument 2", "dict", args[1]);
goto exit;
}
attrib = args[1];
return_value = _elementtree_Element_makeelement_impl(self, tag, attrib);
exit: exit:
return return_value; return return_value;
@ -538,8 +561,8 @@ _elementtree_Element_remove(ElementObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *subelement; PyObject *subelement;
if (!PyObject_TypeCheck(arg, &Element_Type)) { if (!PyObject_TypeCheck(arg, get_elementtree_module_state_by_object(self)->element_type)) {
_PyArg_BadArgument("remove", "argument", (&Element_Type)->tp_name, arg); _PyArg_BadArgument("remove", "argument", (get_elementtree_module_state_by_object(self)->element_type)->tp_name, arg);
goto exit; goto exit;
} }
subelement = arg; subelement = arg;
@ -698,7 +721,29 @@ PyDoc_STRVAR(_elementtree_TreeBuilder_end__doc__,
"\n"); "\n");
#define _ELEMENTTREE_TREEBUILDER_END_METHODDEF \ #define _ELEMENTTREE_TREEBUILDER_END_METHODDEF \
{"end", (PyCFunction)_elementtree_TreeBuilder_end, METH_O, _elementtree_TreeBuilder_end__doc__}, {"end", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_end, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_TreeBuilder_end__doc__},
static PyObject *
_elementtree_TreeBuilder_end_impl(TreeBuilderObject *self, PyTypeObject *cls,
PyObject *tag);
static PyObject *
_elementtree_TreeBuilder_end(TreeBuilderObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O:end", _keywords, 0};
PyObject *tag;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&tag)) {
goto exit;
}
return_value = _elementtree_TreeBuilder_end_impl(self, cls, tag);
exit:
return return_value;
}
PyDoc_STRVAR(_elementtree_TreeBuilder_comment__doc__, PyDoc_STRVAR(_elementtree_TreeBuilder_comment__doc__,
"comment($self, text, /)\n" "comment($self, text, /)\n"
@ -706,7 +751,29 @@ PyDoc_STRVAR(_elementtree_TreeBuilder_comment__doc__,
"\n"); "\n");
#define _ELEMENTTREE_TREEBUILDER_COMMENT_METHODDEF \ #define _ELEMENTTREE_TREEBUILDER_COMMENT_METHODDEF \
{"comment", (PyCFunction)_elementtree_TreeBuilder_comment, METH_O, _elementtree_TreeBuilder_comment__doc__}, {"comment", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_comment, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_TreeBuilder_comment__doc__},
static PyObject *
_elementtree_TreeBuilder_comment_impl(TreeBuilderObject *self,
PyTypeObject *cls, PyObject *text);
static PyObject *
_elementtree_TreeBuilder_comment(TreeBuilderObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O:comment", _keywords, 0};
PyObject *text;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&text)) {
goto exit;
}
return_value = _elementtree_TreeBuilder_comment_impl(self, cls, text);
exit:
return return_value;
}
PyDoc_STRVAR(_elementtree_TreeBuilder_pi__doc__, PyDoc_STRVAR(_elementtree_TreeBuilder_pi__doc__,
"pi($self, target, text=None, /)\n" "pi($self, target, text=None, /)\n"
@ -714,29 +781,26 @@ PyDoc_STRVAR(_elementtree_TreeBuilder_pi__doc__,
"\n"); "\n");
#define _ELEMENTTREE_TREEBUILDER_PI_METHODDEF \ #define _ELEMENTTREE_TREEBUILDER_PI_METHODDEF \
{"pi", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_pi, METH_FASTCALL, _elementtree_TreeBuilder_pi__doc__}, {"pi", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_pi, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_TreeBuilder_pi__doc__},
static PyObject * static PyObject *
_elementtree_TreeBuilder_pi_impl(TreeBuilderObject *self, PyObject *target, _elementtree_TreeBuilder_pi_impl(TreeBuilderObject *self, PyTypeObject *cls,
PyObject *text); PyObject *target, PyObject *text);
static PyObject * static PyObject *
_elementtree_TreeBuilder_pi(TreeBuilderObject *self, PyObject *const *args, Py_ssize_t nargs) _elementtree_TreeBuilder_pi(TreeBuilderObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{ {
PyObject *return_value = NULL; PyObject *return_value = NULL;
static const char * const _keywords[] = {"", "", NULL};
static _PyArg_Parser _parser = {"O|O:pi", _keywords, 0};
PyObject *target; PyObject *target;
PyObject *text = Py_None; PyObject *text = Py_None;
if (!_PyArg_CheckPositional("pi", nargs, 1, 2)) { if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&target, &text)) {
goto exit; goto exit;
} }
target = args[0]; return_value = _elementtree_TreeBuilder_pi_impl(self, cls, target, text);
if (nargs < 2) {
goto skip_optional;
}
text = args[1];
skip_optional:
return_value = _elementtree_TreeBuilder_pi_impl(self, target, text);
exit: exit:
return return_value; return return_value;
@ -765,29 +829,27 @@ PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
"\n"); "\n");
#define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \ #define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \
{"start", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_start, METH_FASTCALL, _elementtree_TreeBuilder_start__doc__}, {"start", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_start, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_TreeBuilder_start__doc__},
static PyObject * static PyObject *
_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag, _elementtree_TreeBuilder_start_impl(TreeBuilderObject *self,
PyTypeObject *cls, PyObject *tag,
PyObject *attrs); PyObject *attrs);
static PyObject * static PyObject *
_elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject *const *args, Py_ssize_t nargs) _elementtree_TreeBuilder_start(TreeBuilderObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{ {
PyObject *return_value = NULL; PyObject *return_value = NULL;
static const char * const _keywords[] = {"", "", NULL};
static _PyArg_Parser _parser = {"OO!:start", _keywords, 0};
PyObject *tag; PyObject *tag;
PyObject *attrs; PyObject *attrs;
if (!_PyArg_CheckPositional("start", nargs, 2, 2)) { if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&tag, &PyDict_Type, &attrs)) {
goto exit; goto exit;
} }
tag = args[0]; return_value = _elementtree_TreeBuilder_start_impl(self, cls, tag, attrs);
if (!PyDict_Check(args[1])) {
_PyArg_BadArgument("start", "argument 2", "dict", args[1]);
goto exit;
}
attrs = args[1];
return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs);
exit: exit:
return return_value; return return_value;
@ -854,15 +916,26 @@ PyDoc_STRVAR(_elementtree_XMLParser_close__doc__,
"\n"); "\n");
#define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF \ #define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF \
{"close", (PyCFunction)_elementtree_XMLParser_close, METH_NOARGS, _elementtree_XMLParser_close__doc__}, {"close", (PyCFunction)(void(*)(void))_elementtree_XMLParser_close, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_XMLParser_close__doc__},
static PyObject * static PyObject *
_elementtree_XMLParser_close_impl(XMLParserObject *self); _elementtree_XMLParser_close_impl(XMLParserObject *self, PyTypeObject *cls);
static PyObject * static PyObject *
_elementtree_XMLParser_close(XMLParserObject *self, PyObject *Py_UNUSED(ignored)) _elementtree_XMLParser_close(XMLParserObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{ {
return _elementtree_XMLParser_close_impl(self); PyObject *return_value = NULL;
static const char * const _keywords[] = { NULL};
static _PyArg_Parser _parser = {":close", _keywords, 0};
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser
)) {
goto exit;
}
return_value = _elementtree_XMLParser_close_impl(self, cls);
exit:
return return_value;
} }
PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__, PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__,
@ -871,7 +944,29 @@ PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__,
"\n"); "\n");
#define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF \ #define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF \
{"feed", (PyCFunction)_elementtree_XMLParser_feed, METH_O, _elementtree_XMLParser_feed__doc__}, {"feed", (PyCFunction)(void(*)(void))_elementtree_XMLParser_feed, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_XMLParser_feed__doc__},
static PyObject *
_elementtree_XMLParser_feed_impl(XMLParserObject *self, PyTypeObject *cls,
PyObject *data);
static PyObject *
_elementtree_XMLParser_feed(XMLParserObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O:feed", _keywords, 0};
PyObject *data;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data)) {
goto exit;
}
return_value = _elementtree_XMLParser_feed_impl(self, cls, data);
exit:
return return_value;
}
PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__, PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__,
"_parse_whole($self, file, /)\n" "_parse_whole($self, file, /)\n"
@ -879,7 +974,29 @@ PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__,
"\n"); "\n");
#define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF \ #define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF \
{"_parse_whole", (PyCFunction)_elementtree_XMLParser__parse_whole, METH_O, _elementtree_XMLParser__parse_whole__doc__}, {"_parse_whole", (PyCFunction)(void(*)(void))_elementtree_XMLParser__parse_whole, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_XMLParser__parse_whole__doc__},
static PyObject *
_elementtree_XMLParser__parse_whole_impl(XMLParserObject *self,
PyTypeObject *cls, PyObject *file);
static PyObject *
_elementtree_XMLParser__parse_whole(XMLParserObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"", NULL};
static _PyArg_Parser _parser = {"O:_parse_whole", _keywords, 0};
PyObject *file;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&file)) {
goto exit;
}
return_value = _elementtree_XMLParser__parse_whole_impl(self, cls, file);
exit:
return return_value;
}
PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__, PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
"_setevents($self, events_queue, events_to_report=None, /)\n" "_setevents($self, events_queue, events_to_report=None, /)\n"
@ -887,32 +1004,30 @@ PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
"\n"); "\n");
#define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \ #define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \
{"_setevents", (PyCFunction)(void(*)(void))_elementtree_XMLParser__setevents, METH_FASTCALL, _elementtree_XMLParser__setevents__doc__}, {"_setevents", (PyCFunction)(void(*)(void))_elementtree_XMLParser__setevents, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _elementtree_XMLParser__setevents__doc__},
static PyObject * static PyObject *
_elementtree_XMLParser__setevents_impl(XMLParserObject *self, _elementtree_XMLParser__setevents_impl(XMLParserObject *self,
PyTypeObject *cls,
PyObject *events_queue, PyObject *events_queue,
PyObject *events_to_report); PyObject *events_to_report);
static PyObject * static PyObject *
_elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *const *args, Py_ssize_t nargs) _elementtree_XMLParser__setevents(XMLParserObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{ {
PyObject *return_value = NULL; PyObject *return_value = NULL;
static const char * const _keywords[] = {"", "", NULL};
static _PyArg_Parser _parser = {"O|O:_setevents", _keywords, 0};
PyObject *events_queue; PyObject *events_queue;
PyObject *events_to_report = Py_None; PyObject *events_to_report = Py_None;
if (!_PyArg_CheckPositional("_setevents", nargs, 1, 2)) { if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&events_queue, &events_to_report)) {
goto exit; goto exit;
} }
events_queue = args[0]; return_value = _elementtree_XMLParser__setevents_impl(self, cls, events_queue, events_to_report);
if (nargs < 2) {
goto skip_optional;
}
events_to_report = args[1];
skip_optional:
return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=1385b5e5688f3614 input=a9049054013a1b77]*/ /*[clinic end generated code: output=ddff23d35b4c446f input=a9049054013a1b77]*/