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 *
_elementtree_Element_append(ElementObject * self,PyObject * arg)17 _elementtree_Element_append(ElementObject *self, PyObject *arg)
18 {
19 PyObject *return_value = NULL;
20 PyObject *subelement;
21
22 if (!PyObject_TypeCheck(arg, &Element_Type)) {
23 _PyArg_BadArgument("append", "argument", (&Element_Type)->tp_name, arg);
24 goto exit;
25 }
26 subelement = arg;
27 return_value = _elementtree_Element_append_impl(self, subelement);
28
29 exit:
30 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 *
_elementtree_Element_clear(ElementObject * self,PyObject * Py_UNUSED (ignored))45 _elementtree_Element_clear(ElementObject *self, PyObject *Py_UNUSED(ignored))
46 {
47 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 *
_elementtree_Element___copy__(ElementObject * self,PyObject * Py_UNUSED (ignored))62 _elementtree_Element___copy__(ElementObject *self, PyObject *Py_UNUSED(ignored))
63 {
64 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 *
_elementtree_Element___deepcopy__(ElementObject * self,PyObject * arg)79 _elementtree_Element___deepcopy__(ElementObject *self, PyObject *arg)
80 {
81 PyObject *return_value = NULL;
82 PyObject *memo;
83
84 if (!PyDict_Check(arg)) {
85 _PyArg_BadArgument("__deepcopy__", "argument", "dict", arg);
86 goto exit;
87 }
88 memo = arg;
89 return_value = _elementtree_Element___deepcopy___impl(self, memo);
90
91 exit:
92 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 *
_elementtree_Element___sizeof__(ElementObject * self,PyObject * Py_UNUSED (ignored))107 _elementtree_Element___sizeof__(ElementObject *self, PyObject *Py_UNUSED(ignored))
108 {
109 PyObject *return_value = NULL;
110 Py_ssize_t _return_value;
111
112 _return_value = _elementtree_Element___sizeof___impl(self);
113 if ((_return_value == -1) && PyErr_Occurred()) {
114 goto exit;
115 }
116 return_value = PyLong_FromSsize_t(_return_value);
117
118 exit:
119 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 *
_elementtree_Element___getstate__(ElementObject * self,PyObject * Py_UNUSED (ignored))134 _elementtree_Element___getstate__(ElementObject *self, PyObject *Py_UNUSED(ignored))
135 {
136 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)(void(*)(void))_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 *
_elementtree_Element_find(ElementObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)168 _elementtree_Element_find(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
169 {
170 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 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
175 PyObject *path;
176 PyObject *namespaces = Py_None;
177
178 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
179 if (!args) {
180 goto exit;
181 }
182 path = args[0];
183 if (!noptargs) {
184 goto skip_optional_pos;
185 }
186 namespaces = args[1];
187 skip_optional_pos:
188 return_value = _elementtree_Element_find_impl(self, path, namespaces);
189
190 exit:
191 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)(void(*)(void))_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 *
_elementtree_Element_findtext(ElementObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)208 _elementtree_Element_findtext(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
209 {
210 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 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
215 PyObject *path;
216 PyObject *default_value = Py_None;
217 PyObject *namespaces = Py_None;
218
219 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
220 if (!args) {
221 goto exit;
222 }
223 path = args[0];
224 if (!noptargs) {
225 goto skip_optional_pos;
226 }
227 if (args[1]) {
228 default_value = args[1];
229 if (!--noptargs) {
230 goto skip_optional_pos;
231 }
232 }
233 namespaces = args[2];
234 skip_optional_pos:
235 return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces);
236
237 exit:
238 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)(void(*)(void))_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 *
_elementtree_Element_findall(ElementObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)254 _elementtree_Element_findall(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
255 {
256 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 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
261 PyObject *path;
262 PyObject *namespaces = Py_None;
263
264 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
265 if (!args) {
266 goto exit;
267 }
268 path = args[0];
269 if (!noptargs) {
270 goto skip_optional_pos;
271 }
272 namespaces = args[1];
273 skip_optional_pos:
274 return_value = _elementtree_Element_findall_impl(self, path, namespaces);
275
276 exit:
277 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)(void(*)(void))_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 *
_elementtree_Element_iterfind(ElementObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)293 _elementtree_Element_iterfind(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
294 {
295 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 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
300 PyObject *path;
301 PyObject *namespaces = Py_None;
302
303 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
304 if (!args) {
305 goto exit;
306 }
307 path = args[0];
308 if (!noptargs) {
309 goto skip_optional_pos;
310 }
311 namespaces = args[1];
312 skip_optional_pos:
313 return_value = _elementtree_Element_iterfind_impl(self, path, namespaces);
314
315 exit:
316 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)(void(*)(void))_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 *
_elementtree_Element_get(ElementObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)332 _elementtree_Element_get(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
333 {
334 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 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
339 PyObject *key;
340 PyObject *default_value = Py_None;
341
342 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
343 if (!args) {
344 goto exit;
345 }
346 key = args[0];
347 if (!noptargs) {
348 goto skip_optional_pos;
349 }
350 default_value = args[1];
351 skip_optional_pos:
352 return_value = _elementtree_Element_get_impl(self, key, default_value);
353
354 exit:
355 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)(void(*)(void))_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 *
_elementtree_Element_iter(ElementObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)370 _elementtree_Element_iter(ElementObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
371 {
372 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 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
377 PyObject *tag = Py_None;
378
379 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
380 if (!args) {
381 goto exit;
382 }
383 if (!noptargs) {
384 goto skip_optional_pos;
385 }
386 tag = args[0];
387 skip_optional_pos:
388 return_value = _elementtree_Element_iter_impl(self, tag);
389
390 exit:
391 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 *
_elementtree_Element_itertext(ElementObject * self,PyObject * Py_UNUSED (ignored))406 _elementtree_Element_itertext(ElementObject *self, PyObject *Py_UNUSED(ignored))
407 {
408 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)(void(*)(void))_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 *
_elementtree_Element_insert(ElementObject * self,PyObject * const * args,Py_ssize_t nargs)424 _elementtree_Element_insert(ElementObject *self, PyObject *const *args, Py_ssize_t nargs)
425 {
426 PyObject *return_value = NULL;
427 Py_ssize_t index;
428 PyObject *subelement;
429
430 if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
431 goto exit;
432 }
433 if (PyFloat_Check(args[0])) {
434 PyErr_SetString(PyExc_TypeError,
435 "integer argument expected, got float" );
436 goto exit;
437 }
438 {
439 Py_ssize_t ival = -1;
440 PyObject *iobj = PyNumber_Index(args[0]);
441 if (iobj != NULL) {
442 ival = PyLong_AsSsize_t(iobj);
443 Py_DECREF(iobj);
444 }
445 if (ival == -1 && PyErr_Occurred()) {
446 goto exit;
447 }
448 index = ival;
449 }
450 if (!PyObject_TypeCheck(args[1], &Element_Type)) {
451 _PyArg_BadArgument("insert", "argument 2", (&Element_Type)->tp_name, args[1]);
452 goto exit;
453 }
454 subelement = args[1];
455 return_value = _elementtree_Element_insert_impl(self, index, subelement);
456
457 exit:
458 return return_value;
459 }
460
461 PyDoc_STRVAR(_elementtree_Element_items__doc__,
462 "items($self, /)\n"
463 "--\n"
464 "\n");
465
466 #define _ELEMENTTREE_ELEMENT_ITEMS_METHODDEF \
467 {"items", (PyCFunction)_elementtree_Element_items, METH_NOARGS, _elementtree_Element_items__doc__},
468
469 static PyObject *
470 _elementtree_Element_items_impl(ElementObject *self);
471
472 static PyObject *
_elementtree_Element_items(ElementObject * self,PyObject * Py_UNUSED (ignored))473 _elementtree_Element_items(ElementObject *self, PyObject *Py_UNUSED(ignored))
474 {
475 return _elementtree_Element_items_impl(self);
476 }
477
478 PyDoc_STRVAR(_elementtree_Element_keys__doc__,
479 "keys($self, /)\n"
480 "--\n"
481 "\n");
482
483 #define _ELEMENTTREE_ELEMENT_KEYS_METHODDEF \
484 {"keys", (PyCFunction)_elementtree_Element_keys, METH_NOARGS, _elementtree_Element_keys__doc__},
485
486 static PyObject *
487 _elementtree_Element_keys_impl(ElementObject *self);
488
489 static PyObject *
_elementtree_Element_keys(ElementObject * self,PyObject * Py_UNUSED (ignored))490 _elementtree_Element_keys(ElementObject *self, PyObject *Py_UNUSED(ignored))
491 {
492 return _elementtree_Element_keys_impl(self);
493 }
494
495 PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
496 "makeelement($self, tag, attrib, /)\n"
497 "--\n"
498 "\n");
499
500 #define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
501 {"makeelement", (PyCFunction)(void(*)(void))_elementtree_Element_makeelement, METH_FASTCALL, _elementtree_Element_makeelement__doc__},
502
503 static PyObject *
504 _elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
505 PyObject *attrib);
506
507 static PyObject *
_elementtree_Element_makeelement(ElementObject * self,PyObject * const * args,Py_ssize_t nargs)508 _elementtree_Element_makeelement(ElementObject *self, PyObject *const *args, Py_ssize_t nargs)
509 {
510 PyObject *return_value = NULL;
511 PyObject *tag;
512 PyObject *attrib;
513
514 if (!_PyArg_CheckPositional("makeelement", nargs, 2, 2)) {
515 goto exit;
516 }
517 tag = args[0];
518 if (!PyDict_Check(args[1])) {
519 _PyArg_BadArgument("makeelement", "argument 2", "dict", args[1]);
520 goto exit;
521 }
522 attrib = args[1];
523 return_value = _elementtree_Element_makeelement_impl(self, tag, attrib);
524
525 exit:
526 return return_value;
527 }
528
529 PyDoc_STRVAR(_elementtree_Element_remove__doc__,
530 "remove($self, subelement, /)\n"
531 "--\n"
532 "\n");
533
534 #define _ELEMENTTREE_ELEMENT_REMOVE_METHODDEF \
535 {"remove", (PyCFunction)_elementtree_Element_remove, METH_O, _elementtree_Element_remove__doc__},
536
537 static PyObject *
538 _elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement);
539
540 static PyObject *
_elementtree_Element_remove(ElementObject * self,PyObject * arg)541 _elementtree_Element_remove(ElementObject *self, PyObject *arg)
542 {
543 PyObject *return_value = NULL;
544 PyObject *subelement;
545
546 if (!PyObject_TypeCheck(arg, &Element_Type)) {
547 _PyArg_BadArgument("remove", "argument", (&Element_Type)->tp_name, arg);
548 goto exit;
549 }
550 subelement = arg;
551 return_value = _elementtree_Element_remove_impl(self, subelement);
552
553 exit:
554 return return_value;
555 }
556
557 PyDoc_STRVAR(_elementtree_Element_set__doc__,
558 "set($self, key, value, /)\n"
559 "--\n"
560 "\n");
561
562 #define _ELEMENTTREE_ELEMENT_SET_METHODDEF \
563 {"set", (PyCFunction)(void(*)(void))_elementtree_Element_set, METH_FASTCALL, _elementtree_Element_set__doc__},
564
565 static PyObject *
566 _elementtree_Element_set_impl(ElementObject *self, PyObject *key,
567 PyObject *value);
568
569 static PyObject *
_elementtree_Element_set(ElementObject * self,PyObject * const * args,Py_ssize_t nargs)570 _elementtree_Element_set(ElementObject *self, PyObject *const *args, Py_ssize_t nargs)
571 {
572 PyObject *return_value = NULL;
573 PyObject *key;
574 PyObject *value;
575
576 if (!_PyArg_CheckPositional("set", nargs, 2, 2)) {
577 goto exit;
578 }
579 key = args[0];
580 value = args[1];
581 return_value = _elementtree_Element_set_impl(self, key, value);
582
583 exit:
584 return return_value;
585 }
586
587 static int
588 _elementtree_TreeBuilder___init___impl(TreeBuilderObject *self,
589 PyObject *element_factory,
590 PyObject *comment_factory,
591 PyObject *pi_factory,
592 int insert_comments, int insert_pis);
593
594 static int
_elementtree_TreeBuilder___init__(PyObject * self,PyObject * args,PyObject * kwargs)595 _elementtree_TreeBuilder___init__(PyObject *self, PyObject *args, PyObject *kwargs)
596 {
597 int return_value = -1;
598 static const char * const _keywords[] = {"element_factory", "comment_factory", "pi_factory", "insert_comments", "insert_pis", NULL};
599 static _PyArg_Parser _parser = {NULL, _keywords, "TreeBuilder", 0};
600 PyObject *argsbuf[5];
601 PyObject * const *fastargs;
602 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
603 Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
604 PyObject *element_factory = Py_None;
605 PyObject *comment_factory = Py_None;
606 PyObject *pi_factory = Py_None;
607 int insert_comments = 0;
608 int insert_pis = 0;
609
610 fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 1, 0, argsbuf);
611 if (!fastargs) {
612 goto exit;
613 }
614 if (!noptargs) {
615 goto skip_optional_pos;
616 }
617 if (fastargs[0]) {
618 element_factory = fastargs[0];
619 if (!--noptargs) {
620 goto skip_optional_pos;
621 }
622 }
623 skip_optional_pos:
624 if (!noptargs) {
625 goto skip_optional_kwonly;
626 }
627 if (fastargs[1]) {
628 comment_factory = fastargs[1];
629 if (!--noptargs) {
630 goto skip_optional_kwonly;
631 }
632 }
633 if (fastargs[2]) {
634 pi_factory = fastargs[2];
635 if (!--noptargs) {
636 goto skip_optional_kwonly;
637 }
638 }
639 if (fastargs[3]) {
640 insert_comments = PyObject_IsTrue(fastargs[3]);
641 if (insert_comments < 0) {
642 goto exit;
643 }
644 if (!--noptargs) {
645 goto skip_optional_kwonly;
646 }
647 }
648 insert_pis = PyObject_IsTrue(fastargs[4]);
649 if (insert_pis < 0) {
650 goto exit;
651 }
652 skip_optional_kwonly:
653 return_value = _elementtree_TreeBuilder___init___impl((TreeBuilderObject *)self, element_factory, comment_factory, pi_factory, insert_comments, insert_pis);
654
655 exit:
656 return return_value;
657 }
658
659 PyDoc_STRVAR(_elementtree__set_factories__doc__,
660 "_set_factories($module, comment_factory, pi_factory, /)\n"
661 "--\n"
662 "\n"
663 "Change the factories used to create comments and processing instructions.\n"
664 "\n"
665 "For internal use only.");
666
667 #define _ELEMENTTREE__SET_FACTORIES_METHODDEF \
668 {"_set_factories", (PyCFunction)(void(*)(void))_elementtree__set_factories, METH_FASTCALL, _elementtree__set_factories__doc__},
669
670 static PyObject *
671 _elementtree__set_factories_impl(PyObject *module, PyObject *comment_factory,
672 PyObject *pi_factory);
673
674 static PyObject *
_elementtree__set_factories(PyObject * module,PyObject * const * args,Py_ssize_t nargs)675 _elementtree__set_factories(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
676 {
677 PyObject *return_value = NULL;
678 PyObject *comment_factory;
679 PyObject *pi_factory;
680
681 if (!_PyArg_CheckPositional("_set_factories", nargs, 2, 2)) {
682 goto exit;
683 }
684 comment_factory = args[0];
685 pi_factory = args[1];
686 return_value = _elementtree__set_factories_impl(module, comment_factory, pi_factory);
687
688 exit:
689 return return_value;
690 }
691
692 PyDoc_STRVAR(_elementtree_TreeBuilder_data__doc__,
693 "data($self, data, /)\n"
694 "--\n"
695 "\n");
696
697 #define _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF \
698 {"data", (PyCFunction)_elementtree_TreeBuilder_data, METH_O, _elementtree_TreeBuilder_data__doc__},
699
700 PyDoc_STRVAR(_elementtree_TreeBuilder_end__doc__,
701 "end($self, tag, /)\n"
702 "--\n"
703 "\n");
704
705 #define _ELEMENTTREE_TREEBUILDER_END_METHODDEF \
706 {"end", (PyCFunction)_elementtree_TreeBuilder_end, METH_O, _elementtree_TreeBuilder_end__doc__},
707
708 PyDoc_STRVAR(_elementtree_TreeBuilder_comment__doc__,
709 "comment($self, text, /)\n"
710 "--\n"
711 "\n");
712
713 #define _ELEMENTTREE_TREEBUILDER_COMMENT_METHODDEF \
714 {"comment", (PyCFunction)_elementtree_TreeBuilder_comment, METH_O, _elementtree_TreeBuilder_comment__doc__},
715
716 PyDoc_STRVAR(_elementtree_TreeBuilder_pi__doc__,
717 "pi($self, target, text=None, /)\n"
718 "--\n"
719 "\n");
720
721 #define _ELEMENTTREE_TREEBUILDER_PI_METHODDEF \
722 {"pi", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_pi, METH_FASTCALL, _elementtree_TreeBuilder_pi__doc__},
723
724 static PyObject *
725 _elementtree_TreeBuilder_pi_impl(TreeBuilderObject *self, PyObject *target,
726 PyObject *text);
727
728 static PyObject *
_elementtree_TreeBuilder_pi(TreeBuilderObject * self,PyObject * const * args,Py_ssize_t nargs)729 _elementtree_TreeBuilder_pi(TreeBuilderObject *self, PyObject *const *args, Py_ssize_t nargs)
730 {
731 PyObject *return_value = NULL;
732 PyObject *target;
733 PyObject *text = Py_None;
734
735 if (!_PyArg_CheckPositional("pi", nargs, 1, 2)) {
736 goto exit;
737 }
738 target = args[0];
739 if (nargs < 2) {
740 goto skip_optional;
741 }
742 text = args[1];
743 skip_optional:
744 return_value = _elementtree_TreeBuilder_pi_impl(self, target, text);
745
746 exit:
747 return return_value;
748 }
749
750 PyDoc_STRVAR(_elementtree_TreeBuilder_close__doc__,
751 "close($self, /)\n"
752 "--\n"
753 "\n");
754
755 #define _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF \
756 {"close", (PyCFunction)_elementtree_TreeBuilder_close, METH_NOARGS, _elementtree_TreeBuilder_close__doc__},
757
758 static PyObject *
759 _elementtree_TreeBuilder_close_impl(TreeBuilderObject *self);
760
761 static PyObject *
_elementtree_TreeBuilder_close(TreeBuilderObject * self,PyObject * Py_UNUSED (ignored))762 _elementtree_TreeBuilder_close(TreeBuilderObject *self, PyObject *Py_UNUSED(ignored))
763 {
764 return _elementtree_TreeBuilder_close_impl(self);
765 }
766
767 PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
768 "start($self, tag, attrs, /)\n"
769 "--\n"
770 "\n");
771
772 #define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \
773 {"start", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_start, METH_FASTCALL, _elementtree_TreeBuilder_start__doc__},
774
775 static PyObject *
776 _elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
777 PyObject *attrs);
778
779 static PyObject *
_elementtree_TreeBuilder_start(TreeBuilderObject * self,PyObject * const * args,Py_ssize_t nargs)780 _elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject *const *args, Py_ssize_t nargs)
781 {
782 PyObject *return_value = NULL;
783 PyObject *tag;
784 PyObject *attrs;
785
786 if (!_PyArg_CheckPositional("start", nargs, 2, 2)) {
787 goto exit;
788 }
789 tag = args[0];
790 if (!PyDict_Check(args[1])) {
791 _PyArg_BadArgument("start", "argument 2", "dict", args[1]);
792 goto exit;
793 }
794 attrs = args[1];
795 return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs);
796
797 exit:
798 return return_value;
799 }
800
801 static int
802 _elementtree_XMLParser___init___impl(XMLParserObject *self, PyObject *target,
803 const char *encoding);
804
805 static int
_elementtree_XMLParser___init__(PyObject * self,PyObject * args,PyObject * kwargs)806 _elementtree_XMLParser___init__(PyObject *self, PyObject *args, PyObject *kwargs)
807 {
808 int return_value = -1;
809 static const char * const _keywords[] = {"target", "encoding", NULL};
810 static _PyArg_Parser _parser = {NULL, _keywords, "XMLParser", 0};
811 PyObject *argsbuf[2];
812 PyObject * const *fastargs;
813 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
814 Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
815 PyObject *target = NULL;
816 const char *encoding = NULL;
817
818 fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 0, 0, argsbuf);
819 if (!fastargs) {
820 goto exit;
821 }
822 if (!noptargs) {
823 goto skip_optional_kwonly;
824 }
825 if (fastargs[0]) {
826 target = fastargs[0];
827 if (!--noptargs) {
828 goto skip_optional_kwonly;
829 }
830 }
831 if (fastargs[1] == Py_None) {
832 encoding = NULL;
833 }
834 else if (PyUnicode_Check(fastargs[1])) {
835 Py_ssize_t encoding_length;
836 encoding = PyUnicode_AsUTF8AndSize(fastargs[1], &encoding_length);
837 if (encoding == NULL) {
838 goto exit;
839 }
840 if (strlen(encoding) != (size_t)encoding_length) {
841 PyErr_SetString(PyExc_ValueError, "embedded null character");
842 goto exit;
843 }
844 }
845 else {
846 _PyArg_BadArgument("XMLParser", "argument 'encoding'", "str or None", fastargs[1]);
847 goto exit;
848 }
849 skip_optional_kwonly:
850 return_value = _elementtree_XMLParser___init___impl((XMLParserObject *)self, target, encoding);
851
852 exit:
853 return return_value;
854 }
855
856 PyDoc_STRVAR(_elementtree_XMLParser_close__doc__,
857 "close($self, /)\n"
858 "--\n"
859 "\n");
860
861 #define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF \
862 {"close", (PyCFunction)_elementtree_XMLParser_close, METH_NOARGS, _elementtree_XMLParser_close__doc__},
863
864 static PyObject *
865 _elementtree_XMLParser_close_impl(XMLParserObject *self);
866
867 static PyObject *
_elementtree_XMLParser_close(XMLParserObject * self,PyObject * Py_UNUSED (ignored))868 _elementtree_XMLParser_close(XMLParserObject *self, PyObject *Py_UNUSED(ignored))
869 {
870 return _elementtree_XMLParser_close_impl(self);
871 }
872
873 PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__,
874 "feed($self, data, /)\n"
875 "--\n"
876 "\n");
877
878 #define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF \
879 {"feed", (PyCFunction)_elementtree_XMLParser_feed, METH_O, _elementtree_XMLParser_feed__doc__},
880
881 PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__,
882 "_parse_whole($self, file, /)\n"
883 "--\n"
884 "\n");
885
886 #define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF \
887 {"_parse_whole", (PyCFunction)_elementtree_XMLParser__parse_whole, METH_O, _elementtree_XMLParser__parse_whole__doc__},
888
889 PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
890 "_setevents($self, events_queue, events_to_report=None, /)\n"
891 "--\n"
892 "\n");
893
894 #define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \
895 {"_setevents", (PyCFunction)(void(*)(void))_elementtree_XMLParser__setevents, METH_FASTCALL, _elementtree_XMLParser__setevents__doc__},
896
897 static PyObject *
898 _elementtree_XMLParser__setevents_impl(XMLParserObject *self,
899 PyObject *events_queue,
900 PyObject *events_to_report);
901
902 static PyObject *
_elementtree_XMLParser__setevents(XMLParserObject * self,PyObject * const * args,Py_ssize_t nargs)903 _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *const *args, Py_ssize_t nargs)
904 {
905 PyObject *return_value = NULL;
906 PyObject *events_queue;
907 PyObject *events_to_report = Py_None;
908
909 if (!_PyArg_CheckPositional("_setevents", nargs, 1, 2)) {
910 goto exit;
911 }
912 events_queue = args[0];
913 if (nargs < 2) {
914 goto skip_optional;
915 }
916 events_to_report = args[1];
917 skip_optional:
918 return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report);
919
920 exit:
921 return return_value;
922 }
923 /*[clinic end generated code: output=b7f6a32462fc42a9 input=a9049054013a1b77]*/
924