#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include "pythread.h"

#include "_iomodule.h"

PyDoc_STRVAR(bufferediobase_doc,

"Base class for buffered IO objects.\n"

"\n"

"The main difference with RawIOBase is that the read() method\n"

"supports omitting the size argument, and does not have a default\n"

"implementation that defers to readinto().\n"

"\n"

"In addition, read(), readinto() and write() may raise\n"

"BlockingIOError if the underlying raw stream is in non-blocking\n"

"mode and not ready; unlike their raw counterparts, they will never\n"

"return None.\n"

"\n"

"A typical implementation should not inherit from a RawIOBase\n"

"implementation, but wrap one.\n"

);

static PyObject *

bufferediobase_readinto(PyObject *self, PyObject *args)

{

Py_buffer buf;

Py_ssize_t len;

PyObject *data;

if (!PyArg_ParseTuple(args, "w*:readinto", &buf)) {

return NULL;

}

data = PyObject_CallMethod(self, "read", "n", buf.len);

if (data == NULL)

goto error;

if (!PyBytes_Check(data)) {

Py_DECREF(data);

PyErr_SetString(PyExc_TypeError, "read() should return bytes");

goto error;

}

len = Py_SIZE(data);

memcpy(buf.buf, PyBytes_AS_STRING(data), len);

PyBuffer_Release(&buf);

Py_DECREF(data);

return PyLong_FromSsize_t(len);

error:

PyBuffer_Release(&buf);

return NULL;

}

static PyObject *

bufferediobase_unsupported(const char *message)

{

PyErr_SetString(_PyIO_unsupported_operation, message);

return NULL;

}

PyDoc_STRVAR(bufferediobase_detach_doc,

"Disconnect this buffer from its underlying raw stream and return it.\n"

"\n"

"After the raw stream has been detached, the buffer is in an unusable\n"

"state.\n");

static PyObject *

bufferediobase_detach(PyObject *self)

{

return bufferediobase_unsupported("detach");

}

PyDoc_STRVAR(bufferediobase_read_doc,

"Read and return up to n bytes.\n"

"\n"

"If the argument is omitted, None, or negative, reads and\n"

"returns all data until EOF.\n"

"\n"

"If the argument is positive, and the underlying raw stream is\n"

"not 'interactive', multiple raw reads may be issued to satisfy\n"

"the byte count (unless EOF is reached first). But for\n"

"interactive raw streams (as well as sockets and pipes), at most\n"

"one raw read will be issued, and a short result does not imply\n"

"that EOF is imminent.\n"

"\n"

"Returns an empty bytes object on EOF.\n"

"\n"

"Returns None if the underlying raw stream was open in non-blocking\n"

"mode and no data is available at the moment.\n");

static PyObject *

bufferediobase_read(PyObject *self, PyObject *args)

{

return bufferediobase_unsupported("read");

}

PyDoc_STRVAR(bufferediobase_read1_doc,

"Read and return up to n bytes, with at most one read() call\n"

"to the underlying raw stream. A short result does not imply\n"

"that EOF is imminent.\n"

"\n"

"Returns an empty bytes object on EOF.\n");

static PyObject *

bufferediobase_read1(PyObject *self, PyObject *args)

{

return bufferediobase_unsupported("read1");

}

PyDoc_STRVAR(bufferediobase_write_doc,

"Write the given buffer to the IO stream.\n"

"\n"

"Returns the number of bytes written, which is never less than\n"

"len(b).\n"

"\n"

"Raises BlockingIOError if the buffer is full and the\n"

"underlying raw stream cannot accept more data at the moment.\n");

static PyObject *

bufferediobase_write(PyObject *self, PyObject *args)

{

return bufferediobase_unsupported("write");

}

