LCOV - code coverage report
Current view: | top level - Modules/_io - bufferedio.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 449 | 1067 | 42.1 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 35 | 78 | 44.9 %
|  |  | Branches: | 263 | 1022 | 25.7 %

               Branch data     Line data    Source code
           1                 :            : /*
           2                 :            :     An implementation of Buffered I/O as defined by PEP 3116 - "New I/O"
           3                 :            :
           4                 :            :     Classes defined here: BufferedIOBase, BufferedReader, BufferedWriter,
           5                 :            :     BufferedRandom.
           6                 :            :
           7                 :            :     Written by Amaury Forgeot d'Arc and Antoine Pitrou
           8                 :            : */
           9                 :            :
          10                 :            : #define PY_SSIZE_T_CLEAN
          11                 :            : #include "Python.h"
          12                 :            : #include "pycore_call.h"          // _PyObject_CallNoArgs()
          13                 :            : #include "pycore_object.h"
          14                 :            : #include "structmember.h"         // PyMemberDef
          15                 :            : #include "_iomodule.h"
          16                 :            :
          17                 :            : /*[clinic input]
          18                 :            : module _io
          19                 :            : class _io._BufferedIOBase "PyObject *" "&PyBufferedIOBase_Type"
          20                 :            : class _io._Buffered "buffered *" "&PyBufferedIOBase_Type"
          21                 :            : class _io.BufferedReader "buffered *" "clinic_state()->PyBufferedReader_Type"
          22                 :            : class _io.BufferedWriter "buffered *" "clinic_state()->PyBufferedWriter_Type"
          23                 :            : class _io.BufferedRWPair "rwpair *" "clinic_state()->PyBufferedRWPair_Type"
          24                 :            : class _io.BufferedRandom "buffered *" "clinic_state()->PyBufferedRandom_Type"
          25                 :            : [clinic start generated code]*/
          26                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=abd685b9d94b9888]*/
          27                 :            :
          28                 :            : /*
          29                 :            :  * BufferedIOBase class, inherits from IOBase.
          30                 :            :  */
          31                 :            : PyDoc_STRVAR(bufferediobase_doc,
          32                 :            :     "Base class for buffered IO objects.\n"
          33                 :            :     "\n"
          34                 :            :     "The main difference with RawIOBase is that the read() method\n"
          35                 :            :     "supports omitting the size argument, and does not have a default\n"
          36                 :            :     "implementation that defers to readinto().\n"
          37                 :            :     "\n"
          38                 :            :     "In addition, read(), readinto() and write() may raise\n"
          39                 :            :     "BlockingIOError if the underlying raw stream is in non-blocking\n"
          40                 :            :     "mode and not ready; unlike their raw counterparts, they will never\n"
          41                 :            :     "return None.\n"
          42                 :            :     "\n"
          43                 :            :     "A typical implementation should not inherit from a RawIOBase\n"
          44                 :            :     "implementation, but wrap one.\n"
          45                 :            :     );
          46                 :            :
          47                 :            : static PyObject *
          48                 :          0 : _bufferediobase_readinto_generic(PyObject *self, Py_buffer *buffer, char readinto1)
          49                 :            : {
          50                 :            :     Py_ssize_t len;
          51                 :            :     PyObject *data;
          52                 :            :
          53                 :          0 :     PyObject *attr = readinto1
          54                 :            :         ? &_Py_ID(read1)
          55         [ #  # ]:          0 :         : &_Py_ID(read);
          56                 :          0 :     data = _PyObject_CallMethod(self, attr, "n", buffer->len);
          57         [ #  # ]:          0 :     if (data == NULL)
          58                 :          0 :         return NULL;
          59                 :            :
          60         [ #  # ]:          0 :     if (!PyBytes_Check(data)) {
          61                 :          0 :         Py_DECREF(data);
          62                 :          0 :         PyErr_SetString(PyExc_TypeError, "read() should return bytes");
          63                 :          0 :         return NULL;
          64                 :            :     }
          65                 :            :
          66                 :          0 :     len = PyBytes_GET_SIZE(data);
          67         [ #  # ]:          0 :     if (len > buffer->len) {
          68                 :          0 :         PyErr_Format(PyExc_ValueError,
          69                 :            :                      "read() returned too much data: "
          70                 :            :                      "%zd bytes requested, %zd returned",
          71                 :            :                      buffer->len, len);
          72                 :          0 :         Py_DECREF(data);
          73                 :          0 :         return NULL;
          74                 :            :     }
          75                 :          0 :     memcpy(buffer->buf, PyBytes_AS_STRING(data), len);
          76                 :            :
          77                 :          0 :     Py_DECREF(data);
          78                 :            :
          79                 :          0 :     return PyLong_FromSsize_t(len);
          80                 :            : }
          81                 :            :
          82                 :            : /*[clinic input]
          83                 :            : _io._BufferedIOBase.readinto
          84                 :            :     buffer: Py_buffer(accept={rwbuffer})
          85                 :            :     /
          86                 :            : [clinic start generated code]*/
          87                 :            :
          88                 :            : static PyObject *
          89                 :          0 : _io__BufferedIOBase_readinto_impl(PyObject *self, Py_buffer *buffer)
          90                 :            : /*[clinic end generated code: output=8c8cda6684af8038 input=00a6b9a38f29830a]*/
          91                 :            : {
          92                 :          0 :     return _bufferediobase_readinto_generic(self, buffer, 0);
          93                 :            : }
          94                 :            :
          95                 :            : /*[clinic input]
          96                 :            : _io._BufferedIOBase.readinto1
          97                 :            :     buffer: Py_buffer(accept={rwbuffer})
          98                 :            :     /
          99                 :            : [clinic start generated code]*/
         100                 :            :
         101                 :            : static PyObject *
         102                 :          0 : _io__BufferedIOBase_readinto1_impl(PyObject *self, Py_buffer *buffer)
         103                 :            : /*[clinic end generated code: output=358623e4fd2b69d3 input=ebad75b4aadfb9be]*/
         104                 :            : {
         105                 :          0 :     return _bufferediobase_readinto_generic(self, buffer, 1);
         106                 :            : }
         107                 :            :
         108                 :            : static PyObject *
         109                 :          0 : bufferediobase_unsupported(const char *message)
         110                 :            : {
         111                 :          0 :     _PyIO_State *state = IO_STATE();
         112         [ #  # ]:          0 :     if (state != NULL)
         113                 :          0 :         PyErr_SetString(state->unsupported_operation, message);
         114                 :          0 :     return NULL;
         115                 :            : }
         116                 :            :
         117                 :            : /*[clinic input]
         118                 :            : _io._BufferedIOBase.detach
         119                 :            :
         120                 :            : Disconnect this buffer from its underlying raw stream and return it.
         121                 :            :
         122                 :            : After the raw stream has been detached, the buffer is in an unusable
         123                 :            : state.
         124                 :            : [clinic start generated code]*/
         125                 :            :
         126                 :            : static PyObject *
         127                 :          0 : _io__BufferedIOBase_detach_impl(PyObject *self)
         128                 :            : /*[clinic end generated code: output=754977c8d10ed88c input=822427fb58fe4169]*/
         129                 :            : {
         130                 :          0 :     return bufferediobase_unsupported("detach");
         131                 :            : }
         132                 :            :
         133                 :            : PyDoc_STRVAR(bufferediobase_read_doc,
         134                 :            :     "Read and return up to n bytes.\n"
         135                 :            :     "\n"
         136                 :            :     "If the argument is omitted, None, or negative, reads and\n"
         137                 :            :     "returns all data until EOF.\n"
         138                 :            :     "\n"
         139                 :            :     "If the argument is positive, and the underlying raw stream is\n"
         140                 :            :     "not 'interactive', multiple raw reads may be issued to satisfy\n"
         141                 :            :     "the byte count (unless EOF is reached first).  But for\n"
         142                 :            :     "interactive raw streams (as well as sockets and pipes), at most\n"
         143                 :            :     "one raw read will be issued, and a short result does not imply\n"
         144                 :            :     "that EOF is imminent.\n"
         145                 :            :     "\n"
         146                 :            :     "Returns an empty bytes object on EOF.\n"
         147                 :            :     "\n"
         148                 :            :     "Returns None if the underlying raw stream was open in non-blocking\n"
         149                 :            :     "mode and no data is available at the moment.\n");
         150                 :            :
         151                 :            : static PyObject *
         152                 :          0 : bufferediobase_read(PyObject *self, PyObject *args)
         153                 :            : {
         154                 :          0 :     return bufferediobase_unsupported("read");
         155                 :            : }
         156                 :            :
         157                 :            : PyDoc_STRVAR(bufferediobase_read1_doc,
         158                 :            :     "Read and return up to n bytes, with at most one read() call\n"
         159                 :            :     "to the underlying raw stream. A short result does not imply\n"
         160                 :            :     "that EOF is imminent.\n"
         161                 :            :     "\n"
         162                 :            :     "Returns an empty bytes object on EOF.\n");
         163                 :            :
         164                 :            : static PyObject *
         165                 :          0 : bufferediobase_read1(PyObject *self, PyObject *args)
         166                 :            : {
         167                 :          0 :     return bufferediobase_unsupported("read1");
         168                 :            : }
         169                 :            :
         170                 :            : PyDoc_STRVAR(bufferediobase_write_doc,
         171                 :            :     "Write the given buffer to the IO stream.\n"
         172                 :            :     "\n"
         173                 :            :     "Returns the number of bytes written, which is always the length of b\n"
         174                 :            :     "in bytes.\n"
         175                 :            :     "\n"
         176                 :            :     "Raises BlockingIOError if the buffer is full and the\n"
         177                 :            :     "underlying raw stream cannot accept more data at the moment.\n");
         178                 :            :
         179                 :            : static PyObject *
         180                 :          0 : bufferediobase_write(PyObject *self, PyObject *args)
         181                 :            : {
         182                 :          0 :     return bufferediobase_unsupported("write");
         183                 :            : }
         184                 :            :
         185                 :            :
         186                 :            : typedef struct {
         187                 :            :     PyObject_HEAD
         188                 :            :
         189                 :            :     PyObject *raw;
         190                 :            :     int ok;    /* Initialized? */
         191                 :            :     int detached;
         192                 :            :     int readable;
         193                 :            :     int writable;
         194                 :            :     char finalizing;
         195                 :            :
         196                 :            :     /* True if this is a vanilla Buffered object (rather than a user derived
         197                 :            :        class) *and* the raw stream is a vanilla FileIO object. */
         198                 :            :     int fast_closed_checks;
         199                 :            :
         200                 :            :     /* Absolute position inside the raw stream (-1 if unknown). */
         201                 :            :     Py_off_t abs_pos;
         202                 :            :
         203                 :            :     /* A static buffer of size `buffer_size` */
         204                 :            :     char *buffer;
         205                 :            :     /* Current logical position in the buffer. */
         206                 :            :     Py_off_t pos;
         207                 :            :     /* Position of the raw stream in the buffer. */
         208                 :            :     Py_off_t raw_pos;
         209                 :            :
         210                 :            :     /* Just after the last buffered byte in the buffer, or -1 if the buffer
         211                 :            :        isn't ready for reading. */
         212                 :            :     Py_off_t read_end;
         213                 :            :
         214                 :            :     /* Just after the last byte actually written */
         215                 :            :     Py_off_t write_pos;
         216                 :            :     /* Just after the last byte waiting to be written, or -1 if the buffer
         217                 :            :        isn't ready for writing. */
         218                 :            :     Py_off_t write_end;
         219                 :            :
         220                 :            :     PyThread_type_lock lock;
         221                 :            :     volatile unsigned long owner;
         222                 :            :
         223                 :            :     Py_ssize_t buffer_size;
         224                 :            :     Py_ssize_t buffer_mask;
         225                 :            :
         226                 :            :     PyObject *dict;
         227                 :            :     PyObject *weakreflist;
         228                 :            : } buffered;
         229                 :            :
         230                 :            : /*
         231                 :            :     Implementation notes:
         232                 :            :
         233                 :            :     * BufferedReader, BufferedWriter and BufferedRandom try to share most
         234                 :            :       methods (this is helped by the members `readable` and `writable`, which
         235                 :            :       are initialized in the respective constructors)
         236                 :            :     * They also share a single buffer for reading and writing. This enables
         237                 :            :       interleaved reads and writes without flushing. It also makes the logic
         238                 :            :       a bit trickier to get right.
         239                 :            :     * The absolute position of the raw stream is cached, if possible, in the
         240                 :            :       `abs_pos` member. It must be updated every time an operation is done
         241                 :            :       on the raw stream. If not sure, it can be reinitialized by calling
         242                 :            :       _buffered_raw_tell(), which queries the raw stream (_buffered_raw_seek()
         243                 :            :       also does it). To read it, use RAW_TELL().
         244                 :            :     * Three helpers, _bufferedreader_raw_read, _bufferedwriter_raw_write and
         245                 :            :       _bufferedwriter_flush_unlocked do a lot of useful housekeeping.
         246                 :            :
         247                 :            :     NOTE: we should try to maintain block alignment of reads and writes to the
         248                 :            :     raw stream (according to the buffer size), but for now it is only done
         249                 :            :     in read() and friends.
         250                 :            :
         251                 :            : */
         252                 :            :
         253                 :            : /* These macros protect the buffered object against concurrent operations. */
         254                 :            :
         255                 :            : static int
         256                 :          0 : _enter_buffered_busy(buffered *self)
         257                 :            : {
         258                 :            :     int relax_locking;
         259                 :            :     PyLockStatus st;
         260         [ #  # ]:          0 :     if (self->owner == PyThread_get_thread_ident()) {
         261                 :          0 :         PyErr_Format(PyExc_RuntimeError,
         262                 :            :                      "reentrant call inside %R", self);
         263                 :          0 :         return 0;
         264                 :            :     }
         265                 :          0 :     relax_locking = _Py_IsFinalizing();
         266                 :          0 :     Py_BEGIN_ALLOW_THREADS
         267         [ #  # ]:          0 :     if (!relax_locking)
         268                 :          0 :         st = PyThread_acquire_lock(self->lock, 1);
         269                 :            :     else {
         270                 :            :         /* When finalizing, we don't want a deadlock to happen with daemon
         271                 :            :          * threads abruptly shut down while they owned the lock.
         272                 :            :          * Therefore, only wait for a grace period (1 s.).
         273                 :            :          * Note that non-daemon threads have already exited here, so this
         274                 :            :          * shouldn't affect carefully written threaded I/O code.
         275                 :            :          */
         276                 :          0 :         st = PyThread_acquire_lock_timed(self->lock, (PY_TIMEOUT_T)1e6, 0);
         277                 :            :     }
         278                 :          0 :     Py_END_ALLOW_THREADS
         279   [ #  #  #  # ]:          0 :     if (relax_locking && st != PY_LOCK_ACQUIRED) {
         280                 :          0 :         PyObject *ascii = PyObject_ASCII((PyObject*)self);
         281         [ #  # ]:          0 :         _Py_FatalErrorFormat(__func__,
         282                 :            :             "could not acquire lock for %s at interpreter "
         283                 :            :             "shutdown, possibly due to daemon threads",
         284                 :          0 :             ascii ? PyUnicode_AsUTF8(ascii) : "<ascii(self) failed>");
         285                 :            :     }
         286                 :          0 :     return 1;
         287                 :            : }
         288                 :            :
         289                 :            : #define ENTER_BUFFERED(self) \
         290                 :            :     ( (PyThread_acquire_lock(self->lock, 0) ? \
         291                 :            :        1 : _enter_buffered_busy(self)) \
         292                 :            :      && (self->owner = PyThread_get_thread_ident(), 1) )
         293                 :            :
         294                 :            : #define LEAVE_BUFFERED(self) \
         295                 :            :     do { \
         296                 :            :         self->owner = 0; \
         297                 :            :         PyThread_release_lock(self->lock); \
         298                 :            :     } while(0);
         299                 :            :
         300                 :            : #define CHECK_INITIALIZED(self) \
         301                 :            :     if (self->ok <= 0) { \
         302                 :            :         if (self->detached) { \
         303                 :            :             PyErr_SetString(PyExc_ValueError, \
         304                 :            :                  "raw stream has been detached"); \
         305                 :            :         } else { \
         306                 :            :             PyErr_SetString(PyExc_ValueError, \
         307                 :            :                 "I/O operation on uninitialized object"); \
         308                 :            :         } \
         309                 :            :         return NULL; \
         310                 :            :     }
         311                 :            :
         312                 :            : #define CHECK_INITIALIZED_INT(self) \
         313                 :            :     if (self->ok <= 0) { \
         314                 :            :         if (self->detached) { \
         315                 :            :             PyErr_SetString(PyExc_ValueError, \
         316                 :            :                  "raw stream has been detached"); \
         317                 :            :         } else { \
         318                 :            :             PyErr_SetString(PyExc_ValueError, \
         319                 :            :                 "I/O operation on uninitialized object"); \
         320                 :            :         } \
         321                 :            :         return -1; \
         322                 :            :     }
         323                 :            :
         324                 :            : #define IS_CLOSED(self) \
         325                 :            :     (!self->buffer || \
         326                 :            :     (self->fast_closed_checks \
         327                 :            :      ? _PyFileIO_closed(self->raw) \
         328                 :            :      : buffered_closed(self)))
         329                 :            :
         330                 :            : #define CHECK_CLOSED(self, error_msg) \
         331                 :            :     if (IS_CLOSED(self) && (Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t) == 0)) { \
         332                 :            :         PyErr_SetString(PyExc_ValueError, error_msg); \
         333                 :            :         return NULL; \
         334                 :            :     } \
         335                 :            :
         336                 :            : #define VALID_READ_BUFFER(self) \
         337                 :            :     (self->readable && self->read_end != -1)
         338                 :            :
         339                 :            : #define VALID_WRITE_BUFFER(self) \
         340                 :            :     (self->writable && self->write_end != -1)
         341                 :            :
         342                 :            : #define ADJUST_POSITION(self, _new_pos) \
         343                 :            :     do { \
         344                 :            :         self->pos = _new_pos; \
         345                 :            :         if (VALID_READ_BUFFER(self) && self->read_end < self->pos) \
         346                 :            :             self->read_end = self->pos; \
         347                 :            :     } while(0)
         348                 :            :
         349                 :            : #define READAHEAD(self) \
         350                 :            :     ((self->readable && VALID_READ_BUFFER(self)) \
         351                 :            :         ? (self->read_end - self->pos) : 0)
         352                 :            :
         353                 :            : #define RAW_OFFSET(self) \
         354                 :            :     (((VALID_READ_BUFFER(self) || VALID_WRITE_BUFFER(self)) \
         355                 :            :         && self->raw_pos >= 0) ? self->raw_pos - self->pos : 0)
         356                 :            :
         357                 :            : #define RAW_TELL(self) \
         358                 :            :     (self->abs_pos != -1 ? self->abs_pos : _buffered_raw_tell(self))
         359                 :            :
         360                 :            : #define MINUS_LAST_BLOCK(self, size) \
         361                 :            :     (self->buffer_mask ? \
         362                 :            :         (size & ~self->buffer_mask) : \
         363                 :            :         (self->buffer_size * (size / self->buffer_size)))
         364                 :            :
         365                 :            :
         366                 :            : static void
         367                 :       1341 : buffered_dealloc(buffered *self)
         368                 :            : {
         369                 :       1341 :     PyTypeObject *tp = Py_TYPE(self);
         370                 :       1341 :     self->finalizing = 1;
         371         [ -  + ]:       1341 :     if (_PyIOBase_finalize((PyObject *) self) < 0)
         372                 :          0 :         return;
         373                 :       1341 :     _PyObject_GC_UNTRACK(self);
         374                 :       1341 :     self->ok = 0;
         375         [ -  + ]:       1341 :     if (self->weakreflist != NULL)
         376                 :          0 :         PyObject_ClearWeakRefs((PyObject *)self);
         377         [ +  - ]:       1341 :     Py_CLEAR(self->raw);
         378         [ -  + ]:       1341 :     if (self->buffer) {
         379                 :          0 :         PyMem_Free(self->buffer);
         380                 :          0 :         self->buffer = NULL;
         381                 :            :     }
         382         [ +  - ]:       1341 :     if (self->lock) {
         383                 :       1341 :         PyThread_free_lock(self->lock);
         384                 :       1341 :         self->lock = NULL;
         385                 :            :     }
         386         [ -  + ]:       1341 :     Py_CLEAR(self->dict);
         387                 :       1341 :     tp->tp_free((PyObject *)self);
         388                 :       1341 :     Py_DECREF(tp);
         389                 :            : }
         390                 :            :
         391                 :            : static PyObject *
         392                 :          0 : buffered_sizeof(buffered *self, PyObject *Py_UNUSED(ignored))
         393                 :            : {
         394                 :          0 :     size_t res = _PyObject_SIZE(Py_TYPE(self));
         395         [ #  # ]:          0 :     if (self->buffer) {
         396                 :          0 :         res += (size_t)self->buffer_size;
         397                 :            :     }
         398                 :          0 :     return PyLong_FromSize_t(res);
         399                 :            : }
         400                 :            :
         401                 :            : static int
         402                 :        636 : buffered_traverse(buffered *self, visitproc visit, void *arg)
         403                 :            : {
         404   [ +  -  -  + ]:        636 :     Py_VISIT(Py_TYPE(self));
         405   [ +  -  -  + ]:        636 :     Py_VISIT(self->raw);
         406   [ -  +  -  - ]:        636 :     Py_VISIT(self->dict);
         407                 :        636 :     return 0;
         408                 :            : }
         409                 :            :
         410                 :            : static int
         411                 :          0 : buffered_clear(buffered *self)
         412                 :            : {
         413                 :          0 :     self->ok = 0;
         414         [ #  # ]:          0 :     Py_CLEAR(self->raw);
         415         [ #  # ]:          0 :     Py_CLEAR(self->dict);
         416                 :          0 :     return 0;
         417                 :            : }
         418                 :            :
         419                 :            : /* Because this can call arbitrary code, it shouldn't be called when
         420                 :            :    the refcount is 0 (that is, not directly from tp_dealloc unless
         421                 :            :    the refcount has been temporarily re-incremented). */
         422                 :            : static PyObject *
         423                 :         75 : buffered_dealloc_warn(buffered *self, PyObject *source)
         424                 :            : {
         425   [ +  -  +  - ]:         75 :     if (self->ok && self->raw) {
         426                 :            :         PyObject *r;
         427                 :         75 :         r = PyObject_CallMethodOneArg(self->raw, &_Py_ID(_dealloc_warn), source);
         428         [ +  - ]:         75 :         if (r)
         429                 :         75 :             Py_DECREF(r);
         430                 :            :         else
         431                 :          0 :             PyErr_Clear();
         432                 :            :     }
         433                 :         75 :     Py_RETURN_NONE;
         434                 :            : }
         435                 :            :
         436                 :            : /*
         437                 :            :  * _BufferedIOMixin methods
         438                 :            :  * This is not a class, just a collection of methods that will be reused
         439                 :            :  * by BufferedReader and BufferedWriter
         440                 :            :  */
         441                 :            :
         442                 :            : /* Flush and close */
         443                 :            :
         444                 :            : static PyObject *
         445                 :       1946 : buffered_simple_flush(buffered *self, PyObject *args)
         446                 :            : {
         447   [ -  +  -  - ]:       1946 :     CHECK_INITIALIZED(self)
         448                 :       1946 :     return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(flush));
         449                 :            : }
         450                 :            :
         451                 :            : static int
         452                 :       1341 : buffered_closed(buffered *self)
         453                 :            : {
         454                 :            :     int closed;
         455                 :            :     PyObject *res;
         456   [ -  +  -  - ]:       1341 :     CHECK_INITIALIZED_INT(self)
         457                 :       1341 :     res = PyObject_GetAttr(self->raw, &_Py_ID(closed));
         458         [ -  + ]:       1341 :     if (res == NULL)
         459                 :          0 :         return -1;
         460                 :       1341 :     closed = PyObject_IsTrue(res);
         461                 :       1341 :     Py_DECREF(res);
         462                 :       1341 :     return closed;
         463                 :            : }
         464                 :            :
         465                 :            : static PyObject *
         466                 :     151283 : buffered_closed_get(buffered *self, void *context)
         467                 :            : {
         468   [ -  +  -  - ]:     151283 :     CHECK_INITIALIZED(self)
         469                 :     151283 :     return PyObject_GetAttr(self->raw, &_Py_ID(closed));
         470                 :            : }
         471                 :            :
         472                 :            : static PyObject *
         473                 :       1341 : buffered_close(buffered *self, PyObject *args)
         474                 :            : {
         475                 :       1341 :     PyObject *res = NULL;
         476                 :            :     int r;
         477                 :            :
         478   [ -  +  -  - ]:       1341 :     CHECK_INITIALIZED(self)
         479   [ -  +  -  - ]:       1341 :     if (!ENTER_BUFFERED(self)) {
         480                 :          0 :         return NULL;
         481                 :            :     }
         482                 :            :
         483                 :       1341 :     r = buffered_closed(self);
         484         [ -  + ]:       1341 :     if (r < 0)
         485                 :          0 :         goto end;
         486         [ -  + ]:       1341 :     if (r > 0) {
         487                 :          0 :         res = Py_NewRef(Py_None);
         488                 :          0 :         goto end;
         489                 :            :     }
         490                 :            :
         491         [ -  + ]:       1341 :     if (self->finalizing) {
         492                 :          0 :         PyObject *r = buffered_dealloc_warn(self, (PyObject *) self);
         493         [ #  # ]:          0 :         if (r)
         494                 :          0 :             Py_DECREF(r);
         495                 :            :         else
         496                 :          0 :             PyErr_Clear();
         497                 :            :     }
         498                 :            :     /* flush() will most probably re-take the lock, so drop it first */
         499                 :       1341 :     LEAVE_BUFFERED(self)
         500                 :       1341 :     res = PyObject_CallMethodNoArgs((PyObject *)self, &_Py_ID(flush));
         501   [ -  +  -  - ]:       1341 :     if (!ENTER_BUFFERED(self)) {
         502                 :          0 :         return NULL;
         503                 :            :     }
         504                 :       1341 :     PyObject *exc = NULL;
         505         [ -  + ]:       1341 :     if (res == NULL) {
         506                 :          0 :         exc = PyErr_GetRaisedException();
         507                 :            :     }
         508                 :            :     else {
         509                 :       1341 :         Py_DECREF(res);
         510                 :            :     }
         511                 :            :
         512                 :       1341 :     res = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(close));
         513                 :            :
         514         [ +  - ]:       1341 :     if (self->buffer) {
         515                 :       1341 :         PyMem_Free(self->buffer);
         516                 :       1341 :         self->buffer = NULL;
         517                 :            :     }
         518                 :            :
         519         [ -  + ]:       1341 :     if (exc != NULL) {
         520                 :          0 :         _PyErr_ChainExceptions1(exc);
         521         [ #  # ]:          0 :         Py_CLEAR(res);
         522                 :            :     }
         523                 :            :
         524                 :       1341 :     self->read_end = 0;
         525                 :       1341 :     self->pos = 0;
         526                 :            :
         527                 :       1341 : end:
         528                 :       1341 :     LEAVE_BUFFERED(self)
         529                 :       1341 :     return res;
         530                 :            : }
         531                 :            :
         532                 :            : /* detach */
         533                 :            :
         534                 :            : static PyObject *
         535                 :          0 : buffered_detach(buffered *self, PyObject *Py_UNUSED(ignored))
         536                 :            : {
         537                 :            :     PyObject *raw, *res;
         538   [ #  #  #  # ]:          0 :     CHECK_INITIALIZED(self)
         539                 :          0 :     res = PyObject_CallMethodNoArgs((PyObject *)self, &_Py_ID(flush));
         540         [ #  # ]:          0 :     if (res == NULL)
         541                 :          0 :         return NULL;
         542                 :          0 :     Py_DECREF(res);
         543                 :          0 :     raw = self->raw;
         544                 :          0 :     self->raw = NULL;
         545                 :          0 :     self->detached = 1;
         546                 :          0 :     self->ok = 0;
         547                 :          0 :     return raw;
         548                 :            : }
         549                 :            :
         550                 :            : /* Inquiries */
         551                 :            :
         552                 :            : static PyObject *
         553                 :        753 : buffered_seekable(buffered *self, PyObject *Py_UNUSED(ignored))
         554                 :            : {
         555   [ -  +  -  - ]:        753 :     CHECK_INITIALIZED(self)
         556                 :        753 :     return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(seekable));
         557                 :            : }
         558                 :            :
         559                 :            : static PyObject *
         560                 :        679 : buffered_readable(buffered *self, PyObject *Py_UNUSED(ignored))
         561                 :            : {
         562   [ -  +  -  - ]:        679 :     CHECK_INITIALIZED(self)
         563                 :        679 :     return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(readable));
         564                 :            : }
         565                 :            :
         566                 :            : static PyObject *
         567                 :         74 : buffered_writable(buffered *self, PyObject *Py_UNUSED(ignored))
         568                 :            : {
         569   [ -  +  -  - ]:         74 :     CHECK_INITIALIZED(self)
         570                 :         74 :     return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(writable));
         571                 :            : }
         572                 :            :
         573                 :            : static PyObject *
         574                 :          1 : buffered_name_get(buffered *self, void *context)
         575                 :            : {
         576   [ -  +  -  - ]:          1 :     CHECK_INITIALIZED(self)
         577                 :          1 :     return PyObject_GetAttr(self->raw, &_Py_ID(name));
         578                 :            : }
         579                 :            :
         580                 :            : static PyObject *
         581                 :          0 : buffered_mode_get(buffered *self, void *context)
         582                 :            : {
         583   [ #  #  #  # ]:          0 :     CHECK_INITIALIZED(self)
         584                 :          0 :     return PyObject_GetAttr(self->raw, &_Py_ID(mode));
         585                 :            : }
         586                 :            :
         587                 :            : /* Lower-level APIs */
         588                 :            :
         589                 :            : static PyObject *
         590                 :         13 : buffered_fileno(buffered *self, PyObject *Py_UNUSED(ignored))
         591                 :            : {
         592   [ -  +  -  - ]:         13 :     CHECK_INITIALIZED(self)
         593                 :         13 :     return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(fileno));
         594                 :            : }
         595                 :            :
         596                 :            : static PyObject *
         597                 :          0 : buffered_isatty(buffered *self, PyObject *Py_UNUSED(ignored))
         598                 :            : {
         599   [ #  #  #  # ]:          0 :     CHECK_INITIALIZED(self)
         600                 :          0 :     return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(isatty));
         601                 :            : }
         602                 :            :
         603                 :            : /* Forward decls */
         604                 :            : static PyObject *
         605                 :            : _bufferedwriter_flush_unlocked(buffered *);
         606                 :            : static Py_ssize_t
         607                 :            : _bufferedreader_fill_buffer(buffered *self);
         608                 :            : static void
         609                 :            : _bufferedreader_reset_buf(buffered *self);
         610                 :            : static void
         611                 :            : _bufferedwriter_reset_buf(buffered *self);
         612                 :            : static PyObject *
         613                 :            : _bufferedreader_peek_unlocked(buffered *self);
         614                 :            : static PyObject *
         615                 :            : _bufferedreader_read_all(buffered *self);
         616                 :            : static PyObject *
         617                 :            : _bufferedreader_read_fast(buffered *self, Py_ssize_t);
         618                 :            : static PyObject *
         619                 :            : _bufferedreader_read_generic(buffered *self, Py_ssize_t);
         620                 :            : static Py_ssize_t
         621                 :            : _bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len);
         622                 :            :
         623                 :            : /*
         624                 :            :  * Helpers
         625                 :            :  */
         626                 :            :
         627                 :            : /* Sets the current error to BlockingIOError */
         628                 :            : static void
         629                 :          0 : _set_BlockingIOError(const char *msg, Py_ssize_t written)
         630                 :            : {
         631                 :            :     PyObject *err;
         632                 :          0 :     PyErr_Clear();
         633                 :          0 :     err = PyObject_CallFunction(PyExc_BlockingIOError, "isn",
         634                 :          0 :                                 errno, msg, written);
         635         [ #  # ]:          0 :     if (err)
         636                 :          0 :         PyErr_SetObject(PyExc_BlockingIOError, err);
         637                 :          0 :     Py_XDECREF(err);
         638                 :          0 : }
         639                 :            :
         640                 :            : /* Returns the address of the `written` member if a BlockingIOError was
         641                 :            :    raised, NULL otherwise. The error is always re-raised. */
         642                 :            : static Py_ssize_t *
         643                 :          0 : _buffered_check_blocking_error(void)
         644                 :            : {
         645                 :          0 :     PyObject *exc = PyErr_GetRaisedException();
         646   [ #  #  #  # ]:          0 :     if (exc == NULL || !PyErr_GivenExceptionMatches(exc, PyExc_BlockingIOError)) {
         647                 :          0 :         PyErr_SetRaisedException(exc);
         648                 :          0 :         return NULL;
         649                 :            :     }
         650                 :          0 :     PyOSErrorObject *err = (PyOSErrorObject *)exc;
         651                 :            :     /* TODO: sanity check (err->written >= 0) */
         652                 :          0 :     PyErr_SetRaisedException(exc);
         653                 :          0 :     return &err->written;
         654                 :            : }
         655                 :            :
         656                 :            : static Py_off_t
         657                 :       1431 : _buffered_raw_tell(buffered *self)
         658                 :            : {
         659                 :            :     Py_off_t n;
         660                 :            :     PyObject *res;
         661                 :       1431 :     res = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(tell));
         662         [ +  + ]:       1431 :     if (res == NULL)
         663                 :         75 :         return -1;
         664                 :       1356 :     n = PyNumber_AsOff_t(res, PyExc_ValueError);
         665                 :       1356 :     Py_DECREF(res);
         666         [ -  + ]:       1356 :     if (n < 0) {
         667         [ #  # ]:          0 :         if (!PyErr_Occurred())
         668                 :          0 :             PyErr_Format(PyExc_OSError,
         669                 :            :                          "Raw stream returned invalid position %" PY_PRIdOFF,
         670                 :            :                          (PY_OFF_T_COMPAT)n);
         671                 :          0 :         return -1;
         672                 :            :     }
         673                 :       1356 :     self->abs_pos = n;
         674                 :       1356 :     return n;
         675                 :            : }
         676                 :            :
         677                 :            : static Py_off_t
         678                 :         88 : _buffered_raw_seek(buffered *self, Py_off_t target, int whence)
         679                 :            : {
         680                 :            :     PyObject *res, *posobj, *whenceobj;
         681                 :            :     Py_off_t n;
         682                 :            :
         683                 :         88 :     posobj = PyLong_FromOff_t(target);
         684         [ -  + ]:         88 :     if (posobj == NULL)
         685                 :          0 :         return -1;
         686                 :         88 :     whenceobj = PyLong_FromLong(whence);
         687         [ -  + ]:         88 :     if (whenceobj == NULL) {
         688                 :          0 :         Py_DECREF(posobj);
         689                 :          0 :         return -1;
         690                 :            :     }
         691                 :         88 :     res = PyObject_CallMethodObjArgs(self->raw, &_Py_ID(seek),
         692                 :            :                                      posobj, whenceobj, NULL);
         693                 :         88 :     Py_DECREF(posobj);
         694                 :         88 :     Py_DECREF(whenceobj);
         695         [ -  + ]:         88 :     if (res == NULL)
         696                 :          0 :         return -1;
         697                 :         88 :     n = PyNumber_AsOff_t(res, PyExc_ValueError);
         698                 :         88 :     Py_DECREF(res);
         699         [ -  + ]:         88 :     if (n < 0) {
         700         [ #  # ]:          0 :         if (!PyErr_Occurred())
         701                 :          0 :             PyErr_Format(PyExc_OSError,
         702                 :            :                          "Raw stream returned invalid position %" PY_PRIdOFF,
         703                 :            :                          (PY_OFF_T_COMPAT)n);
         704                 :          0 :         return -1;
         705                 :            :     }
         706                 :         88 :     self->abs_pos = n;
         707                 :         88 :     return n;
         708                 :            : }
         709                 :            :
         710                 :            : static int
         711                 :       1341 : _buffered_init(buffered *self)
         712                 :            : {
         713                 :            :     Py_ssize_t n;
         714         [ -  + ]:       1341 :     if (self->buffer_size <= 0) {
         715                 :          0 :         PyErr_SetString(PyExc_ValueError,
         716                 :            :             "buffer size must be strictly positive");
         717                 :          0 :         return -1;
         718                 :            :     }
         719         [ -  + ]:       1341 :     if (self->buffer)
         720                 :          0 :         PyMem_Free(self->buffer);
         721                 :       1341 :     self->buffer = PyMem_Malloc(self->buffer_size);
         722         [ -  + ]:       1341 :     if (self->buffer == NULL) {
         723                 :          0 :         PyErr_NoMemory();
         724                 :          0 :         return -1;
         725                 :            :     }
         726         [ -  + ]:       1341 :     if (self->lock)
         727                 :          0 :         PyThread_free_lock(self->lock);
         728                 :       1341 :     self->lock = PyThread_allocate_lock();
         729         [ -  + ]:       1341 :     if (self->lock == NULL) {
         730                 :          0 :         PyErr_SetString(PyExc_RuntimeError, "can't allocate read lock");
         731                 :          0 :         return -1;
         732                 :            :     }
         733                 :       1341 :     self->owner = 0;
         734                 :            :     /* Find out whether buffer_size is a power of 2 */
         735                 :            :     /* XXX is this optimization useful? */
         736         [ +  + ]:      17283 :     for (n = self->buffer_size - 1; n & 1; n >>= 1)
         737                 :            :         ;
         738         [ +  - ]:       1341 :     if (n == 0)
         739                 :       1341 :         self->buffer_mask = self->buffer_size - 1;
         740                 :            :     else
         741                 :          0 :         self->buffer_mask = 0;
         742         [ +  + ]:       1341 :     if (_buffered_raw_tell(self) == -1)
         743                 :         75 :         PyErr_Clear();
         744                 :       1341 :     return 0;
         745                 :            : }
         746                 :            :
         747                 :            : /* Return 1 if an OSError with errno == EINTR is set (and then
         748                 :            :    clears the error indicator), 0 otherwise.
         749                 :            :    Should only be called when PyErr_Occurred() is true.
         750                 :            : */
         751                 :            : int
         752                 :          0 : _PyIO_trap_eintr(void)
         753                 :            : {
         754         [ #  # ]:          0 :     if (!PyErr_ExceptionMatches(PyExc_OSError)) {
         755                 :          0 :         return 0;
         756                 :            :     }
         757                 :          0 :     PyObject *exc = PyErr_GetRaisedException();
         758                 :          0 :     PyOSErrorObject *env_err = (PyOSErrorObject *)exc;
         759                 :            :     assert(env_err != NULL);
         760         [ #  # ]:          0 :     if (env_err->myerrno != NULL) {
         761                 :            :         assert(EINTR > 0 && EINTR < INT_MAX);
         762                 :            :         assert(PyLong_CheckExact(env_err->myerrno));
         763                 :            :         int overflow;
         764                 :          0 :         int myerrno = PyLong_AsLongAndOverflow(env_err->myerrno, &overflow);
         765                 :          0 :         PyErr_Clear();
         766         [ #  # ]:          0 :         if (myerrno == EINTR) {
         767                 :          0 :             Py_DECREF(exc);
         768                 :          0 :             return 1;
         769                 :            :         }
         770                 :            :     }
         771                 :            :     /* This silences any error set by PyObject_RichCompareBool() */
         772                 :          0 :     PyErr_SetRaisedException(exc);
         773                 :          0 :     return 0;
         774                 :            : }
         775                 :            :
         776                 :            : /*
         777                 :            :  * Shared methods and wrappers
         778                 :            :  */
         779                 :            :
         780                 :            : static PyObject *
         781                 :        262 : buffered_flush_and_rewind_unlocked(buffered *self)
         782                 :            : {
         783                 :            :     PyObject *res;
         784                 :            :
         785                 :        262 :     res = _bufferedwriter_flush_unlocked(self);
         786         [ -  + ]:        262 :     if (res == NULL)
         787                 :          0 :         return NULL;
         788                 :        262 :     Py_DECREF(res);
         789                 :            :
         790         [ -  + ]:        262 :     if (self->readable) {
         791                 :            :         /* Rewind the raw stream so that its position corresponds to
         792                 :            :            the current logical position. */
         793                 :            :         Py_off_t n;
         794   [ #  #  #  #  :          0 :         n = _buffered_raw_seek(self, -RAW_OFFSET(self), 1);
              #  #  #  #  #
                          # ]
         795                 :          0 :         _bufferedreader_reset_buf(self);
         796         [ #  # ]:          0 :         if (n == -1)
         797                 :          0 :             return NULL;
         798                 :            :     }
         799                 :        262 :     Py_RETURN_NONE;
         800                 :            : }
         801                 :            :
         802                 :            : static PyObject *
         803                 :        262 : buffered_flush(buffered *self, PyObject *args)
         804                 :            : {
         805                 :            :     PyObject *res;
         806                 :            :
         807   [ -  +  -  - ]:        262 :     CHECK_INITIALIZED(self)
         808   [ +  -  +  -  :        262 :     CHECK_CLOSED(self, "flush of closed file")
              -  +  -  -  -
              -  -  -  -  -
                       -  - ]
         809                 :            :
         810   [ -  +  -  - ]:        262 :     if (!ENTER_BUFFERED(self))
         811                 :          0 :         return NULL;
         812                 :        262 :     res = buffered_flush_and_rewind_unlocked(self);
         813                 :        262 :     LEAVE_BUFFERED(self)
         814                 :            :
         815                 :        262 :     return res;
         816                 :            : }
         817                 :            :
         818                 :            : /*[clinic input]
         819                 :            : _io._Buffered.peek
         820                 :            :     size: Py_ssize_t = 0
         821                 :            :     /
         822                 :            :
         823                 :            : [clinic start generated code]*/
         824                 :            :
         825                 :            : static PyObject *
         826                 :          0 : _io__Buffered_peek_impl(buffered *self, Py_ssize_t size)
         827                 :            : /*[clinic end generated code: output=ba7a097ca230102b input=37ffb97d06ff4adb]*/
         828                 :            : {
         829                 :          0 :     PyObject *res = NULL;
         830                 :            :
         831   [ #  #  #  # ]:          0 :     CHECK_INITIALIZED(self)
         832   [ #  #  #  #  :          0 :     CHECK_CLOSED(self, "peek of closed file")
              #  #  #  #  #
              #  #  #  #  #
                       #  # ]
         833                 :            :
         834   [ #  #  #  # ]:          0 :     if (!ENTER_BUFFERED(self))
         835                 :          0 :         return NULL;
         836                 :            :
         837         [ #  # ]:          0 :     if (self->writable) {
         838                 :          0 :         res = buffered_flush_and_rewind_unlocked(self);
         839         [ #  # ]:          0 :         if (res == NULL)
         840                 :          0 :             goto end;
         841         [ #  # ]:          0 :         Py_CLEAR(res);
         842                 :            :     }
         843                 :          0 :     res = _bufferedreader_peek_unlocked(self);
         844                 :            :
         845                 :          0 : end:
         846                 :          0 :     LEAVE_BUFFERED(self)
         847                 :          0 :     return res;
         848                 :            : }
         849                 :            :
         850                 :            : /*[clinic input]
         851                 :            : _io._Buffered.read
         852                 :            :     size as n: Py_ssize_t(accept={int, NoneType}) = -1
         853                 :            :     /
         854                 :            : [clinic start generated code]*/
         855                 :            :
         856                 :            : static PyObject *
         857                 :        634 : _io__Buffered_read_impl(buffered *self, Py_ssize_t n)
         858                 :            : /*[clinic end generated code: output=f41c78bb15b9bbe9 input=7df81e82e08a68a2]*/
         859                 :            : {
         860                 :            :     PyObject *res;
         861                 :            :
         862   [ -  +  -  - ]:        634 :     CHECK_INITIALIZED(self)
         863         [ -  + ]:        634 :     if (n < -1) {
         864                 :          0 :         PyErr_SetString(PyExc_ValueError,
         865                 :            :                         "read length must be non-negative or -1");
         866                 :          0 :         return NULL;
         867                 :            :     }
         868                 :            :
         869   [ +  -  +  -  :        634 :     CHECK_CLOSED(self, "read of closed file")
              -  +  -  -  -
              -  -  -  -  -
                       -  - ]
         870                 :            :
         871         [ +  + ]:        634 :     if (n == -1) {
         872                 :            :         /* The number of bytes is unspecified, read until the end of stream */
         873   [ -  +  -  - ]:        612 :         if (!ENTER_BUFFERED(self))
         874                 :          0 :             return NULL;
         875                 :        612 :         res = _bufferedreader_read_all(self);
         876                 :            :     }
         877                 :            :     else {
         878                 :         22 :         res = _bufferedreader_read_fast(self, n);
         879         [ -  + ]:         22 :         if (res != Py_None)
         880                 :          0 :             return res;
         881                 :         22 :         Py_DECREF(res);
         882   [ -  +  -  - ]:         22 :         if (!ENTER_BUFFERED(self))
         883                 :          0 :             return NULL;
         884                 :         22 :         res = _bufferedreader_read_generic(self, n);
         885                 :            :     }
         886                 :            :
         887                 :        634 :     LEAVE_BUFFERED(self)
         888                 :        634 :     return res;
         889                 :            : }
         890                 :            :
         891                 :            : /*[clinic input]
         892                 :            : _io._Buffered.read1
         893                 :            :     size as n: Py_ssize_t = -1
         894                 :            :     /
         895                 :            : [clinic start generated code]*/
         896                 :            :
         897                 :            : static PyObject *
         898                 :       4070 : _io__Buffered_read1_impl(buffered *self, Py_ssize_t n)
         899                 :            : /*[clinic end generated code: output=bcc4fb4e54d103a3 input=7d22de9630b61774]*/
         900                 :            : {
         901                 :            :     Py_ssize_t have, r;
         902                 :       4070 :     PyObject *res = NULL;
         903                 :            :
         904   [ -  +  -  - ]:       4070 :     CHECK_INITIALIZED(self)
         905         [ -  + ]:       4070 :     if (n < 0) {
         906                 :          0 :         n = self->buffer_size;
         907                 :            :     }
         908                 :            :
         909   [ +  -  +  -  :       4070 :     CHECK_CLOSED(self, "read of closed file")
              -  +  -  -  -
              -  -  -  -  -
                       -  - ]
         910                 :            :
         911         [ -  + ]:       4070 :     if (n == 0)
         912                 :          0 :         return PyBytes_FromStringAndSize(NULL, 0);
         913                 :            :
         914                 :            :     /* Return up to n bytes.  If at least one byte is buffered, we
         915                 :            :        only return buffered bytes.  Otherwise, we do one raw read. */
         916                 :            :
         917   [ +  -  +  -  :       4070 :     have = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
                       +  + ]
         918         [ +  + ]:       4070 :     if (have > 0) {
         919                 :          1 :         n = Py_MIN(have, n);
         920                 :          1 :         res = _bufferedreader_read_fast(self, n);
         921                 :            :         assert(res != Py_None);
         922                 :          1 :         return res;
         923                 :            :     }
         924                 :       4069 :     res = PyBytes_FromStringAndSize(NULL, n);
         925         [ -  + ]:       4069 :     if (res == NULL)
         926                 :          0 :         return NULL;
         927   [ -  +  -  - ]:       4069 :     if (!ENTER_BUFFERED(self)) {
         928                 :          0 :         Py_DECREF(res);
         929                 :          0 :         return NULL;
         930                 :            :     }
         931                 :       4069 :     _bufferedreader_reset_buf(self);
         932                 :       4069 :     r = _bufferedreader_raw_read(self, PyBytes_AS_STRING(res), n);
         933                 :       4069 :     LEAVE_BUFFERED(self)
         934         [ -  + ]:       4069 :     if (r == -1) {
         935                 :          0 :         Py_DECREF(res);
         936                 :          0 :         return NULL;
         937                 :            :     }
         938         [ -  + ]:       4069 :     if (r == -2)
         939                 :          0 :         r = 0;
         940         [ +  + ]:       4069 :     if (n > r)
         941                 :       1261 :         _PyBytes_Resize(&res, r);
         942                 :       4069 :     return res;
         943                 :            : }
         944                 :            :
         945                 :            : static PyObject *
         946                 :          0 : _buffered_readinto_generic(buffered *self, Py_buffer *buffer, char readinto1)
         947                 :            : {
         948                 :          0 :     Py_ssize_t n, written = 0, remaining;
         949                 :          0 :     PyObject *res = NULL;
         950                 :            :
         951   [ #  #  #  # ]:          0 :     CHECK_INITIALIZED(self)
         952   [ #  #  #  #  :          0 :     CHECK_CLOSED(self, "readinto of closed file")
              #  #  #  #  #
              #  #  #  #  #
                       #  # ]
         953                 :            :
         954   [ #  #  #  #  :          0 :     n = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
                       #  # ]
         955         [ #  # ]:          0 :     if (n > 0) {
         956         [ #  # ]:          0 :         if (n >= buffer->len) {
         957                 :          0 :             memcpy(buffer->buf, self->buffer + self->pos, buffer->len);
         958                 :          0 :             self->pos += buffer->len;
         959                 :          0 :             return PyLong_FromSsize_t(buffer->len);
         960                 :            :         }
         961                 :          0 :         memcpy(buffer->buf, self->buffer + self->pos, n);
         962                 :          0 :         self->pos += n;
         963                 :          0 :         written = n;
         964                 :            :     }
         965                 :            :
         966   [ #  #  #  # ]:          0 :     if (!ENTER_BUFFERED(self))
         967                 :          0 :         return NULL;
         968                 :            :
         969         [ #  # ]:          0 :     if (self->writable) {
         970                 :          0 :         res = buffered_flush_and_rewind_unlocked(self);
         971         [ #  # ]:          0 :         if (res == NULL)
         972                 :          0 :             goto end;
         973         [ #  # ]:          0 :         Py_CLEAR(res);
         974                 :            :     }
         975                 :            :
         976                 :          0 :     _bufferedreader_reset_buf(self);
         977                 :          0 :     self->pos = 0;
         978                 :            :
         979         [ #  # ]:          0 :     for (remaining = buffer->len - written;
         980                 :            :          remaining > 0;
         981                 :          0 :          written += n, remaining -= n) {
         982                 :            :         /* If remaining bytes is larger than internal buffer size, copy
         983                 :            :          * directly into caller's buffer. */
         984         [ #  # ]:          0 :         if (remaining > self->buffer_size) {
         985                 :          0 :             n = _bufferedreader_raw_read(self, (char *) buffer->buf + written,
         986                 :            :                                          remaining);
         987                 :            :         }
         988                 :            :
         989                 :            :         /* In readinto1 mode, we do not want to fill the internal
         990                 :            :            buffer if we already have some data to return */
         991   [ #  #  #  # ]:          0 :         else if (!(readinto1 && written)) {
         992                 :          0 :             n = _bufferedreader_fill_buffer(self);
         993         [ #  # ]:          0 :             if (n > 0) {
         994         [ #  # ]:          0 :                 if (n > remaining)
         995                 :          0 :                     n = remaining;
         996                 :          0 :                 memcpy((char *) buffer->buf + written,
         997                 :          0 :                        self->buffer + self->pos, n);
         998                 :          0 :                 self->pos += n;
         999                 :          0 :                 continue; /* short circuit */
        1000                 :            :             }
        1001                 :            :         }
        1002                 :            :         else
        1003                 :          0 :             n = 0;
        1004                 :            :
        1005   [ #  #  #  #  :          0 :         if (n == 0 || (n == -2 && written > 0))
                       #  # ]
        1006                 :            :             break;
        1007         [ #  # ]:          0 :         if (n < 0) {
        1008         [ #  # ]:          0 :             if (n == -2) {
        1009                 :          0 :                 res = Py_NewRef(Py_None);
        1010                 :            :             }
        1011                 :          0 :             goto end;
        1012                 :            :         }
        1013                 :            :
        1014                 :            :         /* At most one read in readinto1 mode */
        1015         [ #  # ]:          0 :         if (readinto1) {
        1016                 :          0 :             written += n;
        1017                 :          0 :             break;
        1018                 :            :         }
        1019                 :            :     }
        1020                 :          0 :     res = PyLong_FromSsize_t(written);
        1021                 :            :
        1022                 :          0 : end:
        1023                 :          0 :     LEAVE_BUFFERED(self);
        1024                 :          0 :     return res;
        1025                 :            : }
        1026                 :            :
        1027                 :            : /*[clinic input]
        1028                 :            : _io._Buffered.readinto
        1029                 :            :     buffer: Py_buffer(accept={rwbuffer})
        1030                 :            :     /
        1031                 :            : [clinic start generated code]*/
        1032                 :            :
        1033                 :            : static PyObject *
        1034                 :          0 : _io__Buffered_readinto_impl(buffered *self, Py_buffer *buffer)
        1035                 :            : /*[clinic end generated code: output=bcb376580b1d8170 input=ed6b98b7a20a3008]*/
        1036                 :            : {
        1037                 :          0 :     return _buffered_readinto_generic(self, buffer, 0);
        1038                 :            : }
        1039                 :            :
        1040                 :            : /*[clinic input]
        1041                 :            : _io._Buffered.readinto1
        1042                 :            :     buffer: Py_buffer(accept={rwbuffer})
        1043                 :            :     /
        1044                 :            : [clinic start generated code]*/
        1045                 :            :
        1046                 :            : static PyObject *
        1047                 :          0 : _io__Buffered_readinto1_impl(buffered *self, Py_buffer *buffer)
        1048                 :            : /*[clinic end generated code: output=6e5c6ac5868205d6 input=4455c5d55fdf1687]*/
        1049                 :            : {
        1050                 :          0 :     return _buffered_readinto_generic(self, buffer, 1);
        1051                 :            : }
        1052                 :            :
        1053                 :            :
        1054                 :            : static PyObject *
        1055                 :          2 : _buffered_readline(buffered *self, Py_ssize_t limit)
        1056                 :            : {
        1057                 :          2 :     PyObject *res = NULL;
        1058                 :          2 :     PyObject *chunks = NULL;
        1059                 :            :     Py_ssize_t n;
        1060                 :            :     const char *start, *s, *end;
        1061                 :            :
        1062   [ +  -  +  -  :          2 :     CHECK_CLOSED(self, "readline of closed file")
              -  +  -  -  -
              -  -  -  -  -
                       -  - ]
        1063                 :            :
        1064                 :            :     /* First, try to find a line in the buffer. This can run unlocked because
        1065                 :            :        the calls to the C API are simple enough that they can't trigger
        1066                 :            :        any thread switch. */
        1067   [ +  -  +  -  :          2 :     n = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
                       +  + ]
        1068   [ -  +  -  - ]:          2 :     if (limit >= 0 && n > limit)
        1069                 :          0 :         n = limit;
        1070                 :          2 :     start = self->buffer + self->pos;
        1071                 :          2 :     s = memchr(start, '\n', n);
        1072         [ +  + ]:          2 :     if (s != NULL) {
        1073                 :          1 :         res = PyBytes_FromStringAndSize(start, s - start + 1);
        1074         [ +  - ]:          1 :         if (res != NULL)
        1075                 :          1 :             self->pos += s - start + 1;
        1076                 :          1 :         goto end_unlocked;
        1077                 :            :     }
        1078         [ -  + ]:          1 :     if (n == limit) {
        1079                 :          0 :         res = PyBytes_FromStringAndSize(start, n);
        1080         [ #  # ]:          0 :         if (res != NULL)
        1081                 :          0 :             self->pos += n;
        1082                 :          0 :         goto end_unlocked;
        1083                 :            :     }
        1084                 :            :
        1085   [ -  +  -  - ]:          1 :     if (!ENTER_BUFFERED(self))
        1086                 :          0 :         goto end_unlocked;
        1087                 :            :
        1088                 :            :     /* Now we try to get some more from the raw stream */
        1089                 :          1 :     chunks = PyList_New(0);
        1090         [ -  + ]:          1 :     if (chunks == NULL)
        1091                 :          0 :         goto end;
        1092         [ -  + ]:          1 :     if (n > 0) {
        1093                 :          0 :         res = PyBytes_FromStringAndSize(start, n);
        1094         [ #  # ]:          0 :         if (res == NULL)
        1095                 :          0 :             goto end;
        1096         [ #  # ]:          0 :         if (PyList_Append(chunks, res) < 0) {
        1097         [ #  # ]:          0 :             Py_CLEAR(res);
        1098                 :          0 :             goto end;
        1099                 :            :         }
        1100         [ #  # ]:          0 :         Py_CLEAR(res);
        1101                 :          0 :         self->pos += n;
        1102         [ #  # ]:          0 :         if (limit >= 0)
        1103                 :          0 :             limit -= n;
        1104                 :            :     }
        1105         [ -  + ]:          1 :     if (self->writable) {
        1106                 :          0 :         PyObject *r = buffered_flush_and_rewind_unlocked(self);
        1107         [ #  # ]:          0 :         if (r == NULL)
        1108                 :          0 :             goto end;
        1109                 :          0 :         Py_DECREF(r);
        1110                 :            :     }
        1111                 :            :
        1112                 :            :     for (;;) {
        1113                 :          1 :         _bufferedreader_reset_buf(self);
        1114                 :          1 :         n = _bufferedreader_fill_buffer(self);
        1115         [ -  + ]:          1 :         if (n == -1)
        1116                 :          0 :             goto end;
        1117         [ -  + ]:          1 :         if (n <= 0)
        1118                 :          0 :             break;
        1119   [ -  +  -  - ]:          1 :         if (limit >= 0 && n > limit)
        1120                 :          0 :             n = limit;
        1121                 :          1 :         start = self->buffer;
        1122                 :          1 :         end = start + n;
        1123                 :          1 :         s = start;
        1124         [ +  - ]:         18 :         while (s < end) {
        1125         [ +  + ]:         18 :             if (*s++ == '\n') {
        1126                 :          1 :                 res = PyBytes_FromStringAndSize(start, s - start);
        1127         [ -  + ]:          1 :                 if (res == NULL)
        1128                 :          0 :                     goto end;
        1129                 :          1 :                 self->pos = s - start;
        1130                 :          1 :                 goto found;
        1131                 :            :             }
        1132                 :            :         }
        1133                 :          0 :         res = PyBytes_FromStringAndSize(start, n);
        1134         [ #  # ]:          0 :         if (res == NULL)
        1135                 :          0 :             goto end;
        1136         [ #  # ]:          0 :         if (n == limit) {
        1137                 :          0 :             self->pos = n;
        1138                 :          0 :             break;
        1139                 :            :         }
        1140         [ #  # ]:          0 :         if (PyList_Append(chunks, res) < 0) {
        1141         [ #  # ]:          0 :             Py_CLEAR(res);
        1142                 :          0 :             goto end;
        1143                 :            :         }
        1144         [ #  # ]:          0 :         Py_CLEAR(res);
        1145         [ #  # ]:          0 :         if (limit >= 0)
        1146                 :          0 :             limit -= n;
        1147                 :            :     }
        1148                 :          1 : found:
        1149   [ +  -  -  + ]:          1 :     if (res != NULL && PyList_Append(chunks, res) < 0) {
        1150         [ #  # ]:          0 :         Py_CLEAR(res);
        1151                 :          0 :         goto end;
        1152                 :            :     }
        1153                 :          1 :     Py_XSETREF(res, _PyBytes_Join((PyObject *)&_Py_SINGLETON(bytes_empty), chunks));
        1154                 :            :
        1155                 :          1 : end:
        1156                 :          1 :     LEAVE_BUFFERED(self)
        1157                 :          2 : end_unlocked:
        1158                 :          2 :     Py_XDECREF(chunks);
        1159                 :          2 :     return res;
        1160                 :            : }
        1161                 :            :
        1162                 :            : /*[clinic input]
        1163                 :            : _io._Buffered.readline
        1164                 :            :     size: Py_ssize_t(accept={int, NoneType}) = -1
        1165                 :            :     /
        1166                 :            : [clinic start generated code]*/
        1167                 :            :
        1168                 :            : static PyObject *
        1169                 :          2 : _io__Buffered_readline_impl(buffered *self, Py_ssize_t size)
        1170                 :            : /*[clinic end generated code: output=24dd2aa6e33be83c input=673b6240e315ef8a]*/
        1171                 :            : {
        1172   [ -  +  -  - ]:          2 :     CHECK_INITIALIZED(self)
        1173                 :          2 :     return _buffered_readline(self, size);
        1174                 :            : }
        1175                 :            :
        1176                 :            :
        1177                 :            : static PyObject *
        1178                 :         90 : buffered_tell(buffered *self, PyObject *Py_UNUSED(ignored))
        1179                 :            : {
        1180                 :            :     Py_off_t pos;
        1181                 :            :
        1182   [ -  +  -  - ]:         90 :     CHECK_INITIALIZED(self)
        1183                 :         90 :     pos = _buffered_raw_tell(self);
        1184         [ -  + ]:         90 :     if (pos == -1)
        1185                 :          0 :         return NULL;
        1186   [ +  +  +  -  :         90 :     pos -= RAW_OFFSET(self);
              +  +  -  +  -
                          - ]
        1187                 :            :     /* TODO: sanity check (pos >= 0) */
        1188                 :         90 :     return PyLong_FromOff_t(pos);
        1189                 :            : }
        1190                 :            :
        1191                 :            : /*[clinic input]
        1192                 :            : _io._Buffered.seek
        1193                 :            :     target as targetobj: object
        1194                 :            :     whence: int = 0
        1195                 :            :     /
        1196                 :            : [clinic start generated code]*/
        1197                 :            :
        1198                 :            : static PyObject *
        1199                 :         89 : _io__Buffered_seek_impl(buffered *self, PyObject *targetobj, int whence)
        1200                 :            : /*[clinic end generated code: output=7ae0e8dc46efdefb input=a9c4920bfcba6163]*/
        1201                 :            : {
        1202                 :            :     Py_off_t target, n;
        1203                 :         89 :     PyObject *res = NULL;
        1204                 :            :
        1205   [ -  +  -  - ]:         89 :     CHECK_INITIALIZED(self)
        1206                 :            :
        1207                 :            :     /* Do some error checking instead of trusting OS 'seek()'
        1208                 :            :     ** error detection, just in case.
        1209                 :            :     */
        1210   [ +  -  -  + ]:         89 :     if ((whence < 0 || whence >2)
        1211                 :            : #ifdef SEEK_HOLE
        1212         [ #  # ]:          0 :         && (whence != SEEK_HOLE)
        1213                 :            : #endif
        1214                 :            : #ifdef SEEK_DATA
        1215         [ #  # ]:          0 :         && (whence != SEEK_DATA)
        1216                 :            : #endif
        1217                 :            :         ) {
        1218                 :          0 :         PyErr_Format(PyExc_ValueError,
        1219                 :            :                      "whence value %d unsupported", whence);
        1220                 :          0 :         return NULL;
        1221                 :            :     }
        1222                 :            :
        1223   [ +  -  +  -  :         89 :     CHECK_CLOSED(self, "seek of closed file")
              -  +  -  -  -
              -  -  -  -  -
                       -  - ]
        1224                 :            :
        1225         [ -  + ]:         89 :     if (_PyIOBase_check_seekable(self->raw, Py_True) == NULL)
        1226                 :          0 :         return NULL;
        1227                 :            :
        1228                 :         89 :     target = PyNumber_AsOff_t(targetobj, PyExc_ValueError);
        1229   [ -  +  -  - ]:         89 :     if (target == -1 && PyErr_Occurred())
        1230                 :          0 :         return NULL;
        1231                 :            :
        1232                 :            :     /* SEEK_SET and SEEK_CUR are special because we could seek inside the
        1233                 :            :        buffer. Other whence values must be managed without this optimization.
        1234                 :            :        Some Operating Systems can provide additional values, like
        1235                 :            :        SEEK_HOLE/SEEK_DATA. */
        1236   [ +  +  -  +  :         89 :     if (((whence == 0) || (whence == 1)) && self->readable) {
                       +  - ]
        1237                 :            :         Py_off_t current, avail;
        1238                 :            :         /* Check if seeking leaves us inside the current buffer,
        1239                 :            :            so as to return quickly if possible. Also, we needn't take the
        1240                 :            :            lock in this fast path.
        1241                 :            :            Don't know how to do that when whence == 2, though. */
        1242                 :            :         /* NOTE: RAW_TELL() can release the GIL but the object is in a stable
        1243                 :            :            state at this point. */
        1244         [ +  - ]:         45 :         current = RAW_TELL(self);
        1245   [ +  -  +  -  :         45 :         avail = READAHEAD(self);
                       +  + ]
        1246         [ +  + ]:         45 :         if (avail > 0) {
        1247                 :            :             Py_off_t offset;
        1248         [ +  - ]:          1 :             if (whence == 0)
        1249   [ +  -  -  +  :          1 :                 offset = target - (current - RAW_OFFSET(self));
              -  -  -  -  +
                          - ]
        1250                 :            :             else
        1251                 :          0 :                 offset = target;
        1252   [ +  -  +  - ]:          1 :             if (offset >= -self->pos && offset <= avail) {
        1253                 :          1 :                 self->pos += offset;
        1254                 :          1 :                 return PyLong_FromOff_t(current - avail + offset);
        1255                 :            :             }
        1256                 :            :         }
        1257                 :            :     }
        1258                 :            :
        1259   [ -  +  -  - ]:         88 :     if (!ENTER_BUFFERED(self))
        1260                 :          0 :         return NULL;
        1261                 :            :
        1262                 :            :     /* Fallback: invoke raw seek() method and clear buffer */
        1263         [ -  + ]:         88 :     if (self->writable) {
        1264                 :          0 :         res = _bufferedwriter_flush_unlocked(self);
        1265         [ #  # ]:          0 :         if (res == NULL)
        1266                 :          0 :             goto end;
        1267         [ #  # ]:          0 :         Py_CLEAR(res);
        1268                 :            :     }
        1269                 :            :
        1270                 :            :     /* TODO: align on block boundary and read buffer if needed? */
        1271         [ -  + ]:         88 :     if (whence == 1)
        1272   [ #  #  #  #  :          0 :         target -= RAW_OFFSET(self);
              #  #  #  #  #
                          # ]
        1273                 :         88 :     n = _buffered_raw_seek(self, target, whence);
        1274         [ -  + ]:         88 :     if (n == -1)
        1275                 :          0 :         goto end;
        1276                 :         88 :     self->raw_pos = -1;
        1277                 :         88 :     res = PyLong_FromOff_t(n);
        1278   [ -  +  -  + ]:         88 :     if (res != NULL && self->readable)
        1279                 :         88 :         _bufferedreader_reset_buf(self);
        1280                 :            :
        1281                 :          0 : end:
        1282                 :         88 :     LEAVE_BUFFERED(self)
        1283                 :         88 :     return res;
        1284                 :            : }
        1285                 :            :
        1286                 :            : /*[clinic input]
        1287                 :            : _io._Buffered.truncate
        1288                 :            :     pos: object = None
        1289                 :            :     /
        1290                 :            : [clinic start generated code]*/
        1291                 :            :
        1292                 :            : static PyObject *
        1293                 :          0 : _io__Buffered_truncate_impl(buffered *self, PyObject *pos)
        1294                 :            : /*[clinic end generated code: output=667ca03c60c270de input=8a1be34d57cca2d3]*/
        1295                 :            : {
        1296                 :          0 :     PyObject *res = NULL;
        1297                 :            :
        1298   [ #  #  #  # ]:          0 :     CHECK_INITIALIZED(self)
        1299   [ #  #  #  #  :          0 :     CHECK_CLOSED(self, "truncate of closed file")
              #  #  #  #  #
              #  #  #  #  #
                       #  # ]
        1300         [ #  # ]:          0 :     if (!self->writable) {
        1301                 :          0 :         return bufferediobase_unsupported("truncate");
        1302                 :            :     }
        1303   [ #  #  #  # ]:          0 :     if (!ENTER_BUFFERED(self))
        1304                 :          0 :         return NULL;
        1305                 :            :
        1306                 :          0 :     res = buffered_flush_and_rewind_unlocked(self);
        1307         [ #  # ]:          0 :     if (res == NULL) {
        1308                 :          0 :         goto end;
        1309                 :            :     }
        1310         [ #  # ]:          0 :     Py_CLEAR(res);
        1311                 :            :
        1312                 :          0 :     res = PyObject_CallMethodOneArg(self->raw, &_Py_ID(truncate), pos);
        1313         [ #  # ]:          0 :     if (res == NULL)
        1314                 :          0 :         goto end;
        1315                 :            :     /* Reset cached position */
        1316         [ #  # ]:          0 :     if (_buffered_raw_tell(self) == -1)
        1317                 :          0 :         PyErr_Clear();
        1318                 :            :
        1319                 :          0 : end:
        1320                 :          0 :     LEAVE_BUFFERED(self)
        1321                 :          0 :     return res;
        1322                 :            : }
        1323                 :            :
        1324                 :            : static PyObject *
        1325                 :          0 : buffered_iternext(buffered *self)
        1326                 :            : {
        1327                 :            :     PyObject *line;
        1328                 :            :     PyTypeObject *tp;
        1329                 :            :
        1330   [ #  #  #  # ]:          0 :     CHECK_INITIALIZED(self);
        1331                 :            :
        1332                 :          0 :     _PyIO_State *state = find_io_state_by_def(Py_TYPE(self));
        1333                 :          0 :     tp = Py_TYPE(self);
        1334   [ #  #  #  # ]:          0 :     if (Py_IS_TYPE(tp, state->PyBufferedReader_Type) ||
        1335                 :          0 :         Py_IS_TYPE(tp, state->PyBufferedRandom_Type))
        1336                 :            :     {
        1337                 :            :         /* Skip method call overhead for speed */
        1338                 :          0 :         line = _buffered_readline(self, -1);
        1339                 :            :     }
        1340                 :            :     else {
        1341                 :          0 :         line = PyObject_CallMethodNoArgs((PyObject *)self,
        1342                 :            :                                              &_Py_ID(readline));
        1343   [ #  #  #  # ]:          0 :         if (line && !PyBytes_Check(line)) {
        1344                 :          0 :             PyErr_Format(PyExc_OSError,
        1345                 :            :                          "readline() should have returned a bytes object, "
        1346                 :          0 :                          "not '%.200s'", Py_TYPE(line)->tp_name);
        1347                 :          0 :             Py_DECREF(line);
        1348                 :          0 :             return NULL;
        1349                 :            :         }
        1350                 :            :     }
        1351                 :            :
        1352         [ #  # ]:          0 :     if (line == NULL)
        1353                 :          0 :         return NULL;
        1354                 :            :
        1355         [ #  # ]:          0 :     if (PyBytes_GET_SIZE(line) == 0) {
        1356                 :            :         /* Reached EOF or would have blocked */
        1357                 :          0 :         Py_DECREF(line);
        1358                 :          0 :         return NULL;
        1359                 :            :     }
        1360                 :            :
        1361                 :          0 :     return line;
        1362                 :            : }
        1363                 :            :
        1364                 :            : static PyObject *
        1365                 :          0 : buffered_repr(buffered *self)
        1366                 :            : {
        1367                 :            :     PyObject *nameobj, *res;
        1368                 :            :
        1369         [ #  # ]:          0 :     if (_PyObject_LookupAttr((PyObject *) self, &_Py_ID(name), &nameobj) < 0) {
        1370         [ #  # ]:          0 :         if (!PyErr_ExceptionMatches(PyExc_ValueError)) {
        1371                 :          0 :             return NULL;
        1372                 :            :         }
        1373                 :            :         /* Ignore ValueError raised if the underlying stream was detached */
        1374                 :          0 :         PyErr_Clear();
        1375                 :            :     }
        1376         [ #  # ]:          0 :     if (nameobj == NULL) {
        1377                 :          0 :         res = PyUnicode_FromFormat("<%s>", Py_TYPE(self)->tp_name);
        1378                 :            :     }
        1379                 :            :     else {
        1380                 :          0 :         int status = Py_ReprEnter((PyObject *)self);
        1381                 :          0 :         res = NULL;
        1382         [ #  # ]:          0 :         if (status == 0) {
        1383                 :          0 :             res = PyUnicode_FromFormat("<%s name=%R>",
        1384                 :          0 :                                        Py_TYPE(self)->tp_name, nameobj);
        1385                 :          0 :             Py_ReprLeave((PyObject *)self);
        1386                 :            :         }
        1387         [ #  # ]:          0 :         else if (status > 0) {
        1388                 :          0 :             PyErr_Format(PyExc_RuntimeError,
        1389                 :            :                          "reentrant call inside %s.__repr__",
        1390                 :          0 :                          Py_TYPE(self)->tp_name);
        1391                 :            :         }
        1392                 :          0 :         Py_DECREF(nameobj);
        1393                 :            :     }
        1394                 :          0 :     return res;
        1395                 :            : }
        1396                 :            :
        1397                 :            : /*
        1398                 :            :  * class BufferedReader
        1399                 :            :  */
        1400                 :            :
        1401                 :       6059 : static void _bufferedreader_reset_buf(buffered *self)
        1402                 :            : {
        1403                 :       6059 :     self->read_end = -1;
        1404                 :       6059 : }
        1405                 :            :
        1406                 :            : /*[clinic input]
        1407                 :            : _io.BufferedReader.__init__
        1408                 :            :     raw: object
        1409                 :            :     buffer_size: Py_ssize_t(c_default="DEFAULT_BUFFER_SIZE") = DEFAULT_BUFFER_SIZE
        1410                 :            :
        1411                 :            : Create a new buffered reader using the given readable raw IO object.
        1412                 :            : [clinic start generated code]*/
        1413                 :            :
        1414                 :            : static int
        1415                 :       1267 : _io_BufferedReader___init___impl(buffered *self, PyObject *raw,
        1416                 :            :                                  Py_ssize_t buffer_size)
        1417                 :            : /*[clinic end generated code: output=cddcfefa0ed294c4 input=fb887e06f11b4e48]*/
        1418                 :            : {
        1419                 :       1267 :     self->ok = 0;
        1420                 :       1267 :     self->detached = 0;
        1421                 :            :
        1422         [ -  + ]:       1267 :     if (_PyIOBase_check_readable(raw, Py_True) == NULL)
        1423                 :          0 :         return -1;
        1424                 :            :
        1425                 :       1267 :     Py_XSETREF(self->raw, Py_NewRef(raw));
        1426                 :       1267 :     self->buffer_size = buffer_size;
        1427                 :       1267 :     self->readable = 1;
        1428                 :       1267 :     self->writable = 0;
        1429                 :            :
        1430         [ -  + ]:       1267 :     if (_buffered_init(self) < 0)
        1431                 :          0 :         return -1;
        1432                 :       1267 :     _bufferedreader_reset_buf(self);
        1433                 :            :
        1434                 :       1267 :     _PyIO_State *state = find_io_state_by_def(Py_TYPE(self));
        1435                 :       1267 :     self->fast_closed_checks = (
        1436   [ +  -  +  - ]:       2534 :         Py_IS_TYPE(self, state->PyBufferedReader_Type) &&
        1437                 :       1267 :         Py_IS_TYPE(raw, state->PyFileIO_Type)
        1438                 :            :     );
        1439                 :            :
        1440                 :       1267 :     self->ok = 1;
        1441                 :       1267 :     return 0;
        1442                 :            : }
        1443                 :            :
        1444                 :            : static Py_ssize_t
        1445                 :       4092 : _bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len)
        1446                 :            : {
        1447                 :            :     Py_buffer buf;
        1448                 :            :     PyObject *memobj, *res;
        1449                 :            :     Py_ssize_t n;
        1450                 :            :     /* NOTE: the buffer needn't be released as its object is NULL. */
        1451         [ -  + ]:       4092 :     if (PyBuffer_FillInfo(&buf, NULL, start, len, 0, PyBUF_CONTIG) == -1)
        1452                 :          0 :         return -1;
        1453                 :       4092 :     memobj = PyMemoryView_FromBuffer(&buf);
        1454         [ -  + ]:       4092 :     if (memobj == NULL)
        1455                 :          0 :         return -1;
        1456                 :            :     /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR
        1457                 :            :        occurs so we needn't do it ourselves.
        1458                 :            :        We then retry reading, ignoring the signal if no handler has
        1459                 :            :        raised (see issue #10956).
        1460                 :            :     */
        1461                 :            :     do {
        1462                 :       4092 :         res = PyObject_CallMethodOneArg(self->raw, &_Py_ID(readinto), memobj);
        1463   [ -  +  -  - ]:       4092 :     } while (res == NULL && _PyIO_trap_eintr());
        1464                 :       4092 :     Py_DECREF(memobj);
        1465         [ -  + ]:       4092 :     if (res == NULL)
        1466                 :          0 :         return -1;
        1467         [ -  + ]:       4092 :     if (res == Py_None) {
        1468                 :            :         /* Non-blocking stream would have blocked. Special return code! */
        1469                 :          0 :         Py_DECREF(res);
        1470                 :          0 :         return -2;
        1471                 :            :     }
        1472                 :       4092 :     n = PyNumber_AsSsize_t(res, PyExc_ValueError);
        1473                 :       4092 :     Py_DECREF(res);
        1474                 :            :
        1475   [ -  +  -  - ]:       4092 :     if (n == -1 && PyErr_Occurred()) {
        1476                 :          0 :         _PyErr_FormatFromCause(
        1477                 :            :             PyExc_OSError,
        1478                 :            :             "raw readinto() failed"
        1479                 :            :         );
        1480                 :          0 :         return -1;
        1481                 :            :     }
        1482                 :            :
        1483   [ +  -  -  + ]:       4092 :     if (n < 0 || n > len) {
        1484                 :          0 :         PyErr_Format(PyExc_OSError,
        1485                 :            :                      "raw readinto() returned invalid length %zd "
        1486                 :            :                      "(should have been between 0 and %zd)", n, len);
        1487                 :          0 :         return -1;
        1488                 :            :     }
        1489   [ +  +  +  - ]:       4092 :     if (n > 0 && self->abs_pos != -1)
        1490                 :       3461 :         self->abs_pos += n;
        1491                 :       4092 :     return n;
        1492                 :            : }
        1493                 :            :
        1494                 :            : static Py_ssize_t
        1495                 :         23 : _bufferedreader_fill_buffer(buffered *self)
        1496                 :            : {
        1497                 :            :     Py_ssize_t start, len, n;
        1498   [ +  -  +  + ]:         23 :     if (VALID_READ_BUFFER(self))
        1499                 :         22 :         start = Py_SAFE_DOWNCAST(self->read_end, Py_off_t, Py_ssize_t);
        1500                 :            :     else
        1501                 :          1 :         start = 0;
        1502                 :         23 :     len = self->buffer_size - start;
        1503                 :         23 :     n = _bufferedreader_raw_read(self, self->buffer + start, len);
        1504         [ -  + ]:         23 :     if (n <= 0)
        1505                 :          0 :         return n;
        1506                 :         23 :     self->read_end = start + n;
        1507                 :         23 :     self->raw_pos = start + n;
        1508                 :         23 :     return n;
        1509                 :            : }
        1510                 :            :
        1511                 :            : static PyObject *
        1512                 :        612 : _bufferedreader_read_all(buffered *self)
        1513                 :            : {
        1514                 :            :     Py_ssize_t current_size;
        1515                 :        612 :     PyObject *res = NULL, *data = NULL, *tmp = NULL, *chunks = NULL, *readall;
        1516                 :            :
        1517                 :            :     /* First copy what we have in the current buffer. */
        1518   [ +  -  +  -  :        612 :     current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
                       -  + ]
        1519         [ -  + ]:        612 :     if (current_size) {
        1520                 :          0 :         data = PyBytes_FromStringAndSize(
        1521                 :          0 :             self->buffer + self->pos, current_size);
        1522         [ #  # ]:          0 :         if (data == NULL)
        1523                 :          0 :             return NULL;
        1524                 :          0 :         self->pos += current_size;
        1525                 :            :     }
        1526                 :            :     /* We're going past the buffer's bounds, flush it */
        1527         [ -  + ]:        612 :     if (self->writable) {
        1528                 :          0 :         tmp = buffered_flush_and_rewind_unlocked(self);
        1529         [ #  # ]:          0 :         if (tmp == NULL)
        1530                 :          0 :             goto cleanup;
        1531         [ #  # ]:          0 :         Py_CLEAR(tmp);
        1532                 :            :     }
        1533                 :        612 :     _bufferedreader_reset_buf(self);
        1534                 :            :
        1535         [ -  + ]:        612 :     if (_PyObject_LookupAttr(self->raw, &_Py_ID(readall), &readall) < 0) {
        1536                 :          0 :         goto cleanup;
        1537                 :            :     }
        1538         [ +  - ]:        612 :     if (readall) {
        1539                 :        612 :         tmp = _PyObject_CallNoArgs(readall);
        1540                 :        612 :         Py_DECREF(readall);
        1541         [ -  + ]:        612 :         if (tmp == NULL)
        1542                 :          0 :             goto cleanup;
        1543   [ +  -  -  + ]:        612 :         if (tmp != Py_None && !PyBytes_Check(tmp)) {
        1544                 :          0 :             PyErr_SetString(PyExc_TypeError, "readall() should return bytes");
        1545                 :          0 :             goto cleanup;
        1546                 :            :         }
        1547         [ +  - ]:        612 :         if (current_size == 0) {
        1548                 :        612 :             res = tmp;
        1549                 :            :         } else {
        1550         [ #  # ]:          0 :             if (tmp != Py_None) {
        1551                 :          0 :                 PyBytes_Concat(&data, tmp);
        1552                 :            :             }
        1553                 :          0 :             res = data;
        1554                 :            :         }
        1555                 :        612 :         goto cleanup;
        1556                 :            :     }
        1557                 :            :
        1558                 :          0 :     chunks = PyList_New(0);
        1559         [ #  # ]:          0 :     if (chunks == NULL)
        1560                 :          0 :         goto cleanup;
        1561                 :            :
        1562                 :            :     while (1) {
        1563         [ #  # ]:          0 :         if (data) {
        1564         [ #  # ]:          0 :             if (PyList_Append(chunks, data) < 0)
        1565                 :          0 :                 goto cleanup;
        1566         [ #  # ]:          0 :             Py_CLEAR(data);
        1567                 :            :         }
        1568                 :            :
        1569                 :            :         /* Read until EOF or until read() would block. */
        1570                 :          0 :         data = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(read));
        1571         [ #  # ]:          0 :         if (data == NULL)
        1572                 :          0 :             goto cleanup;
        1573   [ #  #  #  # ]:          0 :         if (data != Py_None && !PyBytes_Check(data)) {
        1574                 :          0 :             PyErr_SetString(PyExc_TypeError, "read() should return bytes");
        1575                 :          0 :             goto cleanup;
        1576                 :            :         }
        1577   [ #  #  #  # ]:          0 :         if (data == Py_None || PyBytes_GET_SIZE(data) == 0) {
        1578         [ #  # ]:          0 :             if (current_size == 0) {
        1579                 :          0 :                 res = data;
        1580                 :          0 :                 goto cleanup;
        1581                 :            :             }
        1582                 :            :             else {
        1583                 :          0 :                 tmp = _PyBytes_Join((PyObject *)&_Py_SINGLETON(bytes_empty), chunks);
        1584                 :          0 :                 res = tmp;
        1585                 :          0 :                 goto cleanup;
        1586                 :            :             }
        1587                 :            :         }
        1588                 :          0 :         current_size += PyBytes_GET_SIZE(data);
        1589         [ #  # ]:          0 :         if (self->abs_pos != -1)
        1590                 :          0 :             self->abs_pos += PyBytes_GET_SIZE(data);
        1591                 :            :     }
        1592                 :        612 : cleanup:
        1593                 :            :     /* res is either NULL or a borrowed ref */
        1594                 :        612 :     Py_XINCREF(res);
        1595                 :        612 :     Py_XDECREF(data);
        1596                 :        612 :     Py_XDECREF(tmp);
        1597                 :        612 :     Py_XDECREF(chunks);
        1598                 :        612 :     return res;
        1599                 :            : }
        1600                 :            :
        1601                 :            : /* Read n bytes from the buffer if it can, otherwise return None.
        1602                 :            :    This function is simple enough that it can run unlocked. */
        1603                 :            : static PyObject *
        1604                 :         23 : _bufferedreader_read_fast(buffered *self, Py_ssize_t n)
        1605                 :            : {
        1606                 :            :     Py_ssize_t current_size;
        1607                 :            :
        1608   [ +  -  +  -  :         23 :     current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
                       +  + ]
        1609         [ +  + ]:         23 :     if (n <= current_size) {
        1610                 :            :         /* Fast path: the data to read is fully buffered. */
        1611                 :          1 :         PyObject *res = PyBytes_FromStringAndSize(self->buffer + self->pos, n);
        1612         [ +  - ]:          1 :         if (res != NULL)
        1613                 :          1 :             self->pos += n;
        1614                 :          1 :         return res;
        1615                 :            :     }
        1616                 :         22 :     Py_RETURN_NONE;
        1617                 :            : }
        1618                 :            :
        1619                 :            : /* Generic read function: read from the stream until enough bytes are read,
        1620                 :            :  * or until an EOF occurs or until read() would block.
        1621                 :            :  */
        1622                 :            : static PyObject *
        1623                 :         22 : _bufferedreader_read_generic(buffered *self, Py_ssize_t n)
        1624                 :            : {
        1625                 :         22 :     PyObject *res = NULL;
        1626                 :            :     Py_ssize_t current_size, remaining, written;
        1627                 :            :     char *out;
        1628                 :            :
        1629   [ +  -  +  -  :         22 :     current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
                       -  + ]
        1630         [ -  + ]:         22 :     if (n <= current_size)
        1631                 :          0 :         return _bufferedreader_read_fast(self, n);
        1632                 :            :
        1633                 :         22 :     res = PyBytes_FromStringAndSize(NULL, n);
        1634         [ -  + ]:         22 :     if (res == NULL)
        1635                 :          0 :         goto error;
        1636                 :         22 :     out = PyBytes_AS_STRING(res);
        1637                 :         22 :     remaining = n;
        1638                 :         22 :     written = 0;
        1639         [ -  + ]:         22 :     if (current_size > 0) {
        1640                 :          0 :         memcpy(out, self->buffer + self->pos, current_size);
        1641                 :          0 :         remaining -= current_size;
        1642                 :          0 :         written += current_size;
        1643                 :          0 :         self->pos += current_size;
        1644                 :            :     }
        1645                 :            :     /* Flush the write buffer if necessary */
        1646         [ -  + ]:         22 :     if (self->writable) {
        1647                 :          0 :         PyObject *r = buffered_flush_and_rewind_unlocked(self);
        1648         [ #  # ]:          0 :         if (r == NULL)
        1649                 :          0 :             goto error;
        1650                 :          0 :         Py_DECREF(r);
        1651                 :            :     }
        1652                 :         22 :     _bufferedreader_reset_buf(self);
        1653         [ +  - ]:         22 :     while (remaining > 0) {
        1654                 :            :         /* We want to read a whole block at the end into buffer.
        1655                 :            :            If we had readv() we could do this in one pass. */
        1656         [ +  - ]:         22 :         Py_ssize_t r = MINUS_LAST_BLOCK(self, remaining);
        1657         [ +  - ]:         22 :         if (r == 0)
        1658                 :         22 :             break;
        1659                 :          0 :         r = _bufferedreader_raw_read(self, out + written, r);
        1660         [ #  # ]:          0 :         if (r == -1)
        1661                 :          0 :             goto error;
        1662   [ #  #  #  # ]:          0 :         if (r == 0 || r == -2) {
        1663                 :            :             /* EOF occurred or read() would block. */
        1664   [ #  #  #  # ]:          0 :             if (r == 0 || written > 0) {
        1665         [ #  # ]:          0 :                 if (_PyBytes_Resize(&res, written))
        1666                 :          0 :                     goto error;
        1667                 :          0 :                 return res;
        1668                 :            :             }
        1669                 :          0 :             Py_DECREF(res);
        1670                 :          0 :             Py_RETURN_NONE;
        1671                 :            :         }
        1672                 :          0 :         remaining -= r;
        1673                 :          0 :         written += r;
        1674                 :            :     }
        1675                 :            :     assert(remaining <= self->buffer_size);
        1676                 :         22 :     self->pos = 0;
        1677                 :         22 :     self->raw_pos = 0;
        1678                 :         22 :     self->read_end = 0;
        1679                 :            :     /* NOTE: when the read is satisfied, we avoid issuing any additional
        1680                 :            :        reads, which could block indefinitely (e.g. on a socket).
        1681                 :            :        See issue #9550. */
        1682   [ +  -  +  - ]:         22 :     while (remaining > 0 && self->read_end < self->buffer_size) {
        1683                 :         22 :         Py_ssize_t r = _bufferedreader_fill_buffer(self);
        1684         [ -  + ]:         22 :         if (r == -1)
        1685                 :          0 :             goto error;
        1686   [ +  -  -  + ]:         22 :         if (r == 0 || r == -2) {
        1687                 :            :             /* EOF occurred or read() would block. */
        1688   [ #  #  #  # ]:          0 :             if (r == 0 || written > 0) {
        1689         [ #  # ]:          0 :                 if (_PyBytes_Resize(&res, written))
        1690                 :          0 :                     goto error;
        1691                 :          0 :                 return res;
        1692                 :            :             }
        1693                 :          0 :             Py_DECREF(res);
        1694                 :          0 :             Py_RETURN_NONE;
        1695                 :            :         }
        1696         [ -  + ]:         22 :         if (remaining > r) {
        1697                 :          0 :             memcpy(out + written, self->buffer + self->pos, r);
        1698                 :          0 :             written += r;
        1699                 :          0 :             self->pos += r;
        1700                 :          0 :             remaining -= r;
        1701                 :            :         }
        1702         [ +  - ]:         22 :         else if (remaining > 0) {
        1703                 :         22 :             memcpy(out + written, self->buffer + self->pos, remaining);
        1704                 :         22 :             written += remaining;
        1705                 :         22 :             self->pos += remaining;
        1706                 :         22 :             remaining = 0;
        1707                 :            :         }
        1708         [ +  - ]:         22 :         if (remaining == 0)
        1709                 :         22 :             break;
        1710                 :            :     }
        1711                 :            :
        1712                 :         22 :     return res;
        1713                 :            :
        1714                 :          0 : error:
        1715                 :          0 :     Py_XDECREF(res);
        1716                 :          0 :     return NULL;
        1717                 :            : }
        1718                 :            :
        1719                 :            : static PyObject *
        1720                 :          0 : _bufferedreader_peek_unlocked(buffered *self)
        1721                 :            : {
        1722                 :            :     Py_ssize_t have, r;
        1723                 :            :
        1724   [ #  #  #  #  :          0 :     have = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
                       #  # ]
        1725                 :            :     /* Constraints:
        1726                 :            :        1. we don't want to advance the file position.
        1727                 :            :        2. we don't want to lose block alignment, so we can't shift the buffer
        1728                 :            :           to make some place.
        1729                 :            :        Therefore, we either return `have` bytes (if > 0), or a full buffer.
        1730                 :            :     */
        1731         [ #  # ]:          0 :     if (have > 0) {
        1732                 :          0 :         return PyBytes_FromStringAndSize(self->buffer + self->pos, have);
        1733                 :            :     }
        1734                 :            :
        1735                 :            :     /* Fill the buffer from the raw stream, and copy it to the result. */
        1736                 :          0 :     _bufferedreader_reset_buf(self);
        1737                 :          0 :     r = _bufferedreader_fill_buffer(self);
        1738         [ #  # ]:          0 :     if (r == -1)
        1739                 :          0 :         return NULL;
        1740         [ #  # ]:          0 :     if (r == -2)
        1741                 :          0 :         r = 0;
        1742                 :          0 :     self->pos = 0;
        1743                 :          0 :     return PyBytes_FromStringAndSize(self->buffer, r);
        1744                 :            : }
        1745                 :            :
        1746                 :            :
        1747                 :            : /*
        1748                 :            :  * class BufferedWriter
        1749                 :            :  */
        1750                 :            : static void
        1751                 :       1064 : _bufferedwriter_reset_buf(buffered *self)
        1752                 :            : {
        1753                 :       1064 :     self->write_pos = 0;
        1754                 :       1064 :     self->write_end = -1;
        1755                 :       1064 : }
        1756                 :            :
        1757                 :            : /*[clinic input]
        1758                 :            : _io.BufferedWriter.__init__
        1759                 :            :     raw: object
        1760                 :            :     buffer_size: Py_ssize_t(c_default="DEFAULT_BUFFER_SIZE") = DEFAULT_BUFFER_SIZE
        1761                 :            :
        1762                 :            : A buffer for a writeable sequential RawIO object.
        1763                 :            :
        1764                 :            : The constructor creates a BufferedWriter for the given writeable raw
        1765                 :            : stream. If the buffer_size is not given, it defaults to
        1766                 :            : DEFAULT_BUFFER_SIZE.
        1767                 :            : [clinic start generated code]*/
        1768                 :            :
        1769                 :            : static int
        1770                 :         74 : _io_BufferedWriter___init___impl(buffered *self, PyObject *raw,
        1771                 :            :                                  Py_ssize_t buffer_size)
        1772                 :            : /*[clinic end generated code: output=c8942a020c0dee64 input=914be9b95e16007b]*/
        1773                 :            : {
        1774                 :         74 :     self->ok = 0;
        1775                 :         74 :     self->detached = 0;
        1776                 :            :
        1777         [ -  + ]:         74 :     if (_PyIOBase_check_writable(raw, Py_True) == NULL)
        1778                 :          0 :         return -1;
        1779                 :            :
        1780                 :         74 :     Py_INCREF(raw);
        1781                 :         74 :     Py_XSETREF(self->raw, raw);
        1782                 :         74 :     self->readable = 0;
        1783                 :         74 :     self->writable = 1;
        1784                 :            :
        1785                 :         74 :     self->buffer_size = buffer_size;
        1786         [ -  + ]:         74 :     if (_buffered_init(self) < 0)
        1787                 :          0 :         return -1;
        1788                 :         74 :     _bufferedwriter_reset_buf(self);
        1789                 :         74 :     self->pos = 0;
        1790                 :            :
        1791                 :         74 :     _PyIO_State *state = find_io_state_by_def(Py_TYPE(self));
        1792                 :         74 :     self->fast_closed_checks = (
        1793   [ +  -  +  - ]:        148 :         Py_IS_TYPE(self, state->PyBufferedWriter_Type) &&
        1794                 :         74 :         Py_IS_TYPE(raw, state->PyFileIO_Type)
        1795                 :            :     );
        1796                 :            :
        1797                 :         74 :     self->ok = 1;
        1798                 :         74 :     return 0;
        1799                 :            : }
        1800                 :            :
        1801                 :            : static Py_ssize_t
        1802                 :        760 : _bufferedwriter_raw_write(buffered *self, char *start, Py_ssize_t len)
        1803                 :            : {
        1804                 :            :     Py_buffer buf;
        1805                 :            :     PyObject *memobj, *res;
        1806                 :            :     Py_ssize_t n;
        1807                 :            :     int errnum;
        1808                 :            :     /* NOTE: the buffer needn't be released as its object is NULL. */
        1809         [ -  + ]:        760 :     if (PyBuffer_FillInfo(&buf, NULL, start, len, 1, PyBUF_CONTIG_RO) == -1)
        1810                 :          0 :         return -1;
        1811                 :        760 :     memobj = PyMemoryView_FromBuffer(&buf);
        1812         [ -  + ]:        760 :     if (memobj == NULL)
        1813                 :          0 :         return -1;
        1814                 :            :     /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR
        1815                 :            :        occurs so we needn't do it ourselves.
        1816                 :            :        We then retry writing, ignoring the signal if no handler has
        1817                 :            :        raised (see issue #10956).
        1818                 :            :     */
        1819                 :            :     do {
        1820                 :        760 :         errno = 0;
        1821                 :        760 :         res = PyObject_CallMethodOneArg(self->raw, &_Py_ID(write), memobj);
        1822                 :        760 :         errnum = errno;
        1823   [ -  +  -  - ]:        760 :     } while (res == NULL && _PyIO_trap_eintr());
        1824                 :        760 :     Py_DECREF(memobj);
        1825         [ -  + ]:        760 :     if (res == NULL)
        1826                 :          0 :         return -1;
        1827         [ -  + ]:        760 :     if (res == Py_None) {
        1828                 :            :         /* Non-blocking stream would have blocked. Special return code!
        1829                 :            :            Being paranoid we reset errno in case it is changed by code
        1830                 :            :            triggered by a decref.  errno is used by _set_BlockingIOError(). */
        1831                 :          0 :         Py_DECREF(res);
        1832                 :          0 :         errno = errnum;
        1833                 :          0 :         return -2;
        1834                 :            :     }
        1835                 :        760 :     n = PyNumber_AsSsize_t(res, PyExc_ValueError);
        1836                 :        760 :     Py_DECREF(res);
        1837   [ +  -  -  + ]:        760 :     if (n < 0 || n > len) {
        1838                 :          0 :         PyErr_Format(PyExc_OSError,
        1839                 :            :                      "raw write() returned invalid length %zd "
        1840                 :            :                      "(should have been between 0 and %zd)", n, len);
        1841                 :          0 :         return -1;
        1842                 :            :     }
        1843   [ +  -  +  - ]:        760 :     if (n > 0 && self->abs_pos != -1)
        1844                 :        760 :         self->abs_pos += n;
        1845                 :        760 :     return n;
        1846                 :            : }
        1847                 :            :
        1848                 :            : static PyObject *
        1849                 :        990 : _bufferedwriter_flush_unlocked(buffered *self)
        1850                 :            : {
        1851                 :            :     Py_off_t n, rewind;
        1852                 :            :
        1853   [ +  -  +  +  :        990 :     if (!VALID_WRITE_BUFFER(self) || self->write_pos == self->write_end)
                       +  + ]
        1854                 :        958 :         goto end;
        1855                 :            :     /* First, rewind */
        1856   [ -  +  -  -  :         32 :     rewind = RAW_OFFSET(self) + (self->pos - self->write_pos);
              +  -  +  -  +
                          - ]
        1857         [ -  + ]:         32 :     if (rewind != 0) {
        1858                 :          0 :         n = _buffered_raw_seek(self, -rewind, 1);
        1859         [ #  # ]:          0 :         if (n < 0) {
        1860                 :          0 :             goto error;
        1861                 :            :         }
        1862                 :          0 :         self->raw_pos -= rewind;
        1863                 :            :     }
        1864         [ +  + ]:         64 :     while (self->write_pos < self->write_end) {
        1865                 :         32 :         n = _bufferedwriter_raw_write(self,
        1866                 :         32 :             self->buffer + self->write_pos,
        1867                 :         32 :             Py_SAFE_DOWNCAST(self->write_end - self->write_pos,
        1868                 :            :                              Py_off_t, Py_ssize_t));
        1869         [ -  + ]:         32 :         if (n == -1) {
        1870                 :          0 :             goto error;
        1871                 :            :         }
        1872         [ -  + ]:         32 :         else if (n == -2) {
        1873                 :          0 :             _set_BlockingIOError("write could not complete without blocking",
        1874                 :            :                                  0);
        1875                 :          0 :             goto error;
        1876                 :            :         }
        1877                 :         32 :         self->write_pos += n;
        1878                 :         32 :         self->raw_pos = self->write_pos;
        1879                 :            :         /* Partial writes can return successfully when interrupted by a
        1880                 :            :            signal (see write(2)).  We must run signal handlers before
        1881                 :            :            blocking another time, possibly indefinitely. */
        1882         [ -  + ]:         32 :         if (PyErr_CheckSignals() < 0)
        1883                 :          0 :             goto error;
        1884                 :            :     }
        1885                 :            :
        1886                 :            :
        1887                 :         32 : end:
        1888                 :            :     /* This ensures that after return from this function,
        1889                 :            :        VALID_WRITE_BUFFER(self) returns false.
        1890                 :            :
        1891                 :            :        This is a required condition because when a tell() is called
        1892                 :            :        after flushing and if VALID_READ_BUFFER(self) is false, we need
        1893                 :            :        VALID_WRITE_BUFFER(self) to be false to have
        1894                 :            :        RAW_OFFSET(self) == 0.
        1895                 :            :
        1896                 :            :        Issue: https://bugs.python.org/issue32228 */
        1897                 :        990 :     _bufferedwriter_reset_buf(self);
        1898                 :        990 :     Py_RETURN_NONE;
        1899                 :            :
        1900                 :          0 : error:
        1901                 :          0 :     return NULL;
        1902                 :            : }
        1903                 :            :
        1904                 :            : /*[clinic input]
        1905                 :            : _io.BufferedWriter.write
        1906                 :            :     buffer: Py_buffer
        1907                 :            :     /
        1908                 :            : [clinic start generated code]*/
        1909                 :            :
        1910                 :            : static PyObject *
        1911                 :        760 : _io_BufferedWriter_write_impl(buffered *self, Py_buffer *buffer)
        1912                 :            : /*[clinic end generated code: output=7f8d1365759bfc6b input=dd87dd85fc7f8850]*/
        1913                 :            : {
        1914                 :        760 :     PyObject *res = NULL;
        1915                 :            :     Py_ssize_t written, avail, remaining;
        1916                 :            :     Py_off_t offset;
        1917                 :            :
        1918   [ -  +  -  - ]:        760 :     CHECK_INITIALIZED(self)
        1919                 :            :
        1920   [ -  +  -  - ]:        760 :     if (!ENTER_BUFFERED(self))
        1921                 :          0 :         return NULL;
        1922                 :            :
        1923                 :            :     /* Issue #31976: Check for closed file after acquiring the lock. Another
        1924                 :            :        thread could be holding the lock while closing the file. */
        1925   [ +  -  +  -  :        760 :     if (IS_CLOSED(self)) {
                 -  +  -  - ]
        1926                 :          0 :         PyErr_SetString(PyExc_ValueError, "write to closed file");
        1927                 :          0 :         goto error;
        1928                 :            :     }
        1929                 :            :
        1930                 :            :     /* Fast path: the data to write can be fully buffered. */
        1931   [ -  +  -  -  :        760 :     if (!VALID_READ_BUFFER(self) && !VALID_WRITE_BUFFER(self)) {
                 +  -  +  + ]
        1932                 :         35 :         self->pos = 0;
        1933                 :         35 :         self->raw_pos = 0;
        1934                 :            :     }
        1935                 :        760 :     avail = Py_SAFE_DOWNCAST(self->buffer_size - self->pos, Py_off_t, Py_ssize_t);
        1936         [ +  + ]:        760 :     if (buffer->len <= avail) {
        1937                 :         32 :         memcpy(self->buffer + self->pos, buffer->buf, buffer->len);
        1938   [ +  -  +  +  :         32 :         if (!VALID_WRITE_BUFFER(self) || self->write_pos > self->pos) {
                       -  + ]
        1939                 :         20 :             self->write_pos = self->pos;
        1940                 :            :         }
        1941   [ -  +  -  -  :         32 :         ADJUST_POSITION(self, self->pos + buffer->len);
                       -  - ]
        1942         [ +  - ]:         32 :         if (self->pos > self->write_end)
        1943                 :         32 :             self->write_end = self->pos;
        1944                 :         32 :         written = buffer->len;
        1945                 :         32 :         goto end;
        1946                 :            :     }
        1947                 :            :
        1948                 :            :     /* First write the current buffer */
        1949                 :        728 :     res = _bufferedwriter_flush_unlocked(self);
        1950         [ -  + ]:        728 :     if (res == NULL) {
        1951                 :          0 :         Py_ssize_t *w = _buffered_check_blocking_error();
        1952         [ #  # ]:          0 :         if (w == NULL)
        1953                 :          0 :             goto error;
        1954         [ #  # ]:          0 :         if (self->readable)
        1955                 :          0 :             _bufferedreader_reset_buf(self);
        1956                 :            :         /* Make some place by shifting the buffer. */
        1957                 :            :         assert(VALID_WRITE_BUFFER(self));
        1958                 :          0 :         memmove(self->buffer, self->buffer + self->write_pos,
        1959                 :          0 :                 Py_SAFE_DOWNCAST(self->write_end - self->write_pos,
        1960                 :            :                                  Py_off_t, Py_ssize_t));
        1961                 :          0 :         self->write_end -= self->write_pos;
        1962                 :          0 :         self->raw_pos -= self->write_pos;
        1963                 :          0 :         self->pos -= self->write_pos;
        1964                 :          0 :         self->write_pos = 0;
        1965                 :          0 :         avail = Py_SAFE_DOWNCAST(self->buffer_size - self->write_end,
        1966                 :            :                                  Py_off_t, Py_ssize_t);
        1967         [ #  # ]:          0 :         if (buffer->len <= avail) {
        1968                 :            :             /* Everything can be buffered */
        1969                 :          0 :             PyErr_Clear();
        1970                 :          0 :             memcpy(self->buffer + self->write_end, buffer->buf, buffer->len);
        1971                 :          0 :             self->write_end += buffer->len;
        1972                 :          0 :             self->pos += buffer->len;
        1973                 :          0 :             written = buffer->len;
        1974                 :          0 :             goto end;
        1975                 :            :         }
        1976                 :            :         /* Buffer as much as possible. */
        1977                 :          0 :         memcpy(self->buffer + self->write_end, buffer->buf, avail);
        1978                 :          0 :         self->write_end += avail;
        1979                 :          0 :         self->pos += avail;
        1980                 :            :         /* XXX Modifying the existing exception e using the pointer w
        1981                 :            :            will change e.characters_written but not e.args[2].
        1982                 :            :            Therefore we just replace with a new error. */
        1983                 :          0 :         _set_BlockingIOError("write could not complete without blocking",
        1984                 :            :                              avail);
        1985                 :          0 :         goto error;
        1986                 :            :     }
        1987         [ +  - ]:        728 :     Py_CLEAR(res);
        1988                 :            :
        1989                 :            :     /* Adjust the raw stream position if it is away from the logical stream
        1990                 :            :        position. This happens if the read buffer has been filled but not
        1991                 :            :        modified (and therefore _bufferedwriter_flush_unlocked() didn't rewind
        1992                 :            :        the raw stream by itself).
        1993                 :            :        Fixes issue #6629.
        1994                 :            :     */
        1995   [ -  +  -  -  :        728 :     offset = RAW_OFFSET(self);
              +  -  -  +  -
                          - ]
        1996         [ -  + ]:        728 :     if (offset != 0) {
        1997         [ #  # ]:          0 :         if (_buffered_raw_seek(self, -offset, 1) < 0)
        1998                 :          0 :             goto error;
        1999                 :          0 :         self->raw_pos -= offset;
        2000                 :            :     }
        2001                 :            :
        2002                 :            :     /* Then write buf itself. At this point the buffer has been emptied. */
        2003                 :        728 :     remaining = buffer->len;
        2004                 :        728 :     written = 0;
        2005         [ +  + ]:       1456 :     while (remaining > self->buffer_size) {
        2006                 :        728 :         Py_ssize_t n = _bufferedwriter_raw_write(
        2007                 :        728 :             self, (char *) buffer->buf + written, buffer->len - written);
        2008         [ -  + ]:        728 :         if (n == -1) {
        2009                 :          0 :             goto error;
        2010         [ -  + ]:        728 :         } else if (n == -2) {
        2011                 :            :             /* Write failed because raw file is non-blocking */
        2012         [ #  # ]:          0 :             if (remaining > self->buffer_size) {
        2013                 :            :                 /* Can't buffer everything, still buffer as much as possible */
        2014                 :          0 :                 memcpy(self->buffer,
        2015                 :          0 :                        (char *) buffer->buf + written, self->buffer_size);
        2016                 :          0 :                 self->raw_pos = 0;
        2017   [ #  #  #  #  :          0 :                 ADJUST_POSITION(self, self->buffer_size);
                       #  # ]
        2018                 :          0 :                 self->write_end = self->buffer_size;
        2019                 :          0 :                 written += self->buffer_size;
        2020                 :          0 :                 _set_BlockingIOError("write could not complete without "
        2021                 :            :                                      "blocking", written);
        2022                 :          0 :                 goto error;
        2023                 :            :             }
        2024                 :          0 :             PyErr_Clear();
        2025                 :          0 :             break;
        2026                 :            :         }
        2027                 :        728 :         written += n;
        2028                 :        728 :         remaining -= n;
        2029                 :            :         /* Partial writes can return successfully when interrupted by a
        2030                 :            :            signal (see write(2)).  We must run signal handlers before
        2031                 :            :            blocking another time, possibly indefinitely. */
        2032         [ -  + ]:        728 :         if (PyErr_CheckSignals() < 0)
        2033                 :          0 :             goto error;
        2034                 :            :     }
        2035         [ -  + ]:        728 :     if (self->readable)
        2036                 :          0 :         _bufferedreader_reset_buf(self);
        2037         [ -  + ]:        728 :     if (remaining > 0) {
        2038                 :          0 :         memcpy(self->buffer, (char *) buffer->buf + written, remaining);
        2039                 :          0 :         written += remaining;
        2040                 :            :     }
        2041                 :        728 :     self->write_pos = 0;
        2042                 :            :     /* TODO: sanity check (remaining >= 0) */
        2043                 :        728 :     self->write_end = remaining;
        2044   [ -  +  -  -  :        728 :     ADJUST_POSITION(self, remaining);
                       -  - ]
        2045                 :        728 :     self->raw_pos = 0;
        2046                 :            :
        2047                 :        760 : end:
        2048                 :        760 :     res = PyLong_FromSsize_t(written);
        2049                 :            :
        2050                 :        760 : error:
        2051                 :        760 :     LEAVE_BUFFERED(self)
        2052                 :        760 :     return res;
        2053                 :            : }
        2054                 :            :
        2055                 :            :
        2056                 :            : /*
        2057                 :            :  * BufferedRWPair
        2058                 :            :  */
        2059                 :            :
        2060                 :            : /* XXX The usefulness of this (compared to having two separate IO objects) is
        2061                 :            :  * questionable.
        2062                 :            :  */
        2063                 :            :
        2064                 :            : typedef struct {
        2065                 :            :     PyObject_HEAD
        2066                 :            :     buffered *reader;
        2067                 :            :     buffered *writer;
        2068                 :            :     PyObject *dict;
        2069                 :            :     PyObject *weakreflist;
        2070                 :            : } rwpair;
        2071                 :            :
        2072                 :            : /*[clinic input]
        2073                 :            : _io.BufferedRWPair.__init__
        2074                 :            :     reader: object
        2075                 :            :     writer: object
        2076                 :            :     buffer_size: Py_ssize_t(c_default="DEFAULT_BUFFER_SIZE") = DEFAULT_BUFFER_SIZE
        2077                 :            :     /
        2078                 :            :
        2079                 :            : A buffered reader and writer object together.
        2080                 :            :
        2081                 :            : A buffered reader object and buffered writer object put together to
        2082                 :            : form a sequential IO object that can read and write. This is typically
        2083                 :            : used with a socket or two-way pipe.
        2084                 :            :
        2085                 :            : reader and writer are RawIOBase objects that are readable and
        2086                 :            : writeable respectively. If the buffer_size is omitted it defaults to
        2087                 :            : DEFAULT_BUFFER_SIZE.
        2088                 :            : [clinic start generated code]*/
        2089                 :            :
        2090                 :            : static int
        2091                 :          0 : _io_BufferedRWPair___init___impl(rwpair *self, PyObject *reader,
        2092                 :            :                                  PyObject *writer, Py_ssize_t buffer_size)
        2093                 :            : /*[clinic end generated code: output=327e73d1aee8f984 input=620d42d71f33a031]*/
        2094                 :            : {
        2095         [ #  # ]:          0 :     if (_PyIOBase_check_readable(reader, Py_True) == NULL)
        2096                 :          0 :         return -1;
        2097         [ #  # ]:          0 :     if (_PyIOBase_check_writable(writer, Py_True) == NULL)
        2098                 :          0 :         return -1;
        2099                 :            :
        2100                 :          0 :     _PyIO_State *state = find_io_state_by_def(Py_TYPE(self));
        2101                 :          0 :     self->reader = (buffered *) PyObject_CallFunction(
        2102                 :          0 :             (PyObject *)state->PyBufferedReader_Type,
        2103                 :            :             "On", reader, buffer_size);
        2104         [ #  # ]:          0 :     if (self->reader == NULL)
        2105                 :          0 :         return -1;
        2106                 :            :
        2107                 :          0 :     self->writer = (buffered *) PyObject_CallFunction(
        2108                 :          0 :             (PyObject *)state->PyBufferedWriter_Type,
        2109                 :            :             "On", writer, buffer_size);
        2110         [ #  # ]:          0 :     if (self->writer == NULL) {
        2111         [ #  # ]:          0 :         Py_CLEAR(self->reader);
        2112                 :          0 :         return -1;
        2113                 :            :     }
        2114                 :            :
        2115                 :          0 :     return 0;
        2116                 :            : }
        2117                 :            :
        2118                 :            : static int
        2119                 :          0 : bufferedrwpair_traverse(rwpair *self, visitproc visit, void *arg)
        2120                 :            : {
        2121   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(self));
        2122   [ #  #  #  # ]:          0 :     Py_VISIT(self->dict);
        2123                 :          0 :     return 0;
        2124                 :            : }
        2125                 :            :
        2126                 :            : static int
        2127                 :          0 : bufferedrwpair_clear(rwpair *self)
        2128                 :            : {
        2129         [ #  # ]:          0 :     Py_CLEAR(self->reader);
        2130         [ #  # ]:          0 :     Py_CLEAR(self->writer);
        2131         [ #  # ]:          0 :     Py_CLEAR(self->dict);
        2132                 :          0 :     return 0;
        2133                 :            : }
        2134                 :            :
        2135                 :            : static void
        2136                 :          0 : bufferedrwpair_dealloc(rwpair *self)
        2137                 :            : {
        2138                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
        2139                 :          0 :     _PyObject_GC_UNTRACK(self);
        2140         [ #  # ]:          0 :     if (self->weakreflist != NULL)
        2141                 :          0 :         PyObject_ClearWeakRefs((PyObject *)self);
        2142         [ #  # ]:          0 :     Py_CLEAR(self->reader);
        2143         [ #  # ]:          0 :     Py_CLEAR(self->writer);
        2144         [ #  # ]:          0 :     Py_CLEAR(self->dict);
        2145                 :          0 :     tp->tp_free((PyObject *) self);
        2146                 :          0 :     Py_DECREF(tp);
        2147                 :          0 : }
        2148                 :            :
        2149                 :            : static PyObject *
        2150                 :          0 : _forward_call(buffered *self, PyObject *name, PyObject *args)
        2151                 :            : {
        2152                 :            :     PyObject *func, *ret;
        2153         [ #  # ]:          0 :     if (self == NULL) {
        2154                 :          0 :         PyErr_SetString(PyExc_ValueError,
        2155                 :            :                         "I/O operation on uninitialized object");
        2156                 :          0 :         return NULL;
        2157                 :            :     }
        2158                 :            :
        2159                 :          0 :     func = PyObject_GetAttr((PyObject *)self, name);
        2160         [ #  # ]:          0 :     if (func == NULL) {
        2161                 :          0 :         PyErr_SetObject(PyExc_AttributeError, name);
        2162                 :          0 :         return NULL;
        2163                 :            :     }
        2164                 :            :
        2165                 :          0 :     ret = PyObject_CallObject(func, args);
        2166                 :          0 :     Py_DECREF(func);
        2167                 :          0 :     return ret;
        2168                 :            : }
        2169                 :            :
        2170                 :            : static PyObject *
        2171                 :          0 : bufferedrwpair_read(rwpair *self, PyObject *args)
        2172                 :            : {
        2173                 :          0 :     return _forward_call(self->reader, &_Py_ID(read), args);
        2174                 :            : }
        2175                 :            :
        2176                 :            : static PyObject *
        2177                 :          0 : bufferedrwpair_peek(rwpair *self, PyObject *args)
        2178                 :            : {
        2179                 :          0 :     return _forward_call(self->reader, &_Py_ID(peek), args);
        2180                 :            : }
        2181                 :            :
        2182                 :            : static PyObject *
        2183                 :          0 : bufferedrwpair_read1(rwpair *self, PyObject *args)
        2184                 :            : {
        2185                 :          0 :     return _forward_call(self->reader, &_Py_ID(read1), args);
        2186                 :            : }
        2187                 :            :
        2188                 :            : static PyObject *
        2189                 :          0 : bufferedrwpair_readinto(rwpair *self, PyObject *args)
        2190                 :            : {
        2191                 :          0 :     return _forward_call(self->reader, &_Py_ID(readinto), args);
        2192                 :            : }
        2193                 :            :
        2194                 :            : static PyObject *
        2195                 :          0 : bufferedrwpair_readinto1(rwpair *self, PyObject *args)
        2196                 :            : {
        2197                 :          0 :     return _forward_call(self->reader, &_Py_ID(readinto1), args);
        2198                 :            : }
        2199                 :            :
        2200                 :            : static PyObject *
        2201                 :          0 : bufferedrwpair_write(rwpair *self, PyObject *args)
        2202                 :            : {
        2203                 :          0 :     return _forward_call(self->writer, &_Py_ID(write), args);
        2204                 :            : }
        2205                 :            :
        2206                 :            : static PyObject *
        2207                 :          0 : bufferedrwpair_flush(rwpair *self, PyObject *Py_UNUSED(ignored))
        2208                 :            : {
        2209                 :          0 :     return _forward_call(self->writer, &_Py_ID(flush), NULL);
        2210                 :            : }
        2211                 :            :
        2212                 :            : static PyObject *
        2213                 :          0 : bufferedrwpair_readable(rwpair *self, PyObject *Py_UNUSED(ignored))
        2214                 :            : {
        2215                 :          0 :     return _forward_call(self->reader, &_Py_ID(readable), NULL);
        2216                 :            : }
        2217                 :            :
        2218                 :            : static PyObject *
        2219                 :          0 : bufferedrwpair_writable(rwpair *self, PyObject *Py_UNUSED(ignored))
        2220                 :            : {
        2221                 :          0 :     return _forward_call(self->writer, &_Py_ID(writable), NULL);
        2222                 :            : }
        2223                 :            :
        2224                 :            : static PyObject *
        2225                 :          0 : bufferedrwpair_close(rwpair *self, PyObject *Py_UNUSED(ignored))
        2226                 :            : {
        2227                 :          0 :     PyObject *exc = NULL;
        2228                 :          0 :     PyObject *ret = _forward_call(self->writer, &_Py_ID(close), NULL);
        2229         [ #  # ]:          0 :     if (ret == NULL) {
        2230                 :          0 :         exc = PyErr_GetRaisedException();
        2231                 :            :     }
        2232                 :            :     else {
        2233                 :          0 :         Py_DECREF(ret);
        2234                 :            :     }
        2235                 :          0 :     ret = _forward_call(self->reader, &_Py_ID(close), NULL);
        2236         [ #  # ]:          0 :     if (exc != NULL) {
        2237                 :          0 :         _PyErr_ChainExceptions1(exc);
        2238         [ #  # ]:          0 :         Py_CLEAR(ret);
        2239                 :            :     }
        2240                 :          0 :     return ret;
        2241                 :            : }
        2242                 :            :
        2243                 :            : static PyObject *
        2244                 :          0 : bufferedrwpair_isatty(rwpair *self, PyObject *Py_UNUSED(ignored))
        2245                 :            : {
        2246                 :          0 :     PyObject *ret = _forward_call(self->writer, &_Py_ID(isatty), NULL);
        2247                 :            :
        2248         [ #  # ]:          0 :     if (ret != Py_False) {
        2249                 :            :         /* either True or exception */
        2250                 :          0 :         return ret;
        2251                 :            :     }
        2252                 :          0 :     Py_DECREF(ret);
        2253                 :            :
        2254                 :          0 :     return _forward_call(self->reader, &_Py_ID(isatty), NULL);
        2255                 :            : }
        2256                 :            :
        2257                 :            : static PyObject *
        2258                 :          0 : bufferedrwpair_closed_get(rwpair *self, void *context)
        2259                 :            : {
        2260         [ #  # ]:          0 :     if (self->writer == NULL) {
        2261                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
        2262                 :            :                 "the BufferedRWPair object is being garbage-collected");
        2263                 :          0 :         return NULL;
        2264                 :            :     }
        2265                 :          0 :     return PyObject_GetAttr((PyObject *) self->writer, &_Py_ID(closed));
        2266                 :            : }
        2267                 :            :
        2268                 :            :
        2269                 :            : /*
        2270                 :            :  * BufferedRandom
        2271                 :            :  */
        2272                 :            :
        2273                 :            : /*[clinic input]
        2274                 :            : _io.BufferedRandom.__init__
        2275                 :            :     raw: object
        2276                 :            :     buffer_size: Py_ssize_t(c_default="DEFAULT_BUFFER_SIZE") = DEFAULT_BUFFER_SIZE
        2277                 :            :
        2278                 :            : A buffered interface to random access streams.
        2279                 :            :
        2280                 :            : The constructor creates a reader and writer for a seekable stream,
        2281                 :            : raw, given in the first argument. If the buffer_size is omitted it
        2282                 :            : defaults to DEFAULT_BUFFER_SIZE.
        2283                 :            : [clinic start generated code]*/
        2284                 :            :
        2285                 :            : static int
        2286                 :          0 : _io_BufferedRandom___init___impl(buffered *self, PyObject *raw,
        2287                 :            :                                  Py_ssize_t buffer_size)
        2288                 :            : /*[clinic end generated code: output=d3d64eb0f64e64a3 input=a4e818fb86d0e50c]*/
        2289                 :            : {
        2290                 :          0 :     self->ok = 0;
        2291                 :          0 :     self->detached = 0;
        2292                 :            :
        2293         [ #  # ]:          0 :     if (_PyIOBase_check_seekable(raw, Py_True) == NULL)
        2294                 :          0 :         return -1;
        2295         [ #  # ]:          0 :     if (_PyIOBase_check_readable(raw, Py_True) == NULL)
        2296                 :          0 :         return -1;
        2297         [ #  # ]:          0 :     if (_PyIOBase_check_writable(raw, Py_True) == NULL)
        2298                 :          0 :         return -1;
        2299                 :            :
        2300                 :          0 :     Py_INCREF(raw);
        2301                 :          0 :     Py_XSETREF(self->raw, raw);
        2302                 :          0 :     self->buffer_size = buffer_size;
        2303                 :          0 :     self->readable = 1;
        2304                 :          0 :     self->writable = 1;
        2305                 :            :
        2306         [ #  # ]:          0 :     if (_buffered_init(self) < 0)
        2307                 :          0 :         return -1;
        2308                 :          0 :     _bufferedreader_reset_buf(self);
        2309                 :          0 :     _bufferedwriter_reset_buf(self);
        2310                 :          0 :     self->pos = 0;
        2311                 :            :
        2312                 :          0 :     _PyIO_State *state = find_io_state_by_def(Py_TYPE(self));
        2313   [ #  #  #  # ]:          0 :     self->fast_closed_checks = (Py_IS_TYPE(self, state->PyBufferedRandom_Type) &&
        2314                 :          0 :                                 Py_IS_TYPE(raw, state->PyFileIO_Type));
        2315                 :            :
        2316                 :          0 :     self->ok = 1;
        2317                 :          0 :     return 0;
        2318                 :            : }
        2319                 :            :
        2320                 :            : #define clinic_state() (find_io_state_by_def(Py_TYPE(self)))
        2321                 :            : #include "clinic/bufferedio.c.h"
        2322                 :            : #undef clinic_state
        2323                 :            :
        2324                 :            :
        2325                 :            : static PyMethodDef bufferediobase_methods[] = {
        2326                 :            :     _IO__BUFFEREDIOBASE_DETACH_METHODDEF
        2327                 :            :     {"read", bufferediobase_read, METH_VARARGS, bufferediobase_read_doc},
        2328                 :            :     {"read1", bufferediobase_read1, METH_VARARGS, bufferediobase_read1_doc},
        2329                 :            :     _IO__BUFFEREDIOBASE_READINTO_METHODDEF
        2330                 :            :     _IO__BUFFEREDIOBASE_READINTO1_METHODDEF
        2331                 :            :     {"write", bufferediobase_write, METH_VARARGS, bufferediobase_write_doc},
        2332                 :            :     {NULL, NULL}
        2333                 :            : };
        2334                 :            :
        2335                 :            : PyTypeObject PyBufferedIOBase_Type = {
        2336                 :            :     PyVarObject_HEAD_INIT(NULL, 0)
        2337                 :            :     "_io._BufferedIOBase",      /*tp_name*/
        2338                 :            :     0,                          /*tp_basicsize*/
        2339                 :            :     0,                          /*tp_itemsize*/
        2340                 :            :     0,                          /*tp_dealloc*/
        2341                 :            :     0,                          /*tp_vectorcall_offset*/
        2342                 :            :     0,                          /*tp_getattr*/
        2343                 :            :     0,                          /*tp_setattr*/
        2344                 :            :     0,                          /*tp_as_async*/
        2345                 :            :     0,                          /*tp_repr*/
        2346                 :            :     0,                          /*tp_as_number*/
        2347                 :            :     0,                          /*tp_as_sequence*/
        2348                 :            :     0,                          /*tp_as_mapping*/
        2349                 :            :     0,                          /*tp_hash */
        2350                 :            :     0,                          /*tp_call*/
        2351                 :            :     0,                          /*tp_str*/
        2352                 :            :     0,                          /*tp_getattro*/
        2353                 :            :     0,                          /*tp_setattro*/
        2354                 :            :     0,                          /*tp_as_buffer*/
        2355                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
        2356                 :            :     bufferediobase_doc,         /* tp_doc */
        2357                 :            :     0,                          /* tp_traverse */
        2358                 :            :     0,                          /* tp_clear */
        2359                 :            :     0,                          /* tp_richcompare */
        2360                 :            :     0,                          /* tp_weaklistoffset */
        2361                 :            :     0,                          /* tp_iter */
        2362                 :            :     0,                          /* tp_iternext */
        2363                 :            :     bufferediobase_methods,     /* tp_methods */
        2364                 :            :     0,                          /* tp_members */
        2365                 :            :     0,                          /* tp_getset */
        2366                 :            :     &PyIOBase_Type,             /* tp_base */
        2367                 :            :     0,                          /* tp_dict */
        2368                 :            :     0,                          /* tp_descr_get */
        2369                 :            :     0,                          /* tp_descr_set */
        2370                 :            :     0,                          /* tp_dictoffset */
        2371                 :            :     0,                          /* tp_init */
        2372                 :            :     0,                          /* tp_alloc */
        2373                 :            :     0,                          /* tp_new */
        2374                 :            :     0,                          /* tp_free */
        2375                 :            :     0,                          /* tp_is_gc */
        2376                 :            :     0,                          /* tp_bases */
        2377                 :            :     0,                          /* tp_mro */
        2378                 :            :     0,                          /* tp_cache */
        2379                 :            :     0,                          /* tp_subclasses */
        2380                 :            :     0,                          /* tp_weaklist */
        2381                 :            :     0,                          /* tp_del */
        2382                 :            :     0,                          /* tp_version_tag */
        2383                 :            :     0,                          /* tp_finalize */
        2384                 :            : };
        2385                 :            :
        2386                 :            :
        2387                 :            : static PyMethodDef bufferedreader_methods[] = {
        2388                 :            :     /* BufferedIOMixin methods */
        2389                 :            :     {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
        2390                 :            :     {"flush", (PyCFunction)buffered_simple_flush, METH_NOARGS},
        2391                 :            :     {"close", (PyCFunction)buffered_close, METH_NOARGS},
        2392                 :            :     {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
        2393                 :            :     {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
        2394                 :            :     {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
        2395                 :            :     {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
        2396                 :            :     {"_dealloc_warn", (PyCFunction)buffered_dealloc_warn, METH_O},
        2397                 :            :
        2398                 :            :     _IO__BUFFERED_READ_METHODDEF
        2399                 :            :     _IO__BUFFERED_PEEK_METHODDEF
        2400                 :            :     _IO__BUFFERED_READ1_METHODDEF
        2401                 :            :     _IO__BUFFERED_READINTO_METHODDEF
        2402                 :            :     _IO__BUFFERED_READINTO1_METHODDEF
        2403                 :            :     _IO__BUFFERED_READLINE_METHODDEF
        2404                 :            :     _IO__BUFFERED_SEEK_METHODDEF
        2405                 :            :     {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
        2406                 :            :     _IO__BUFFERED_TRUNCATE_METHODDEF
        2407                 :            :     {"__sizeof__", (PyCFunction)buffered_sizeof, METH_NOARGS},
        2408                 :            :     {NULL, NULL}
        2409                 :            : };
        2410                 :            :
        2411                 :            : static PyMemberDef bufferedreader_members[] = {
        2412                 :            :     {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
        2413                 :            :     {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0},
        2414                 :            :     {"__weaklistoffset__", T_PYSSIZET, offsetof(buffered, weakreflist), READONLY},
        2415                 :            :     {"__dictoffset__", T_PYSSIZET, offsetof(buffered, dict), READONLY},
        2416                 :            :     {NULL}
        2417                 :            : };
        2418                 :            :
        2419                 :            : static PyGetSetDef bufferedreader_getset[] = {
        2420                 :            :     {"closed", (getter)buffered_closed_get, NULL, NULL},
        2421                 :            :     {"name", (getter)buffered_name_get, NULL, NULL},
        2422                 :            :     {"mode", (getter)buffered_mode_get, NULL, NULL},
        2423                 :            :     {NULL}
        2424                 :            : };
        2425                 :            :
        2426                 :            :
        2427                 :            : static PyType_Slot bufferedreader_slots[] = {
        2428                 :            :     {Py_tp_dealloc, buffered_dealloc},
        2429                 :            :     {Py_tp_repr, buffered_repr},
        2430                 :            :     {Py_tp_doc, (void *)_io_BufferedReader___init____doc__},
        2431                 :            :     {Py_tp_traverse, buffered_traverse},
        2432                 :            :     {Py_tp_clear, buffered_clear},
        2433                 :            :     {Py_tp_iternext, buffered_iternext},
        2434                 :            :     {Py_tp_methods, bufferedreader_methods},
        2435                 :            :     {Py_tp_members, bufferedreader_members},
        2436                 :            :     {Py_tp_getset, bufferedreader_getset},
        2437                 :            :     {Py_tp_init, _io_BufferedReader___init__},
        2438                 :            :     {0, NULL},
        2439                 :            : };
        2440                 :            :
        2441                 :            : PyType_Spec bufferedreader_spec = {
        2442                 :            :     .name = "_io.BufferedReader",
        2443                 :            :     .basicsize = sizeof(buffered),
        2444                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
        2445                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        2446                 :            :     .slots = bufferedreader_slots,
        2447                 :            : };
        2448                 :            :
        2449                 :            : static PyMethodDef bufferedwriter_methods[] = {
        2450                 :            :     /* BufferedIOMixin methods */
        2451                 :            :     {"close", (PyCFunction)buffered_close, METH_NOARGS},
        2452                 :            :     {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
        2453                 :            :     {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
        2454                 :            :     {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
        2455                 :            :     {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
        2456                 :            :     {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
        2457                 :            :     {"_dealloc_warn", (PyCFunction)buffered_dealloc_warn, METH_O},
        2458                 :            :
        2459                 :            :     _IO_BUFFEREDWRITER_WRITE_METHODDEF
        2460                 :            :     _IO__BUFFERED_TRUNCATE_METHODDEF
        2461                 :            :     {"flush", (PyCFunction)buffered_flush, METH_NOARGS},
        2462                 :            :     _IO__BUFFERED_SEEK_METHODDEF
        2463                 :            :     {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
        2464                 :            :     {"__sizeof__", (PyCFunction)buffered_sizeof, METH_NOARGS},
        2465                 :            :     {NULL, NULL}
        2466                 :            : };
        2467                 :            :
        2468                 :            : static PyMemberDef bufferedwriter_members[] = {
        2469                 :            :     {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
        2470                 :            :     {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0},
        2471                 :            :     {"__weaklistoffset__", T_PYSSIZET, offsetof(buffered, weakreflist), READONLY},
        2472                 :            :     {"__dictoffset__", T_PYSSIZET, offsetof(buffered, dict), READONLY},
        2473                 :            :     {NULL}
        2474                 :            : };
        2475                 :            :
        2476                 :            : static PyGetSetDef bufferedwriter_getset[] = {
        2477                 :            :     {"closed", (getter)buffered_closed_get, NULL, NULL},
        2478                 :            :     {"name", (getter)buffered_name_get, NULL, NULL},
        2479                 :            :     {"mode", (getter)buffered_mode_get, NULL, NULL},
        2480                 :            :     {NULL}
        2481                 :            : };
        2482                 :            :
        2483                 :            :
        2484                 :            : static PyType_Slot bufferedwriter_slots[] = {
        2485                 :            :     {Py_tp_dealloc, buffered_dealloc},
        2486                 :            :     {Py_tp_repr, buffered_repr},
        2487                 :            :     {Py_tp_doc, (void *)_io_BufferedWriter___init____doc__},
        2488                 :            :     {Py_tp_traverse, buffered_traverse},
        2489                 :            :     {Py_tp_clear, buffered_clear},
        2490                 :            :     {Py_tp_methods, bufferedwriter_methods},
        2491                 :            :     {Py_tp_members, bufferedwriter_members},
        2492                 :            :     {Py_tp_getset, bufferedwriter_getset},
        2493                 :            :     {Py_tp_init, _io_BufferedWriter___init__},
        2494                 :            :     {0, NULL},
        2495                 :            : };
        2496                 :            :
        2497                 :            : PyType_Spec bufferedwriter_spec = {
        2498                 :            :     .name = "_io.BufferedWriter",
        2499                 :            :     .basicsize = sizeof(buffered),
        2500                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
        2501                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        2502                 :            :     .slots = bufferedwriter_slots,
        2503                 :            : };
        2504                 :            :
        2505                 :            : static PyMethodDef bufferedrwpair_methods[] = {
        2506                 :            :     {"read", (PyCFunction)bufferedrwpair_read, METH_VARARGS},
        2507                 :            :     {"peek", (PyCFunction)bufferedrwpair_peek, METH_VARARGS},
        2508                 :            :     {"read1", (PyCFunction)bufferedrwpair_read1, METH_VARARGS},
        2509                 :            :     {"readinto", (PyCFunction)bufferedrwpair_readinto, METH_VARARGS},
        2510                 :            :     {"readinto1", (PyCFunction)bufferedrwpair_readinto1, METH_VARARGS},
        2511                 :            :
        2512                 :            :     {"write", (PyCFunction)bufferedrwpair_write, METH_VARARGS},
        2513                 :            :     {"flush", (PyCFunction)bufferedrwpair_flush, METH_NOARGS},
        2514                 :            :
        2515                 :            :     {"readable", (PyCFunction)bufferedrwpair_readable, METH_NOARGS},
        2516                 :            :     {"writable", (PyCFunction)bufferedrwpair_writable, METH_NOARGS},
        2517                 :            :
        2518                 :            :     {"close", (PyCFunction)bufferedrwpair_close, METH_NOARGS},
        2519                 :            :     {"isatty", (PyCFunction)bufferedrwpair_isatty, METH_NOARGS},
        2520                 :            :
        2521                 :            :     {NULL, NULL}
        2522                 :            : };
        2523                 :            :
        2524                 :            : static PyMemberDef bufferedrwpair_members[] = {
        2525                 :            :     {"__weaklistoffset__", T_PYSSIZET, offsetof(rwpair, weakreflist), READONLY},
        2526                 :            :     {"__dictoffset__", T_PYSSIZET, offsetof(rwpair, dict), READONLY},
        2527                 :            :     {NULL}
        2528                 :            : };
        2529                 :            :
        2530                 :            : static PyGetSetDef bufferedrwpair_getset[] = {
        2531                 :            :     {"closed", (getter)bufferedrwpair_closed_get, NULL, NULL},
        2532                 :            :     {NULL}
        2533                 :            : };
        2534                 :            :
        2535                 :            : static PyType_Slot bufferedrwpair_slots[] = {
        2536                 :            :     {Py_tp_dealloc, bufferedrwpair_dealloc},
        2537                 :            :     {Py_tp_doc, (void *)_io_BufferedRWPair___init____doc__},
        2538                 :            :     {Py_tp_traverse, bufferedrwpair_traverse},
        2539                 :            :     {Py_tp_clear, bufferedrwpair_clear},
        2540                 :            :     {Py_tp_methods, bufferedrwpair_methods},
        2541                 :            :     {Py_tp_members, bufferedrwpair_members},
        2542                 :            :     {Py_tp_getset, bufferedrwpair_getset},
        2543                 :            :     {Py_tp_init, _io_BufferedRWPair___init__},
        2544                 :            :     {0, NULL},
        2545                 :            : };
        2546                 :            :
        2547                 :            : PyType_Spec bufferedrwpair_spec = {
        2548                 :            :     .name = "_io.BufferedRWPair",
        2549                 :            :     .basicsize = sizeof(rwpair),
        2550                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
        2551                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        2552                 :            :     .slots = bufferedrwpair_slots,
        2553                 :            : };
        2554                 :            :
        2555                 :            :
        2556                 :            : static PyMethodDef bufferedrandom_methods[] = {
        2557                 :            :     /* BufferedIOMixin methods */
        2558                 :            :     {"close", (PyCFunction)buffered_close, METH_NOARGS},
        2559                 :            :     {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
        2560                 :            :     {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
        2561                 :            :     {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
        2562                 :            :     {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
        2563                 :            :     {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
        2564                 :            :     {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
        2565                 :            :     {"_dealloc_warn", (PyCFunction)buffered_dealloc_warn, METH_O},
        2566                 :            :
        2567                 :            :     {"flush", (PyCFunction)buffered_flush, METH_NOARGS},
        2568                 :            :
        2569                 :            :     _IO__BUFFERED_SEEK_METHODDEF
        2570                 :            :     {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
        2571                 :            :     _IO__BUFFERED_TRUNCATE_METHODDEF
        2572                 :            :     _IO__BUFFERED_READ_METHODDEF
        2573                 :            :     _IO__BUFFERED_READ1_METHODDEF
        2574                 :            :     _IO__BUFFERED_READINTO_METHODDEF
        2575                 :            :     _IO__BUFFERED_READINTO1_METHODDEF
        2576                 :            :     _IO__BUFFERED_READLINE_METHODDEF
        2577                 :            :     _IO__BUFFERED_PEEK_METHODDEF
        2578                 :            :     _IO_BUFFEREDWRITER_WRITE_METHODDEF
        2579                 :            :     {"__sizeof__", (PyCFunction)buffered_sizeof, METH_NOARGS},
        2580                 :            :     {NULL, NULL}
        2581                 :            : };
        2582                 :            :
        2583                 :            : static PyMemberDef bufferedrandom_members[] = {
        2584                 :            :     {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
        2585                 :            :     {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0},
        2586                 :            :     {"__weaklistoffset__", T_PYSSIZET, offsetof(buffered, weakreflist), READONLY},
        2587                 :            :     {"__dictoffset__", T_PYSSIZET, offsetof(buffered, dict), READONLY},
        2588                 :            :     {NULL}
        2589                 :            : };
        2590                 :            :
        2591                 :            : static PyGetSetDef bufferedrandom_getset[] = {
        2592                 :            :     {"closed", (getter)buffered_closed_get, NULL, NULL},
        2593                 :            :     {"name", (getter)buffered_name_get, NULL, NULL},
        2594                 :            :     {"mode", (getter)buffered_mode_get, NULL, NULL},
        2595                 :            :     {NULL}
        2596                 :            : };
        2597                 :            :
        2598                 :            :
        2599                 :            : static PyType_Slot bufferedrandom_slots[] = {
        2600                 :            :     {Py_tp_dealloc, buffered_dealloc},
        2601                 :            :     {Py_tp_repr, buffered_repr},
        2602                 :            :     {Py_tp_doc, (void *)_io_BufferedRandom___init____doc__},
        2603                 :            :     {Py_tp_traverse, buffered_traverse},
        2604                 :            :     {Py_tp_clear, buffered_clear},
        2605                 :            :     {Py_tp_iternext, buffered_iternext},
        2606                 :            :     {Py_tp_methods, bufferedrandom_methods},
        2607                 :            :     {Py_tp_members, bufferedrandom_members},
        2608                 :            :     {Py_tp_getset, bufferedrandom_getset},
        2609                 :            :     {Py_tp_init, _io_BufferedRandom___init__},
        2610                 :            :     {0, NULL},
        2611                 :            : };
        2612                 :            :
        2613                 :            : PyType_Spec bufferedrandom_spec = {
        2614                 :            :     .name = "_io.BufferedRandom",
        2615                 :            :     .basicsize = sizeof(buffered),
        2616                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
        2617                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        2618                 :            :     .slots = bufferedrandom_slots,
        2619                 :            : };

Generated by: LCOV version 1.14