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