static PyMethodDef bufferediobase_methods[] = {

{"detach", (PyCFunction)bufferediobase_detach, METH_NOARGS, bufferediobase_detach_doc},

{"read", bufferediobase_read, METH_VARARGS, bufferediobase_read_doc},

{"read1", bufferediobase_read1, METH_VARARGS, bufferediobase_read1_doc},

{"readinto", bufferediobase_readinto, METH_VARARGS, NULL},

{"write", bufferediobase_write, METH_VARARGS, bufferediobase_write_doc},

{NULL, NULL}

};

PyTypeObject PyBufferedIOBase_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_io._BufferedIOBase", /*tp_name*/

0, /*tp_basicsize*/

0, /*tp_itemsize*/

0, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_compare */

0, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash */

0, /*tp_call*/

0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/

bufferediobase_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

bufferediobase_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

&PyIOBase_Type, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

};

typedef struct {

PyObject_HEAD

PyObject *raw;

int ok; /* Initialized? */

int detached;

int readable;

int writable;

/* True if this is a vanilla Buffered object (rather than a user derived

int fast_closed_checks;

/* Absolute position inside the raw stream (-1 if unknown). */

Py_off_t abs_pos;

/* A static buffer of size `buffer_size` */

char *buffer;

/* Current logical position in the buffer. */

Py_off_t pos;

/* Position of the raw stream in the buffer. */

Py_off_t raw_pos;

/* Just after the last buffered byte in the buffer, or -1 if the buffer

Py_off_t read_end;

/* Just after the last byte actually written */

Py_off_t write_pos;

/* Just after the last byte waiting to be written, or -1 if the buffer

Py_off_t write_end;

#ifdef WITH_THREAD

PyThread_type_lock lock;

volatile long owner;

Py_ssize_t buffer_size;

Py_ssize_t buffer_mask;

PyObject *dict;

PyObject *weakreflist;

} buffered;

#ifdef WITH_THREAD

static int

_enter_buffered_busy(buffered *self)

{

if (self->owner == PyThread_get_thread_ident()) {

PyObject *r = PyObject_Repr((PyObject *) self);

if (r != NULL) {

PyErr_Format(PyExc_RuntimeError,

"reentrant call inside %s",

PyString_AS_STRING(r));

Py_DECREF(r);

}

return 0;

}

Py_BEGIN_ALLOW_THREADS

PyThread_acquire_lock(self->lock, 1);

Py_END_ALLOW_THREADS

return 1;

}

#define ENTER_BUFFERED(self) \

( (PyThread_acquire_lock(self->lock, 0) ? \

1 : _enter_buffered_busy(self)) \

&& (self->owner = PyThread_get_thread_ident(), 1) )

#define LEAVE_BUFFERED(self) \

do { \

self->owner = 0; \

PyThread_release_lock(self->lock); \

} while(0);

#define ENTER_BUFFERED(self) 1

#define LEAVE_BUFFERED(self)

#define CHECK_INITIALIZED(self) \

if (self->ok <= 0) { \

if (self->detached) { \

PyErr_SetString(PyExc_ValueError, \

"raw stream has been detached"); \

} else { \

PyErr_SetString(PyExc_ValueError, \

"I/O operation on uninitialized object"); \

} \

return NULL; \

}

#define CHECK_INITIALIZED_INT(self) \

if (self->ok <= 0) { \

if (self->detached) { \

PyErr_SetString(PyExc_ValueError, \

"raw stream has been detached"); \

} else { \

PyErr_SetString(PyExc_ValueError, \

"I/O operation on uninitialized object"); \

} \

return -1; \

}

#define IS_CLOSED(self) \

(self->fast_closed_checks \

? _PyFileIO_closed(self->raw) \

: buffered_closed(self))

#define CHECK_CLOSED(self, error_msg) \

if (IS_CLOSED(self)) { \

PyErr_SetString(PyExc_ValueError, error_msg); \

return NULL; \

}

#define VALID_READ_BUFFER(self) \

(self->readable && self->read_end != -1)

#define VALID_WRITE_BUFFER(self) \

(self->writable && self->write_end != -1)

#define ADJUST_POSITION(self, _new_pos) \

do { \

self->pos = _new_pos; \

if (VALID_READ_BUFFER(self) && self->read_end < self->pos) \

self->read_end = self->pos; \

} while(0)

#define READAHEAD(self) \

((self->readable && VALID_READ_BUFFER(self)) \

? (self->read_end - self->pos) : 0)

#define RAW_OFFSET(self) \

(((VALID_READ_BUFFER(self) || VALID_WRITE_BUFFER(self)) \

&& self->raw_pos >= 0) ? self->raw_pos - self->pos : 0)

#define RAW_TELL(self) \

(self->abs_pos != -1 ? self->abs_pos : _buffered_raw_tell(self))

#define MINUS_LAST_BLOCK(self, size) \

(self->buffer_mask ? \

(size & ~self->buffer_mask) : \

(self->buffer_size * (size / self->buffer_size)))

static void

buffered_dealloc(buffered *self)

{

if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)

return;

_PyObject_GC_UNTRACK(self);

self->ok = 0;

if (self->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *)self);

Py_CLEAR(self->raw);

if (self->buffer) {

PyMem_Free(self->buffer);

self->buffer = NULL;

}

#ifdef WITH_THREAD

if (self->lock) {

PyThread_free_lock(self->lock);

self->lock = NULL;

}

Py_CLEAR(self->dict);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static PyObject *

buffered_sizeof(buffered *self, void *unused)

{

Py_ssize_t res;

res = sizeof(buffered);

if (self->buffer)

res += self->buffer_size;

return PyLong_FromSsize_t(res);

}

static int

buffered_traverse(buffered *self, visitproc visit, void *arg)

{

Py_VISIT(self->raw);

Py_VISIT(self->dict);

return 0;

}

static int

buffered_clear(buffered *self)

{

if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)

return -1;

self->ok = 0;

Py_CLEAR(self->raw);

Py_CLEAR(self->dict);

return 0;

}

static PyObject *

buffered_simple_flush(buffered *self, PyObject *args)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_flush, NULL);

}

static int

buffered_closed(buffered *self)

{

int closed;

PyObject *res;

CHECK_INITIALIZED_INT(self)

res = PyObject_GetAttr(self->raw, _PyIO_str_closed);

if (res == NULL)

return -1;

closed = PyObject_IsTrue(res);

Py_DECREF(res);

return closed;

}

static PyObject *

buffered_closed_get(buffered *self, void *context)

{

CHECK_INITIALIZED(self)

return PyObject_GetAttr(self->raw, _PyIO_str_closed);

}

static PyObject *

buffered_close(buffered *self, PyObject *args)

{

PyObject *res = NULL, *exc = NULL, *val, *tb;

int r;

CHECK_INITIALIZED(self)

if (!ENTER_BUFFERED(self))

return NULL;

r = buffered_closed(self);

if (r < 0)

goto end;

if (r > 0) {

res = Py_None;

Py_INCREF(res);

goto end;

}

/* flush() will most probably re-take the lock, so drop it first */

LEAVE_BUFFERED(self)

res = PyObject_CallMethodObjArgs((PyObject *)self, _PyIO_str_flush, NULL);

if (!ENTER_BUFFERED(self))

return NULL;

if (res == NULL)

PyErr_Fetch(&exc, &val, &tb);

else

Py_DECREF(res);

res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_close, NULL);

