Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(_io_IncrementalNewlineDecoder___init____doc__,
6 : : "IncrementalNewlineDecoder(decoder, translate, errors=\'strict\')\n"
7 : : "--\n"
8 : : "\n"
9 : : "Codec used when reading a file in universal newlines mode.\n"
10 : : "\n"
11 : : "It wraps another incremental decoder, translating \\r\\n and \\r into \\n.\n"
12 : : "It also records the types of newlines encountered. When used with\n"
13 : : "translate=False, it ensures that the newline sequence is returned in\n"
14 : : "one piece. When used with decoder=None, it expects unicode strings as\n"
15 : : "decode input and translates newlines without first invoking an external\n"
16 : : "decoder.");
17 : :
18 : : static int
19 : : _io_IncrementalNewlineDecoder___init___impl(nldecoder_object *self,
20 : : PyObject *decoder, int translate,
21 : : PyObject *errors);
22 : :
23 : : static int
24 : 15026 : _io_IncrementalNewlineDecoder___init__(PyObject *self, PyObject *args, PyObject *kwargs)
25 : : {
26 : 15026 : int return_value = -1;
27 : : static const char * const _keywords[] = {"decoder", "translate", "errors", NULL};
28 : : static _PyArg_Parser _parser = {NULL, _keywords, "IncrementalNewlineDecoder", 0};
29 : : PyObject *argsbuf[3];
30 : : PyObject * const *fastargs;
31 : 15026 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
32 [ + + ]: 15026 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 2;
33 : : PyObject *decoder;
34 : : int translate;
35 : 15026 : PyObject *errors = NULL;
36 : :
37 [ + + + - : 15026 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 2, 3, 0, argsbuf);
+ - + - ]
38 [ - + ]: 15026 : if (!fastargs) {
39 : 0 : goto exit;
40 : : }
41 : 15026 : decoder = fastargs[0];
42 : 15026 : translate = _PyLong_AsInt(fastargs[1]);
43 [ + + - + ]: 15026 : if (translate == -1 && PyErr_Occurred()) {
44 : 0 : goto exit;
45 : : }
46 [ + - ]: 15026 : if (!noptargs) {
47 : 15026 : goto skip_optional_pos;
48 : : }
49 : 0 : errors = fastargs[2];
50 : 15026 : skip_optional_pos:
51 : 15026 : return_value = _io_IncrementalNewlineDecoder___init___impl((nldecoder_object *)self, decoder, translate, errors);
52 : :
53 : 15026 : exit:
54 : 15026 : return return_value;
55 : : }
56 : :
57 : : PyDoc_STRVAR(_io_IncrementalNewlineDecoder_decode__doc__,
58 : : "decode($self, /, input, final=False)\n"
59 : : "--\n"
60 : : "\n");
61 : :
62 : : #define _IO_INCREMENTALNEWLINEDECODER_DECODE_METHODDEF \
63 : : {"decode", _PyCFunction_CAST(_io_IncrementalNewlineDecoder_decode), METH_FASTCALL|METH_KEYWORDS, _io_IncrementalNewlineDecoder_decode__doc__},
64 : :
65 : : static PyObject *
66 : : _io_IncrementalNewlineDecoder_decode_impl(nldecoder_object *self,
67 : : PyObject *input, int final);
68 : :
69 : : static PyObject *
70 : 20997 : _io_IncrementalNewlineDecoder_decode(nldecoder_object *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
71 : : {
72 : 20997 : PyObject *return_value = NULL;
73 : : static const char * const _keywords[] = {"input", "final", NULL};
74 : : static _PyArg_Parser _parser = {NULL, _keywords, "decode", 0};
75 : : PyObject *argsbuf[2];
76 [ + + ]: 20997 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
77 : : PyObject *input;
78 : 20997 : int final = 0;
79 : :
80 [ + + + - : 20997 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
81 [ - + ]: 20997 : if (!args) {
82 : 0 : goto exit;
83 : : }
84 : 20997 : input = args[0];
85 [ + + ]: 20997 : if (!noptargs) {
86 : 19254 : goto skip_optional_pos;
87 : : }
88 : 1743 : final = _PyLong_AsInt(args[1]);
89 [ - + - - ]: 1743 : if (final == -1 && PyErr_Occurred()) {
90 : 0 : goto exit;
91 : : }
92 : 1743 : skip_optional_pos:
93 : 20997 : return_value = _io_IncrementalNewlineDecoder_decode_impl(self, input, final);
94 : :
95 : 20997 : exit:
96 : 20997 : return return_value;
97 : : }
98 : :
99 : : PyDoc_STRVAR(_io_IncrementalNewlineDecoder_getstate__doc__,
100 : : "getstate($self, /)\n"
101 : : "--\n"
102 : : "\n");
103 : :
104 : : #define _IO_INCREMENTALNEWLINEDECODER_GETSTATE_METHODDEF \
105 : : {"getstate", (PyCFunction)_io_IncrementalNewlineDecoder_getstate, METH_NOARGS, _io_IncrementalNewlineDecoder_getstate__doc__},
106 : :
107 : : static PyObject *
108 : : _io_IncrementalNewlineDecoder_getstate_impl(nldecoder_object *self);
109 : :
110 : : static PyObject *
111 : 34235 : _io_IncrementalNewlineDecoder_getstate(nldecoder_object *self, PyObject *Py_UNUSED(ignored))
112 : : {
113 : 34235 : return _io_IncrementalNewlineDecoder_getstate_impl(self);
114 : : }
115 : :
116 : : PyDoc_STRVAR(_io_IncrementalNewlineDecoder_setstate__doc__,
117 : : "setstate($self, state, /)\n"
118 : : "--\n"
119 : : "\n");
120 : :
121 : : #define _IO_INCREMENTALNEWLINEDECODER_SETSTATE_METHODDEF \
122 : : {"setstate", (PyCFunction)_io_IncrementalNewlineDecoder_setstate, METH_O, _io_IncrementalNewlineDecoder_setstate__doc__},
123 : :
124 : : PyDoc_STRVAR(_io_IncrementalNewlineDecoder_reset__doc__,
125 : : "reset($self, /)\n"
126 : : "--\n"
127 : : "\n");
128 : :
129 : : #define _IO_INCREMENTALNEWLINEDECODER_RESET_METHODDEF \
130 : : {"reset", (PyCFunction)_io_IncrementalNewlineDecoder_reset, METH_NOARGS, _io_IncrementalNewlineDecoder_reset__doc__},
131 : :
132 : : static PyObject *
133 : : _io_IncrementalNewlineDecoder_reset_impl(nldecoder_object *self);
134 : :
135 : : static PyObject *
136 : 5172 : _io_IncrementalNewlineDecoder_reset(nldecoder_object *self, PyObject *Py_UNUSED(ignored))
137 : : {
138 : 5172 : return _io_IncrementalNewlineDecoder_reset_impl(self);
139 : : }
140 : :
141 : : PyDoc_STRVAR(_io_TextIOWrapper___init____doc__,
142 : : "TextIOWrapper(buffer, encoding=None, errors=None, newline=None,\n"
143 : : " line_buffering=False, write_through=False)\n"
144 : : "--\n"
145 : : "\n"
146 : : "Character and line based layer over a BufferedIOBase object, buffer.\n"
147 : : "\n"
148 : : "encoding gives the name of the encoding that the stream will be\n"
149 : : "decoded or encoded with. It defaults to locale.getencoding().\n"
150 : : "\n"
151 : : "errors determines the strictness of encoding and decoding (see\n"
152 : : "help(codecs.Codec) or the documentation for codecs.register) and\n"
153 : : "defaults to \"strict\".\n"
154 : : "\n"
155 : : "newline controls how line endings are handled. It can be None, \'\',\n"
156 : : "\'\\n\', \'\\r\', and \'\\r\\n\'. It works as follows:\n"
157 : : "\n"
158 : : "* On input, if newline is None, universal newlines mode is\n"
159 : : " enabled. Lines in the input can end in \'\\n\', \'\\r\', or \'\\r\\n\', and\n"
160 : : " these are translated into \'\\n\' before being returned to the\n"
161 : : " caller. If it is \'\', universal newline mode is enabled, but line\n"
162 : : " endings are returned to the caller untranslated. If it has any of\n"
163 : : " the other legal values, input lines are only terminated by the given\n"
164 : : " string, and the line ending is returned to the caller untranslated.\n"
165 : : "\n"
166 : : "* On output, if newline is None, any \'\\n\' characters written are\n"
167 : : " translated to the system default line separator, os.linesep. If\n"
168 : : " newline is \'\' or \'\\n\', no translation takes place. If newline is any\n"
169 : : " of the other legal values, any \'\\n\' characters written are translated\n"
170 : : " to the given string.\n"
171 : : "\n"
172 : : "If line_buffering is True, a call to flush is implied when a call to\n"
173 : : "write contains a newline character.");
174 : :
175 : : static int
176 : : _io_TextIOWrapper___init___impl(textio *self, PyObject *buffer,
177 : : const char *encoding, PyObject *errors,
178 : : const char *newline, int line_buffering,
179 : : int write_through);
180 : :
181 : : static int
182 : 36773 : _io_TextIOWrapper___init__(PyObject *self, PyObject *args, PyObject *kwargs)
183 : : {
184 : 36773 : int return_value = -1;
185 : : static const char * const _keywords[] = {"buffer", "encoding", "errors", "newline", "line_buffering", "write_through", NULL};
186 : : static _PyArg_Parser _parser = {NULL, _keywords, "TextIOWrapper", 0};
187 : : PyObject *argsbuf[6];
188 : : PyObject * const *fastargs;
189 : 36773 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
190 [ + + ]: 36773 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
191 : : PyObject *buffer;
192 : 36773 : const char *encoding = NULL;
193 : 36773 : PyObject *errors = Py_None;
194 : 36773 : const char *newline = NULL;
195 : 36773 : int line_buffering = 0;
196 : 36773 : int write_through = 0;
197 : :
198 [ + + + - : 36773 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 6, 0, argsbuf);
+ - + - ]
199 [ - + ]: 36773 : if (!fastargs) {
200 : 0 : goto exit;
201 : : }
202 : 36773 : buffer = fastargs[0];
203 [ + + ]: 36773 : if (!noptargs) {
204 : 19 : goto skip_optional_pos;
205 : : }
206 [ + + ]: 36754 : if (fastargs[1]) {
207 [ + + ]: 36753 : if (fastargs[1] == Py_None) {
208 : 855 : encoding = NULL;
209 : : }
210 [ + - ]: 35898 : else if (PyUnicode_Check(fastargs[1])) {
211 : : Py_ssize_t encoding_length;
212 : 35898 : encoding = PyUnicode_AsUTF8AndSize(fastargs[1], &encoding_length);
213 [ - + ]: 35898 : if (encoding == NULL) {
214 : 0 : goto exit;
215 : : }
216 [ - + ]: 35898 : if (strlen(encoding) != (size_t)encoding_length) {
217 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
218 : 0 : goto exit;
219 : : }
220 : : }
221 : : else {
222 : 0 : _PyArg_BadArgument("TextIOWrapper", "argument 'encoding'", "str or None", fastargs[1]);
223 : 0 : goto exit;
224 : : }
225 [ + + ]: 36753 : if (!--noptargs) {
226 : 2595 : goto skip_optional_pos;
227 : : }
228 : : }
229 [ + + ]: 34159 : if (fastargs[2]) {
230 : 22957 : errors = fastargs[2];
231 [ + + ]: 22957 : if (!--noptargs) {
232 : 674 : goto skip_optional_pos;
233 : : }
234 : : }
235 [ + + ]: 33485 : if (fastargs[3]) {
236 [ + + ]: 32043 : if (fastargs[3] == Py_None) {
237 : 11457 : newline = NULL;
238 : : }
239 [ + + ]: 20586 : else if (PyUnicode_Check(fastargs[3])) {
240 : : Py_ssize_t newline_length;
241 : 20585 : newline = PyUnicode_AsUTF8AndSize(fastargs[3], &newline_length);
242 [ - + ]: 20585 : if (newline == NULL) {
243 : 0 : goto exit;
244 : : }
245 [ - + ]: 20585 : if (strlen(newline) != (size_t)newline_length) {
246 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
247 : 0 : goto exit;
248 : : }
249 : : }
250 : : else {
251 : 1 : _PyArg_BadArgument("TextIOWrapper", "argument 'newline'", "str or None", fastargs[3]);
252 : 1 : goto exit;
253 : : }
254 [ + + ]: 32042 : if (!--noptargs) {
255 : 10494 : goto skip_optional_pos;
256 : : }
257 : : }
258 [ + + ]: 22990 : if (fastargs[4]) {
259 : 22889 : line_buffering = _PyLong_AsInt(fastargs[4]);
260 [ - + - - ]: 22889 : if (line_buffering == -1 && PyErr_Occurred()) {
261 : 0 : goto exit;
262 : : }
263 [ + + ]: 22889 : if (!--noptargs) {
264 : 13389 : goto skip_optional_pos;
265 : : }
266 : : }
267 : 9601 : write_through = _PyLong_AsInt(fastargs[5]);
268 [ - + - - ]: 9601 : if (write_through == -1 && PyErr_Occurred()) {
269 : 0 : goto exit;
270 : : }
271 : 9601 : skip_optional_pos:
272 : 36772 : return_value = _io_TextIOWrapper___init___impl((textio *)self, buffer, encoding, errors, newline, line_buffering, write_through);
273 : :
274 : 36773 : exit:
275 : 36773 : return return_value;
276 : : }
277 : :
278 : : PyDoc_STRVAR(_io_TextIOWrapper_reconfigure__doc__,
279 : : "reconfigure($self, /, *, encoding=None, errors=None, newline=None,\n"
280 : : " line_buffering=None, write_through=None)\n"
281 : : "--\n"
282 : : "\n"
283 : : "Reconfigure the text stream with new parameters.\n"
284 : : "\n"
285 : : "This also does an implicit stream flush.");
286 : :
287 : : #define _IO_TEXTIOWRAPPER_RECONFIGURE_METHODDEF \
288 : : {"reconfigure", _PyCFunction_CAST(_io_TextIOWrapper_reconfigure), METH_FASTCALL|METH_KEYWORDS, _io_TextIOWrapper_reconfigure__doc__},
289 : :
290 : : static PyObject *
291 : : _io_TextIOWrapper_reconfigure_impl(textio *self, PyObject *encoding,
292 : : PyObject *errors, PyObject *newline_obj,
293 : : PyObject *line_buffering_obj,
294 : : PyObject *write_through_obj);
295 : :
296 : : static PyObject *
297 : 36 : _io_TextIOWrapper_reconfigure(textio *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
298 : : {
299 : 36 : PyObject *return_value = NULL;
300 : : static const char * const _keywords[] = {"encoding", "errors", "newline", "line_buffering", "write_through", NULL};
301 : : static _PyArg_Parser _parser = {NULL, _keywords, "reconfigure", 0};
302 : : PyObject *argsbuf[5];
303 [ + + ]: 36 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
304 : 36 : PyObject *encoding = Py_None;
305 : 36 : PyObject *errors = Py_None;
306 : 36 : PyObject *newline_obj = NULL;
307 : 36 : PyObject *line_buffering_obj = Py_None;
308 : 36 : PyObject *write_through_obj = Py_None;
309 : :
310 [ + + + - : 36 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
+ - - + ]
311 [ - + ]: 36 : if (!args) {
312 : 0 : goto exit;
313 : : }
314 [ + + ]: 36 : if (!noptargs) {
315 : 4 : goto skip_optional_kwonly;
316 : : }
317 [ + + ]: 32 : if (args[0]) {
318 : 9 : encoding = args[0];
319 [ + + ]: 9 : if (!--noptargs) {
320 : 8 : goto skip_optional_kwonly;
321 : : }
322 : : }
323 [ + + ]: 24 : if (args[1]) {
324 : 1 : errors = args[1];
325 [ + - ]: 1 : if (!--noptargs) {
326 : 1 : goto skip_optional_kwonly;
327 : : }
328 : : }
329 [ + + ]: 23 : if (args[2]) {
330 : 13 : newline_obj = args[2];
331 [ + - ]: 13 : if (!--noptargs) {
332 : 13 : goto skip_optional_kwonly;
333 : : }
334 : : }
335 [ + + ]: 10 : if (args[3]) {
336 : 5 : line_buffering_obj = args[3];
337 [ + - ]: 5 : if (!--noptargs) {
338 : 5 : goto skip_optional_kwonly;
339 : : }
340 : : }
341 : 5 : write_through_obj = args[4];
342 : 36 : skip_optional_kwonly:
343 : 36 : return_value = _io_TextIOWrapper_reconfigure_impl(self, encoding, errors, newline_obj, line_buffering_obj, write_through_obj);
344 : :
345 : 36 : exit:
346 : 36 : return return_value;
347 : : }
348 : :
349 : : PyDoc_STRVAR(_io_TextIOWrapper_detach__doc__,
350 : : "detach($self, /)\n"
351 : : "--\n"
352 : : "\n");
353 : :
354 : : #define _IO_TEXTIOWRAPPER_DETACH_METHODDEF \
355 : : {"detach", (PyCFunction)_io_TextIOWrapper_detach, METH_NOARGS, _io_TextIOWrapper_detach__doc__},
356 : :
357 : : static PyObject *
358 : : _io_TextIOWrapper_detach_impl(textio *self);
359 : :
360 : : static PyObject *
361 : 546 : _io_TextIOWrapper_detach(textio *self, PyObject *Py_UNUSED(ignored))
362 : : {
363 : 546 : return _io_TextIOWrapper_detach_impl(self);
364 : : }
365 : :
366 : : PyDoc_STRVAR(_io_TextIOWrapper_write__doc__,
367 : : "write($self, text, /)\n"
368 : : "--\n"
369 : : "\n");
370 : :
371 : : #define _IO_TEXTIOWRAPPER_WRITE_METHODDEF \
372 : : {"write", (PyCFunction)_io_TextIOWrapper_write, METH_O, _io_TextIOWrapper_write__doc__},
373 : :
374 : : static PyObject *
375 : : _io_TextIOWrapper_write_impl(textio *self, PyObject *text);
376 : :
377 : : static PyObject *
378 : 895181 : _io_TextIOWrapper_write(textio *self, PyObject *arg)
379 : : {
380 : 895181 : PyObject *return_value = NULL;
381 : : PyObject *text;
382 : :
383 [ + + ]: 895181 : if (!PyUnicode_Check(arg)) {
384 : 14 : _PyArg_BadArgument("write", "argument", "str", arg);
385 : 14 : goto exit;
386 : : }
387 [ - + ]: 895167 : if (PyUnicode_READY(arg) == -1) {
388 : 0 : goto exit;
389 : : }
390 : 895167 : text = arg;
391 : 895167 : return_value = _io_TextIOWrapper_write_impl(self, text);
392 : :
393 : 895181 : exit:
394 : 895181 : return return_value;
395 : : }
396 : :
397 : : PyDoc_STRVAR(_io_TextIOWrapper_read__doc__,
398 : : "read($self, size=-1, /)\n"
399 : : "--\n"
400 : : "\n");
401 : :
402 : : #define _IO_TEXTIOWRAPPER_READ_METHODDEF \
403 : : {"read", _PyCFunction_CAST(_io_TextIOWrapper_read), METH_FASTCALL, _io_TextIOWrapper_read__doc__},
404 : :
405 : : static PyObject *
406 : : _io_TextIOWrapper_read_impl(textio *self, Py_ssize_t n);
407 : :
408 : : static PyObject *
409 : 18562 : _io_TextIOWrapper_read(textio *self, PyObject *const *args, Py_ssize_t nargs)
410 : : {
411 : 18562 : PyObject *return_value = NULL;
412 : 18562 : Py_ssize_t n = -1;
413 : :
414 [ + - - + : 18562 : if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
- - ]
415 : 0 : goto exit;
416 : : }
417 [ + + ]: 18562 : if (nargs < 1) {
418 : 4617 : goto skip_optional;
419 : : }
420 [ - + ]: 13945 : if (!_Py_convert_optional_to_ssize_t(args[0], &n)) {
421 : 0 : goto exit;
422 : : }
423 : 13945 : skip_optional:
424 : 18562 : return_value = _io_TextIOWrapper_read_impl(self, n);
425 : :
426 : 18562 : exit:
427 : 18562 : return return_value;
428 : : }
429 : :
430 : : PyDoc_STRVAR(_io_TextIOWrapper_readline__doc__,
431 : : "readline($self, size=-1, /)\n"
432 : : "--\n"
433 : : "\n");
434 : :
435 : : #define _IO_TEXTIOWRAPPER_READLINE_METHODDEF \
436 : : {"readline", _PyCFunction_CAST(_io_TextIOWrapper_readline), METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
437 : :
438 : : static PyObject *
439 : : _io_TextIOWrapper_readline_impl(textio *self, Py_ssize_t size);
440 : :
441 : : static PyObject *
442 : 566793 : _io_TextIOWrapper_readline(textio *self, PyObject *const *args, Py_ssize_t nargs)
443 : : {
444 : 566793 : PyObject *return_value = NULL;
445 : 566793 : Py_ssize_t size = -1;
446 : :
447 [ + - - + : 566793 : if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
- - ]
448 : 0 : goto exit;
449 : : }
450 [ + + ]: 566793 : if (nargs < 1) {
451 : 559784 : goto skip_optional;
452 : : }
453 : : {
454 : 7009 : Py_ssize_t ival = -1;
455 : 7009 : PyObject *iobj = _PyNumber_Index(args[0]);
456 [ + + ]: 7009 : if (iobj != NULL) {
457 : 7008 : ival = PyLong_AsSsize_t(iobj);
458 : 7008 : Py_DECREF(iobj);
459 : : }
460 [ + + + - ]: 7009 : if (ival == -1 && PyErr_Occurred()) {
461 : 1 : goto exit;
462 : : }
463 : 7008 : size = ival;
464 : : }
465 : 566792 : skip_optional:
466 : 566792 : return_value = _io_TextIOWrapper_readline_impl(self, size);
467 : :
468 : 566793 : exit:
469 : 566793 : return return_value;
470 : : }
471 : :
472 : : PyDoc_STRVAR(_io_TextIOWrapper_seek__doc__,
473 : : "seek($self, cookie, whence=0, /)\n"
474 : : "--\n"
475 : : "\n");
476 : :
477 : : #define _IO_TEXTIOWRAPPER_SEEK_METHODDEF \
478 : : {"seek", _PyCFunction_CAST(_io_TextIOWrapper_seek), METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
479 : :
480 : : static PyObject *
481 : : _io_TextIOWrapper_seek_impl(textio *self, PyObject *cookieObj, int whence);
482 : :
483 : : static PyObject *
484 : 2697 : _io_TextIOWrapper_seek(textio *self, PyObject *const *args, Py_ssize_t nargs)
485 : : {
486 : 2697 : PyObject *return_value = NULL;
487 : : PyObject *cookieObj;
488 : 2697 : int whence = 0;
489 : :
490 [ + - - + : 2697 : if (!_PyArg_CheckPositional("seek", nargs, 1, 2)) {
- - ]
491 : 0 : goto exit;
492 : : }
493 : 2697 : cookieObj = args[0];
494 [ + + ]: 2697 : if (nargs < 2) {
495 : 2625 : goto skip_optional;
496 : : }
497 : 72 : whence = _PyLong_AsInt(args[1]);
498 [ - + - - ]: 72 : if (whence == -1 && PyErr_Occurred()) {
499 : 0 : goto exit;
500 : : }
501 : 72 : skip_optional:
502 : 2697 : return_value = _io_TextIOWrapper_seek_impl(self, cookieObj, whence);
503 : :
504 : 2697 : exit:
505 : 2697 : return return_value;
506 : : }
507 : :
508 : : PyDoc_STRVAR(_io_TextIOWrapper_tell__doc__,
509 : : "tell($self, /)\n"
510 : : "--\n"
511 : : "\n");
512 : :
513 : : #define _IO_TEXTIOWRAPPER_TELL_METHODDEF \
514 : : {"tell", (PyCFunction)_io_TextIOWrapper_tell, METH_NOARGS, _io_TextIOWrapper_tell__doc__},
515 : :
516 : : static PyObject *
517 : : _io_TextIOWrapper_tell_impl(textio *self);
518 : :
519 : : static PyObject *
520 : 2266 : _io_TextIOWrapper_tell(textio *self, PyObject *Py_UNUSED(ignored))
521 : : {
522 : 2266 : return _io_TextIOWrapper_tell_impl(self);
523 : : }
524 : :
525 : : PyDoc_STRVAR(_io_TextIOWrapper_truncate__doc__,
526 : : "truncate($self, pos=None, /)\n"
527 : : "--\n"
528 : : "\n");
529 : :
530 : : #define _IO_TEXTIOWRAPPER_TRUNCATE_METHODDEF \
531 : : {"truncate", _PyCFunction_CAST(_io_TextIOWrapper_truncate), METH_FASTCALL, _io_TextIOWrapper_truncate__doc__},
532 : :
533 : : static PyObject *
534 : : _io_TextIOWrapper_truncate_impl(textio *self, PyObject *pos);
535 : :
536 : : static PyObject *
537 : 29 : _io_TextIOWrapper_truncate(textio *self, PyObject *const *args, Py_ssize_t nargs)
538 : : {
539 : 29 : PyObject *return_value = NULL;
540 : 29 : PyObject *pos = Py_None;
541 : :
542 [ + - - + : 29 : if (!_PyArg_CheckPositional("truncate", nargs, 0, 1)) {
- - ]
543 : 0 : goto exit;
544 : : }
545 [ + + ]: 29 : if (nargs < 1) {
546 : 27 : goto skip_optional;
547 : : }
548 : 2 : pos = args[0];
549 : 29 : skip_optional:
550 : 29 : return_value = _io_TextIOWrapper_truncate_impl(self, pos);
551 : :
552 : 29 : exit:
553 : 29 : return return_value;
554 : : }
555 : :
556 : : PyDoc_STRVAR(_io_TextIOWrapper_fileno__doc__,
557 : : "fileno($self, /)\n"
558 : : "--\n"
559 : : "\n");
560 : :
561 : : #define _IO_TEXTIOWRAPPER_FILENO_METHODDEF \
562 : : {"fileno", (PyCFunction)_io_TextIOWrapper_fileno, METH_NOARGS, _io_TextIOWrapper_fileno__doc__},
563 : :
564 : : static PyObject *
565 : : _io_TextIOWrapper_fileno_impl(textio *self);
566 : :
567 : : static PyObject *
568 : 14963 : _io_TextIOWrapper_fileno(textio *self, PyObject *Py_UNUSED(ignored))
569 : : {
570 : 14963 : return _io_TextIOWrapper_fileno_impl(self);
571 : : }
572 : :
573 : : PyDoc_STRVAR(_io_TextIOWrapper_seekable__doc__,
574 : : "seekable($self, /)\n"
575 : : "--\n"
576 : : "\n");
577 : :
578 : : #define _IO_TEXTIOWRAPPER_SEEKABLE_METHODDEF \
579 : : {"seekable", (PyCFunction)_io_TextIOWrapper_seekable, METH_NOARGS, _io_TextIOWrapper_seekable__doc__},
580 : :
581 : : static PyObject *
582 : : _io_TextIOWrapper_seekable_impl(textio *self);
583 : :
584 : : static PyObject *
585 : 4 : _io_TextIOWrapper_seekable(textio *self, PyObject *Py_UNUSED(ignored))
586 : : {
587 : 4 : return _io_TextIOWrapper_seekable_impl(self);
588 : : }
589 : :
590 : : PyDoc_STRVAR(_io_TextIOWrapper_readable__doc__,
591 : : "readable($self, /)\n"
592 : : "--\n"
593 : : "\n");
594 : :
595 : : #define _IO_TEXTIOWRAPPER_READABLE_METHODDEF \
596 : : {"readable", (PyCFunction)_io_TextIOWrapper_readable, METH_NOARGS, _io_TextIOWrapper_readable__doc__},
597 : :
598 : : static PyObject *
599 : : _io_TextIOWrapper_readable_impl(textio *self);
600 : :
601 : : static PyObject *
602 : 2 : _io_TextIOWrapper_readable(textio *self, PyObject *Py_UNUSED(ignored))
603 : : {
604 : 2 : return _io_TextIOWrapper_readable_impl(self);
605 : : }
606 : :
607 : : PyDoc_STRVAR(_io_TextIOWrapper_writable__doc__,
608 : : "writable($self, /)\n"
609 : : "--\n"
610 : : "\n");
611 : :
612 : : #define _IO_TEXTIOWRAPPER_WRITABLE_METHODDEF \
613 : : {"writable", (PyCFunction)_io_TextIOWrapper_writable, METH_NOARGS, _io_TextIOWrapper_writable__doc__},
614 : :
615 : : static PyObject *
616 : : _io_TextIOWrapper_writable_impl(textio *self);
617 : :
618 : : static PyObject *
619 : 2 : _io_TextIOWrapper_writable(textio *self, PyObject *Py_UNUSED(ignored))
620 : : {
621 : 2 : return _io_TextIOWrapper_writable_impl(self);
622 : : }
623 : :
624 : : PyDoc_STRVAR(_io_TextIOWrapper_isatty__doc__,
625 : : "isatty($self, /)\n"
626 : : "--\n"
627 : : "\n");
628 : :
629 : : #define _IO_TEXTIOWRAPPER_ISATTY_METHODDEF \
630 : : {"isatty", (PyCFunction)_io_TextIOWrapper_isatty, METH_NOARGS, _io_TextIOWrapper_isatty__doc__},
631 : :
632 : : static PyObject *
633 : : _io_TextIOWrapper_isatty_impl(textio *self);
634 : :
635 : : static PyObject *
636 : 349 : _io_TextIOWrapper_isatty(textio *self, PyObject *Py_UNUSED(ignored))
637 : : {
638 : 349 : return _io_TextIOWrapper_isatty_impl(self);
639 : : }
640 : :
641 : : PyDoc_STRVAR(_io_TextIOWrapper_flush__doc__,
642 : : "flush($self, /)\n"
643 : : "--\n"
644 : : "\n");
645 : :
646 : : #define _IO_TEXTIOWRAPPER_FLUSH_METHODDEF \
647 : : {"flush", (PyCFunction)_io_TextIOWrapper_flush, METH_NOARGS, _io_TextIOWrapper_flush__doc__},
648 : :
649 : : static PyObject *
650 : : _io_TextIOWrapper_flush_impl(textio *self);
651 : :
652 : : static PyObject *
653 : 123135 : _io_TextIOWrapper_flush(textio *self, PyObject *Py_UNUSED(ignored))
654 : : {
655 : 123135 : return _io_TextIOWrapper_flush_impl(self);
656 : : }
657 : :
658 : : PyDoc_STRVAR(_io_TextIOWrapper_close__doc__,
659 : : "close($self, /)\n"
660 : : "--\n"
661 : : "\n");
662 : :
663 : : #define _IO_TEXTIOWRAPPER_CLOSE_METHODDEF \
664 : : {"close", (PyCFunction)_io_TextIOWrapper_close, METH_NOARGS, _io_TextIOWrapper_close__doc__},
665 : :
666 : : static PyObject *
667 : : _io_TextIOWrapper_close_impl(textio *self);
668 : :
669 : : static PyObject *
670 : 34519 : _io_TextIOWrapper_close(textio *self, PyObject *Py_UNUSED(ignored))
671 : : {
672 : 34519 : return _io_TextIOWrapper_close_impl(self);
673 : : }
674 : : /*[clinic end generated code: output=bb78b568b24759d6 input=a9049054013a1b77]*/
|
