Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 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 | _elementtree_Element_append(ElementObject *self, PyObject *arg) |
| 18 | { |
| 19 | PyObject *return_value = NULL; |
| 20 | PyObject *subelement; |
| 21 | |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 22 | if (!PyArg_Parse(arg, "O!:append", &Element_Type, &subelement)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 23 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 24 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 25 | return_value = _elementtree_Element_append_impl(self, subelement); |
| 26 | |
| 27 | exit: |
| 28 | return return_value; |
| 29 | } |
| 30 | |
| 31 | PyDoc_STRVAR(_elementtree_Element_clear__doc__, |
| 32 | "clear($self, /)\n" |
| 33 | "--\n" |
| 34 | "\n"); |
| 35 | |
| 36 | #define _ELEMENTTREE_ELEMENT_CLEAR_METHODDEF \ |
| 37 | {"clear", (PyCFunction)_elementtree_Element_clear, METH_NOARGS, _elementtree_Element_clear__doc__}, |
| 38 | |
| 39 | static PyObject * |
| 40 | _elementtree_Element_clear_impl(ElementObject *self); |
| 41 | |
| 42 | static PyObject * |
| 43 | _elementtree_Element_clear(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 44 | { |
| 45 | return _elementtree_Element_clear_impl(self); |
| 46 | } |
| 47 | |
| 48 | PyDoc_STRVAR(_elementtree_Element___copy____doc__, |
| 49 | "__copy__($self, /)\n" |
| 50 | "--\n" |
| 51 | "\n"); |
| 52 | |
| 53 | #define _ELEMENTTREE_ELEMENT___COPY___METHODDEF \ |
| 54 | {"__copy__", (PyCFunction)_elementtree_Element___copy__, METH_NOARGS, _elementtree_Element___copy____doc__}, |
| 55 | |
| 56 | static PyObject * |
| 57 | _elementtree_Element___copy___impl(ElementObject *self); |
| 58 | |
| 59 | static PyObject * |
| 60 | _elementtree_Element___copy__(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 61 | { |
| 62 | return _elementtree_Element___copy___impl(self); |
| 63 | } |
| 64 | |
| 65 | PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__, |
| 66 | "__deepcopy__($self, memo, /)\n" |
| 67 | "--\n" |
| 68 | "\n"); |
| 69 | |
| 70 | #define _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF \ |
| 71 | {"__deepcopy__", (PyCFunction)_elementtree_Element___deepcopy__, METH_O, _elementtree_Element___deepcopy____doc__}, |
| 72 | |
| 73 | PyDoc_STRVAR(_elementtree_Element___sizeof____doc__, |
| 74 | "__sizeof__($self, /)\n" |
| 75 | "--\n" |
| 76 | "\n"); |
| 77 | |
| 78 | #define _ELEMENTTREE_ELEMENT___SIZEOF___METHODDEF \ |
| 79 | {"__sizeof__", (PyCFunction)_elementtree_Element___sizeof__, METH_NOARGS, _elementtree_Element___sizeof____doc__}, |
| 80 | |
| 81 | static Py_ssize_t |
| 82 | _elementtree_Element___sizeof___impl(ElementObject *self); |
| 83 | |
| 84 | static PyObject * |
| 85 | _elementtree_Element___sizeof__(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 86 | { |
| 87 | PyObject *return_value = NULL; |
| 88 | Py_ssize_t _return_value; |
| 89 | |
| 90 | _return_value = _elementtree_Element___sizeof___impl(self); |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 91 | if ((_return_value == -1) && PyErr_Occurred()) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 92 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 93 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 94 | return_value = PyLong_FromSsize_t(_return_value); |
| 95 | |
| 96 | exit: |
| 97 | return return_value; |
| 98 | } |
| 99 | |
| 100 | PyDoc_STRVAR(_elementtree_Element___getstate____doc__, |
| 101 | "__getstate__($self, /)\n" |
| 102 | "--\n" |
| 103 | "\n"); |
| 104 | |
| 105 | #define _ELEMENTTREE_ELEMENT___GETSTATE___METHODDEF \ |
| 106 | {"__getstate__", (PyCFunction)_elementtree_Element___getstate__, METH_NOARGS, _elementtree_Element___getstate____doc__}, |
| 107 | |
| 108 | static PyObject * |
| 109 | _elementtree_Element___getstate___impl(ElementObject *self); |
| 110 | |
| 111 | static PyObject * |
| 112 | _elementtree_Element___getstate__(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 113 | { |
| 114 | return _elementtree_Element___getstate___impl(self); |
| 115 | } |
| 116 | |
| 117 | PyDoc_STRVAR(_elementtree_Element___setstate____doc__, |
| 118 | "__setstate__($self, state, /)\n" |
| 119 | "--\n" |
| 120 | "\n"); |
| 121 | |
| 122 | #define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF \ |
| 123 | {"__setstate__", (PyCFunction)_elementtree_Element___setstate__, METH_O, _elementtree_Element___setstate____doc__}, |
| 124 | |
| 125 | PyDoc_STRVAR(_elementtree_Element_extend__doc__, |
| 126 | "extend($self, elements, /)\n" |
| 127 | "--\n" |
| 128 | "\n"); |
| 129 | |
| 130 | #define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF \ |
| 131 | {"extend", (PyCFunction)_elementtree_Element_extend, METH_O, _elementtree_Element_extend__doc__}, |
| 132 | |
| 133 | PyDoc_STRVAR(_elementtree_Element_find__doc__, |
| 134 | "find($self, /, path, namespaces=None)\n" |
| 135 | "--\n" |
| 136 | "\n"); |
| 137 | |
| 138 | #define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \ |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 139 | {"find", (PyCFunction)_elementtree_Element_find, METH_FASTCALL, _elementtree_Element_find__doc__}, |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 140 | |
| 141 | static PyObject * |
| 142 | _elementtree_Element_find_impl(ElementObject *self, PyObject *path, |
| 143 | PyObject *namespaces); |
| 144 | |
| 145 | static PyObject * |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 146 | _elementtree_Element_find(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 147 | { |
| 148 | PyObject *return_value = NULL; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 149 | static const char * const _keywords[] = {"path", "namespaces", NULL}; |
| 150 | static _PyArg_Parser _parser = {"O|O:find", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 151 | PyObject *path; |
| 152 | PyObject *namespaces = Py_None; |
| 153 | |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 154 | if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 155 | &path, &namespaces)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 156 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 157 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 158 | return_value = _elementtree_Element_find_impl(self, path, namespaces); |
| 159 | |
| 160 | exit: |
| 161 | return return_value; |
| 162 | } |
| 163 | |
| 164 | PyDoc_STRVAR(_elementtree_Element_findtext__doc__, |
| 165 | "findtext($self, /, path, default=None, namespaces=None)\n" |
| 166 | "--\n" |
| 167 | "\n"); |
| 168 | |
| 169 | #define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \ |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 170 | {"findtext", (PyCFunction)_elementtree_Element_findtext, METH_FASTCALL, _elementtree_Element_findtext__doc__}, |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 171 | |
| 172 | static PyObject * |
| 173 | _elementtree_Element_findtext_impl(ElementObject *self, PyObject *path, |
| 174 | PyObject *default_value, |
| 175 | PyObject *namespaces); |
| 176 | |
| 177 | static PyObject * |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 178 | _elementtree_Element_findtext(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 179 | { |
| 180 | PyObject *return_value = NULL; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 181 | static const char * const _keywords[] = {"path", "default", "namespaces", NULL}; |
| 182 | static _PyArg_Parser _parser = {"O|OO:findtext", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 183 | PyObject *path; |
| 184 | PyObject *default_value = Py_None; |
| 185 | PyObject *namespaces = Py_None; |
| 186 | |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 187 | if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 188 | &path, &default_value, &namespaces)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 189 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 190 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 191 | return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces); |
| 192 | |
| 193 | exit: |
| 194 | return return_value; |
| 195 | } |
| 196 | |
| 197 | PyDoc_STRVAR(_elementtree_Element_findall__doc__, |
| 198 | "findall($self, /, path, namespaces=None)\n" |
| 199 | "--\n" |
| 200 | "\n"); |
| 201 | |
| 202 | #define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \ |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 203 | {"findall", (PyCFunction)_elementtree_Element_findall, METH_FASTCALL, _elementtree_Element_findall__doc__}, |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 204 | |
| 205 | static PyObject * |
| 206 | _elementtree_Element_findall_impl(ElementObject *self, PyObject *path, |
| 207 | PyObject *namespaces); |
| 208 | |
| 209 | static PyObject * |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 210 | _elementtree_Element_findall(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 211 | { |
| 212 | PyObject *return_value = NULL; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 213 | static const char * const _keywords[] = {"path", "namespaces", NULL}; |
| 214 | static _PyArg_Parser _parser = {"O|O:findall", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 215 | PyObject *path; |
| 216 | PyObject *namespaces = Py_None; |
| 217 | |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 218 | if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 219 | &path, &namespaces)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 220 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 221 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 222 | return_value = _elementtree_Element_findall_impl(self, path, namespaces); |
| 223 | |
| 224 | exit: |
| 225 | return return_value; |
| 226 | } |
| 227 | |
| 228 | PyDoc_STRVAR(_elementtree_Element_iterfind__doc__, |
| 229 | "iterfind($self, /, path, namespaces=None)\n" |
| 230 | "--\n" |
| 231 | "\n"); |
| 232 | |
| 233 | #define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \ |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 234 | {"iterfind", (PyCFunction)_elementtree_Element_iterfind, METH_FASTCALL, _elementtree_Element_iterfind__doc__}, |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 235 | |
| 236 | static PyObject * |
| 237 | _elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path, |
| 238 | PyObject *namespaces); |
| 239 | |
| 240 | static PyObject * |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 241 | _elementtree_Element_iterfind(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 242 | { |
| 243 | PyObject *return_value = NULL; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 244 | static const char * const _keywords[] = {"path", "namespaces", NULL}; |
| 245 | static _PyArg_Parser _parser = {"O|O:iterfind", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 246 | PyObject *path; |
| 247 | PyObject *namespaces = Py_None; |
| 248 | |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 249 | if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 250 | &path, &namespaces)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 251 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 252 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 253 | return_value = _elementtree_Element_iterfind_impl(self, path, namespaces); |
| 254 | |
| 255 | exit: |
| 256 | return return_value; |
| 257 | } |
| 258 | |
| 259 | PyDoc_STRVAR(_elementtree_Element_get__doc__, |
| 260 | "get($self, /, key, default=None)\n" |
| 261 | "--\n" |
| 262 | "\n"); |
| 263 | |
| 264 | #define _ELEMENTTREE_ELEMENT_GET_METHODDEF \ |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 265 | {"get", (PyCFunction)_elementtree_Element_get, METH_FASTCALL, _elementtree_Element_get__doc__}, |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 266 | |
| 267 | static PyObject * |
| 268 | _elementtree_Element_get_impl(ElementObject *self, PyObject *key, |
| 269 | PyObject *default_value); |
| 270 | |
| 271 | static PyObject * |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 272 | _elementtree_Element_get(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 273 | { |
| 274 | PyObject *return_value = NULL; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 275 | static const char * const _keywords[] = {"key", "default", NULL}; |
| 276 | static _PyArg_Parser _parser = {"O|O:get", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 277 | PyObject *key; |
| 278 | PyObject *default_value = Py_None; |
| 279 | |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 280 | if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 281 | &key, &default_value)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 282 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 283 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 284 | return_value = _elementtree_Element_get_impl(self, key, default_value); |
| 285 | |
| 286 | exit: |
| 287 | return return_value; |
| 288 | } |
| 289 | |
| 290 | PyDoc_STRVAR(_elementtree_Element_getchildren__doc__, |
| 291 | "getchildren($self, /)\n" |
| 292 | "--\n" |
| 293 | "\n"); |
| 294 | |
| 295 | #define _ELEMENTTREE_ELEMENT_GETCHILDREN_METHODDEF \ |
| 296 | {"getchildren", (PyCFunction)_elementtree_Element_getchildren, METH_NOARGS, _elementtree_Element_getchildren__doc__}, |
| 297 | |
| 298 | static PyObject * |
| 299 | _elementtree_Element_getchildren_impl(ElementObject *self); |
| 300 | |
| 301 | static PyObject * |
| 302 | _elementtree_Element_getchildren(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 303 | { |
| 304 | return _elementtree_Element_getchildren_impl(self); |
| 305 | } |
| 306 | |
| 307 | PyDoc_STRVAR(_elementtree_Element_iter__doc__, |
| 308 | "iter($self, /, tag=None)\n" |
| 309 | "--\n" |
| 310 | "\n"); |
| 311 | |
| 312 | #define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \ |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 313 | {"iter", (PyCFunction)_elementtree_Element_iter, METH_FASTCALL, _elementtree_Element_iter__doc__}, |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 314 | |
| 315 | static PyObject * |
| 316 | _elementtree_Element_iter_impl(ElementObject *self, PyObject *tag); |
| 317 | |
| 318 | static PyObject * |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 319 | _elementtree_Element_iter(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 320 | { |
| 321 | PyObject *return_value = NULL; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 322 | static const char * const _keywords[] = {"tag", NULL}; |
| 323 | static _PyArg_Parser _parser = {"|O:iter", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 324 | PyObject *tag = Py_None; |
| 325 | |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 326 | if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 327 | &tag)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 328 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 329 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 330 | return_value = _elementtree_Element_iter_impl(self, tag); |
| 331 | |
| 332 | exit: |
| 333 | return return_value; |
| 334 | } |
| 335 | |
| 336 | PyDoc_STRVAR(_elementtree_Element_itertext__doc__, |
| 337 | "itertext($self, /)\n" |
| 338 | "--\n" |
| 339 | "\n"); |
| 340 | |
| 341 | #define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF \ |
| 342 | {"itertext", (PyCFunction)_elementtree_Element_itertext, METH_NOARGS, _elementtree_Element_itertext__doc__}, |
| 343 | |
| 344 | static PyObject * |
| 345 | _elementtree_Element_itertext_impl(ElementObject *self); |
| 346 | |
| 347 | static PyObject * |
| 348 | _elementtree_Element_itertext(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 349 | { |
| 350 | return _elementtree_Element_itertext_impl(self); |
| 351 | } |
| 352 | |
| 353 | PyDoc_STRVAR(_elementtree_Element_insert__doc__, |
| 354 | "insert($self, index, subelement, /)\n" |
| 355 | "--\n" |
| 356 | "\n"); |
| 357 | |
| 358 | #define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF \ |
| 359 | {"insert", (PyCFunction)_elementtree_Element_insert, METH_VARARGS, _elementtree_Element_insert__doc__}, |
| 360 | |
| 361 | static PyObject * |
| 362 | _elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index, |
| 363 | PyObject *subelement); |
| 364 | |
| 365 | static PyObject * |
| 366 | _elementtree_Element_insert(ElementObject *self, PyObject *args) |
| 367 | { |
| 368 | PyObject *return_value = NULL; |
| 369 | Py_ssize_t index; |
| 370 | PyObject *subelement; |
| 371 | |
| 372 | if (!PyArg_ParseTuple(args, "nO!:insert", |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 373 | &index, &Element_Type, &subelement)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 374 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 375 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 376 | return_value = _elementtree_Element_insert_impl(self, index, subelement); |
| 377 | |
| 378 | exit: |
| 379 | return return_value; |
| 380 | } |
| 381 | |
| 382 | PyDoc_STRVAR(_elementtree_Element_items__doc__, |
| 383 | "items($self, /)\n" |
| 384 | "--\n" |
| 385 | "\n"); |
| 386 | |
| 387 | #define _ELEMENTTREE_ELEMENT_ITEMS_METHODDEF \ |
| 388 | {"items", (PyCFunction)_elementtree_Element_items, METH_NOARGS, _elementtree_Element_items__doc__}, |
| 389 | |
| 390 | static PyObject * |
| 391 | _elementtree_Element_items_impl(ElementObject *self); |
| 392 | |
| 393 | static PyObject * |
| 394 | _elementtree_Element_items(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 395 | { |
| 396 | return _elementtree_Element_items_impl(self); |
| 397 | } |
| 398 | |
| 399 | PyDoc_STRVAR(_elementtree_Element_keys__doc__, |
| 400 | "keys($self, /)\n" |
| 401 | "--\n" |
| 402 | "\n"); |
| 403 | |
| 404 | #define _ELEMENTTREE_ELEMENT_KEYS_METHODDEF \ |
| 405 | {"keys", (PyCFunction)_elementtree_Element_keys, METH_NOARGS, _elementtree_Element_keys__doc__}, |
| 406 | |
| 407 | static PyObject * |
| 408 | _elementtree_Element_keys_impl(ElementObject *self); |
| 409 | |
| 410 | static PyObject * |
| 411 | _elementtree_Element_keys(ElementObject *self, PyObject *Py_UNUSED(ignored)) |
| 412 | { |
| 413 | return _elementtree_Element_keys_impl(self); |
| 414 | } |
| 415 | |
| 416 | PyDoc_STRVAR(_elementtree_Element_makeelement__doc__, |
| 417 | "makeelement($self, tag, attrib, /)\n" |
| 418 | "--\n" |
| 419 | "\n"); |
| 420 | |
| 421 | #define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \ |
| 422 | {"makeelement", (PyCFunction)_elementtree_Element_makeelement, METH_VARARGS, _elementtree_Element_makeelement__doc__}, |
| 423 | |
| 424 | static PyObject * |
| 425 | _elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag, |
| 426 | PyObject *attrib); |
| 427 | |
| 428 | static PyObject * |
| 429 | _elementtree_Element_makeelement(ElementObject *self, PyObject *args) |
| 430 | { |
| 431 | PyObject *return_value = NULL; |
| 432 | PyObject *tag; |
| 433 | PyObject *attrib; |
| 434 | |
| 435 | if (!PyArg_UnpackTuple(args, "makeelement", |
| 436 | 2, 2, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 437 | &tag, &attrib)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 438 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 439 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 440 | return_value = _elementtree_Element_makeelement_impl(self, tag, attrib); |
| 441 | |
| 442 | exit: |
| 443 | return return_value; |
| 444 | } |
| 445 | |
| 446 | PyDoc_STRVAR(_elementtree_Element_remove__doc__, |
| 447 | "remove($self, subelement, /)\n" |
| 448 | "--\n" |
| 449 | "\n"); |
| 450 | |
| 451 | #define _ELEMENTTREE_ELEMENT_REMOVE_METHODDEF \ |
| 452 | {"remove", (PyCFunction)_elementtree_Element_remove, METH_O, _elementtree_Element_remove__doc__}, |
| 453 | |
| 454 | static PyObject * |
| 455 | _elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement); |
| 456 | |
| 457 | static PyObject * |
| 458 | _elementtree_Element_remove(ElementObject *self, PyObject *arg) |
| 459 | { |
| 460 | PyObject *return_value = NULL; |
| 461 | PyObject *subelement; |
| 462 | |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 463 | if (!PyArg_Parse(arg, "O!:remove", &Element_Type, &subelement)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 464 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 465 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 466 | return_value = _elementtree_Element_remove_impl(self, subelement); |
| 467 | |
| 468 | exit: |
| 469 | return return_value; |
| 470 | } |
| 471 | |
| 472 | PyDoc_STRVAR(_elementtree_Element_set__doc__, |
| 473 | "set($self, key, value, /)\n" |
| 474 | "--\n" |
| 475 | "\n"); |
| 476 | |
| 477 | #define _ELEMENTTREE_ELEMENT_SET_METHODDEF \ |
| 478 | {"set", (PyCFunction)_elementtree_Element_set, METH_VARARGS, _elementtree_Element_set__doc__}, |
| 479 | |
| 480 | static PyObject * |
| 481 | _elementtree_Element_set_impl(ElementObject *self, PyObject *key, |
| 482 | PyObject *value); |
| 483 | |
| 484 | static PyObject * |
| 485 | _elementtree_Element_set(ElementObject *self, PyObject *args) |
| 486 | { |
| 487 | PyObject *return_value = NULL; |
| 488 | PyObject *key; |
| 489 | PyObject *value; |
| 490 | |
| 491 | if (!PyArg_UnpackTuple(args, "set", |
| 492 | 2, 2, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 493 | &key, &value)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 494 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 495 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 496 | return_value = _elementtree_Element_set_impl(self, key, value); |
| 497 | |
| 498 | exit: |
| 499 | return return_value; |
| 500 | } |
| 501 | |
| 502 | static int |
| 503 | _elementtree_TreeBuilder___init___impl(TreeBuilderObject *self, |
| 504 | PyObject *element_factory); |
| 505 | |
| 506 | static int |
| 507 | _elementtree_TreeBuilder___init__(PyObject *self, PyObject *args, PyObject *kwargs) |
| 508 | { |
| 509 | int return_value = -1; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 510 | static const char * const _keywords[] = {"element_factory", NULL}; |
| 511 | static _PyArg_Parser _parser = {"|O:TreeBuilder", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 512 | PyObject *element_factory = NULL; |
| 513 | |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 514 | if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 515 | &element_factory)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 516 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 517 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 518 | return_value = _elementtree_TreeBuilder___init___impl((TreeBuilderObject *)self, element_factory); |
| 519 | |
| 520 | exit: |
| 521 | return return_value; |
| 522 | } |
| 523 | |
| 524 | PyDoc_STRVAR(_elementtree_TreeBuilder_data__doc__, |
| 525 | "data($self, data, /)\n" |
| 526 | "--\n" |
| 527 | "\n"); |
| 528 | |
| 529 | #define _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF \ |
| 530 | {"data", (PyCFunction)_elementtree_TreeBuilder_data, METH_O, _elementtree_TreeBuilder_data__doc__}, |
| 531 | |
| 532 | PyDoc_STRVAR(_elementtree_TreeBuilder_end__doc__, |
| 533 | "end($self, tag, /)\n" |
| 534 | "--\n" |
| 535 | "\n"); |
| 536 | |
| 537 | #define _ELEMENTTREE_TREEBUILDER_END_METHODDEF \ |
| 538 | {"end", (PyCFunction)_elementtree_TreeBuilder_end, METH_O, _elementtree_TreeBuilder_end__doc__}, |
| 539 | |
| 540 | PyDoc_STRVAR(_elementtree_TreeBuilder_close__doc__, |
| 541 | "close($self, /)\n" |
| 542 | "--\n" |
| 543 | "\n"); |
| 544 | |
| 545 | #define _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF \ |
| 546 | {"close", (PyCFunction)_elementtree_TreeBuilder_close, METH_NOARGS, _elementtree_TreeBuilder_close__doc__}, |
| 547 | |
| 548 | static PyObject * |
| 549 | _elementtree_TreeBuilder_close_impl(TreeBuilderObject *self); |
| 550 | |
| 551 | static PyObject * |
| 552 | _elementtree_TreeBuilder_close(TreeBuilderObject *self, PyObject *Py_UNUSED(ignored)) |
| 553 | { |
| 554 | return _elementtree_TreeBuilder_close_impl(self); |
| 555 | } |
| 556 | |
| 557 | PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__, |
| 558 | "start($self, tag, attrs=None, /)\n" |
| 559 | "--\n" |
| 560 | "\n"); |
| 561 | |
| 562 | #define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \ |
| 563 | {"start", (PyCFunction)_elementtree_TreeBuilder_start, METH_VARARGS, _elementtree_TreeBuilder_start__doc__}, |
| 564 | |
| 565 | static PyObject * |
| 566 | _elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag, |
| 567 | PyObject *attrs); |
| 568 | |
| 569 | static PyObject * |
| 570 | _elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject *args) |
| 571 | { |
| 572 | PyObject *return_value = NULL; |
| 573 | PyObject *tag; |
| 574 | PyObject *attrs = Py_None; |
| 575 | |
| 576 | if (!PyArg_UnpackTuple(args, "start", |
| 577 | 1, 2, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 578 | &tag, &attrs)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 579 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 580 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 581 | return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs); |
| 582 | |
| 583 | exit: |
| 584 | return return_value; |
| 585 | } |
| 586 | |
| 587 | static int |
| 588 | _elementtree_XMLParser___init___impl(XMLParserObject *self, PyObject *html, |
| 589 | PyObject *target, const char *encoding); |
| 590 | |
| 591 | static int |
| 592 | _elementtree_XMLParser___init__(PyObject *self, PyObject *args, PyObject *kwargs) |
| 593 | { |
| 594 | int return_value = -1; |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 595 | static const char * const _keywords[] = {"html", "target", "encoding", NULL}; |
| 596 | static _PyArg_Parser _parser = {"|OOz:XMLParser", _keywords, 0}; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 597 | PyObject *html = NULL; |
| 598 | PyObject *target = NULL; |
| 599 | const char *encoding = NULL; |
| 600 | |
Serhiy Storchaka | 9171a8b | 2016-08-14 10:52:18 +0300 | [diff] [blame] | 601 | if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 602 | &html, &target, &encoding)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 603 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 604 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 605 | return_value = _elementtree_XMLParser___init___impl((XMLParserObject *)self, html, target, encoding); |
| 606 | |
| 607 | exit: |
| 608 | return return_value; |
| 609 | } |
| 610 | |
| 611 | PyDoc_STRVAR(_elementtree_XMLParser_close__doc__, |
| 612 | "close($self, /)\n" |
| 613 | "--\n" |
| 614 | "\n"); |
| 615 | |
| 616 | #define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF \ |
| 617 | {"close", (PyCFunction)_elementtree_XMLParser_close, METH_NOARGS, _elementtree_XMLParser_close__doc__}, |
| 618 | |
| 619 | static PyObject * |
| 620 | _elementtree_XMLParser_close_impl(XMLParserObject *self); |
| 621 | |
| 622 | static PyObject * |
| 623 | _elementtree_XMLParser_close(XMLParserObject *self, PyObject *Py_UNUSED(ignored)) |
| 624 | { |
| 625 | return _elementtree_XMLParser_close_impl(self); |
| 626 | } |
| 627 | |
| 628 | PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__, |
| 629 | "feed($self, data, /)\n" |
| 630 | "--\n" |
| 631 | "\n"); |
| 632 | |
| 633 | #define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF \ |
| 634 | {"feed", (PyCFunction)_elementtree_XMLParser_feed, METH_O, _elementtree_XMLParser_feed__doc__}, |
| 635 | |
| 636 | PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__, |
| 637 | "_parse_whole($self, file, /)\n" |
| 638 | "--\n" |
| 639 | "\n"); |
| 640 | |
| 641 | #define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF \ |
| 642 | {"_parse_whole", (PyCFunction)_elementtree_XMLParser__parse_whole, METH_O, _elementtree_XMLParser__parse_whole__doc__}, |
| 643 | |
| 644 | PyDoc_STRVAR(_elementtree_XMLParser_doctype__doc__, |
Serhiy Storchaka | 4a01cab | 2015-06-29 23:08:52 +0300 | [diff] [blame] | 645 | "doctype($self, name, pubid, system, /)\n" |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 646 | "--\n" |
| 647 | "\n"); |
| 648 | |
| 649 | #define _ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF \ |
Serhiy Storchaka | 4a01cab | 2015-06-29 23:08:52 +0300 | [diff] [blame] | 650 | {"doctype", (PyCFunction)_elementtree_XMLParser_doctype, METH_VARARGS, _elementtree_XMLParser_doctype__doc__}, |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 651 | |
| 652 | static PyObject * |
Serhiy Storchaka | 4a01cab | 2015-06-29 23:08:52 +0300 | [diff] [blame] | 653 | _elementtree_XMLParser_doctype_impl(XMLParserObject *self, PyObject *name, |
| 654 | PyObject *pubid, PyObject *system); |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 655 | |
| 656 | static PyObject * |
Serhiy Storchaka | 4a01cab | 2015-06-29 23:08:52 +0300 | [diff] [blame] | 657 | _elementtree_XMLParser_doctype(XMLParserObject *self, PyObject *args) |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 658 | { |
Serhiy Storchaka | 4a01cab | 2015-06-29 23:08:52 +0300 | [diff] [blame] | 659 | PyObject *return_value = NULL; |
| 660 | PyObject *name; |
| 661 | PyObject *pubid; |
| 662 | PyObject *system; |
| 663 | |
| 664 | if (!PyArg_UnpackTuple(args, "doctype", |
| 665 | 3, 3, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 666 | &name, &pubid, &system)) { |
Serhiy Storchaka | 4a01cab | 2015-06-29 23:08:52 +0300 | [diff] [blame] | 667 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 668 | } |
Serhiy Storchaka | 4a01cab | 2015-06-29 23:08:52 +0300 | [diff] [blame] | 669 | return_value = _elementtree_XMLParser_doctype_impl(self, name, pubid, system); |
| 670 | |
| 671 | exit: |
| 672 | return return_value; |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 673 | } |
| 674 | |
| 675 | PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__, |
| 676 | "_setevents($self, events_queue, events_to_report=None, /)\n" |
| 677 | "--\n" |
| 678 | "\n"); |
| 679 | |
| 680 | #define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \ |
| 681 | {"_setevents", (PyCFunction)_elementtree_XMLParser__setevents, METH_VARARGS, _elementtree_XMLParser__setevents__doc__}, |
| 682 | |
| 683 | static PyObject * |
| 684 | _elementtree_XMLParser__setevents_impl(XMLParserObject *self, |
| 685 | PyObject *events_queue, |
| 686 | PyObject *events_to_report); |
| 687 | |
| 688 | static PyObject * |
| 689 | _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *args) |
| 690 | { |
| 691 | PyObject *return_value = NULL; |
| 692 | PyObject *events_queue; |
| 693 | PyObject *events_to_report = Py_None; |
| 694 | |
Serhiy Storchaka | 9ec5e25 | 2015-12-07 02:31:11 +0200 | [diff] [blame] | 695 | if (!PyArg_UnpackTuple(args, "_setevents", |
| 696 | 1, 2, |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 697 | &events_queue, &events_to_report)) { |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 698 | goto exit; |
Serhiy Storchaka | 5dee655 | 2016-06-09 16:16:06 +0300 | [diff] [blame] | 699 | } |
Serhiy Storchaka | cb98556 | 2015-05-04 15:32:48 +0300 | [diff] [blame] | 700 | return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report); |
| 701 | |
| 702 | exit: |
| 703 | return return_value; |
| 704 | } |
Victor Stinner | 37e4ef7 | 2016-09-09 20:00:13 -0700 | [diff] [blame] | 705 | /*[clinic end generated code: output=b4a571a98ced3163 input=a9049054013a1b77]*/ |