if (exc != NULL) {

if (res != NULL) {

Py_CLEAR(res);

PyErr_Restore(exc, val, tb);

}

else {

Py_DECREF(exc);

Py_XDECREF(val);

Py_XDECREF(tb);

}

}

end:

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

buffered_detach(buffered *self, PyObject *args)

{

PyObject *raw, *res;

CHECK_INITIALIZED(self)

res = PyObject_CallMethodObjArgs((PyObject *)self, _PyIO_str_flush, NULL);

if (res == NULL)

return NULL;

Py_DECREF(res);

raw = self->raw;

self->raw = NULL;

self->detached = 1;

self->ok = 0;

return raw;

}

static PyObject *

buffered_seekable(buffered *self, PyObject *args)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_seekable, NULL);

}

static PyObject *

buffered_readable(buffered *self, PyObject *args)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_readable, NULL);

}

static PyObject *

buffered_writable(buffered *self, PyObject *args)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_writable, NULL);

}

static PyObject *

buffered_name_get(buffered *self, void *context)

{

CHECK_INITIALIZED(self)

return PyObject_GetAttrString(self->raw, "name");

}

static PyObject *

buffered_mode_get(buffered *self, void *context)

{

CHECK_INITIALIZED(self)

return PyObject_GetAttrString(self->raw, "mode");

}

