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, acting on streams of\n"
38 "bytes. There is no public constructor.\n"
39 "\n"
40 "This class provides dummy implementations for many methods that\n"
41 "derived classes can override selectively; the default implementations\n"
42 "represent a file that cannot be read, written or seeked.\n"
43 "\n"
44 "Even though IOBase does not declare read, readinto, or write because\n"
45 "their signatures will vary, implementations and clients should\n"
46 "consider those methods part of the interface. Also, implementations\n"
47 "may raise UnsupportedOperation when operations they do not support are\n"
48 "called.\n"
49 "\n"
50 "The basic type used for binary data read from or written to a file is\n"
51 "bytes. Other bytes-like objects are accepted as method arguments too.\n"
52 "In some cases (such as readinto), a writable object is required. Text\n"
53 "I/O classes work with str data.\n"
54 "\n"
55 "Note that calling any method (except additional calls to close(),\n"
56 "which are ignored) on a closed stream should raise a ValueError.\n"
57 "\n"
58 "IOBase (and its subclasses) support the iterator protocol, meaning\n"
59 "that an IOBase object can be iterated over yielding the lines in a\n"
60 "stream.\n"
61 "\n"
62 "IOBase also supports the :keyword:`with` statement. In this example,\n"
63 "fp is closed after the suite of the with statement is complete:\n"
64 "\n"
65 "with open('spam.txt', 'r') as fp:\n"
66 " fp.write('Spam and eggs!')\n");
67
68 /* Use this macro whenever you want to check the internal `closed` status
69 of the IOBase object rather than the virtual `closed` attribute as returned
70 by whatever subclass. */
71
72 _Py_IDENTIFIER(__IOBase_closed);
73 _Py_IDENTIFIER(read);
74
75
76 /* Internal methods */
77 static PyObject *
iobase_unsupported(const char * message)78 iobase_unsupported(const char *message)
79 {
80 _PyIO_State *state = IO_STATE();
81 if (state != NULL)
82 PyErr_SetString(state->unsupported_operation, message);
83 return NULL;
84 }
85
86 /* Positioning */
87
88 PyDoc_STRVAR(iobase_seek_doc,
89 "Change stream position.\n"
90 "\n"
91 "Change the stream position to the given byte offset. The offset is\n"
92 "interpreted relative to the position indicated by whence. Values\n"
93 "for whence are:\n"
94 "\n"
95 "* 0 -- start of stream (the default); offset should be zero or positive\n"
96 "* 1 -- current stream position; offset may be negative\n"
97 "* 2 -- end of stream; offset is usually negative\n"
98 "\n"
99 "Return the new absolute position.");
100
101 static PyObject *
iobase_seek(PyObject * self,PyObject * args)102 iobase_seek(PyObject *self, PyObject *args)
103 {
104 return iobase_unsupported("seek");
105 }
106
107 /*[clinic input]
108 _io._IOBase.tell
109
110 Return current stream position.
111 [clinic start generated code]*/
112
113 static PyObject *
_io__IOBase_tell_impl(PyObject * self)114 _io__IOBase_tell_impl(PyObject *self)
115 /*[clinic end generated code: output=89a1c0807935abe2 input=04e615fec128801f]*/
116 {
117 _Py_IDENTIFIER(seek);
118
119 return _PyObject_CallMethodId(self, &PyId_seek, "ii", 0, 1);
120 }
121
122 PyDoc_STRVAR(iobase_truncate_doc,
123 "Truncate file to size bytes.\n"
124 "\n"
125 "File pointer is left unchanged. Size defaults to the current IO\n"
126 "position as reported by tell(). Returns the new size.");
127
128 static PyObject *
iobase_truncate(PyObject * self,PyObject * args)129 iobase_truncate(PyObject *self, PyObject *args)
130 {
131 return iobase_unsupported("truncate");
132 }
133
134 static int
iobase_is_closed(PyObject * self)135 iobase_is_closed(PyObject *self)
136 {
137 PyObject *res;
138 int ret;
139 /* This gets the derived attribute, which is *not* __IOBase_closed
140 in most cases! */
141 ret = _PyObject_LookupAttrId(self, &PyId___IOBase_closed, &res);
142 Py_XDECREF(res);
143 return ret;
144 }
145
146 /* Flush and close methods */
147
148 /*[clinic input]
149 _io._IOBase.flush
150
151 Flush write buffers, if applicable.
152
153 This is not implemented for read-only and non-blocking streams.
154 [clinic start generated code]*/
155
156 static PyObject *
_io__IOBase_flush_impl(PyObject * self)157 _io__IOBase_flush_impl(PyObject *self)
158 /*[clinic end generated code: output=7cef4b4d54656a3b input=773be121abe270aa]*/
159 {
160 /* XXX Should this return the number of bytes written??? */
161 int closed = iobase_is_closed(self);
162
163 if (!closed) {
164 Py_RETURN_NONE;
165 }
166 if (closed > 0) {
167 PyErr_SetString(PyExc_ValueError, "I/O operation on closed file.");
168 }
169 return NULL;
170 }
171
172 static PyObject *
iobase_closed_get(PyObject * self,void * context)173 iobase_closed_get(PyObject *self, void *context)
174 {
175 int closed = iobase_is_closed(self);
176 if (closed < 0) {
177 return NULL;
178 }
179 return PyBool_FromLong(closed);
180 }
181
182 static int
iobase_check_closed(PyObject * self)183 iobase_check_closed(PyObject *self)
184 {
185 PyObject *res;
186 int closed;
187 /* This gets the derived attribute, which is *not* __IOBase_closed
188 in most cases! */
189 closed = _PyObject_LookupAttr(self, _PyIO_str_closed, &res);
190 if (closed > 0) {
191 closed = PyObject_IsTrue(res);
192 Py_DECREF(res);
193 if (closed > 0) {
194 PyErr_SetString(PyExc_ValueError, "I/O operation on closed file.");
195 return -1;
196 }
197 }
198 return closed;
199 }
200
201 PyObject *
_PyIOBase_check_closed(PyObject * self,PyObject * args)202 _PyIOBase_check_closed(PyObject *self, PyObject *args)
203 {
204 if (iobase_check_closed(self)) {
205 return NULL;
206 }
207 if (args == Py_True) {
208 return Py_None;
209 }
210 Py_RETURN_NONE;
211 }
212
213 /* XXX: IOBase thinks it has to maintain its own internal state in
214 `__IOBase_closed` and call flush() by itself, but it is redundant with
215 whatever behaviour a non-trivial derived class will implement. */
216
217 /*[clinic input]
218 _io._IOBase.close
219
220 Flush and close the IO object.
221
222 This method has no effect if the file is already closed.
223 [clinic start generated code]*/
224
225 static PyObject *
_io__IOBase_close_impl(PyObject * self)226 _io__IOBase_close_impl(PyObject *self)
227 /*[clinic end generated code: output=63c6a6f57d783d6d input=f4494d5c31dbc6b7]*/
228 {
229 PyObject *res, *exc, *val, *tb;
230 int rc, closed = iobase_is_closed(self);
231
232 if (closed < 0) {
233 return NULL;
234 }
235 if (closed) {
236 Py_RETURN_NONE;
237 }
238
239 res = PyObject_CallMethodNoArgs(self, _PyIO_str_flush);
240
241 PyErr_Fetch(&exc, &val, &tb);
242 rc = _PyObject_SetAttrId(self, &PyId___IOBase_closed, Py_True);
243 _PyErr_ChainExceptions(exc, val, tb);
244 if (rc < 0) {
245 Py_CLEAR(res);
246 }
247
248 if (res == NULL)
249 return NULL;
250
251 Py_DECREF(res);
252 Py_RETURN_NONE;
253 }
254
255 /* Finalization and garbage collection support */
256
257 static void
iobase_finalize(PyObject * self)258 iobase_finalize(PyObject *self)
259 {
260 PyObject *res;
261 PyObject *error_type, *error_value, *error_traceback;
262 int closed;
263 _Py_IDENTIFIER(_finalizing);
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, _PyIO_str_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_SetAttrId(self, &PyId__finalizing, Py_True))
284 PyErr_Clear();
285 res = PyObject_CallMethodNoArgs((PyObject *)self, _PyIO_str_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
_PyIOBase_finalize(PyObject * self)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
iobase_traverse(iobase * self,visitproc visit,void * arg)327 iobase_traverse(iobase *self, visitproc visit, void *arg)
328 {
329 Py_VISIT(self->dict);
330 return 0;
331 }
332
333 static int
iobase_clear(iobase * self)334 iobase_clear(iobase *self)
335 {
336 Py_CLEAR(self->dict);
337 return 0;
338 }
339
340 /* Destructor */
341
342 static void
iobase_dealloc(iobase * self)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 *
_io__IOBase_seekable_impl(PyObject * self)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 *
_PyIOBase_check_seekable(PyObject * self,PyObject * args)384 _PyIOBase_check_seekable(PyObject *self, PyObject *args)
385 {
386 PyObject *res = PyObject_CallMethodNoArgs(self, _PyIO_str_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 *
_io__IOBase_readable_impl(PyObject * self)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 *
_PyIOBase_check_readable(PyObject * self,PyObject * args)417 _PyIOBase_check_readable(PyObject *self, PyObject *args)
418 {
419 PyObject *res = PyObject_CallMethodNoArgs(self, _PyIO_str_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 *
_io__IOBase_writable_impl(PyObject * self)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 *
_PyIOBase_check_writable(PyObject * self,PyObject * args)450 _PyIOBase_check_writable(PyObject *self, PyObject *args)
451 {
452 PyObject *res = PyObject_CallMethodNoArgs(self, _PyIO_str_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 *
iobase_enter(PyObject * self,PyObject * args)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 *
iobase_exit(PyObject * self,PyObject * args)479 iobase_exit(PyObject *self, PyObject *args)
480 {
481 return PyObject_CallMethodNoArgs(self, _PyIO_str_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 *
_io__IOBase_fileno_impl(PyObject * self)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 *
_io__IOBase_isatty_impl(PyObject * self)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 *
_io__IOBase_readline_impl(PyObject * self,Py_ssize_t limit)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, _PyIO_str_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_CallMethodId(self, &PyId_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 *
iobase_iter(PyObject * self)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 *
iobase_iternext(PyObject * self)657 iobase_iternext(PyObject *self)
658 {
659 PyObject *line = PyObject_CallMethodNoArgs(self, _PyIO_str_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 *
_io__IOBase_readlines_impl(PyObject * self,Py_ssize_t hint)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 _Py_IDENTIFIER(extend);
701 PyObject *ret = _PyObject_CallMethodIdObjArgs(result, &PyId_extend,
702 self, NULL);
703
704 if (ret == NULL) {
705 goto error;
706 }
707 Py_DECREF(ret);
708 return result;
709 }
710
711 it = PyObject_GetIter(self);
712 if (it == NULL) {
713 goto error;
714 }
715
716 while (1) {
717 Py_ssize_t line_length;
718 PyObject *line = PyIter_Next(it);
719 if (line == NULL) {
720 if (PyErr_Occurred()) {
721 goto error;
722 }
723 else
724 break; /* StopIteration raised */
725 }
726
727 if (PyList_Append(result, line) < 0) {
728 Py_DECREF(line);
729 goto error;
730 }
731 line_length = PyObject_Size(line);
732 Py_DECREF(line);
733 if (line_length < 0) {
734 goto error;
735 }
736 if (line_length > hint - length)
737 break;
738 length += line_length;
739 }
740
741 Py_DECREF(it);
742 return result;
743
744 error:
745 Py_XDECREF(it);
746 Py_DECREF(result);
747 return NULL;
748 }
749
750 /*[clinic input]
751 _io._IOBase.writelines
752 lines: object
753 /
754
755 Write a list of lines to stream.
756
757 Line separators are not added, so it is usual for each of the
758 lines provided to have a line separator at the end.
759 [clinic start generated code]*/
760
761 static PyObject *
_io__IOBase_writelines(PyObject * self,PyObject * lines)762 _io__IOBase_writelines(PyObject *self, PyObject *lines)
763 /*[clinic end generated code: output=976eb0a9b60a6628 input=cac3fc8864183359]*/
764 {
765 PyObject *iter, *res;
766
767 if (iobase_check_closed(self))
768 return NULL;
769
770 iter = PyObject_GetIter(lines);
771 if (iter == NULL)
772 return NULL;
773
774 while (1) {
775 PyObject *line = PyIter_Next(iter);
776 if (line == NULL) {
777 if (PyErr_Occurred()) {
778 Py_DECREF(iter);
779 return NULL;
780 }
781 else
782 break; /* Stop Iteration */
783 }
784
785 res = NULL;
786 do {
787 res = PyObject_CallMethodObjArgs(self, _PyIO_str_write, line, NULL);
788 } while (res == NULL && _PyIO_trap_eintr());
789 Py_DECREF(line);
790 if (res == NULL) {
791 Py_DECREF(iter);
792 return NULL;
793 }
794 Py_DECREF(res);
795 }
796 Py_DECREF(iter);
797 Py_RETURN_NONE;
798 }
799
800 #include "clinic/iobase.c.h"
801
802 static PyMethodDef iobase_methods[] = {
803 {"seek", iobase_seek, METH_VARARGS, iobase_seek_doc},
804 _IO__IOBASE_TELL_METHODDEF
805 {"truncate", iobase_truncate, METH_VARARGS, iobase_truncate_doc},
806 _IO__IOBASE_FLUSH_METHODDEF
807 _IO__IOBASE_CLOSE_METHODDEF
808
809 _IO__IOBASE_SEEKABLE_METHODDEF
810 _IO__IOBASE_READABLE_METHODDEF
811 _IO__IOBASE_WRITABLE_METHODDEF
812
813 {"_checkClosed", _PyIOBase_check_closed, METH_NOARGS},
814 {"_checkSeekable", _PyIOBase_check_seekable, METH_NOARGS},
815 {"_checkReadable", _PyIOBase_check_readable, METH_NOARGS},
816 {"_checkWritable", _PyIOBase_check_writable, METH_NOARGS},
817
818 _IO__IOBASE_FILENO_METHODDEF
819 _IO__IOBASE_ISATTY_METHODDEF
820
821 {"__enter__", iobase_enter, METH_NOARGS},
822 {"__exit__", iobase_exit, METH_VARARGS},
823
824 _IO__IOBASE_READLINE_METHODDEF
825 _IO__IOBASE_READLINES_METHODDEF
826 _IO__IOBASE_WRITELINES_METHODDEF
827
828 {NULL, NULL}
829 };
830
831 static PyGetSetDef iobase_getset[] = {
832 {"__dict__", PyObject_GenericGetDict, NULL, NULL},
833 {"closed", (getter)iobase_closed_get, NULL, NULL},
834 {NULL}
835 };
836
837
838 PyTypeObject PyIOBase_Type = {
839 PyVarObject_HEAD_INIT(NULL, 0)
840 "_io._IOBase", /*tp_name*/
841 sizeof(iobase), /*tp_basicsize*/
842 0, /*tp_itemsize*/
843 (destructor)iobase_dealloc, /*tp_dealloc*/
844 0, /*tp_vectorcall_offset*/
845 0, /*tp_getattr*/
846 0, /*tp_setattr*/
847 0, /*tp_as_async*/
848 0, /*tp_repr*/
849 0, /*tp_as_number*/
850 0, /*tp_as_sequence*/
851 0, /*tp_as_mapping*/
852 0, /*tp_hash */
853 0, /*tp_call*/
854 0, /*tp_str*/
855 0, /*tp_getattro*/
856 0, /*tp_setattro*/
857 0, /*tp_as_buffer*/
858 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
859 | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
860 iobase_doc, /* tp_doc */
861 (traverseproc)iobase_traverse, /* tp_traverse */
862 (inquiry)iobase_clear, /* tp_clear */
863 0, /* tp_richcompare */
864 offsetof(iobase, weakreflist), /* tp_weaklistoffset */
865 iobase_iter, /* tp_iter */
866 iobase_iternext, /* tp_iternext */
867 iobase_methods, /* tp_methods */
868 0, /* tp_members */
869 iobase_getset, /* tp_getset */
870 0, /* tp_base */
871 0, /* tp_dict */
872 0, /* tp_descr_get */
873 0, /* tp_descr_set */
874 offsetof(iobase, dict), /* tp_dictoffset */
875 0, /* tp_init */
876 0, /* tp_alloc */
877 PyType_GenericNew, /* tp_new */
878 0, /* tp_free */
879 0, /* tp_is_gc */
880 0, /* tp_bases */
881 0, /* tp_mro */
882 0, /* tp_cache */
883 0, /* tp_subclasses */
884 0, /* tp_weaklist */
885 0, /* tp_del */
886 0, /* tp_version_tag */
887 iobase_finalize, /* tp_finalize */
888 };
889
890
891 /*
892 * RawIOBase class, Inherits from IOBase.
893 */
894 PyDoc_STRVAR(rawiobase_doc,
895 "Base class for raw binary I/O.");
896
897 /*
898 * The read() method is implemented by calling readinto(); derived classes
899 * that want to support read() only need to implement readinto() as a
900 * primitive operation. In general, readinto() can be more efficient than
901 * read().
902 *
903 * (It would be tempting to also provide an implementation of readinto() in
904 * terms of read(), in case the latter is a more suitable primitive operation,
905 * but that would lead to nasty recursion in case a subclass doesn't implement
906 * either.)
907 */
908
909 /*[clinic input]
910 _io._RawIOBase.read
911 size as n: Py_ssize_t = -1
912 /
913 [clinic start generated code]*/
914
915 static PyObject *
_io__RawIOBase_read_impl(PyObject * self,Py_ssize_t n)916 _io__RawIOBase_read_impl(PyObject *self, Py_ssize_t n)
917 /*[clinic end generated code: output=6cdeb731e3c9f13c input=b6d0dcf6417d1374]*/
918 {
919 PyObject *b, *res;
920
921 if (n < 0) {
922 _Py_IDENTIFIER(readall);
923
924 return _PyObject_CallMethodIdNoArgs(self, &PyId_readall);
925 }
926
927 /* TODO: allocate a bytes object directly instead and manually construct
928 a writable memoryview pointing to it. */
929 b = PyByteArray_FromStringAndSize(NULL, n);
930 if (b == NULL)
931 return NULL;
932
933 res = PyObject_CallMethodObjArgs(self, _PyIO_str_readinto, b, NULL);
934 if (res == NULL || res == Py_None) {
935 Py_DECREF(b);
936 return res;
937 }
938
939 n = PyNumber_AsSsize_t(res, PyExc_ValueError);
940 Py_DECREF(res);
941 if (n == -1 && PyErr_Occurred()) {
942 Py_DECREF(b);
943 return NULL;
944 }
945
946 res = PyBytes_FromStringAndSize(PyByteArray_AsString(b), n);
947 Py_DECREF(b);
948 return res;
949 }
950
951
952 /*[clinic input]
953 _io._RawIOBase.readall
954
955 Read until EOF, using multiple read() call.
956 [clinic start generated code]*/
957
958 static PyObject *
_io__RawIOBase_readall_impl(PyObject * self)959 _io__RawIOBase_readall_impl(PyObject *self)
960 /*[clinic end generated code: output=1987b9ce929425a0 input=688874141213622a]*/
961 {
962 int r;
963 PyObject *chunks = PyList_New(0);
964 PyObject *result;
965
966 if (chunks == NULL)
967 return NULL;
968
969 while (1) {
970 PyObject *data = _PyObject_CallMethodId(self, &PyId_read,
971 "i", DEFAULT_BUFFER_SIZE);
972 if (!data) {
973 /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
974 when EINTR occurs so we needn't do it ourselves. */
975 if (_PyIO_trap_eintr()) {
976 continue;
977 }
978 Py_DECREF(chunks);
979 return NULL;
980 }
981 if (data == Py_None) {
982 if (PyList_GET_SIZE(chunks) == 0) {
983 Py_DECREF(chunks);
984 return data;
985 }
986 Py_DECREF(data);
987 break;
988 }
989 if (!PyBytes_Check(data)) {
990 Py_DECREF(chunks);
991 Py_DECREF(data);
992 PyErr_SetString(PyExc_TypeError, "read() should return bytes");
993 return NULL;
994 }
995 if (PyBytes_GET_SIZE(data) == 0) {
996 /* EOF */
997 Py_DECREF(data);
998 break;
999 }
1000 r = PyList_Append(chunks, data);
1001 Py_DECREF(data);
1002 if (r < 0) {
1003 Py_DECREF(chunks);
1004 return NULL;
1005 }
1006 }
1007 result = _PyBytes_Join(_PyIO_empty_bytes, chunks);
1008 Py_DECREF(chunks);
1009 return result;
1010 }
1011
1012 static PyObject *
rawiobase_readinto(PyObject * self,PyObject * args)1013 rawiobase_readinto(PyObject *self, PyObject *args)
1014 {
1015 PyErr_SetNone(PyExc_NotImplementedError);
1016 return NULL;
1017 }
1018
1019 static PyObject *
rawiobase_write(PyObject * self,PyObject * args)1020 rawiobase_write(PyObject *self, PyObject *args)
1021 {
1022 PyErr_SetNone(PyExc_NotImplementedError);
1023 return NULL;
1024 }
1025
1026 static PyMethodDef rawiobase_methods[] = {
1027 _IO__RAWIOBASE_READ_METHODDEF
1028 _IO__RAWIOBASE_READALL_METHODDEF
1029 {"readinto", rawiobase_readinto, METH_VARARGS},
1030 {"write", rawiobase_write, METH_VARARGS},
1031 {NULL, NULL}
1032 };
1033
1034 PyTypeObject PyRawIOBase_Type = {
1035 PyVarObject_HEAD_INIT(NULL, 0)
1036 "_io._RawIOBase", /*tp_name*/
1037 0, /*tp_basicsize*/
1038 0, /*tp_itemsize*/
1039 0, /*tp_dealloc*/
1040 0, /*tp_vectorcall_offset*/
1041 0, /*tp_getattr*/
1042 0, /*tp_setattr*/
1043 0, /*tp_as_async*/
1044 0, /*tp_repr*/
1045 0, /*tp_as_number*/
1046 0, /*tp_as_sequence*/
1047 0, /*tp_as_mapping*/
1048 0, /*tp_hash */
1049 0, /*tp_call*/
1050 0, /*tp_str*/
1051 0, /*tp_getattro*/
1052 0, /*tp_setattro*/
1053 0, /*tp_as_buffer*/
1054 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1055 rawiobase_doc, /* tp_doc */
1056 0, /* tp_traverse */
1057 0, /* tp_clear */
1058 0, /* tp_richcompare */
1059 0, /* tp_weaklistoffset */
1060 0, /* tp_iter */
1061 0, /* tp_iternext */
1062 rawiobase_methods, /* tp_methods */
1063 0, /* tp_members */
1064 0, /* tp_getset */
1065 &PyIOBase_Type, /* tp_base */
1066 0, /* tp_dict */
1067 0, /* tp_descr_get */
1068 0, /* tp_descr_set */
1069 0, /* tp_dictoffset */
1070 0, /* tp_init */
1071 0, /* tp_alloc */
1072 0, /* tp_new */
1073 0, /* tp_free */
1074 0, /* tp_is_gc */
1075 0, /* tp_bases */
1076 0, /* tp_mro */
1077 0, /* tp_cache */
1078 0, /* tp_subclasses */
1079 0, /* tp_weaklist */
1080 0, /* tp_del */
1081 0, /* tp_version_tag */
1082 0, /* tp_finalize */
1083 };
1084