1 /*
2 An implementation of the I/O abstract base classes hierarchy
3 as defined by PEP 3116 - "New I/O"
4
5 Classes defined here: IOBase, RawIOBase.
6
7 Written by Amaury Forgeot d'Arc and Antoine Pitrou
8 */
9
10
11 #define PY_SSIZE_T_CLEAN
12 #include "Python.h"
13 #include "pycore_long.h" // _PyLong_GetOne()
14 #include "pycore_object.h"
15 #include <stddef.h> // offsetof()
16 #include "_iomodule.h"
17
18 /*[clinic input]
19 module _io
20 class _io._IOBase "PyObject *" "&PyIOBase_Type"
21 class _io._RawIOBase "PyObject *" "&PyRawIOBase_Type"
22 [clinic start generated code]*/
23 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=d29a4d076c2b211c]*/
24
25 /*
26 * IOBase class, an abstract class
27 */
28
29 typedef struct {
30 PyObject_HEAD
31
32 PyObject *dict;
33 PyObject *weakreflist;
34 } iobase;
35
36 PyDoc_STRVAR(iobase_doc,
37 "The abstract base class for all I/O classes.\n"
38 "\n"
39 "This class provides dummy implementations for many methods that\n"
40 "derived classes can override selectively; the default implementations\n"
41 "represent a file that cannot be read, written or seeked.\n"
42 "\n"
43 "Even though IOBase does not declare read, readinto, or write because\n"
44 "their signatures will vary, implementations and clients should\n"
45 "consider those methods part of the interface. Also, implementations\n"
46 "may raise UnsupportedOperation when operations they do not support are\n"
47 "called.\n"
48 "\n"
49 "The basic type used for binary data read from or written to a file is\n"
50 "bytes. Other bytes-like objects are accepted as method arguments too.\n"
51 "In some cases (such as readinto), a writable object is required. Text\n"
52 "I/O classes work with str data.\n"
53 "\n"
54 "Note that calling any method (except additional calls to close(),\n"
55 "which are ignored) on a closed stream should raise a ValueError.\n"
56 "\n"
57 "IOBase (and its subclasses) support the iterator protocol, meaning\n"
58 "that an IOBase object can be iterated over yielding the lines in a\n"
59 "stream.\n"
60 "\n"
61 "IOBase also supports the :keyword:`with` statement. In this example,\n"
62 "fp is closed after the suite of the with statement is complete:\n"
63 "\n"
64 "with open('spam.txt', 'r') as fp:\n"
65 " fp.write('Spam and eggs!')\n");
66
67 /* Use this macro whenever you want to check the internal `closed` status
68 of the IOBase object rather than the virtual `closed` attribute as returned
69 by whatever subclass. */
70
71
72 /* Internal methods */
73 static PyObject *
74 iobase_unsupported(const char *message)
75 {
76 _PyIO_State *state = IO_STATE();
77 if (state != NULL)
78 PyErr_SetString(state->unsupported_operation, message);
79 return NULL;
80 }
81
82 /* Positioning */
83
84 PyDoc_STRVAR(iobase_seek_doc,
85 "seek($self, offset, whence=os.SEEK_SET, /)\n"
86 "--\n"
87 "\n"
88 "Change the stream position to the given byte offset.\n"
89 "\n"
90 " offset\n"
91 " The stream position, relative to \'whence\'.\n"
92 " whence\n"
93 " The relative position to seek from.\n"
94 "\n"
95 "The offset is interpreted relative to the position indicated by whence.\n"
96 "Values for whence are:\n"
97 "\n"
98 "* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive\n"
99 "* os.SEEK_CUR or 1 -- current stream position; offset may be negative\n"
100 "* os.SEEK_END or 2 -- end of stream; offset is usually negative\n"
101 "\n"
102 "Return the new absolute position.");
103
104 static PyObject *
105 iobase_seek(PyObject *self, PyObject *args)
106 {
107 return iobase_unsupported("seek");
108 }
109
110 /*[clinic input]
111 _io._IOBase.tell
112
113 Return current stream position.
114 [clinic start generated code]*/
115
116 static PyObject *
117 _io__IOBase_tell_impl(PyObject *self)
118 /*[clinic end generated code: output=89a1c0807935abe2 input=04e615fec128801f]*/
119 {
120 return _PyObject_CallMethod(self, &_Py_ID(seek), "ii", 0, 1);
121 }
122
123 PyDoc_STRVAR(iobase_truncate_doc,
124 "Truncate file to size bytes.\n"
125 "\n"
126 "File pointer is left unchanged. Size defaults to the current IO\n"
127 "position as reported by tell(). Returns the new size.");
128
129 static PyObject *
130 iobase_truncate(PyObject *self, PyObject *args)
131 {
132 return iobase_unsupported("truncate");
133 }
134
135 static int
136 iobase_is_closed(PyObject *self)
137 {
138 PyObject *res;
139 int ret;
140 /* This gets the derived attribute, which is *not* __IOBase_closed
141 in most cases! */
142 ret = _PyObject_LookupAttr(self, &_Py_ID(__IOBase_closed), &res);
143 Py_XDECREF(res);
144 return ret;
145 }
146
147 /* Flush and close methods */
148
149 /*[clinic input]
150 _io._IOBase.flush
151
152 Flush write buffers, if applicable.
153
154 This is not implemented for read-only and non-blocking streams.
155 [clinic start generated code]*/
156
157 static PyObject *
158 _io__IOBase_flush_impl(PyObject *self)
159 /*[clinic end generated code: output=7cef4b4d54656a3b input=773be121abe270aa]*/
160 {
161 /* XXX Should this return the number of bytes written??? */
162 int closed = iobase_is_closed(self);
163
164 if (!closed) {
165 Py_RETURN_NONE;
166 }
167 if (closed > 0) {
168 PyErr_SetString(PyExc_ValueError, "I/O operation on closed file.");
169 }
170 return NULL;
171 }
172
173 static PyObject *
174 iobase_closed_get(PyObject *self, void *context)
175 {
176 int closed = iobase_is_closed(self);
177 if (closed < 0) {
178 return NULL;
179 }
180 return PyBool_FromLong(closed);
181 }
182
183 static int
184 iobase_check_closed(PyObject *self)
185 {
186 PyObject *res;
187 int closed;
188 /* This gets the derived attribute, which is *not* __IOBase_closed
189 in most cases! */
190 closed = _PyObject_LookupAttr(self, &_Py_ID(closed), &res);
191 if (closed > 0) {
192 closed = PyObject_IsTrue(res);
193 Py_DECREF(res);
194 if (closed > 0) {
195 PyErr_SetString(PyExc_ValueError, "I/O operation on closed file.");
196 return -1;
197 }
198 }
199 return closed;
200 }
201
202 PyObject *
203 _PyIOBase_check_closed(PyObject *self, PyObject *args)
204 {
205 if (iobase_check_closed(self)) {
206 return NULL;
207 }
208 if (args == Py_True) {
209 return Py_None;
210 }
211 Py_RETURN_NONE;
212 }
213
214 /* XXX: IOBase thinks it has to maintain its own internal state in
215 `__IOBase_closed` and call flush() by itself, but it is redundant with
216 whatever behaviour a non-trivial derived class will implement. */
217
218 /*[clinic input]
219 _io._IOBase.close
220
221 Flush and close the IO object.
222
223 This method has no effect if the file is already closed.
224 [clinic start generated code]*/
225
226 static PyObject *
227 _io__IOBase_close_impl(PyObject *self)
228 /*[clinic end generated code: output=63c6a6f57d783d6d input=f4494d5c31dbc6b7]*/
229 {
230 PyObject *res, *exc, *val, *tb;
231 int rc, closed = iobase_is_closed(self);
232
233 if (closed < 0) {
234 return NULL;
235 }
236 if (closed) {
237 Py_RETURN_NONE;
238 }
239
240 res = PyObject_CallMethodNoArgs(self, &_Py_ID(flush));
241
242 PyErr_Fetch(&exc, &val, &tb);
243 rc = PyObject_SetAttr(self, &_Py_ID(__IOBase_closed), Py_True);
244 _PyErr_ChainExceptions(exc, val, tb);
245 if (rc < 0) {
246 Py_CLEAR(res);
247 }
248
249 if (res == NULL)
250 return NULL;
251
252 Py_DECREF(res);
253 Py_RETURN_NONE;
254 }
255
256 /* Finalization and garbage collection support */
257
258 static void
259 iobase_finalize(PyObject *self)
260 {
261 PyObject *res;
262 PyObject *error_type, *error_value, *error_traceback;
263 int closed;
264
265 /* Save the current exception, if any. */
266 PyErr_Fetch(&error_type, &error_value, &error_traceback);
267
268 /* If `closed` doesn't exist or can't be evaluated as bool, then the
269 object is probably in an unusable state, so ignore. */
270 if (_PyObject_LookupAttr(self, &_Py_ID(closed), &res) <= 0) {
271 PyErr_Clear();
272 closed = -1;
273 }
274 else {
275 closed = PyObject_IsTrue(res);
276 Py_DECREF(res);
277 if (closed == -1)
278 PyErr_Clear();
279 }
280 if (closed == 0) {
281 /* Signal close() that it was called as part of the object
282 finalization process. */
283 if (PyObject_SetAttr(self, &_Py_ID(_finalizing), Py_True))
284 PyErr_Clear();
285 res = PyObject_CallMethodNoArgs((PyObject *)self, &_Py_ID(close));
286 /* Silencing I/O errors is bad, but printing spurious tracebacks is
287 equally as bad, and potentially more frequent (because of
288 shutdown issues). */
289 if (res == NULL) {
290 #ifndef Py_DEBUG
291 if (_Py_GetConfig()->dev_mode) {
292 PyErr_WriteUnraisable(self);
293 }
294 else {
295 PyErr_Clear();
296 }
297 #else
298 PyErr_WriteUnraisable(self);
299 #endif
300 }
301 else {
302 Py_DECREF(res);
303 }
304 }
305
306 /* Restore the saved exception. */
307 PyErr_Restore(error_type, error_value, error_traceback);
308 }
309
310 int
311 _PyIOBase_finalize(PyObject *self)
312 {
313 int is_zombie;
314
315 /* If _PyIOBase_finalize() is called from a destructor, we need to
316 resurrect the object as calling close() can invoke arbitrary code. */
317 is_zombie = (Py_REFCNT(self) == 0);
318 if (is_zombie)
319 return PyObject_CallFinalizerFromDealloc(self);
320 else {
321 PyObject_CallFinalizer(self);
322 return 0;
323 }
324 }
325
326 static int
327 iobase_traverse(iobase *self, visitproc visit, void *arg)
328 {
329 Py_VISIT(self->dict);
330 return 0;
331 }
332
333 static int
334 iobase_clear(iobase *self)
335 {
336 Py_CLEAR(self->dict);
337 return 0;
338 }
339
340 /* Destructor */
341
342 static void
343 iobase_dealloc(iobase *self)
344 {
345 /* NOTE: since IOBaseObject has its own dict, Python-defined attributes
346 are still available here for close() to use.
347 However, if the derived class declares a __slots__, those slots are
348 already gone.
349 */
350 if (_PyIOBase_finalize((PyObject *) self) < 0) {
351 /* When called from a heap type's dealloc, the type will be
352 decref'ed on return (see e.g. subtype_dealloc in typeobject.c). */
353 if (_PyType_HasFeature(Py_TYPE(self), Py_TPFLAGS_HEAPTYPE)) {
354 Py_INCREF(Py_TYPE(self));
355 }
356 return;
357 }
358 _PyObject_GC_UNTRACK(self);
359 if (self->weakreflist != NULL)
360 PyObject_ClearWeakRefs((PyObject *) self);
361 Py_CLEAR(self->dict);
362 Py_TYPE(self)->tp_free((PyObject *) self);
363 }
364
365 /* Inquiry methods */
366
367 /*[clinic input]
368 _io._IOBase.seekable
369
370 Return whether object supports random access.
371
372 If False, seek(), tell() and truncate() will raise OSError.
373 This method may need to do a test seek().
374 [clinic start generated code]*/
375
376 static PyObject *
377 _io__IOBase_seekable_impl(PyObject *self)
378 /*[clinic end generated code: output=4c24c67f5f32a43d input=b976622f7fdf3063]*/
379 {
380 Py_RETURN_FALSE;
381 }
382
383 PyObject *
384 _PyIOBase_check_seekable(PyObject *self, PyObject *args)
385 {
386 PyObject *res = PyObject_CallMethodNoArgs(self, &_Py_ID(seekable));
387 if (res == NULL)
388 return NULL;
389 if (res != Py_True) {
390 Py_CLEAR(res);
391 iobase_unsupported("File or stream is not seekable.");
392 return NULL;
393 }
394 if (args == Py_True) {
395 Py_DECREF(res);
396 }
397 return res;
398 }
399
400 /*[clinic input]
401 _io._IOBase.readable
402
403 Return whether object was opened for reading.
404
405 If False, read() will raise OSError.
406 [clinic start generated code]*/
407
408 static PyObject *
409 _io__IOBase_readable_impl(PyObject *self)
410 /*[clinic end generated code: output=e48089250686388b input=285b3b866a0ec35f]*/
411 {
412 Py_RETURN_FALSE;
413 }
414
415 /* May be called with any object */
416 PyObject *
417 _PyIOBase_check_readable(PyObject *self, PyObject *args)
418 {
419 PyObject *res = PyObject_CallMethodNoArgs(self, &_Py_ID(readable));
420 if (res == NULL)
421 return NULL;
422 if (res != Py_True) {
423 Py_CLEAR(res);
424 iobase_unsupported("File or stream is not readable.");
425 return NULL;
426 }
427 if (args == Py_True) {
428 Py_DECREF(res);
429 }
430 return res;
431 }
432
433 /*[clinic input]
434 _io._IOBase.writable
435
436 Return whether object was opened for writing.
437
438 If False, write() will raise OSError.
439 [clinic start generated code]*/
440
441 static PyObject *
442 _io__IOBase_writable_impl(PyObject *self)
443 /*[clinic end generated code: output=406001d0985be14f input=9dcac18a013a05b5]*/
444 {
445 Py_RETURN_FALSE;
446 }
447
448 /* May be called with any object */
449 PyObject *
450 _PyIOBase_check_writable(PyObject *self, PyObject *args)
451 {
452 PyObject *res = PyObject_CallMethodNoArgs(self, &_Py_ID(writable));
453 if (res == NULL)
454 return NULL;
455 if (res != Py_True) {
456 Py_CLEAR(res);
457 iobase_unsupported("File or stream is not writable.");
458 return NULL;
459 }
460 if (args == Py_True) {
461 Py_DECREF(res);
462 }
463 return res;
464 }
465
466 /* Context manager */
467
468 static PyObject *
469 iobase_enter(PyObject *self, PyObject *args)
470 {
471 if (iobase_check_closed(self))
472 return NULL;
473
474 Py_INCREF(self);
475 return self;
476 }
477
478 static PyObject *
479 iobase_exit(PyObject *self, PyObject *args)
480 {
481 return PyObject_CallMethodNoArgs(self, &_Py_ID(close));
482 }
483
484 /* Lower-level APIs */
485
486 /* XXX Should these be present even if unimplemented? */
487
488 /*[clinic input]
489 _io._IOBase.fileno
490
491 Returns underlying file descriptor if one exists.
492
493 OSError is raised if the IO object does not use a file descriptor.
494 [clinic start generated code]*/
495
496 static PyObject *
497 _io__IOBase_fileno_impl(PyObject *self)
498 /*[clinic end generated code: output=7cc0973f0f5f3b73 input=4e37028947dc1cc8]*/
499 {
500 return iobase_unsupported("fileno");
501 }
502
503 /*[clinic input]
504 _io._IOBase.isatty
505
506 Return whether this is an 'interactive' stream.
507
508 Return False if it can't be determined.
509 [clinic start generated code]*/
510
511 static PyObject *
512 _io__IOBase_isatty_impl(PyObject *self)
513 /*[clinic end generated code: output=60cab77cede41cdd input=9ef76530d368458b]*/
514 {
515 if (iobase_check_closed(self))
516 return NULL;
517 Py_RETURN_FALSE;
518 }
519
520 /* Readline(s) and writelines */
521
522 /*[clinic input]
523 _io._IOBase.readline
524 size as limit: Py_ssize_t(accept={int, NoneType}) = -1
525 /
526
527 Read and return a line from the stream.
528
529 If size is specified, at most size bytes will be read.
530
531 The line terminator is always b'\n' for binary files; for text
532 files, the newlines argument to open can be used to select the line
533 terminator(s) recognized.
534 [clinic start generated code]*/
535
536 static PyObject *
537 _io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit)
538 /*[clinic end generated code: output=4479f79b58187840 input=d0c596794e877bff]*/
539 {
540 /* For backwards compatibility, a (slowish) readline(). */
541
542 PyObject *peek, *buffer, *result;
543 Py_ssize_t old_size = -1;
544
545 if (_PyObject_LookupAttr(self, &_Py_ID(peek), &peek) < 0) {
546 return NULL;
547 }
548
549 buffer = PyByteArray_FromStringAndSize(NULL, 0);
550 if (buffer == NULL) {
551 Py_XDECREF(peek);
552 return NULL;
553 }
554
555 while (limit < 0 || PyByteArray_GET_SIZE(buffer) < limit) {
556 Py_ssize_t nreadahead = 1;
557 PyObject *b;
558
559 if (peek != NULL) {
560 PyObject *readahead = PyObject_CallOneArg(peek, _PyLong_GetOne());
561 if (readahead == NULL) {
562 /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
563 when EINTR occurs so we needn't do it ourselves. */
564 if (_PyIO_trap_eintr()) {
565 continue;
566 }
567 goto fail;
568 }
569 if (!PyBytes_Check(readahead)) {
570 PyErr_Format(PyExc_OSError,
571 "peek() should have returned a bytes object, "
572 "not '%.200s'", Py_TYPE(readahead)->tp_name);
573 Py_DECREF(readahead);
574 goto fail;
575 }
576 if (PyBytes_GET_SIZE(readahead) > 0) {
577 Py_ssize_t n = 0;
578 const char *buf = PyBytes_AS_STRING(readahead);
579 if (limit >= 0) {
580 do {
581 if (n >= PyBytes_GET_SIZE(readahead) || n >= limit)
582 break;
583 if (buf[n++] == '\n')
584 break;
585 } while (1);
586 }
587 else {
588 do {
589 if (n >= PyBytes_GET_SIZE(readahead))
590 break;
591 if (buf[n++] == '\n')
592 break;
593 } while (1);
594 }
595 nreadahead = n;
596 }
597 Py_DECREF(readahead);
598 }
599
600 b = _PyObject_CallMethod(self, &_Py_ID(read), "n", nreadahead);
601 if (b == NULL) {
602 /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
603 when EINTR occurs so we needn't do it ourselves. */
604 if (_PyIO_trap_eintr()) {
605 continue;
606 }
607 goto fail;
608 }
609 if (!PyBytes_Check(b)) {
610 PyErr_Format(PyExc_OSError,
611 "read() should have returned a bytes object, "
612 "not '%.200s'", Py_TYPE(b)->tp_name);
613 Py_DECREF(b);
614 goto fail;
615 }
616 if (PyBytes_GET_SIZE(b) == 0) {
617 Py_DECREF(b);
618 break;
619 }
620
621 old_size = PyByteArray_GET_SIZE(buffer);
622 if (PyByteArray_Resize(buffer, old_size + PyBytes_GET_SIZE(b)) < 0) {
623 Py_DECREF(b);
624 goto fail;
625 }
626 memcpy(PyByteArray_AS_STRING(buffer) + old_size,
627 PyBytes_AS_STRING(b), PyBytes_GET_SIZE(b));
628
629 Py_DECREF(b);
630
631 if (PyByteArray_AS_STRING(buffer)[PyByteArray_GET_SIZE(buffer) - 1] == '\n')
632 break;
633 }
634
635 result = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(buffer),
636 PyByteArray_GET_SIZE(buffer));
637 Py_XDECREF(peek);
638 Py_DECREF(buffer);
639 return result;
640 fail:
641 Py_XDECREF(peek);
642 Py_DECREF(buffer);
643 return NULL;
644 }
645
646 static PyObject *
647 iobase_iter(PyObject *self)
648 {
649 if (iobase_check_closed(self))
650 return NULL;
651
652 Py_INCREF(self);
653 return self;
654 }
655
656 static PyObject *
657 iobase_iternext(PyObject *self)
658 {
659 PyObject *line = PyObject_CallMethodNoArgs(self, &_Py_ID(readline));
660
661 if (line == NULL)
662 return NULL;
663
664 if (PyObject_Size(line) <= 0) {
665 /* Error or empty */
666 Py_DECREF(line);
667 return NULL;
668 }
669
670 return line;
671 }
672
673 /*[clinic input]
674 _io._IOBase.readlines
675 hint: Py_ssize_t(accept={int, NoneType}) = -1
676 /
677
678 Return a list of lines from the stream.
679
680 hint can be specified to control the number of lines read: no more
681 lines will be read if the total size (in bytes/characters) of all
682 lines so far exceeds hint.
683 [clinic start generated code]*/
684
685 static PyObject *
686 _io__IOBase_readlines_impl(PyObject *self, Py_ssize_t hint)
687 /*[clinic end generated code: output=2f50421677fa3dea input=9400c786ea9dc416]*/
688 {
689 Py_ssize_t length = 0;
690 PyObject *result, *it = NULL;
691
692 result = PyList_New(0);
693 if (result == NULL)
694 return NULL;
695
696 if (hint <= 0) {
697 /* XXX special-casing this made sense in the Python version in order
698 to remove the bytecode interpretation overhead, but it could
699 probably be removed here. */
700 PyObject *ret = PyObject_CallMethodObjArgs(result, &_Py_ID(extend),
701 self, NULL);
702 if (ret == NULL) {
703 goto error;
704 }
705 Py_DECREF(ret);
706 return result;
707 }
708
709 it = PyObject_GetIter(self);
710 if (it == NULL) {
711 goto error;
712 }
713
714 while (1) {
715 Py_ssize_t line_length;
716 PyObject *line = PyIter_Next(it);
717 if (line == NULL) {
718 if (PyErr_Occurred()) {
719 goto error;
720 }
721 else
722 break; /* StopIteration raised */
723 }
724
725 if (PyList_Append(result, line) < 0) {
726 Py_DECREF(line);
727 goto error;
728 }
729 line_length = PyObject_Size(line);
730 Py_DECREF(line);
731 if (line_length < 0) {
732 goto error;
733 }
734 if (line_length > hint - length)
735 break;
736 length += line_length;
737 }
738
739 Py_DECREF(it);
740 return result;
741
742 error:
743 Py_XDECREF(it);
744 Py_DECREF(result);
745 return NULL;
746 }
747
748 /*[clinic input]
749 _io._IOBase.writelines
750 lines: object
751 /
752
753 Write a list of lines to stream.
754
755 Line separators are not added, so it is usual for each of the
756 lines provided to have a line separator at the end.
757 [clinic start generated code]*/
758
759 static PyObject *
760 _io__IOBase_writelines(PyObject *self, PyObject *lines)
761 /*[clinic end generated code: output=976eb0a9b60a6628 input=cac3fc8864183359]*/
762 {
763 PyObject *iter, *res;
764
765 if (iobase_check_closed(self))
766 return NULL;
767
768 iter = PyObject_GetIter(lines);
769 if (iter == NULL)
770 return NULL;
771
772 while (1) {
773 PyObject *line = PyIter_Next(iter);
774 if (line == NULL) {
775 if (PyErr_Occurred()) {
776 Py_DECREF(iter);
777 return NULL;
778 }
779 else
780 break; /* Stop Iteration */
781 }
782
783 res = NULL;
784 do {
785 res = PyObject_CallMethodObjArgs(self, &_Py_ID(write), line, NULL);
786 } while (res == NULL && _PyIO_trap_eintr());
787 Py_DECREF(line);
788 if (res == NULL) {
789 Py_DECREF(iter);
790 return NULL;
791 }
792 Py_DECREF(res);
793 }
794 Py_DECREF(iter);
795 Py_RETURN_NONE;
796 }
797
798 #include "clinic/iobase.c.h"
799
800 static PyMethodDef iobase_methods[] = {
801 {"seek", iobase_seek, METH_VARARGS, iobase_seek_doc},
802 _IO__IOBASE_TELL_METHODDEF
803 {"truncate", iobase_truncate, METH_VARARGS, iobase_truncate_doc},
804 _IO__IOBASE_FLUSH_METHODDEF
805 _IO__IOBASE_CLOSE_METHODDEF
806
807 _IO__IOBASE_SEEKABLE_METHODDEF
808 _IO__IOBASE_READABLE_METHODDEF
809 _IO__IOBASE_WRITABLE_METHODDEF
810
811 {"_checkClosed", _PyIOBase_check_closed, METH_NOARGS},
812 {"_checkSeekable", _PyIOBase_check_seekable, METH_NOARGS},
813 {"_checkReadable", _PyIOBase_check_readable, METH_NOARGS},
814 {"_checkWritable", _PyIOBase_check_writable, METH_NOARGS},
815
816 _IO__IOBASE_FILENO_METHODDEF
817 _IO__IOBASE_ISATTY_METHODDEF
818
819 {"__enter__", iobase_enter, METH_NOARGS},
820 {"__exit__", iobase_exit, METH_VARARGS},
821
822 _IO__IOBASE_READLINE_METHODDEF
823 _IO__IOBASE_READLINES_METHODDEF
824 _IO__IOBASE_WRITELINES_METHODDEF
825
826 {NULL, NULL}
827 };
828
829 static PyGetSetDef iobase_getset[] = {
830 {"__dict__", PyObject_GenericGetDict, NULL, NULL},
831 {"closed", (getter)iobase_closed_get, NULL, NULL},
832 {NULL}
833 };
834
835
836 PyTypeObject PyIOBase_Type = {
837 PyVarObject_HEAD_INIT(NULL, 0)
838 "_io._IOBase", /*tp_name*/
839 sizeof(iobase), /*tp_basicsize*/
840 0, /*tp_itemsize*/
841 (destructor)iobase_dealloc, /*tp_dealloc*/
842 0, /*tp_vectorcall_offset*/
843 0, /*tp_getattr*/
844 0, /*tp_setattr*/
845 0, /*tp_as_async*/
846 0, /*tp_repr*/
847 0, /*tp_as_number*/
848 0, /*tp_as_sequence*/
849 0, /*tp_as_mapping*/
850 0, /*tp_hash */
851 0, /*tp_call*/
852 0, /*tp_str*/
853 0, /*tp_getattro*/
854 0, /*tp_setattro*/
855 0, /*tp_as_buffer*/
856 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
857 | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
858 iobase_doc, /* tp_doc */
859 (traverseproc)iobase_traverse, /* tp_traverse */
860 (inquiry)iobase_clear, /* tp_clear */
861 0, /* tp_richcompare */
862 offsetof(iobase, weakreflist), /* tp_weaklistoffset */
863 iobase_iter, /* tp_iter */
864 iobase_iternext, /* tp_iternext */
865 iobase_methods, /* tp_methods */
866 0, /* tp_members */
867 iobase_getset, /* tp_getset */
868 0, /* tp_base */
869 0, /* tp_dict */
870 0, /* tp_descr_get */
871 0, /* tp_descr_set */
872 offsetof(iobase, dict), /* tp_dictoffset */
873 0, /* tp_init */
874 0, /* tp_alloc */
875 PyType_GenericNew, /* tp_new */
876 0, /* tp_free */
877 0, /* tp_is_gc */
878 0, /* tp_bases */
879 0, /* tp_mro */
880 0, /* tp_cache */
881 0, /* tp_subclasses */
882 0, /* tp_weaklist */
883 0, /* tp_del */
884 0, /* tp_version_tag */
885 iobase_finalize, /* tp_finalize */
886 };
887
888
889 /*
890 * RawIOBase class, Inherits from IOBase.
891 */
892 PyDoc_STRVAR(rawiobase_doc,
893 "Base class for raw binary I/O.");
894
895 /*
896 * The read() method is implemented by calling readinto(); derived classes
897 * that want to support read() only need to implement readinto() as a
898 * primitive operation. In general, readinto() can be more efficient than
899 * read().
900 *
901 * (It would be tempting to also provide an implementation of readinto() in
902 * terms of read(), in case the latter is a more suitable primitive operation,
903 * but that would lead to nasty recursion in case a subclass doesn't implement
904 * either.)
905 */
906
907 /*[clinic input]
908 _io._RawIOBase.read
909 size as n: Py_ssize_t = -1
910 /
911 [clinic start generated code]*/
912
913 static PyObject *
914 _io__RawIOBase_read_impl(PyObject *self, Py_ssize_t n)
915 /*[clinic end generated code: output=6cdeb731e3c9f13c input=b6d0dcf6417d1374]*/
916 {
917 PyObject *b, *res;
918
919 if (n < 0) {
920 return PyObject_CallMethodNoArgs(self, &_Py_ID(readall));
921 }
922
923 /* TODO: allocate a bytes object directly instead and manually construct
924 a writable memoryview pointing to it. */
925 b = PyByteArray_FromStringAndSize(NULL, n);
926 if (b == NULL)
927 return NULL;
928
929 res = PyObject_CallMethodObjArgs(self, &_Py_ID(readinto), b, NULL);
930 if (res == NULL || res == Py_None) {
931 Py_DECREF(b);
932 return res;
933 }
934
935 n = PyNumber_AsSsize_t(res, PyExc_ValueError);
936 Py_DECREF(res);
937 if (n == -1 && PyErr_Occurred()) {
938 Py_DECREF(b);
939 return NULL;
940 }
941
942 res = PyBytes_FromStringAndSize(PyByteArray_AsString(b), n);
943 Py_DECREF(b);
944 return res;
945 }
946
947
948 /*[clinic input]
949 _io._RawIOBase.readall
950
951 Read until EOF, using multiple read() call.
952 [clinic start generated code]*/
953
954 static PyObject *
955 _io__RawIOBase_readall_impl(PyObject *self)
956 /*[clinic end generated code: output=1987b9ce929425a0 input=688874141213622a]*/
957 {
958 int r;
959 PyObject *chunks = PyList_New(0);
960 PyObject *result;
961
962 if (chunks == NULL)
963 return NULL;
964
965 while (1) {
966 PyObject *data = _PyObject_CallMethod(self, &_Py_ID(read),
967 "i", DEFAULT_BUFFER_SIZE);
968 if (!data) {
969 /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
970 when EINTR occurs so we needn't do it ourselves. */
971 if (_PyIO_trap_eintr()) {
972 continue;
973 }
974 Py_DECREF(chunks);
975 return NULL;
976 }
977 if (data == Py_None) {
978 if (PyList_GET_SIZE(chunks) == 0) {
979 Py_DECREF(chunks);
980 return data;
981 }
982 Py_DECREF(data);
983 break;
984 }
985 if (!PyBytes_Check(data)) {
986 Py_DECREF(chunks);
987 Py_DECREF(data);
988 PyErr_SetString(PyExc_TypeError, "read() should return bytes");
989 return NULL;
990 }
991 if (PyBytes_GET_SIZE(data) == 0) {
992 /* EOF */
993 Py_DECREF(data);
994 break;
995 }
996 r = PyList_Append(chunks, data);
997 Py_DECREF(data);
998 if (r < 0) {
999 Py_DECREF(chunks);
1000 return NULL;
1001 }
1002 }
1003 result = _PyBytes_Join((PyObject *)&_Py_SINGLETON(bytes_empty), chunks);
1004 Py_DECREF(chunks);
1005 return result;
1006 }
1007
1008 static PyObject *
1009 rawiobase_readinto(PyObject *self, PyObject *args)
1010 {
1011 PyErr_SetNone(PyExc_NotImplementedError);
1012 return NULL;
1013 }
1014
1015 static PyObject *
1016 rawiobase_write(PyObject *self, PyObject *args)
1017 {
1018 PyErr_SetNone(PyExc_NotImplementedError);
1019 return NULL;
1020 }
1021
1022 static PyMethodDef rawiobase_methods[] = {
1023 _IO__RAWIOBASE_READ_METHODDEF
1024 _IO__RAWIOBASE_READALL_METHODDEF
1025 {"readinto", rawiobase_readinto, METH_VARARGS},
1026 {"write", rawiobase_write, METH_VARARGS},
1027 {NULL, NULL}
1028 };
1029
1030 PyTypeObject PyRawIOBase_Type = {
1031 PyVarObject_HEAD_INIT(NULL, 0)
1032 "_io._RawIOBase", /*tp_name*/
1033 0, /*tp_basicsize*/
1034 0, /*tp_itemsize*/
1035 0, /*tp_dealloc*/
1036 0, /*tp_vectorcall_offset*/
1037 0, /*tp_getattr*/
1038 0, /*tp_setattr*/
1039 0, /*tp_as_async*/
1040 0, /*tp_repr*/
1041 0, /*tp_as_number*/
1042 0, /*tp_as_sequence*/
1043 0, /*tp_as_mapping*/
1044 0, /*tp_hash */
1045 0, /*tp_call*/
1046 0, /*tp_str*/
1047 0, /*tp_getattro*/
1048 0, /*tp_setattro*/
1049 0, /*tp_as_buffer*/
1050 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1051 rawiobase_doc, /* tp_doc */
1052 0, /* tp_traverse */
1053 0, /* tp_clear */
1054 0, /* tp_richcompare */
1055 0, /* tp_weaklistoffset */
1056 0, /* tp_iter */
1057 0, /* tp_iternext */
1058 rawiobase_methods, /* tp_methods */
1059 0, /* tp_members */
1060 0, /* tp_getset */
1061 &PyIOBase_Type, /* tp_base */
1062 0, /* tp_dict */
1063 0, /* tp_descr_get */
1064 0, /* tp_descr_set */
1065 0, /* tp_dictoffset */
1066 0, /* tp_init */
1067 0, /* tp_alloc */
1068 0, /* tp_new */
1069 0, /* tp_free */
1070 0, /* tp_is_gc */
1071 0, /* tp_bases */
1072 0, /* tp_mro */
1073 0, /* tp_cache */
1074 0, /* tp_subclasses */
1075 0, /* tp_weaklist */
1076 0, /* tp_del */
1077 0, /* tp_version_tag */
1078 0, /* tp_finalize */
1079 };