static PyObject *

buffered_fileno(buffered *self, PyObject *args)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_fileno, NULL);

}

static PyObject *

buffered_isatty(buffered *self, PyObject *args)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_isatty, NULL);

}

static PyObject *

_bufferedwriter_flush_unlocked(buffered *);

static Py_ssize_t

_bufferedreader_fill_buffer(buffered *self);

static void

_bufferedreader_reset_buf(buffered *self);

static void

_bufferedwriter_reset_buf(buffered *self);

static PyObject *

_bufferedreader_peek_unlocked(buffered *self, Py_ssize_t);

static PyObject *

_bufferedreader_read_all(buffered *self);

static PyObject *

_bufferedreader_read_fast(buffered *self, Py_ssize_t);

static PyObject *

_bufferedreader_read_generic(buffered *self, Py_ssize_t);

static void

_set_BlockingIOError(char *msg, Py_ssize_t written)

{

PyObject *err;

err = PyObject_CallFunction(PyExc_BlockingIOError, "isn",

errno, msg, written);

if (err)

PyErr_SetObject(PyExc_BlockingIOError, err);

Py_XDECREF(err);

}

static Py_ssize_t *

_buffered_check_blocking_error(void)

{

PyObject *t, *v, *tb;

PyBlockingIOErrorObject *err;

PyErr_Fetch(&t, &v, &tb);

if (v == NULL || !PyErr_GivenExceptionMatches(v, PyExc_BlockingIOError)) {

PyErr_Restore(t, v, tb);

return NULL;

}

err = (PyBlockingIOErrorObject *) v;

/* TODO: sanity check (err->written >= 0) */

PyErr_Restore(t, v, tb);

return &err->written;

}

static Py_off_t

_buffered_raw_tell(buffered *self)

{

Py_off_t n;

PyObject *res;

res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_tell, NULL);

if (res == NULL)

return -1;

n = PyNumber_AsOff_t(res, PyExc_ValueError);

Py_DECREF(res);

if (n < 0) {

if (!PyErr_Occurred())

PyErr_Format(PyExc_IOError,

"Raw stream returned invalid position %" PY_PRIdOFF,

(PY_OFF_T_COMPAT)n);

return -1;

}

self->abs_pos = n;

return n;

}

static Py_off_t

_buffered_raw_seek(buffered *self, Py_off_t target, int whence)

{

PyObject *res, *posobj, *whenceobj;

Py_off_t n;

posobj = PyLong_FromOff_t(target);

if (posobj == NULL)

return -1;

whenceobj = PyLong_FromLong(whence);

if (whenceobj == NULL) {

Py_DECREF(posobj);

return -1;

}

res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_seek,

posobj, whenceobj, NULL);

Py_DECREF(posobj);

Py_DECREF(whenceobj);

if (res == NULL)

return -1;

n = PyNumber_AsOff_t(res, PyExc_ValueError);

Py_DECREF(res);

