Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(_io__BufferedIOBase_readinto__doc__,
6 : : "readinto($self, buffer, /)\n"
7 : : "--\n"
8 : : "\n");
9 : :
10 : : #define _IO__BUFFEREDIOBASE_READINTO_METHODDEF \
11 : : {"readinto", (PyCFunction)_io__BufferedIOBase_readinto, METH_O, _io__BufferedIOBase_readinto__doc__},
12 : :
13 : : static PyObject *
14 : : _io__BufferedIOBase_readinto_impl(PyObject *self, Py_buffer *buffer);
15 : :
16 : : static PyObject *
17 : 11 : _io__BufferedIOBase_readinto(PyObject *self, PyObject *arg)
18 : : {
19 : 11 : PyObject *return_value = NULL;
20 : 11 : Py_buffer buffer = {NULL, NULL};
21 : :
22 [ + + ]: 11 : if (PyObject_GetBuffer(arg, &buffer, PyBUF_WRITABLE) < 0) {
23 : 1 : PyErr_Clear();
24 : 1 : _PyArg_BadArgument("readinto", "argument", "read-write bytes-like object", arg);
25 : 1 : goto exit;
26 : : }
27 [ - + ]: 10 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
28 : 0 : _PyArg_BadArgument("readinto", "argument", "contiguous buffer", arg);
29 : 0 : goto exit;
30 : : }
31 : 10 : return_value = _io__BufferedIOBase_readinto_impl(self, &buffer);
32 : :
33 : 11 : exit:
34 : : /* Cleanup for buffer */
35 [ + + ]: 11 : if (buffer.obj) {
36 : 10 : PyBuffer_Release(&buffer);
37 : : }
38 : :
39 : 11 : return return_value;
40 : : }
41 : :
42 : : PyDoc_STRVAR(_io__BufferedIOBase_readinto1__doc__,
43 : : "readinto1($self, buffer, /)\n"
44 : : "--\n"
45 : : "\n");
46 : :
47 : : #define _IO__BUFFEREDIOBASE_READINTO1_METHODDEF \
48 : : {"readinto1", (PyCFunction)_io__BufferedIOBase_readinto1, METH_O, _io__BufferedIOBase_readinto1__doc__},
49 : :
50 : : static PyObject *
51 : : _io__BufferedIOBase_readinto1_impl(PyObject *self, Py_buffer *buffer);
52 : :
53 : : static PyObject *
54 : 8 : _io__BufferedIOBase_readinto1(PyObject *self, PyObject *arg)
55 : : {
56 : 8 : PyObject *return_value = NULL;
57 : 8 : Py_buffer buffer = {NULL, NULL};
58 : :
59 [ - + ]: 8 : if (PyObject_GetBuffer(arg, &buffer, PyBUF_WRITABLE) < 0) {
60 : 0 : PyErr_Clear();
61 : 0 : _PyArg_BadArgument("readinto1", "argument", "read-write bytes-like object", arg);
62 : 0 : goto exit;
63 : : }
64 [ - + ]: 8 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
65 : 0 : _PyArg_BadArgument("readinto1", "argument", "contiguous buffer", arg);
66 : 0 : goto exit;
67 : : }
68 : 8 : return_value = _io__BufferedIOBase_readinto1_impl(self, &buffer);
69 : :
70 : 8 : exit:
71 : : /* Cleanup for buffer */
72 [ + - ]: 8 : if (buffer.obj) {
73 : 8 : PyBuffer_Release(&buffer);
74 : : }
75 : :
76 : 8 : return return_value;
77 : : }
78 : :
79 : : PyDoc_STRVAR(_io__BufferedIOBase_detach__doc__,
80 : : "detach($self, /)\n"
81 : : "--\n"
82 : : "\n"
83 : : "Disconnect this buffer from its underlying raw stream and return it.\n"
84 : : "\n"
85 : : "After the raw stream has been detached, the buffer is in an unusable\n"
86 : : "state.");
87 : :
88 : : #define _IO__BUFFEREDIOBASE_DETACH_METHODDEF \
89 : : {"detach", (PyCFunction)_io__BufferedIOBase_detach, METH_NOARGS, _io__BufferedIOBase_detach__doc__},
90 : :
91 : : static PyObject *
92 : : _io__BufferedIOBase_detach_impl(PyObject *self);
93 : :
94 : : static PyObject *
95 : 2 : _io__BufferedIOBase_detach(PyObject *self, PyObject *Py_UNUSED(ignored))
96 : : {
97 : 2 : return _io__BufferedIOBase_detach_impl(self);
98 : : }
99 : :
100 : : PyDoc_STRVAR(_io__Buffered_peek__doc__,
101 : : "peek($self, size=0, /)\n"
102 : : "--\n"
103 : : "\n");
104 : :
105 : : #define _IO__BUFFERED_PEEK_METHODDEF \
106 : : {"peek", _PyCFunction_CAST(_io__Buffered_peek), METH_FASTCALL, _io__Buffered_peek__doc__},
107 : :
108 : : static PyObject *
109 : : _io__Buffered_peek_impl(buffered *self, Py_ssize_t size);
110 : :
111 : : static PyObject *
112 : 8872 : _io__Buffered_peek(buffered *self, PyObject *const *args, Py_ssize_t nargs)
113 : : {
114 : 8872 : PyObject *return_value = NULL;
115 : 8872 : Py_ssize_t size = 0;
116 : :
117 [ + - - + : 8872 : if (!_PyArg_CheckPositional("peek", nargs, 0, 1)) {
- - ]
118 : 0 : goto exit;
119 : : }
120 [ + + ]: 8872 : if (nargs < 1) {
121 : 4 : goto skip_optional;
122 : : }
123 : : {
124 : 8868 : Py_ssize_t ival = -1;
125 : 8868 : PyObject *iobj = _PyNumber_Index(args[0]);
126 [ + - ]: 8868 : if (iobj != NULL) {
127 : 8868 : ival = PyLong_AsSsize_t(iobj);
128 : 8868 : Py_DECREF(iobj);
129 : : }
130 [ + + - + ]: 8868 : if (ival == -1 && PyErr_Occurred()) {
131 : 0 : goto exit;
132 : : }
133 : 8868 : size = ival;
134 : : }
135 : 8872 : skip_optional:
136 : 8872 : return_value = _io__Buffered_peek_impl(self, size);
137 : :
138 : 8872 : exit:
139 : 8872 : return return_value;
140 : : }
141 : :
142 : : PyDoc_STRVAR(_io__Buffered_read__doc__,
143 : : "read($self, size=-1, /)\n"
144 : : "--\n"
145 : : "\n");
146 : :
147 : : #define _IO__BUFFERED_READ_METHODDEF \
148 : : {"read", _PyCFunction_CAST(_io__Buffered_read), METH_FASTCALL, _io__Buffered_read__doc__},
149 : :
150 : : static PyObject *
151 : : _io__Buffered_read_impl(buffered *self, Py_ssize_t n);
152 : :
153 : : static PyObject *
154 : 365469 : _io__Buffered_read(buffered *self, PyObject *const *args, Py_ssize_t nargs)
155 : : {
156 : 365469 : PyObject *return_value = NULL;
157 : 365469 : Py_ssize_t n = -1;
158 : :
159 [ + - - + : 365469 : if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
- - ]
160 : 0 : goto exit;
161 : : }
162 [ + + ]: 365469 : if (nargs < 1) {
163 : 180952 : goto skip_optional;
164 : : }
165 [ + + ]: 184517 : if (!_Py_convert_optional_to_ssize_t(args[0], &n)) {
166 : 6 : goto exit;
167 : : }
168 : 184511 : skip_optional:
169 : 365463 : return_value = _io__Buffered_read_impl(self, n);
170 : :
171 : 365469 : exit:
172 : 365469 : return return_value;
173 : : }
174 : :
175 : : PyDoc_STRVAR(_io__Buffered_read1__doc__,
176 : : "read1($self, size=-1, /)\n"
177 : : "--\n"
178 : : "\n");
179 : :
180 : : #define _IO__BUFFERED_READ1_METHODDEF \
181 : : {"read1", _PyCFunction_CAST(_io__Buffered_read1), METH_FASTCALL, _io__Buffered_read1__doc__},
182 : :
183 : : static PyObject *
184 : : _io__Buffered_read1_impl(buffered *self, Py_ssize_t n);
185 : :
186 : : static PyObject *
187 : 35792 : _io__Buffered_read1(buffered *self, PyObject *const *args, Py_ssize_t nargs)
188 : : {
189 : 35792 : PyObject *return_value = NULL;
190 : 35792 : Py_ssize_t n = -1;
191 : :
192 [ + - - + : 35792 : if (!_PyArg_CheckPositional("read1", nargs, 0, 1)) {
- - ]
193 : 0 : goto exit;
194 : : }
195 [ + + ]: 35792 : if (nargs < 1) {
196 : 9 : goto skip_optional;
197 : : }
198 : : {
199 : 35783 : Py_ssize_t ival = -1;
200 : 35783 : PyObject *iobj = _PyNumber_Index(args[0]);
201 [ + - ]: 35783 : if (iobj != NULL) {
202 : 35783 : ival = PyLong_AsSsize_t(iobj);
203 : 35783 : Py_DECREF(iobj);
204 : : }
205 [ + + - + ]: 35783 : if (ival == -1 && PyErr_Occurred()) {
206 : 0 : goto exit;
207 : : }
208 : 35783 : n = ival;
209 : : }
210 : 35792 : skip_optional:
211 : 35792 : return_value = _io__Buffered_read1_impl(self, n);
212 : :
213 : 35788 : exit:
214 : 35788 : return return_value;
215 : : }
216 : :
217 : : PyDoc_STRVAR(_io__Buffered_readinto__doc__,
218 : : "readinto($self, buffer, /)\n"
219 : : "--\n"
220 : : "\n");
221 : :
222 : : #define _IO__BUFFERED_READINTO_METHODDEF \
223 : : {"readinto", (PyCFunction)_io__Buffered_readinto, METH_O, _io__Buffered_readinto__doc__},
224 : :
225 : : static PyObject *
226 : : _io__Buffered_readinto_impl(buffered *self, Py_buffer *buffer);
227 : :
228 : : static PyObject *
229 : 132935 : _io__Buffered_readinto(buffered *self, PyObject *arg)
230 : : {
231 : 132935 : PyObject *return_value = NULL;
232 : 132935 : Py_buffer buffer = {NULL, NULL};
233 : :
234 [ - + ]: 132935 : if (PyObject_GetBuffer(arg, &buffer, PyBUF_WRITABLE) < 0) {
235 : 0 : PyErr_Clear();
236 : 0 : _PyArg_BadArgument("readinto", "argument", "read-write bytes-like object", arg);
237 : 0 : goto exit;
238 : : }
239 [ - + ]: 132935 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
240 : 0 : _PyArg_BadArgument("readinto", "argument", "contiguous buffer", arg);
241 : 0 : goto exit;
242 : : }
243 : 132935 : return_value = _io__Buffered_readinto_impl(self, &buffer);
244 : :
245 : 132935 : exit:
246 : : /* Cleanup for buffer */
247 [ + - ]: 132935 : if (buffer.obj) {
248 : 132935 : PyBuffer_Release(&buffer);
249 : : }
250 : :
251 : 132935 : return return_value;
252 : : }
253 : :
254 : : PyDoc_STRVAR(_io__Buffered_readinto1__doc__,
255 : : "readinto1($self, buffer, /)\n"
256 : : "--\n"
257 : : "\n");
258 : :
259 : : #define _IO__BUFFERED_READINTO1_METHODDEF \
260 : : {"readinto1", (PyCFunction)_io__Buffered_readinto1, METH_O, _io__Buffered_readinto1__doc__},
261 : :
262 : : static PyObject *
263 : : _io__Buffered_readinto1_impl(buffered *self, Py_buffer *buffer);
264 : :
265 : : static PyObject *
266 : 14 : _io__Buffered_readinto1(buffered *self, PyObject *arg)
267 : : {
268 : 14 : PyObject *return_value = NULL;
269 : 14 : Py_buffer buffer = {NULL, NULL};
270 : :
271 [ - + ]: 14 : if (PyObject_GetBuffer(arg, &buffer, PyBUF_WRITABLE) < 0) {
272 : 0 : PyErr_Clear();
273 : 0 : _PyArg_BadArgument("readinto1", "argument", "read-write bytes-like object", arg);
274 : 0 : goto exit;
275 : : }
276 [ - + ]: 14 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
277 : 0 : _PyArg_BadArgument("readinto1", "argument", "contiguous buffer", arg);
278 : 0 : goto exit;
279 : : }
280 : 14 : return_value = _io__Buffered_readinto1_impl(self, &buffer);
281 : :
282 : 14 : exit:
283 : : /* Cleanup for buffer */
284 [ + - ]: 14 : if (buffer.obj) {
285 : 14 : PyBuffer_Release(&buffer);
286 : : }
287 : :
288 : 14 : return return_value;
289 : : }
290 : :
291 : : PyDoc_STRVAR(_io__Buffered_readline__doc__,
292 : : "readline($self, size=-1, /)\n"
293 : : "--\n"
294 : : "\n");
295 : :
296 : : #define _IO__BUFFERED_READLINE_METHODDEF \
297 : : {"readline", _PyCFunction_CAST(_io__Buffered_readline), METH_FASTCALL, _io__Buffered_readline__doc__},
298 : :
299 : : static PyObject *
300 : : _io__Buffered_readline_impl(buffered *self, Py_ssize_t size);
301 : :
302 : : static PyObject *
303 : 22141 : _io__Buffered_readline(buffered *self, PyObject *const *args, Py_ssize_t nargs)
304 : : {
305 : 22141 : PyObject *return_value = NULL;
306 : 22141 : Py_ssize_t size = -1;
307 : :
308 [ + - - + : 22141 : if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
- - ]
309 : 0 : goto exit;
310 : : }
311 [ + + ]: 22141 : if (nargs < 1) {
312 : 15936 : goto skip_optional;
313 : : }
314 [ + + ]: 6205 : if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
315 : 1 : goto exit;
316 : : }
317 : 6204 : skip_optional:
318 : 22140 : return_value = _io__Buffered_readline_impl(self, size);
319 : :
320 : 22140 : exit:
321 : 22140 : return return_value;
322 : : }
323 : :
324 : : PyDoc_STRVAR(_io__Buffered_seek__doc__,
325 : : "seek($self, target, whence=0, /)\n"
326 : : "--\n"
327 : : "\n");
328 : :
329 : : #define _IO__BUFFERED_SEEK_METHODDEF \
330 : : {"seek", _PyCFunction_CAST(_io__Buffered_seek), METH_FASTCALL, _io__Buffered_seek__doc__},
331 : :
332 : : static PyObject *
333 : : _io__Buffered_seek_impl(buffered *self, PyObject *targetobj, int whence);
334 : :
335 : : static PyObject *
336 : 111183 : _io__Buffered_seek(buffered *self, PyObject *const *args, Py_ssize_t nargs)
337 : : {
338 : 111183 : PyObject *return_value = NULL;
339 : : PyObject *targetobj;
340 : 111183 : int whence = 0;
341 : :
342 [ + - - + : 111183 : if (!_PyArg_CheckPositional("seek", nargs, 1, 2)) {
- - ]
343 : 0 : goto exit;
344 : : }
345 : 111183 : targetobj = args[0];
346 [ + + ]: 111183 : if (nargs < 2) {
347 : 40077 : goto skip_optional;
348 : : }
349 : 71106 : whence = _PyLong_AsInt(args[1]);
350 [ + + + + ]: 71106 : if (whence == -1 && PyErr_Occurred()) {
351 : 1 : goto exit;
352 : : }
353 : 71105 : skip_optional:
354 : 111182 : return_value = _io__Buffered_seek_impl(self, targetobj, whence);
355 : :
356 : 111183 : exit:
357 : 111183 : return return_value;
358 : : }
359 : :
360 : : PyDoc_STRVAR(_io__Buffered_truncate__doc__,
361 : : "truncate($self, pos=None, /)\n"
362 : : "--\n"
363 : : "\n");
364 : :
365 : : #define _IO__BUFFERED_TRUNCATE_METHODDEF \
366 : : {"truncate", _PyCFunction_CAST(_io__Buffered_truncate), METH_FASTCALL, _io__Buffered_truncate__doc__},
367 : :
368 : : static PyObject *
369 : : _io__Buffered_truncate_impl(buffered *self, PyObject *pos);
370 : :
371 : : static PyObject *
372 : 5642 : _io__Buffered_truncate(buffered *self, PyObject *const *args, Py_ssize_t nargs)
373 : : {
374 : 5642 : PyObject *return_value = NULL;
375 : 5642 : PyObject *pos = Py_None;
376 : :
377 [ + - - + : 5642 : if (!_PyArg_CheckPositional("truncate", nargs, 0, 1)) {
- - ]
378 : 0 : goto exit;
379 : : }
380 [ + + ]: 5642 : if (nargs < 1) {
381 : 45 : goto skip_optional;
382 : : }
383 : 5597 : pos = args[0];
384 : 5642 : skip_optional:
385 : 5642 : return_value = _io__Buffered_truncate_impl(self, pos);
386 : :
387 : 5642 : exit:
388 : 5642 : return return_value;
389 : : }
390 : :
391 : : PyDoc_STRVAR(_io_BufferedReader___init____doc__,
392 : : "BufferedReader(raw, buffer_size=DEFAULT_BUFFER_SIZE)\n"
393 : : "--\n"
394 : : "\n"
395 : : "Create a new buffered reader using the given readable raw IO object.");
396 : :
397 : : static int
398 : : _io_BufferedReader___init___impl(buffered *self, PyObject *raw,
399 : : Py_ssize_t buffer_size);
400 : :
401 : : static int
402 : 263669 : _io_BufferedReader___init__(PyObject *self, PyObject *args, PyObject *kwargs)
403 : : {
404 : 263669 : int return_value = -1;
405 : : static const char * const _keywords[] = {"raw", "buffer_size", NULL};
406 : : static _PyArg_Parser _parser = {NULL, _keywords, "BufferedReader", 0};
407 : : PyObject *argsbuf[2];
408 : : PyObject * const *fastargs;
409 : 263669 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
410 [ + + ]: 263669 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
411 : : PyObject *raw;
412 : 263669 : Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
413 : :
414 [ + + + - : 263669 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 2, 0, argsbuf);
+ + + - ]
415 [ + + ]: 263669 : if (!fastargs) {
416 : 1 : goto exit;
417 : : }
418 : 263668 : raw = fastargs[0];
419 [ + + ]: 263668 : if (!noptargs) {
420 : 12704 : goto skip_optional_pos;
421 : : }
422 : : {
423 : 250964 : Py_ssize_t ival = -1;
424 : 250964 : PyObject *iobj = _PyNumber_Index(fastargs[1]);
425 [ + - ]: 250964 : if (iobj != NULL) {
426 : 250964 : ival = PyLong_AsSsize_t(iobj);
427 : 250964 : Py_DECREF(iobj);
428 : : }
429 [ + + - + ]: 250964 : if (ival == -1 && PyErr_Occurred()) {
430 : 0 : goto exit;
431 : : }
432 : 250964 : buffer_size = ival;
433 : : }
434 : 263668 : skip_optional_pos:
435 : 263668 : return_value = _io_BufferedReader___init___impl((buffered *)self, raw, buffer_size);
436 : :
437 : 263669 : exit:
438 : 263669 : return return_value;
439 : : }
440 : :
441 : : PyDoc_STRVAR(_io_BufferedWriter___init____doc__,
442 : : "BufferedWriter(raw, buffer_size=DEFAULT_BUFFER_SIZE)\n"
443 : : "--\n"
444 : : "\n"
445 : : "A buffer for a writeable sequential RawIO object.\n"
446 : : "\n"
447 : : "The constructor creates a BufferedWriter for the given writeable raw\n"
448 : : "stream. If the buffer_size is not given, it defaults to\n"
449 : : "DEFAULT_BUFFER_SIZE.");
450 : :
451 : : static int
452 : : _io_BufferedWriter___init___impl(buffered *self, PyObject *raw,
453 : : Py_ssize_t buffer_size);
454 : :
455 : : static int
456 : 56674 : _io_BufferedWriter___init__(PyObject *self, PyObject *args, PyObject *kwargs)
457 : : {
458 : 56674 : int return_value = -1;
459 : : static const char * const _keywords[] = {"raw", "buffer_size", NULL};
460 : : static _PyArg_Parser _parser = {NULL, _keywords, "BufferedWriter", 0};
461 : : PyObject *argsbuf[2];
462 : : PyObject * const *fastargs;
463 : 56674 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
464 [ + + ]: 56674 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
465 : : PyObject *raw;
466 : 56674 : Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
467 : :
468 [ + + + - : 56674 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 2, 0, argsbuf);
+ + + - ]
469 [ + + ]: 56674 : if (!fastargs) {
470 : 2 : goto exit;
471 : : }
472 : 56672 : raw = fastargs[0];
473 [ + + ]: 56672 : if (!noptargs) {
474 : 9147 : goto skip_optional_pos;
475 : : }
476 : : {
477 : 47525 : Py_ssize_t ival = -1;
478 : 47525 : PyObject *iobj = _PyNumber_Index(fastargs[1]);
479 [ + - ]: 47525 : if (iobj != NULL) {
480 : 47525 : ival = PyLong_AsSsize_t(iobj);
481 : 47525 : Py_DECREF(iobj);
482 : : }
483 [ + + - + ]: 47525 : if (ival == -1 && PyErr_Occurred()) {
484 : 0 : goto exit;
485 : : }
486 : 47525 : buffer_size = ival;
487 : : }
488 : 56672 : skip_optional_pos:
489 : 56672 : return_value = _io_BufferedWriter___init___impl((buffered *)self, raw, buffer_size);
490 : :
491 : 56674 : exit:
492 : 56674 : return return_value;
493 : : }
494 : :
495 : : PyDoc_STRVAR(_io_BufferedWriter_write__doc__,
496 : : "write($self, buffer, /)\n"
497 : : "--\n"
498 : : "\n");
499 : :
500 : : #define _IO_BUFFEREDWRITER_WRITE_METHODDEF \
501 : : {"write", (PyCFunction)_io_BufferedWriter_write, METH_O, _io_BufferedWriter_write__doc__},
502 : :
503 : : static PyObject *
504 : : _io_BufferedWriter_write_impl(buffered *self, Py_buffer *buffer);
505 : :
506 : : static PyObject *
507 : 444324 : _io_BufferedWriter_write(buffered *self, PyObject *arg)
508 : : {
509 : 444324 : PyObject *return_value = NULL;
510 : 444324 : Py_buffer buffer = {NULL, NULL};
511 : :
512 [ + + ]: 444324 : if (PyObject_GetBuffer(arg, &buffer, PyBUF_SIMPLE) != 0) {
513 : 7 : goto exit;
514 : : }
515 [ - + ]: 444317 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
516 : 0 : _PyArg_BadArgument("write", "argument", "contiguous buffer", arg);
517 : 0 : goto exit;
518 : : }
519 : 444317 : return_value = _io_BufferedWriter_write_impl(self, &buffer);
520 : :
521 : 444323 : exit:
522 : : /* Cleanup for buffer */
523 [ + + ]: 444323 : if (buffer.obj) {
524 : 444316 : PyBuffer_Release(&buffer);
525 : : }
526 : :
527 : 444323 : return return_value;
528 : : }
529 : :
530 : : PyDoc_STRVAR(_io_BufferedRWPair___init____doc__,
531 : : "BufferedRWPair(reader, writer, buffer_size=DEFAULT_BUFFER_SIZE, /)\n"
532 : : "--\n"
533 : : "\n"
534 : : "A buffered reader and writer object together.\n"
535 : : "\n"
536 : : "A buffered reader object and buffered writer object put together to\n"
537 : : "form a sequential IO object that can read and write. This is typically\n"
538 : : "used with a socket or two-way pipe.\n"
539 : : "\n"
540 : : "reader and writer are RawIOBase objects that are readable and\n"
541 : : "writeable respectively. If the buffer_size is omitted it defaults to\n"
542 : : "DEFAULT_BUFFER_SIZE.");
543 : :
544 : : static int
545 : : _io_BufferedRWPair___init___impl(rwpair *self, PyObject *reader,
546 : : PyObject *writer, Py_ssize_t buffer_size);
547 : :
548 : : static int
549 : 2102 : _io_BufferedRWPair___init__(PyObject *self, PyObject *args, PyObject *kwargs)
550 : : {
551 : 2102 : int return_value = -1;
552 : : PyObject *reader;
553 : : PyObject *writer;
554 : 2102 : Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
555 : :
556 [ - + ]: 2102 : if ((Py_IS_TYPE(self, &PyBufferedRWPair_Type) ||
557 [ - - + + ]: 2102 : Py_TYPE(self)->tp_new == PyBufferedRWPair_Type.tp_new) &&
558 [ - + ]: 2 : !_PyArg_NoKeywords("BufferedRWPair", kwargs)) {
559 : 0 : goto exit;
560 : : }
561 [ + - + + : 2102 : if (!_PyArg_CheckPositional("BufferedRWPair", PyTuple_GET_SIZE(args), 2, 3)) {
+ - ]
562 : 1 : goto exit;
563 : : }
564 : 2101 : reader = PyTuple_GET_ITEM(args, 0);
565 : 2101 : writer = PyTuple_GET_ITEM(args, 1);
566 [ + + ]: 2101 : if (PyTuple_GET_SIZE(args) < 3) {
567 : 2092 : goto skip_optional;
568 : : }
569 : : {
570 : 9 : Py_ssize_t ival = -1;
571 : 9 : PyObject *iobj = _PyNumber_Index(PyTuple_GET_ITEM(args, 2));
572 [ + - ]: 9 : if (iobj != NULL) {
573 : 9 : ival = PyLong_AsSsize_t(iobj);
574 : 9 : Py_DECREF(iobj);
575 : : }
576 [ - + - - ]: 9 : if (ival == -1 && PyErr_Occurred()) {
577 : 0 : goto exit;
578 : : }
579 : 9 : buffer_size = ival;
580 : : }
581 : 2101 : skip_optional:
582 : 2101 : return_value = _io_BufferedRWPair___init___impl((rwpair *)self, reader, writer, buffer_size);
583 : :
584 : 2102 : exit:
585 : 2102 : return return_value;
586 : : }
587 : :
588 : : PyDoc_STRVAR(_io_BufferedRandom___init____doc__,
589 : : "BufferedRandom(raw, buffer_size=DEFAULT_BUFFER_SIZE)\n"
590 : : "--\n"
591 : : "\n"
592 : : "A buffered interface to random access streams.\n"
593 : : "\n"
594 : : "The constructor creates a reader and writer for a seekable stream,\n"
595 : : "raw, given in the first argument. If the buffer_size is omitted it\n"
596 : : "defaults to DEFAULT_BUFFER_SIZE.");
597 : :
598 : : static int
599 : : _io_BufferedRandom___init___impl(buffered *self, PyObject *raw,
600 : : Py_ssize_t buffer_size);
601 : :
602 : : static int
603 : 4139 : _io_BufferedRandom___init__(PyObject *self, PyObject *args, PyObject *kwargs)
604 : : {
605 : 4139 : int return_value = -1;
606 : : static const char * const _keywords[] = {"raw", "buffer_size", NULL};
607 : : static _PyArg_Parser _parser = {NULL, _keywords, "BufferedRandom", 0};
608 : : PyObject *argsbuf[2];
609 : : PyObject * const *fastargs;
610 : 4139 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
611 [ + + ]: 4139 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
612 : : PyObject *raw;
613 : 4139 : Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
614 : :
615 [ + + + - : 4139 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 2, 0, argsbuf);
+ + + - ]
616 [ + + ]: 4139 : if (!fastargs) {
617 : 2 : goto exit;
618 : : }
619 : 4137 : raw = fastargs[0];
620 [ + + ]: 4137 : if (!noptargs) {
621 : 47 : goto skip_optional_pos;
622 : : }
623 : : {
624 : 4090 : Py_ssize_t ival = -1;
625 : 4090 : PyObject *iobj = _PyNumber_Index(fastargs[1]);
626 [ + - ]: 4090 : if (iobj != NULL) {
627 : 4090 : ival = PyLong_AsSsize_t(iobj);
628 : 4090 : Py_DECREF(iobj);
629 : : }
630 [ + + - + ]: 4090 : if (ival == -1 && PyErr_Occurred()) {
631 : 0 : goto exit;
632 : : }
633 : 4090 : buffer_size = ival;
634 : : }
635 : 4137 : skip_optional_pos:
636 : 4137 : return_value = _io_BufferedRandom___init___impl((buffered *)self, raw, buffer_size);
637 : :
638 : 4139 : exit:
639 : 4139 : return return_value;
640 : : }
641 : : /*[clinic end generated code: output=820461c6b0e29e48 input=a9049054013a1b77]*/
|
