Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(_elementtree_Element_append__doc__,
6 : : "append($self, subelement, /)\n"
7 : : "--\n"
8 : : "\n");
9 : :
10 : : #define _ELEMENTTREE_ELEMENT_APPEND_METHODDEF \
11 : : {"append", (PyCFunction)_elementtree_Element_append, METH_O, _elementtree_Element_append__doc__},
12 : :
13 : : static PyObject *
14 : : _elementtree_Element_append_impl(ElementObject *self, PyObject *subelement);
15 : :
16 : : static PyObject *
17 : 39 : _elementtree_Element_append(ElementObject *self, PyObject *arg)
18 : : {
19 : 39 : PyObject *return_value = NULL;
20 : : PyObject *subelement;
21 : :
22 [ + + ]: 39 : if (!PyObject_TypeCheck(arg, &Element_Type)) {
23 : 1 : _PyArg_BadArgument("append", "argument", (&Element_Type)->tp_name, arg);
24 : 1 : goto exit;
25 : : }
26 : 38 : subelement = arg;
27 : 38 : return_value = _elementtree_Element_append_impl(self, subelement);
28 : :
29 : 39 : exit:
30 : 39 : return return_value;
31 : : }
32 : :
33 : : PyDoc_STRVAR(_elementtree_Element_clear__doc__,
34 : : "clear($self, /)\n"
35 : : "--\n"
36 : : "\n");
37 : :
38 : : #define _ELEMENTTREE_ELEMENT_CLEAR_METHODDEF \
39 : : {"clear", (PyCFunction)_elementtree_Element_clear, METH_NOARGS, _elementtree_Element_clear__doc__},
40 : :
41 : : static PyObject *
42 : : _elementtree_Element_clear_impl(ElementObject *self);
43 : :
44 : : static PyObject *
45 : 20 : _elementtree_Element_clear(ElementObject *self, PyObject *Py_UNUSED(ignored))
46 : : {
47 : 20 : return _elementtree_Element_clear_impl(self);
48 : : }
49 : :
50 : : PyDoc_STRVAR(_elementtree_Element___copy____doc__,
51 : : "__copy__($self, /)\n"
52 : : "--\n"
53 : : "\n");
54 : :
55 : : #define _ELEMENTTREE_ELEMENT___COPY___METHODDEF \
56 : : {"__copy__", (PyCFunction)_elementtree_Element___copy__, METH_NOARGS, _elementtree_Element___copy____doc__},
57 : :
58 : : static PyObject *
59 : : _elementtree_Element___copy___impl(ElementObject *self);
60 : :
61 : : static PyObject *
62 : 24 : _elementtree_Element___copy__(ElementObject *self, PyObject *Py_UNUSED(ignored))
63 : : {
64 : 24 : return _elementtree_Element___copy___impl(self);
65 : : }
66 : :
67 : : PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__,
68 : : "__deepcopy__($self, memo, /)\n"
69 : : "--\n"
70 : : "\n");
71 : :
72 : : #define _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF \
73 : : {"__deepcopy__", (PyCFunction)_elementtree_Element___deepcopy__, METH_O, _elementtree_Element___deepcopy____doc__},
74 : :
75 : : static PyObject *
76 : : _elementtree_Element___deepcopy___impl(ElementObject *self, PyObject *memo);
77 : :
78 : : static PyObject *
79 : 4 : _elementtree_Element___deepcopy__(ElementObject *self, PyObject *arg)
80 : : {
81 : 4 : PyObject *return_value = NULL;
82 : : PyObject *memo;
83 : :
84 [ - + ]: 4 : if (!PyDict_Check(arg)) {
85 : 0 : _PyArg_BadArgument("__deepcopy__", "argument", "dict", arg);
86 : 0 : goto exit;
87 : : }
88 : 4 : memo = arg;
89 : 4 : return_value = _elementtree_Element___deepcopy___impl(self, memo);
90 : :
91 : 4 : exit:
92 : 4 : return return_value;
93 : : }
94 : :
95 : : PyDoc_STRVAR(_elementtree_Element___sizeof____doc__,
96 : : "__sizeof__($self, /)\n"
97 : : "--\n"
98 : : "\n");
99 : :
100 : : #define _ELEMENTTREE_ELEMENT___SIZEOF___METHODDEF \
101 : : {"__sizeof__", (PyCFunction)_elementtree_Element___sizeof__, METH_NOARGS, _elementtree_Element___sizeof____doc__},
102 : :
103 : : static Py_ssize_t
104 : : _elementtree_Element___sizeof___impl(ElementObject *self);
105 : :
106 : : static PyObject *
107 : 3 : _elementtree_Element___sizeof__(ElementObject *self, PyObject *Py_UNUSED(ignored))
108 : : {
109 : 3 : PyObject *return_value = NULL;
110 : : Py_ssize_t _return_value;
111 : :
112 : 3 : _return_value = _elementtree_Element___sizeof___impl(self);
113 [ - + - - ]: 3 : if ((_return_value == -1) && PyErr_Occurred()) {
114 : 0 : goto exit;
115 : : }
116 : 3 : return_value = PyLong_FromSsize_t(_return_value);
117 : :
118 : 3 : exit:
119 : 3 : return return_value;
120 : : }
121 : :
122 : : PyDoc_STRVAR(_elementtree_Element___getstate____doc__,
123 : : "__getstate__($self, /)\n"
124 : : "--\n"
125 : : "\n");
126 : :
127 : : #define _ELEMENTTREE_ELEMENT___GETSTATE___METHODDEF \
128 : : {"__getstate__", (PyCFunction)_elementtree_Element___getstate__, METH_NOARGS, _elementtree_Element___getstate____doc__},
129 : :
130 : : static PyObject *
131 : : _elementtree_Element___getstate___impl(ElementObject *self);
132 : :
133 : : static PyObject *
134 : 56 : _elementtree_Element___getstate__(ElementObject *self, PyObject *Py_UNUSED(ignored))
135 : : {
136 : 56 : return _elementtree_Element___getstate___impl(self);
137 : : }
138 : :
139 : : PyDoc_STRVAR(_elementtree_Element___setstate____doc__,
140 : : "__setstate__($self, state, /)\n"
141 : : "--\n"
142 : : "\n");
143 : :
144 : : #define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF \
145 : : {"__setstate__", (PyCFunction)_elementtree_Element___setstate__, METH_O, _elementtree_Element___setstate____doc__},
146 : :
147 : : PyDoc_STRVAR(_elementtree_Element_extend__doc__,
148 : : "extend($self, elements, /)\n"
149 : : "--\n"
150 : : "\n");
151 : :
152 : : #define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF \
153 : : {"extend", (PyCFunction)_elementtree_Element_extend, METH_O, _elementtree_Element_extend__doc__},
154 : :
155 : : PyDoc_STRVAR(_elementtree_Element_find__doc__,
156 : : "find($self, /, path, namespaces=None)\n"
157 : : "--\n"
158 : : "\n");
159 : :
160 : : #define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \
161 : : {"find", _PyCFunction_CAST(_elementtree_Element_find), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
162 : :
163 : : static PyObject *
164 : : _elementtree_Element_find_impl(ElementObject *self, PyObject *path,
165 : : PyObject *namespaces);
166 : :
167 : : static PyObject *
168 : 674 : _elementtree_Element_find(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
169 : : {
170 : 674 : PyObject *return_value = NULL;
171 : : static const char * const _keywords[] = {"path", "namespaces", NULL};
172 : : static _PyArg_Parser _parser = {NULL, _keywords, "find", 0};
173 : : PyObject *argsbuf[2];
174 [ + + ]: 674 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
175 : : PyObject *path;
176 : 674 : PyObject *namespaces = Py_None;
177 : :
178 [ + + + - : 674 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
179 [ - + ]: 674 : if (!args) {
180 : 0 : goto exit;
181 : : }
182 : 674 : path = args[0];
183 [ + + ]: 674 : if (!noptargs) {
184 : 27 : goto skip_optional_pos;
185 : : }
186 : 647 : namespaces = args[1];
187 : 674 : skip_optional_pos:
188 : 674 : return_value = _elementtree_Element_find_impl(self, path, namespaces);
189 : :
190 : 674 : exit:
191 : 674 : return return_value;
192 : : }
193 : :
194 : : PyDoc_STRVAR(_elementtree_Element_findtext__doc__,
195 : : "findtext($self, /, path, default=None, namespaces=None)\n"
196 : : "--\n"
197 : : "\n");
198 : :
199 : : #define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \
200 : : {"findtext", _PyCFunction_CAST(_elementtree_Element_findtext), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
201 : :
202 : : static PyObject *
203 : : _elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,
204 : : PyObject *default_value,
205 : : PyObject *namespaces);
206 : :
207 : : static PyObject *
208 : 15 : _elementtree_Element_findtext(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
209 : : {
210 : 15 : PyObject *return_value = NULL;
211 : : static const char * const _keywords[] = {"path", "default", "namespaces", NULL};
212 : : static _PyArg_Parser _parser = {NULL, _keywords, "findtext", 0};
213 : : PyObject *argsbuf[3];
214 [ + + ]: 15 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
215 : : PyObject *path;
216 : 15 : PyObject *default_value = Py_None;
217 : 15 : PyObject *namespaces = Py_None;
218 : :
219 [ + + + - : 15 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ - - + ]
220 [ - + ]: 15 : if (!args) {
221 : 0 : goto exit;
222 : : }
223 : 15 : path = args[0];
224 [ + + ]: 15 : if (!noptargs) {
225 : 8 : goto skip_optional_pos;
226 : : }
227 [ + - ]: 7 : if (args[1]) {
228 : 7 : default_value = args[1];
229 [ + + ]: 7 : if (!--noptargs) {
230 : 2 : goto skip_optional_pos;
231 : : }
232 : : }
233 : 5 : namespaces = args[2];
234 : 15 : skip_optional_pos:
235 : 15 : return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces);
236 : :
237 : 15 : exit:
238 : 15 : return return_value;
239 : : }
240 : :
241 : : PyDoc_STRVAR(_elementtree_Element_findall__doc__,
242 : : "findall($self, /, path, namespaces=None)\n"
243 : : "--\n"
244 : : "\n");
245 : :
246 : : #define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \
247 : : {"findall", _PyCFunction_CAST(_elementtree_Element_findall), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
248 : :
249 : : static PyObject *
250 : : _elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
251 : : PyObject *namespaces);
252 : :
253 : : static PyObject *
254 : 131 : _elementtree_Element_findall(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
255 : : {
256 : 131 : PyObject *return_value = NULL;
257 : : static const char * const _keywords[] = {"path", "namespaces", NULL};
258 : : static _PyArg_Parser _parser = {NULL, _keywords, "findall", 0};
259 : : PyObject *argsbuf[2];
260 [ + + ]: 131 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
261 : : PyObject *path;
262 : 131 : PyObject *namespaces = Py_None;
263 : :
264 [ + + + - : 131 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
265 [ - + ]: 131 : if (!args) {
266 : 0 : goto exit;
267 : : }
268 : 131 : path = args[0];
269 [ + + ]: 131 : if (!noptargs) {
270 : 121 : goto skip_optional_pos;
271 : : }
272 : 10 : namespaces = args[1];
273 : 131 : skip_optional_pos:
274 : 131 : return_value = _elementtree_Element_findall_impl(self, path, namespaces);
275 : :
276 : 131 : exit:
277 : 131 : return return_value;
278 : : }
279 : :
280 : : PyDoc_STRVAR(_elementtree_Element_iterfind__doc__,
281 : : "iterfind($self, /, path, namespaces=None)\n"
282 : : "--\n"
283 : : "\n");
284 : :
285 : : #define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \
286 : : {"iterfind", _PyCFunction_CAST(_elementtree_Element_iterfind), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
287 : :
288 : : static PyObject *
289 : : _elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
290 : : PyObject *namespaces);
291 : :
292 : : static PyObject *
293 : 11 : _elementtree_Element_iterfind(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
294 : : {
295 : 11 : PyObject *return_value = NULL;
296 : : static const char * const _keywords[] = {"path", "namespaces", NULL};
297 : : static _PyArg_Parser _parser = {NULL, _keywords, "iterfind", 0};
298 : : PyObject *argsbuf[2];
299 [ + + ]: 11 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
300 : : PyObject *path;
301 : 11 : PyObject *namespaces = Py_None;
302 : :
303 [ + + + - : 11 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
304 [ - + ]: 11 : if (!args) {
305 : 0 : goto exit;
306 : : }
307 : 11 : path = args[0];
308 [ + + ]: 11 : if (!noptargs) {
309 : 7 : goto skip_optional_pos;
310 : : }
311 : 4 : namespaces = args[1];
312 : 11 : skip_optional_pos:
313 : 11 : return_value = _elementtree_Element_iterfind_impl(self, path, namespaces);
314 : :
315 : 11 : exit:
316 : 11 : return return_value;
317 : : }
318 : :
319 : : PyDoc_STRVAR(_elementtree_Element_get__doc__,
320 : : "get($self, /, key, default=None)\n"
321 : : "--\n"
322 : : "\n");
323 : :
324 : : #define _ELEMENTTREE_ELEMENT_GET_METHODDEF \
325 : : {"get", _PyCFunction_CAST(_elementtree_Element_get), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_get__doc__},
326 : :
327 : : static PyObject *
328 : : _elementtree_Element_get_impl(ElementObject *self, PyObject *key,
329 : : PyObject *default_value);
330 : :
331 : : static PyObject *
332 : 128 : _elementtree_Element_get(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
333 : : {
334 : 128 : PyObject *return_value = NULL;
335 : : static const char * const _keywords[] = {"key", "default", NULL};
336 : : static _PyArg_Parser _parser = {NULL, _keywords, "get", 0};
337 : : PyObject *argsbuf[2];
338 [ + + ]: 128 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
339 : : PyObject *key;
340 : 128 : PyObject *default_value = Py_None;
341 : :
342 [ + + + - : 128 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
343 [ - + ]: 128 : if (!args) {
344 : 0 : goto exit;
345 : : }
346 : 128 : key = args[0];
347 [ + + ]: 128 : if (!noptargs) {
348 : 90 : goto skip_optional_pos;
349 : : }
350 : 38 : default_value = args[1];
351 : 128 : skip_optional_pos:
352 : 128 : return_value = _elementtree_Element_get_impl(self, key, default_value);
353 : :
354 : 128 : exit:
355 : 128 : return return_value;
356 : : }
357 : :
358 : : PyDoc_STRVAR(_elementtree_Element_iter__doc__,
359 : : "iter($self, /, tag=None)\n"
360 : : "--\n"
361 : : "\n");
362 : :
363 : : #define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \
364 : : {"iter", _PyCFunction_CAST(_elementtree_Element_iter), METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
365 : :
366 : : static PyObject *
367 : : _elementtree_Element_iter_impl(ElementObject *self, PyObject *tag);
368 : :
369 : : static PyObject *
370 : 448 : _elementtree_Element_iter(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
371 : : {
372 : 448 : PyObject *return_value = NULL;
373 : : static const char * const _keywords[] = {"tag", NULL};
374 : : static _PyArg_Parser _parser = {NULL, _keywords, "iter", 0};
375 : : PyObject *argsbuf[1];
376 [ + + ]: 448 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
377 : 448 : PyObject *tag = Py_None;
378 : :
379 [ + + + - : 448 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ - - + ]
380 [ - + ]: 448 : if (!args) {
381 : 0 : goto exit;
382 : : }
383 [ + + ]: 448 : if (!noptargs) {
384 : 367 : goto skip_optional_pos;
385 : : }
386 : 81 : tag = args[0];
387 : 448 : skip_optional_pos:
388 : 448 : return_value = _elementtree_Element_iter_impl(self, tag);
389 : :
390 : 448 : exit:
391 : 448 : return return_value;
392 : : }
393 : :
394 : : PyDoc_STRVAR(_elementtree_Element_itertext__doc__,
395 : : "itertext($self, /)\n"
396 : : "--\n"
397 : : "\n");
398 : :
399 : : #define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF \
400 : : {"itertext", (PyCFunction)_elementtree_Element_itertext, METH_NOARGS, _elementtree_Element_itertext__doc__},
401 : :
402 : : static PyObject *
403 : : _elementtree_Element_itertext_impl(ElementObject *self);
404 : :
405 : : static PyObject *
406 : 80 : _elementtree_Element_itertext(ElementObject *self, PyObject *Py_UNUSED(ignored))
407 : : {
408 : 80 : return _elementtree_Element_itertext_impl(self);
409 : : }
410 : :
411 : : PyDoc_STRVAR(_elementtree_Element_insert__doc__,
412 : : "insert($self, index, subelement, /)\n"
413 : : "--\n"
414 : : "\n");
415 : :
416 : : #define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF \
417 : : {"insert", _PyCFunction_CAST(_elementtree_Element_insert), METH_FASTCALL, _elementtree_Element_insert__doc__},
418 : :
419 : : static PyObject *
420 : : _elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,
421 : : PyObject *subelement);
422 : :
423 : : static PyObject *
424 : 16 : _elementtree_Element_insert(ElementObject *self, PyObject *const *args, Py_ssize_t nargs)
425 : : {
426 : 16 : PyObject *return_value = NULL;
427 : : Py_ssize_t index;
428 : : PyObject *subelement;
429 : :
430 [ + - - + : 16 : if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
- - ]
431 : 0 : goto exit;
432 : : }
433 : : {
434 : 16 : Py_ssize_t ival = -1;
435 : 16 : PyObject *iobj = _PyNumber_Index(args[0]);
436 [ + - ]: 16 : if (iobj != NULL) {
437 : 16 : ival = PyLong_AsSsize_t(iobj);
438 : 16 : Py_DECREF(iobj);
439 : : }
440 [ + + - + ]: 16 : if (ival == -1 && PyErr_Occurred()) {
441 : 0 : goto exit;
442 : : }
443 : 16 : index = ival;
444 : : }
445 [ + + ]: 16 : if (!PyObject_TypeCheck(args[1], &Element_Type)) {
446 : 1 : _PyArg_BadArgument("insert", "argument 2", (&Element_Type)->tp_name, args[1]);
447 : 1 : goto exit;
448 : : }
449 : 15 : subelement = args[1];
450 : 15 : return_value = _elementtree_Element_insert_impl(self, index, subelement);
451 : :
452 : 16 : exit:
453 : 16 : return return_value;
454 : : }
455 : :
456 : : PyDoc_STRVAR(_elementtree_Element_items__doc__,
457 : : "items($self, /)\n"
458 : : "--\n"
459 : : "\n");
460 : :
461 : : #define _ELEMENTTREE_ELEMENT_ITEMS_METHODDEF \
462 : : {"items", (PyCFunction)_elementtree_Element_items, METH_NOARGS, _elementtree_Element_items__doc__},
463 : :
464 : : static PyObject *
465 : : _elementtree_Element_items_impl(ElementObject *self);
466 : :
467 : : static PyObject *
468 : 994 : _elementtree_Element_items(ElementObject *self, PyObject *Py_UNUSED(ignored))
469 : : {
470 : 994 : return _elementtree_Element_items_impl(self);
471 : : }
472 : :
473 : : PyDoc_STRVAR(_elementtree_Element_keys__doc__,
474 : : "keys($self, /)\n"
475 : : "--\n"
476 : : "\n");
477 : :
478 : : #define _ELEMENTTREE_ELEMENT_KEYS_METHODDEF \
479 : : {"keys", (PyCFunction)_elementtree_Element_keys, METH_NOARGS, _elementtree_Element_keys__doc__},
480 : :
481 : : static PyObject *
482 : : _elementtree_Element_keys_impl(ElementObject *self);
483 : :
484 : : static PyObject *
485 : 1 : _elementtree_Element_keys(ElementObject *self, PyObject *Py_UNUSED(ignored))
486 : : {
487 : 1 : return _elementtree_Element_keys_impl(self);
488 : : }
489 : :
490 : : PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
491 : : "makeelement($self, tag, attrib, /)\n"
492 : : "--\n"
493 : : "\n");
494 : :
495 : : #define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
496 : : {"makeelement", _PyCFunction_CAST(_elementtree_Element_makeelement), METH_FASTCALL, _elementtree_Element_makeelement__doc__},
497 : :
498 : : static PyObject *
499 : : _elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
500 : : PyObject *attrib);
501 : :
502 : : static PyObject *
503 : 1 : _elementtree_Element_makeelement(ElementObject *self, PyObject *const *args, Py_ssize_t nargs)
504 : : {
505 : 1 : PyObject *return_value = NULL;
506 : : PyObject *tag;
507 : : PyObject *attrib;
508 : :
509 [ + - - + : 1 : if (!_PyArg_CheckPositional("makeelement", nargs, 2, 2)) {
- - ]
510 : 0 : goto exit;
511 : : }
512 : 1 : tag = args[0];
513 [ - + ]: 1 : if (!PyDict_Check(args[1])) {
514 : 0 : _PyArg_BadArgument("makeelement", "argument 2", "dict", args[1]);
515 : 0 : goto exit;
516 : : }
517 : 1 : attrib = args[1];
518 : 1 : return_value = _elementtree_Element_makeelement_impl(self, tag, attrib);
519 : :
520 : 1 : exit:
521 : 1 : return return_value;
522 : : }
523 : :
524 : : PyDoc_STRVAR(_elementtree_Element_remove__doc__,
525 : : "remove($self, subelement, /)\n"
526 : : "--\n"
527 : : "\n");
528 : :
529 : : #define _ELEMENTTREE_ELEMENT_REMOVE_METHODDEF \
530 : : {"remove", (PyCFunction)_elementtree_Element_remove, METH_O, _elementtree_Element_remove__doc__},
531 : :
532 : : static PyObject *
533 : : _elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement);
534 : :
535 : : static PyObject *
536 : 9 : _elementtree_Element_remove(ElementObject *self, PyObject *arg)
537 : : {
538 : 9 : PyObject *return_value = NULL;
539 : : PyObject *subelement;
540 : :
541 [ - + ]: 9 : if (!PyObject_TypeCheck(arg, &Element_Type)) {
542 : 0 : _PyArg_BadArgument("remove", "argument", (&Element_Type)->tp_name, arg);
543 : 0 : goto exit;
544 : : }
545 : 9 : subelement = arg;
546 : 9 : return_value = _elementtree_Element_remove_impl(self, subelement);
547 : :
548 : 9 : exit:
549 : 9 : return return_value;
550 : : }
551 : :
552 : : PyDoc_STRVAR(_elementtree_Element_set__doc__,
553 : : "set($self, key, value, /)\n"
554 : : "--\n"
555 : : "\n");
556 : :
557 : : #define _ELEMENTTREE_ELEMENT_SET_METHODDEF \
558 : : {"set", _PyCFunction_CAST(_elementtree_Element_set), METH_FASTCALL, _elementtree_Element_set__doc__},
559 : :
560 : : static PyObject *
561 : : _elementtree_Element_set_impl(ElementObject *self, PyObject *key,
562 : : PyObject *value);
563 : :
564 : : static PyObject *
565 : 18 : _elementtree_Element_set(ElementObject *self, PyObject *const *args, Py_ssize_t nargs)
566 : : {
567 : 18 : PyObject *return_value = NULL;
568 : : PyObject *key;
569 : : PyObject *value;
570 : :
571 [ + - - + : 18 : if (!_PyArg_CheckPositional("set", nargs, 2, 2)) {
- - ]
572 : 0 : goto exit;
573 : : }
574 : 18 : key = args[0];
575 : 18 : value = args[1];
576 : 18 : return_value = _elementtree_Element_set_impl(self, key, value);
577 : :
578 : 18 : exit:
579 : 18 : return return_value;
580 : : }
581 : :
582 : : static int
583 : : _elementtree_TreeBuilder___init___impl(TreeBuilderObject *self,
584 : : PyObject *element_factory,
585 : : PyObject *comment_factory,
586 : : PyObject *pi_factory,
587 : : int insert_comments, int insert_pis);
588 : :
589 : : static int
590 : 1388 : _elementtree_TreeBuilder___init__(PyObject *self, PyObject *args, PyObject *kwargs)
591 : : {
592 : 1388 : int return_value = -1;
593 : : static const char * const _keywords[] = {"element_factory", "comment_factory", "pi_factory", "insert_comments", "insert_pis", NULL};
594 : : static _PyArg_Parser _parser = {NULL, _keywords, "TreeBuilder", 0};
595 : : PyObject *argsbuf[5];
596 : : PyObject * const *fastargs;
597 : 1388 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
598 [ + + ]: 1388 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
599 : 1388 : PyObject *element_factory = Py_None;
600 : 1388 : PyObject *comment_factory = Py_None;
601 : 1388 : PyObject *pi_factory = Py_None;
602 : 1388 : int insert_comments = 0;
603 : 1388 : int insert_pis = 0;
604 : :
605 [ + + + - : 1388 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 1, 0, argsbuf);
+ - + - ]
606 [ - + ]: 1388 : if (!fastargs) {
607 : 0 : goto exit;
608 : : }
609 [ + + ]: 1388 : if (!noptargs) {
610 : 1373 : goto skip_optional_pos;
611 : : }
612 [ + + ]: 15 : if (fastargs[0]) {
613 : 6 : element_factory = fastargs[0];
614 [ - + ]: 6 : if (!--noptargs) {
615 : 6 : goto skip_optional_pos;
616 : : }
617 : : }
618 : 9 : skip_optional_pos:
619 [ + + ]: 1388 : if (!noptargs) {
620 : 1379 : goto skip_optional_kwonly;
621 : : }
622 [ + + ]: 9 : if (fastargs[1]) {
623 : 3 : comment_factory = fastargs[1];
624 [ + + ]: 3 : if (!--noptargs) {
625 : 2 : goto skip_optional_kwonly;
626 : : }
627 : : }
628 [ + + ]: 7 : if (fastargs[2]) {
629 : 3 : pi_factory = fastargs[2];
630 [ + - ]: 3 : if (!--noptargs) {
631 : 3 : goto skip_optional_kwonly;
632 : : }
633 : : }
634 [ + + ]: 4 : if (fastargs[3]) {
635 : 2 : insert_comments = PyObject_IsTrue(fastargs[3]);
636 [ - + ]: 2 : if (insert_comments < 0) {
637 : 0 : goto exit;
638 : : }
639 [ + - ]: 2 : if (!--noptargs) {
640 : 2 : goto skip_optional_kwonly;
641 : : }
642 : : }
643 : 2 : insert_pis = PyObject_IsTrue(fastargs[4]);
644 [ - + ]: 2 : if (insert_pis < 0) {
645 : 0 : goto exit;
646 : : }
647 : 2 : skip_optional_kwonly:
648 : 1388 : return_value = _elementtree_TreeBuilder___init___impl((TreeBuilderObject *)self, element_factory, comment_factory, pi_factory, insert_comments, insert_pis);
649 : :
650 : 1388 : exit:
651 : 1388 : return return_value;
652 : : }
653 : :
654 : : PyDoc_STRVAR(_elementtree__set_factories__doc__,
655 : : "_set_factories($module, comment_factory, pi_factory, /)\n"
656 : : "--\n"
657 : : "\n"
658 : : "Change the factories used to create comments and processing instructions.\n"
659 : : "\n"
660 : : "For internal use only.");
661 : :
662 : : #define _ELEMENTTREE__SET_FACTORIES_METHODDEF \
663 : : {"_set_factories", _PyCFunction_CAST(_elementtree__set_factories), METH_FASTCALL, _elementtree__set_factories__doc__},
664 : :
665 : : static PyObject *
666 : : _elementtree__set_factories_impl(PyObject *module, PyObject *comment_factory,
667 : : PyObject *pi_factory);
668 : :
669 : : static PyObject *
670 : 15 : _elementtree__set_factories(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
671 : : {
672 : 15 : PyObject *return_value = NULL;
673 : : PyObject *comment_factory;
674 : : PyObject *pi_factory;
675 : :
676 [ + - - + : 15 : if (!_PyArg_CheckPositional("_set_factories", nargs, 2, 2)) {
- - ]
677 : 0 : goto exit;
678 : : }
679 : 15 : comment_factory = args[0];
680 : 15 : pi_factory = args[1];
681 : 15 : return_value = _elementtree__set_factories_impl(module, comment_factory, pi_factory);
682 : :
683 : 15 : exit:
684 : 15 : return return_value;
685 : : }
686 : :
687 : : PyDoc_STRVAR(_elementtree_TreeBuilder_data__doc__,
688 : : "data($self, data, /)\n"
689 : : "--\n"
690 : : "\n");
691 : :
692 : : #define _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF \
693 : : {"data", (PyCFunction)_elementtree_TreeBuilder_data, METH_O, _elementtree_TreeBuilder_data__doc__},
694 : :
695 : : PyDoc_STRVAR(_elementtree_TreeBuilder_end__doc__,
696 : : "end($self, tag, /)\n"
697 : : "--\n"
698 : : "\n");
699 : :
700 : : #define _ELEMENTTREE_TREEBUILDER_END_METHODDEF \
701 : : {"end", (PyCFunction)_elementtree_TreeBuilder_end, METH_O, _elementtree_TreeBuilder_end__doc__},
702 : :
703 : : PyDoc_STRVAR(_elementtree_TreeBuilder_comment__doc__,
704 : : "comment($self, text, /)\n"
705 : : "--\n"
706 : : "\n");
707 : :
708 : : #define _ELEMENTTREE_TREEBUILDER_COMMENT_METHODDEF \
709 : : {"comment", (PyCFunction)_elementtree_TreeBuilder_comment, METH_O, _elementtree_TreeBuilder_comment__doc__},
710 : :
711 : : PyDoc_STRVAR(_elementtree_TreeBuilder_pi__doc__,
712 : : "pi($self, target, text=None, /)\n"
713 : : "--\n"
714 : : "\n");
715 : :
716 : : #define _ELEMENTTREE_TREEBUILDER_PI_METHODDEF \
717 : : {"pi", _PyCFunction_CAST(_elementtree_TreeBuilder_pi), METH_FASTCALL, _elementtree_TreeBuilder_pi__doc__},
718 : :
719 : : static PyObject *
720 : : _elementtree_TreeBuilder_pi_impl(TreeBuilderObject *self, PyObject *target,
721 : : PyObject *text);
722 : :
723 : : static PyObject *
724 : 13 : _elementtree_TreeBuilder_pi(TreeBuilderObject *self, PyObject *const *args, Py_ssize_t nargs)
725 : : {
726 : 13 : PyObject *return_value = NULL;
727 : : PyObject *target;
728 : 13 : PyObject *text = Py_None;
729 : :
730 [ + - - + : 13 : if (!_PyArg_CheckPositional("pi", nargs, 1, 2)) {
- - ]
731 : 0 : goto exit;
732 : : }
733 : 13 : target = args[0];
734 [ + + ]: 13 : if (nargs < 2) {
735 : 3 : goto skip_optional;
736 : : }
737 : 10 : text = args[1];
738 : 13 : skip_optional:
739 : 13 : return_value = _elementtree_TreeBuilder_pi_impl(self, target, text);
740 : :
741 : 13 : exit:
742 : 13 : return return_value;
743 : : }
744 : :
745 : : PyDoc_STRVAR(_elementtree_TreeBuilder_close__doc__,
746 : : "close($self, /)\n"
747 : : "--\n"
748 : : "\n");
749 : :
750 : : #define _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF \
751 : : {"close", (PyCFunction)_elementtree_TreeBuilder_close, METH_NOARGS, _elementtree_TreeBuilder_close__doc__},
752 : :
753 : : static PyObject *
754 : : _elementtree_TreeBuilder_close_impl(TreeBuilderObject *self);
755 : :
756 : : static PyObject *
757 : 9 : _elementtree_TreeBuilder_close(TreeBuilderObject *self, PyObject *Py_UNUSED(ignored))
758 : : {
759 : 9 : return _elementtree_TreeBuilder_close_impl(self);
760 : : }
761 : :
762 : : PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
763 : : "start($self, tag, attrs, /)\n"
764 : : "--\n"
765 : : "\n");
766 : :
767 : : #define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \
768 : : {"start", _PyCFunction_CAST(_elementtree_TreeBuilder_start), METH_FASTCALL, _elementtree_TreeBuilder_start__doc__},
769 : :
770 : : static PyObject *
771 : : _elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
772 : : PyObject *attrs);
773 : :
774 : : static PyObject *
775 : 1018 : _elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject *const *args, Py_ssize_t nargs)
776 : : {
777 : 1018 : PyObject *return_value = NULL;
778 : : PyObject *tag;
779 : : PyObject *attrs;
780 : :
781 [ + + - + : 1018 : if (!_PyArg_CheckPositional("start", nargs, 2, 2)) {
+ - ]
782 : 1 : goto exit;
783 : : }
784 : 1017 : tag = args[0];
785 [ + + ]: 1017 : if (!PyDict_Check(args[1])) {
786 : 1 : _PyArg_BadArgument("start", "argument 2", "dict", args[1]);
787 : 1 : goto exit;
788 : : }
789 : 1016 : attrs = args[1];
790 : 1016 : return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs);
791 : :
792 : 1018 : exit:
793 : 1018 : return return_value;
794 : : }
795 : :
796 : : static int
797 : : _elementtree_XMLParser___init___impl(XMLParserObject *self, PyObject *target,
798 : : const char *encoding);
799 : :
800 : : static int
801 : 452 : _elementtree_XMLParser___init__(PyObject *self, PyObject *args, PyObject *kwargs)
802 : : {
803 : 452 : int return_value = -1;
804 : : static const char * const _keywords[] = {"target", "encoding", NULL};
805 : : static _PyArg_Parser _parser = {NULL, _keywords, "XMLParser", 0};
806 : : PyObject *argsbuf[2];
807 : : PyObject * const *fastargs;
808 : 452 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
809 [ + + ]: 452 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
810 : 452 : PyObject *target = Py_None;
811 : 452 : const char *encoding = NULL;
812 : :
813 [ + + + - : 452 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 0, 0, argsbuf);
+ - + - ]
814 [ - + ]: 452 : if (!fastargs) {
815 : 0 : goto exit;
816 : : }
817 [ + + ]: 452 : if (!noptargs) {
818 : 30 : goto skip_optional_kwonly;
819 : : }
820 [ + - ]: 422 : if (fastargs[0]) {
821 : 422 : target = fastargs[0];
822 [ + + ]: 422 : if (!--noptargs) {
823 : 421 : goto skip_optional_kwonly;
824 : : }
825 : : }
826 [ - + ]: 1 : if (fastargs[1] == Py_None) {
827 : 0 : encoding = NULL;
828 : : }
829 [ + - ]: 1 : else if (PyUnicode_Check(fastargs[1])) {
830 : : Py_ssize_t encoding_length;
831 : 1 : encoding = PyUnicode_AsUTF8AndSize(fastargs[1], &encoding_length);
832 [ - + ]: 1 : if (encoding == NULL) {
833 : 0 : goto exit;
834 : : }
835 [ - + ]: 1 : if (strlen(encoding) != (size_t)encoding_length) {
836 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
837 : 0 : goto exit;
838 : : }
839 : : }
840 : : else {
841 : 0 : _PyArg_BadArgument("XMLParser", "argument 'encoding'", "str or None", fastargs[1]);
842 : 0 : goto exit;
843 : : }
844 : 452 : skip_optional_kwonly:
845 : 452 : return_value = _elementtree_XMLParser___init___impl((XMLParserObject *)self, target, encoding);
846 : :
847 : 452 : exit:
848 : 452 : return return_value;
849 : : }
850 : :
851 : : PyDoc_STRVAR(_elementtree_XMLParser_close__doc__,
852 : : "close($self, /)\n"
853 : : "--\n"
854 : : "\n");
855 : :
856 : : #define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF \
857 : : {"close", (PyCFunction)_elementtree_XMLParser_close, METH_NOARGS, _elementtree_XMLParser_close__doc__},
858 : :
859 : : static PyObject *
860 : : _elementtree_XMLParser_close_impl(XMLParserObject *self);
861 : :
862 : : static PyObject *
863 : 364 : _elementtree_XMLParser_close(XMLParserObject *self, PyObject *Py_UNUSED(ignored))
864 : : {
865 : 364 : return _elementtree_XMLParser_close_impl(self);
866 : : }
867 : :
868 : : PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__,
869 : : "feed($self, data, /)\n"
870 : : "--\n"
871 : : "\n");
872 : :
873 : : #define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF \
874 : : {"feed", (PyCFunction)_elementtree_XMLParser_feed, METH_O, _elementtree_XMLParser_feed__doc__},
875 : :
876 : : PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__,
877 : : "_parse_whole($self, file, /)\n"
878 : : "--\n"
879 : : "\n");
880 : :
881 : : #define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF \
882 : : {"_parse_whole", (PyCFunction)_elementtree_XMLParser__parse_whole, METH_O, _elementtree_XMLParser__parse_whole__doc__},
883 : :
884 : : PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
885 : : "_setevents($self, events_queue, events_to_report=None, /)\n"
886 : : "--\n"
887 : : "\n");
888 : :
889 : : #define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \
890 : : {"_setevents", _PyCFunction_CAST(_elementtree_XMLParser__setevents), METH_FASTCALL, _elementtree_XMLParser__setevents__doc__},
891 : :
892 : : static PyObject *
893 : : _elementtree_XMLParser__setevents_impl(XMLParserObject *self,
894 : : PyObject *events_queue,
895 : : PyObject *events_to_report);
896 : :
897 : : static PyObject *
898 : 38 : _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *const *args, Py_ssize_t nargs)
899 : : {
900 : 38 : PyObject *return_value = NULL;
901 : : PyObject *events_queue;
902 : 38 : PyObject *events_to_report = Py_None;
903 : :
904 [ + - - + : 38 : if (!_PyArg_CheckPositional("_setevents", nargs, 1, 2)) {
- - ]
905 : 0 : goto exit;
906 : : }
907 : 38 : events_queue = args[0];
908 [ + + ]: 38 : if (nargs < 2) {
909 : 1 : goto skip_optional;
910 : : }
911 : 37 : events_to_report = args[1];
912 : 38 : skip_optional:
913 : 38 : return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report);
914 : :
915 : 38 : exit:
916 : 38 : return return_value;
917 : : }
918 : : /*[clinic end generated code: output=3fd6fa2ce1aeca76 input=a9049054013a1b77]*/
|