if (n < 0) {

if (!PyErr_Occurred())

PyErr_Format(PyExc_IOError,

"Raw stream returned invalid position %" PY_PRIdOFF,

(PY_OFF_T_COMPAT)n);

return -1;

}

self->abs_pos = n;

return n;

}

static int

_buffered_init(buffered *self)

{

Py_ssize_t n;

if (self->buffer_size <= 0) {

PyErr_SetString(PyExc_ValueError,

"buffer size must be strictly positive");

return -1;

}

if (self->buffer)

PyMem_Free(self->buffer);

self->buffer = PyMem_Malloc(self->buffer_size);

if (self->buffer == NULL) {

PyErr_NoMemory();

return -1;

}

#ifdef WITH_THREAD

if (self->lock)

PyThread_free_lock(self->lock);

self->lock = PyThread_allocate_lock();

if (self->lock == NULL) {

PyErr_SetString(PyExc_RuntimeError, "can't allocate read lock");

return -1;

}

self->owner = 0;

/* Find out whether buffer_size is a power of 2 */

/* XXX is this optimization useful? */

for (n = self->buffer_size - 1; n & 1; n >>= 1)

;

if (n == 0)

self->buffer_mask = self->buffer_size - 1;

else

self->buffer_mask = 0;

if (_buffered_raw_tell(self) == -1)

PyErr_Clear();

return 0;

}

_PyIO_trap_eintr(void)

{

static PyObject *eintr_int = NULL;

PyObject *typ, *val, *tb;

PyEnvironmentErrorObject *env_err;

if (eintr_int == NULL) {

eintr_int = PyLong_FromLong(EINTR);

assert(eintr_int != NULL);

}

if (!PyErr_ExceptionMatches(PyExc_EnvironmentError))

return 0;

PyErr_Fetch(&typ, &val, &tb);

PyErr_NormalizeException(&typ, &val, &tb);

env_err = (PyEnvironmentErrorObject *) val;

assert(env_err != NULL);

if (env_err->myerrno != NULL &&

PyObject_RichCompareBool(env_err->myerrno, eintr_int, Py_EQ) > 0) {

Py_DECREF(typ);

Py_DECREF(val);

Py_XDECREF(tb);

return 1;

}

/* This silences any error set by PyObject_RichCompareBool() */

PyErr_Restore(typ, val, tb);

return 0;

}

static PyObject *

buffered_flush_and_rewind_unlocked(buffered *self)

{

PyObject *res;

res = _bufferedwriter_flush_unlocked(self);

if (res == NULL)

return NULL;

Py_DECREF(res);

if (self->readable) {

/* Rewind the raw stream so that its position corresponds to

Py_off_t n;

n = _buffered_raw_seek(self, -RAW_OFFSET(self), 1);

_bufferedreader_reset_buf(self);

if (n == -1)

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

buffered_flush(buffered *self, PyObject *args)

{

PyObject *res;

CHECK_INITIALIZED(self)

CHECK_CLOSED(self, "flush of closed file")

if (!ENTER_BUFFERED(self))

return NULL;

res = buffered_flush_and_rewind_unlocked(self);

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

buffered_peek(buffered *self, PyObject *args)

{

Py_ssize_t n = 0;

PyObject *res = NULL;

CHECK_INITIALIZED(self)

if (!PyArg_ParseTuple(args, "|n:peek", &n)) {

return NULL;

}

if (!ENTER_BUFFERED(self))

return NULL;

if (self->writable) {

res = buffered_flush_and_rewind_unlocked(self);

if (res == NULL)

goto end;

Py_CLEAR(res);

}

res = _bufferedreader_peek_unlocked(self, n);

end:

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

buffered_read(buffered *self, PyObject *args)

{

Py_ssize_t n = -1;

PyObject *res;

CHECK_INITIALIZED(self)

if (!PyArg_ParseTuple(args, "|O&:read", &_PyIO_ConvertSsize_t, &n)) {

return NULL;

}

if (n < -1) {

PyErr_SetString(PyExc_ValueError,

"read length must be positive or -1");

return NULL;

}

CHECK_CLOSED(self, "read of closed file")

if (n == -1) {

/* The number of bytes is unspecified, read until the end of stream */

if (!ENTER_BUFFERED(self))

return NULL;

res = _bufferedreader_read_all(self);

}

else {

res = _bufferedreader_read_fast(self, n);

if (res != Py_None)

return res;

Py_DECREF(res);

if (!ENTER_BUFFERED(self))

return NULL;

res = _bufferedreader_read_generic(self, n);

}

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

buffered_read1(buffered *self, PyObject *args)

{

Py_ssize_t n, have, r;

PyObject *res = NULL;

CHECK_INITIALIZED(self)

if (!PyArg_ParseTuple(args, "n:read1", &n)) {

return NULL;

}

if (n < 0) {

PyErr_SetString(PyExc_ValueError,

"read length must be positive");

return NULL;

}

if (n == 0)

return PyBytes_FromStringAndSize(NULL, 0);

if (!ENTER_BUFFERED(self))

return NULL;

/* Return up to n bytes. If at least one byte is buffered, we

/* XXX: this mimicks the io.py implementation but is probably wrong.

have = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);

if (have > 0) {

if (n > have)

n = have;

res = PyBytes_FromStringAndSize(self->buffer + self->pos, n);

if (res == NULL)

goto end;

self->pos += n;

goto end;

}

if (self->writable) {

res = buffered_flush_and_rewind_unlocked(self);

if (res == NULL)

goto end;

Py_DECREF(res);

}

/* Fill the buffer from the raw stream, and copy it to the result. */

_bufferedreader_reset_buf(self);

r = _bufferedreader_fill_buffer(self);

if (r == -1)

goto end;

if (r == -2)

r = 0;

if (n > r)

n = r;

res = PyBytes_FromStringAndSize(self->buffer, n);

if (res == NULL)

goto end;

self->pos = n;

end:

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

buffered_readinto(buffered *self, PyObject *args)

{

CHECK_INITIALIZED(self)

/* TODO: use raw.readinto() (or a direct copy from our buffer) instead! */

return bufferediobase_readinto((PyObject *)self, args);

}

static PyObject *

_buffered_readline(buffered *self, Py_ssize_t limit)

{

PyObject *res = NULL;

PyObject *chunks = NULL;

Py_ssize_t n, written = 0;

const char *start, *s, *end;

CHECK_CLOSED(self, "readline of closed file")

/* First, try to find a line in the buffer. This can run unlocked because

n = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);

if (limit >= 0 && n > limit)

n = limit;

start = self->buffer + self->pos;

s = memchr(start, '\n', n);

if (s != NULL) {

res = PyBytes_FromStringAndSize(start, s - start + 1);

if (res != NULL)

self->pos += s - start + 1;

goto end_unlocked;

}

if (n == limit) {

res = PyBytes_FromStringAndSize(start, n);

if (res != NULL)

self->pos += n;

goto end_unlocked;

}

if (!ENTER_BUFFERED(self))

goto end_unlocked;

/* Now we try to get some more from the raw stream */

chunks = PyList_New(0);

if (chunks == NULL)

goto end;

if (n > 0) {

res = PyBytes_FromStringAndSize(start, n);

if (res == NULL)

goto end;

if (PyList_Append(chunks, res) < 0) {

Py_CLEAR(res);

goto end;

}

Py_CLEAR(res);

written += n;

self->pos += n;

if (limit >= 0)

limit -= n;

}

if (self->writable) {

PyObject *r = buffered_flush_and_rewind_unlocked(self);

if (r == NULL)

goto end;

Py_DECREF(r);

}

for (;;) {

_bufferedreader_reset_buf(self);

n = _bufferedreader_fill_buffer(self);

if (n == -1)

goto end;