diff options
Diffstat (limited to 'contrib/tools/python3/src/Modules/_io/bytesio.c')
| -rw-r--r-- | contrib/tools/python3/src/Modules/_io/bytesio.c | 2178 |
1 files changed, 1089 insertions, 1089 deletions
diff --git a/contrib/tools/python3/src/Modules/_io/bytesio.c b/contrib/tools/python3/src/Modules/_io/bytesio.c index 2468f45f941..47471efd436 100644 --- a/contrib/tools/python3/src/Modules/_io/bytesio.c +++ b/contrib/tools/python3/src/Modules/_io/bytesio.c @@ -1,36 +1,36 @@ -#include "Python.h" +#include "Python.h" #include "pycore_object.h" #include <stddef.h> // offsetof() -#include "_iomodule.h" - -/*[clinic input] -module _io -class _io.BytesIO "bytesio *" "&PyBytesIO_Type" -[clinic start generated code]*/ -/*[clinic end generated code: output=da39a3ee5e6b4b0d input=7f50ec034f5c0b26]*/ - -typedef struct { - PyObject_HEAD - PyObject *buf; - Py_ssize_t pos; - Py_ssize_t string_size; - PyObject *dict; - PyObject *weakreflist; - Py_ssize_t exports; -} bytesio; - -typedef struct { - PyObject_HEAD - bytesio *source; -} bytesiobuf; - -/* The bytesio object can be in three states: - * Py_REFCNT(buf) == 1, exports == 0. - * Py_REFCNT(buf) > 1. exports == 0, - first modification or export causes the internal buffer copying. - * exports > 0. Py_REFCNT(buf) == 1, any modifications are forbidden. -*/ - +#include "_iomodule.h" + +/*[clinic input] +module _io +class _io.BytesIO "bytesio *" "&PyBytesIO_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=7f50ec034f5c0b26]*/ + +typedef struct { + PyObject_HEAD + PyObject *buf; + Py_ssize_t pos; + Py_ssize_t string_size; + PyObject *dict; + PyObject *weakreflist; + Py_ssize_t exports; +} bytesio; + +typedef struct { + PyObject_HEAD + bytesio *source; +} bytesiobuf; + +/* The bytesio object can be in three states: + * Py_REFCNT(buf) == 1, exports == 0. + * Py_REFCNT(buf) > 1. exports == 0, + first modification or export causes the internal buffer copying. + * exports > 0. Py_REFCNT(buf) == 1, any modifications are forbidden. +*/ + static int check_closed(bytesio *self) { @@ -52,133 +52,133 @@ check_exports(bytesio *self) return 0; } -#define CHECK_CLOSED(self) \ +#define CHECK_CLOSED(self) \ if (check_closed(self)) { \ - return NULL; \ - } - -#define CHECK_EXPORTS(self) \ + return NULL; \ + } + +#define CHECK_EXPORTS(self) \ if (check_exports(self)) { \ - return NULL; \ - } - -#define SHARED_BUF(self) (Py_REFCNT((self)->buf) > 1) - - -/* Internal routine to get a line from the buffer of a BytesIO - object. Returns the length between the current position to the - next newline character. */ -static Py_ssize_t -scan_eol(bytesio *self, Py_ssize_t len) -{ - const char *start, *n; - Py_ssize_t maxlen; - - assert(self->buf != NULL); - assert(self->pos >= 0); - - if (self->pos >= self->string_size) - return 0; - - /* Move to the end of the line, up to the end of the string, s. */ - maxlen = self->string_size - self->pos; - if (len < 0 || len > maxlen) - len = maxlen; - - if (len) { - start = PyBytes_AS_STRING(self->buf) + self->pos; - n = memchr(start, '\n', len); - if (n) - /* Get the length from the current position to the end of - the line. */ - len = n - start + 1; - } - assert(len >= 0); - assert(self->pos < PY_SSIZE_T_MAX - len); - - return len; -} - -/* Internal routine for detaching the shared buffer of BytesIO objects. - The caller should ensure that the 'size' argument is non-negative and - not lesser than self->string_size. Returns 0 on success, -1 otherwise. */ -static int -unshare_buffer(bytesio *self, size_t size) -{ - PyObject *new_buf; - assert(SHARED_BUF(self)); - assert(self->exports == 0); - assert(size >= (size_t)self->string_size); - new_buf = PyBytes_FromStringAndSize(NULL, size); - if (new_buf == NULL) - return -1; - memcpy(PyBytes_AS_STRING(new_buf), PyBytes_AS_STRING(self->buf), - self->string_size); - Py_SETREF(self->buf, new_buf); - return 0; -} - -/* Internal routine for changing the size of the buffer of BytesIO objects. - The caller should ensure that the 'size' argument is non-negative. Returns - 0 on success, -1 otherwise. */ -static int -resize_buffer(bytesio *self, size_t size) -{ - /* Here, unsigned types are used to avoid dealing with signed integer - overflow, which is undefined in C. */ - size_t alloc = PyBytes_GET_SIZE(self->buf); - - assert(self->buf != NULL); - - /* For simplicity, stay in the range of the signed type. Anyway, Python - doesn't allow strings to be longer than this. */ - if (size > PY_SSIZE_T_MAX) - goto overflow; - - if (size < alloc / 2) { - /* Major downsize; resize down to exact size. */ - alloc = size + 1; - } - else if (size < alloc) { - /* Within allocated size; quick exit */ - return 0; - } - else if (size <= alloc * 1.125) { - /* Moderate upsize; overallocate similar to list_resize() */ - alloc = size + (size >> 3) + (size < 9 ? 3 : 6); - } - else { - /* Major upsize; resize up to exact size */ - alloc = size + 1; - } - - if (alloc > ((size_t)-1) / sizeof(char)) - goto overflow; - - if (SHARED_BUF(self)) { - if (unshare_buffer(self, alloc) < 0) - return -1; - } - else { - if (_PyBytes_Resize(&self->buf, alloc) < 0) - return -1; - } - - return 0; - - overflow: - PyErr_SetString(PyExc_OverflowError, - "new buffer size too large"); - return -1; -} - -/* Internal routine for writing a string of bytes to the buffer of a BytesIO + return NULL; \ + } + +#define SHARED_BUF(self) (Py_REFCNT((self)->buf) > 1) + + +/* Internal routine to get a line from the buffer of a BytesIO + object. Returns the length between the current position to the + next newline character. */ +static Py_ssize_t +scan_eol(bytesio *self, Py_ssize_t len) +{ + const char *start, *n; + Py_ssize_t maxlen; + + assert(self->buf != NULL); + assert(self->pos >= 0); + + if (self->pos >= self->string_size) + return 0; + + /* Move to the end of the line, up to the end of the string, s. */ + maxlen = self->string_size - self->pos; + if (len < 0 || len > maxlen) + len = maxlen; + + if (len) { + start = PyBytes_AS_STRING(self->buf) + self->pos; + n = memchr(start, '\n', len); + if (n) + /* Get the length from the current position to the end of + the line. */ + len = n - start + 1; + } + assert(len >= 0); + assert(self->pos < PY_SSIZE_T_MAX - len); + + return len; +} + +/* Internal routine for detaching the shared buffer of BytesIO objects. + The caller should ensure that the 'size' argument is non-negative and + not lesser than self->string_size. Returns 0 on success, -1 otherwise. */ +static int +unshare_buffer(bytesio *self, size_t size) +{ + PyObject *new_buf; + assert(SHARED_BUF(self)); + assert(self->exports == 0); + assert(size >= (size_t)self->string_size); + new_buf = PyBytes_FromStringAndSize(NULL, size); + if (new_buf == NULL) + return -1; + memcpy(PyBytes_AS_STRING(new_buf), PyBytes_AS_STRING(self->buf), + self->string_size); + Py_SETREF(self->buf, new_buf); + return 0; +} + +/* Internal routine for changing the size of the buffer of BytesIO objects. + The caller should ensure that the 'size' argument is non-negative. Returns + 0 on success, -1 otherwise. */ +static int +resize_buffer(bytesio *self, size_t size) +{ + /* Here, unsigned types are used to avoid dealing with signed integer + overflow, which is undefined in C. */ + size_t alloc = PyBytes_GET_SIZE(self->buf); + + assert(self->buf != NULL); + + /* For simplicity, stay in the range of the signed type. Anyway, Python + doesn't allow strings to be longer than this. */ + if (size > PY_SSIZE_T_MAX) + goto overflow; + + if (size < alloc / 2) { + /* Major downsize; resize down to exact size. */ + alloc = size + 1; + } + else if (size < alloc) { + /* Within allocated size; quick exit */ + return 0; + } + else if (size <= alloc * 1.125) { + /* Moderate upsize; overallocate similar to list_resize() */ + alloc = size + (size >> 3) + (size < 9 ? 3 : 6); + } + else { + /* Major upsize; resize up to exact size */ + alloc = size + 1; + } + + if (alloc > ((size_t)-1) / sizeof(char)) + goto overflow; + + if (SHARED_BUF(self)) { + if (unshare_buffer(self, alloc) < 0) + return -1; + } + else { + if (_PyBytes_Resize(&self->buf, alloc) < 0) + return -1; + } + + return 0; + + overflow: + PyErr_SetString(PyExc_OverflowError, + "new buffer size too large"); + return -1; +} + +/* Internal routine for writing a string of bytes to the buffer of a BytesIO object. Returns the number of bytes written, or -1 on error. Inlining is disabled because it's significantly decreases performance of writelines() in PGO build. */ _Py_NO_INLINE static Py_ssize_t write_bytes(bytesio *self, PyObject *b) -{ +{ if (check_closed(self)) { return -1; } @@ -195,777 +195,777 @@ write_bytes(bytesio *self, PyObject *b) goto done; } - assert(self->pos >= 0); + assert(self->pos >= 0); size_t endpos = (size_t)self->pos + len; - if (endpos > (size_t)PyBytes_GET_SIZE(self->buf)) { + if (endpos > (size_t)PyBytes_GET_SIZE(self->buf)) { if (resize_buffer(self, endpos) < 0) { len = -1; goto done; } - } - else if (SHARED_BUF(self)) { + } + else if (SHARED_BUF(self)) { if (unshare_buffer(self, Py_MAX(endpos, (size_t)self->string_size)) < 0) { len = -1; goto done; } - } - - if (self->pos > self->string_size) { - /* In case of overseek, pad with null bytes the buffer region between - the end of stream and the current position. - - 0 lo string_size hi - | |<---used--->|<----------available----------->| - | | <--to pad-->|<---to write---> | - 0 buf position - */ - memset(PyBytes_AS_STRING(self->buf) + self->string_size, '\0', - (self->pos - self->string_size) * sizeof(char)); - } - - /* Copy the data to the internal buffer, overwriting some of the existing - data if self->pos < self->string_size. */ + } + + if (self->pos > self->string_size) { + /* In case of overseek, pad with null bytes the buffer region between + the end of stream and the current position. + + 0 lo string_size hi + | |<---used--->|<----------available----------->| + | | <--to pad-->|<---to write---> | + 0 buf position + */ + memset(PyBytes_AS_STRING(self->buf) + self->string_size, '\0', + (self->pos - self->string_size) * sizeof(char)); + } + + /* Copy the data to the internal buffer, overwriting some of the existing + data if self->pos < self->string_size. */ memcpy(PyBytes_AS_STRING(self->buf) + self->pos, buf.buf, len); - self->pos = endpos; - - /* Set the new length of the internal string if it has changed. */ - if ((size_t)self->string_size < endpos) { - self->string_size = endpos; - } - + self->pos = endpos; + + /* Set the new length of the internal string if it has changed. */ + if ((size_t)self->string_size < endpos) { + self->string_size = endpos; + } + done: PyBuffer_Release(&buf); - return len; -} - -static PyObject * -bytesio_get_closed(bytesio *self, void *Py_UNUSED(ignored)) -{ - if (self->buf == NULL) { - Py_RETURN_TRUE; - } - else { - Py_RETURN_FALSE; - } -} - -/*[clinic input] -_io.BytesIO.readable - -Returns True if the IO object can be read. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_readable_impl(bytesio *self) -/*[clinic end generated code: output=4e93822ad5b62263 input=96c5d0cccfb29f5c]*/ -{ - CHECK_CLOSED(self); - Py_RETURN_TRUE; -} - -/*[clinic input] -_io.BytesIO.writable - -Returns True if the IO object can be written. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_writable_impl(bytesio *self) -/*[clinic end generated code: output=64ff6a254b1150b8 input=700eed808277560a]*/ -{ - CHECK_CLOSED(self); - Py_RETURN_TRUE; -} - -/*[clinic input] -_io.BytesIO.seekable - -Returns True if the IO object can be seeked. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_seekable_impl(bytesio *self) -/*[clinic end generated code: output=6b417f46dcc09b56 input=9421f65627a344dd]*/ -{ - CHECK_CLOSED(self); - Py_RETURN_TRUE; -} - -/*[clinic input] -_io.BytesIO.flush - -Does nothing. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_flush_impl(bytesio *self) -/*[clinic end generated code: output=187e3d781ca134a0 input=561ea490be4581a7]*/ -{ - CHECK_CLOSED(self); - Py_RETURN_NONE; -} - -/*[clinic input] -_io.BytesIO.getbuffer - -Get a read-write view over the contents of the BytesIO object. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_getbuffer_impl(bytesio *self) -/*[clinic end generated code: output=72cd7c6e13aa09ed input=8f738ef615865176]*/ -{ - PyTypeObject *type = &_PyBytesIOBuffer_Type; - bytesiobuf *buf; - PyObject *view; - - CHECK_CLOSED(self); - - buf = (bytesiobuf *) type->tp_alloc(type, 0); - if (buf == NULL) - return NULL; - Py_INCREF(self); - buf->source = self; - view = PyMemoryView_FromObject((PyObject *) buf); - Py_DECREF(buf); - return view; -} - -/*[clinic input] -_io.BytesIO.getvalue - -Retrieve the entire contents of the BytesIO object. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_getvalue_impl(bytesio *self) -/*[clinic end generated code: output=b3f6a3233c8fd628 input=4b403ac0af3973ed]*/ -{ - CHECK_CLOSED(self); - if (self->string_size <= 1 || self->exports > 0) - return PyBytes_FromStringAndSize(PyBytes_AS_STRING(self->buf), - self->string_size); - - if (self->string_size != PyBytes_GET_SIZE(self->buf)) { - if (SHARED_BUF(self)) { - if (unshare_buffer(self, self->string_size) < 0) - return NULL; - } - else { - if (_PyBytes_Resize(&self->buf, self->string_size) < 0) - return NULL; - } - } - Py_INCREF(self->buf); - return self->buf; -} - -/*[clinic input] -_io.BytesIO.isatty - -Always returns False. - -BytesIO objects are not connected to a TTY-like device. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_isatty_impl(bytesio *self) -/*[clinic end generated code: output=df67712e669f6c8f input=6f97f0985d13f827]*/ -{ - CHECK_CLOSED(self); - Py_RETURN_FALSE; -} - -/*[clinic input] -_io.BytesIO.tell - -Current file position, an integer. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_tell_impl(bytesio *self) -/*[clinic end generated code: output=b54b0f93cd0e5e1d input=b106adf099cb3657]*/ -{ - CHECK_CLOSED(self); - return PyLong_FromSsize_t(self->pos); -} - -static PyObject * -read_bytes(bytesio *self, Py_ssize_t size) -{ + return len; +} + +static PyObject * +bytesio_get_closed(bytesio *self, void *Py_UNUSED(ignored)) +{ + if (self->buf == NULL) { + Py_RETURN_TRUE; + } + else { + Py_RETURN_FALSE; + } +} + +/*[clinic input] +_io.BytesIO.readable + +Returns True if the IO object can be read. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_readable_impl(bytesio *self) +/*[clinic end generated code: output=4e93822ad5b62263 input=96c5d0cccfb29f5c]*/ +{ + CHECK_CLOSED(self); + Py_RETURN_TRUE; +} + +/*[clinic input] +_io.BytesIO.writable + +Returns True if the IO object can be written. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_writable_impl(bytesio *self) +/*[clinic end generated code: output=64ff6a254b1150b8 input=700eed808277560a]*/ +{ + CHECK_CLOSED(self); + Py_RETURN_TRUE; +} + +/*[clinic input] +_io.BytesIO.seekable + +Returns True if the IO object can be seeked. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_seekable_impl(bytesio *self) +/*[clinic end generated code: output=6b417f46dcc09b56 input=9421f65627a344dd]*/ +{ + CHECK_CLOSED(self); + Py_RETURN_TRUE; +} + +/*[clinic input] +_io.BytesIO.flush + +Does nothing. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_flush_impl(bytesio *self) +/*[clinic end generated code: output=187e3d781ca134a0 input=561ea490be4581a7]*/ +{ + CHECK_CLOSED(self); + Py_RETURN_NONE; +} + +/*[clinic input] +_io.BytesIO.getbuffer + +Get a read-write view over the contents of the BytesIO object. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_getbuffer_impl(bytesio *self) +/*[clinic end generated code: output=72cd7c6e13aa09ed input=8f738ef615865176]*/ +{ + PyTypeObject *type = &_PyBytesIOBuffer_Type; + bytesiobuf *buf; + PyObject *view; + + CHECK_CLOSED(self); + + buf = (bytesiobuf *) type->tp_alloc(type, 0); + if (buf == NULL) + return NULL; + Py_INCREF(self); + buf->source = self; + view = PyMemoryView_FromObject((PyObject *) buf); + Py_DECREF(buf); + return view; +} + +/*[clinic input] +_io.BytesIO.getvalue + +Retrieve the entire contents of the BytesIO object. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_getvalue_impl(bytesio *self) +/*[clinic end generated code: output=b3f6a3233c8fd628 input=4b403ac0af3973ed]*/ +{ + CHECK_CLOSED(self); + if (self->string_size <= 1 || self->exports > 0) + return PyBytes_FromStringAndSize(PyBytes_AS_STRING(self->buf), + self->string_size); + + if (self->string_size != PyBytes_GET_SIZE(self->buf)) { + if (SHARED_BUF(self)) { + if (unshare_buffer(self, self->string_size) < 0) + return NULL; + } + else { + if (_PyBytes_Resize(&self->buf, self->string_size) < 0) + return NULL; + } + } + Py_INCREF(self->buf); + return self->buf; +} + +/*[clinic input] +_io.BytesIO.isatty + +Always returns False. + +BytesIO objects are not connected to a TTY-like device. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_isatty_impl(bytesio *self) +/*[clinic end generated code: output=df67712e669f6c8f input=6f97f0985d13f827]*/ +{ + CHECK_CLOSED(self); + Py_RETURN_FALSE; +} + +/*[clinic input] +_io.BytesIO.tell + +Current file position, an integer. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_tell_impl(bytesio *self) +/*[clinic end generated code: output=b54b0f93cd0e5e1d input=b106adf099cb3657]*/ +{ + CHECK_CLOSED(self); + return PyLong_FromSsize_t(self->pos); +} + +static PyObject * +read_bytes(bytesio *self, Py_ssize_t size) +{ const char *output; - - assert(self->buf != NULL); - assert(size <= self->string_size); - if (size > 1 && - self->pos == 0 && size == PyBytes_GET_SIZE(self->buf) && - self->exports == 0) { - self->pos += size; - Py_INCREF(self->buf); - return self->buf; - } - - output = PyBytes_AS_STRING(self->buf) + self->pos; - self->pos += size; - return PyBytes_FromStringAndSize(output, size); -} - -/*[clinic input] -_io.BytesIO.read - size: Py_ssize_t(accept={int, NoneType}) = -1 - / - -Read at most size bytes, returned as a bytes object. - -If the size argument is negative, read until EOF is reached. -Return an empty bytes object at EOF. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_read_impl(bytesio *self, Py_ssize_t size) -/*[clinic end generated code: output=9cc025f21c75bdd2 input=74344a39f431c3d7]*/ -{ - Py_ssize_t n; - - CHECK_CLOSED(self); - - /* adjust invalid sizes */ - n = self->string_size - self->pos; - if (size < 0 || size > n) { - size = n; - if (size < 0) - size = 0; - } - - return read_bytes(self, size); -} - - -/*[clinic input] -_io.BytesIO.read1 - size: Py_ssize_t(accept={int, NoneType}) = -1 - / - -Read at most size bytes, returned as a bytes object. - -If the size argument is negative or omitted, read until EOF is reached. -Return an empty bytes object at EOF. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size) -/*[clinic end generated code: output=d0f843285aa95f1c input=440a395bf9129ef5]*/ -{ - return _io_BytesIO_read_impl(self, size); -} - -/*[clinic input] -_io.BytesIO.readline - size: Py_ssize_t(accept={int, NoneType}) = -1 - / - -Next line from the file, as a bytes object. - -Retain newline. A non-negative size argument limits the maximum -number of bytes to return (an incomplete line may be returned then). -Return an empty bytes object at EOF. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size) -/*[clinic end generated code: output=4bff3c251df8ffcd input=e7c3fbd1744e2783]*/ -{ - Py_ssize_t n; - - CHECK_CLOSED(self); - - n = scan_eol(self, size); - - return read_bytes(self, n); -} - -/*[clinic input] -_io.BytesIO.readlines - size as arg: object = None - / - -List of bytes objects, each a line from the file. - -Call readline() repeatedly and return a list of the lines so read. -The optional size argument, if given, is an approximate bound on the -total number of bytes in the lines returned. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_readlines_impl(bytesio *self, PyObject *arg) -/*[clinic end generated code: output=09b8e34c880808ff input=691aa1314f2c2a87]*/ -{ - Py_ssize_t maxsize, size, n; - PyObject *result, *line; + + assert(self->buf != NULL); + assert(size <= self->string_size); + if (size > 1 && + self->pos == 0 && size == PyBytes_GET_SIZE(self->buf) && + self->exports == 0) { + self->pos += size; + Py_INCREF(self->buf); + return self->buf; + } + + output = PyBytes_AS_STRING(self->buf) + self->pos; + self->pos += size; + return PyBytes_FromStringAndSize(output, size); +} + +/*[clinic input] +_io.BytesIO.read + size: Py_ssize_t(accept={int, NoneType}) = -1 + / + +Read at most size bytes, returned as a bytes object. + +If the size argument is negative, read until EOF is reached. +Return an empty bytes object at EOF. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_read_impl(bytesio *self, Py_ssize_t size) +/*[clinic end generated code: output=9cc025f21c75bdd2 input=74344a39f431c3d7]*/ +{ + Py_ssize_t n; + + CHECK_CLOSED(self); + + /* adjust invalid sizes */ + n = self->string_size - self->pos; + if (size < 0 || size > n) { + size = n; + if (size < 0) + size = 0; + } + + return read_bytes(self, size); +} + + +/*[clinic input] +_io.BytesIO.read1 + size: Py_ssize_t(accept={int, NoneType}) = -1 + / + +Read at most size bytes, returned as a bytes object. + +If the size argument is negative or omitted, read until EOF is reached. +Return an empty bytes object at EOF. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size) +/*[clinic end generated code: output=d0f843285aa95f1c input=440a395bf9129ef5]*/ +{ + return _io_BytesIO_read_impl(self, size); +} + +/*[clinic input] +_io.BytesIO.readline + size: Py_ssize_t(accept={int, NoneType}) = -1 + / + +Next line from the file, as a bytes object. + +Retain newline. A non-negative size argument limits the maximum +number of bytes to return (an incomplete line may be returned then). +Return an empty bytes object at EOF. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size) +/*[clinic end generated code: output=4bff3c251df8ffcd input=e7c3fbd1744e2783]*/ +{ + Py_ssize_t n; + + CHECK_CLOSED(self); + + n = scan_eol(self, size); + + return read_bytes(self, n); +} + +/*[clinic input] +_io.BytesIO.readlines + size as arg: object = None + / + +List of bytes objects, each a line from the file. + +Call readline() repeatedly and return a list of the lines so read. +The optional size argument, if given, is an approximate bound on the +total number of bytes in the lines returned. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_readlines_impl(bytesio *self, PyObject *arg) +/*[clinic end generated code: output=09b8e34c880808ff input=691aa1314f2c2a87]*/ +{ + Py_ssize_t maxsize, size, n; + PyObject *result, *line; const char *output; - - CHECK_CLOSED(self); - - if (PyLong_Check(arg)) { - maxsize = PyLong_AsSsize_t(arg); - if (maxsize == -1 && PyErr_Occurred()) - return NULL; - } - else if (arg == Py_None) { - /* No size limit, by default. */ - maxsize = -1; - } - else { - PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'", - Py_TYPE(arg)->tp_name); - return NULL; - } - - size = 0; - result = PyList_New(0); - if (!result) - return NULL; - - output = PyBytes_AS_STRING(self->buf) + self->pos; - while ((n = scan_eol(self, -1)) != 0) { - self->pos += n; - line = PyBytes_FromStringAndSize(output, n); - if (!line) - goto on_error; - if (PyList_Append(result, line) == -1) { - Py_DECREF(line); - goto on_error; - } - Py_DECREF(line); - size += n; - if (maxsize > 0 && size >= maxsize) - break; - output += n; - } - return result; - - on_error: - Py_DECREF(result); - return NULL; -} - -/*[clinic input] -_io.BytesIO.readinto - buffer: Py_buffer(accept={rwbuffer}) - / - -Read bytes into buffer. - -Returns number of bytes read (0 for EOF), or None if the object -is set not to block and has no data to read. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_readinto_impl(bytesio *self, Py_buffer *buffer) -/*[clinic end generated code: output=a5d407217dcf0639 input=1424d0fdce857919]*/ -{ - Py_ssize_t len, n; - - CHECK_CLOSED(self); - - /* adjust invalid sizes */ - len = buffer->len; - n = self->string_size - self->pos; - if (len > n) { - len = n; - if (len < 0) - len = 0; - } - - memcpy(buffer->buf, PyBytes_AS_STRING(self->buf) + self->pos, len); - assert(self->pos + len < PY_SSIZE_T_MAX); - assert(len >= 0); - self->pos += len; - - return PyLong_FromSsize_t(len); -} - -/*[clinic input] -_io.BytesIO.truncate - size: Py_ssize_t(accept={int, NoneType}, c_default="self->pos") = None - / - -Truncate the file to at most size bytes. - -Size defaults to the current file position, as returned by tell(). -The current file position is unchanged. Returns the new size. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_truncate_impl(bytesio *self, Py_ssize_t size) -/*[clinic end generated code: output=9ad17650c15fa09b input=423759dd42d2f7c1]*/ -{ - CHECK_CLOSED(self); - CHECK_EXPORTS(self); - - if (size < 0) { - PyErr_Format(PyExc_ValueError, - "negative size value %zd", size); - return NULL; - } - - if (size < self->string_size) { - self->string_size = size; - if (resize_buffer(self, size) < 0) - return NULL; - } - - return PyLong_FromSsize_t(size); -} - -static PyObject * -bytesio_iternext(bytesio *self) -{ - Py_ssize_t n; - - CHECK_CLOSED(self); - - n = scan_eol(self, -1); - - if (n == 0) - return NULL; - - return read_bytes(self, n); -} - -/*[clinic input] -_io.BytesIO.seek - pos: Py_ssize_t - whence: int = 0 - / - -Change stream position. - -Seek to byte offset pos relative to position indicated by whence: - 0 Start of stream (the default). pos should be >= 0; - 1 Current position - pos may be negative; - 2 End of stream - pos usually negative. -Returns the new absolute position. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence) -/*[clinic end generated code: output=c26204a68e9190e4 input=1e875e6ebc652948]*/ -{ - CHECK_CLOSED(self); - - if (pos < 0 && whence == 0) { - PyErr_Format(PyExc_ValueError, - "negative seek value %zd", pos); - return NULL; - } - - /* whence = 0: offset relative to beginning of the string. - whence = 1: offset relative to current position. - whence = 2: offset relative the end of the string. */ - if (whence == 1) { - if (pos > PY_SSIZE_T_MAX - self->pos) { - PyErr_SetString(PyExc_OverflowError, - "new position too large"); - return NULL; - } - pos += self->pos; - } - else if (whence == 2) { - if (pos > PY_SSIZE_T_MAX - self->string_size) { - PyErr_SetString(PyExc_OverflowError, - "new position too large"); - return NULL; - } - pos += self->string_size; - } - else if (whence != 0) { - PyErr_Format(PyExc_ValueError, - "invalid whence (%i, should be 0, 1 or 2)", whence); - return NULL; - } - - if (pos < 0) - pos = 0; - self->pos = pos; - - return PyLong_FromSsize_t(self->pos); -} - -/*[clinic input] -_io.BytesIO.write - b: object - / - -Write bytes to file. - -Return the number of bytes written. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_write(bytesio *self, PyObject *b) -/*[clinic end generated code: output=53316d99800a0b95 input=f5ec7c8c64ed720a]*/ -{ + + CHECK_CLOSED(self); + + if (PyLong_Check(arg)) { + maxsize = PyLong_AsSsize_t(arg); + if (maxsize == -1 && PyErr_Occurred()) + return NULL; + } + else if (arg == Py_None) { + /* No size limit, by default. */ + maxsize = -1; + } + else { + PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'", + Py_TYPE(arg)->tp_name); + return NULL; + } + + size = 0; + result = PyList_New(0); + if (!result) + return NULL; + + output = PyBytes_AS_STRING(self->buf) + self->pos; + while ((n = scan_eol(self, -1)) != 0) { + self->pos += n; + line = PyBytes_FromStringAndSize(output, n); + if (!line) + goto on_error; + if (PyList_Append(result, line) == -1) { + Py_DECREF(line); + goto on_error; + } + Py_DECREF(line); + size += n; + if (maxsize > 0 && size >= maxsize) + break; + output += n; + } + return result; + + on_error: + Py_DECREF(result); + return NULL; +} + +/*[clinic input] +_io.BytesIO.readinto + buffer: Py_buffer(accept={rwbuffer}) + / + +Read bytes into buffer. + +Returns number of bytes read (0 for EOF), or None if the object +is set not to block and has no data to read. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_readinto_impl(bytesio *self, Py_buffer *buffer) +/*[clinic end generated code: output=a5d407217dcf0639 input=1424d0fdce857919]*/ +{ + Py_ssize_t len, n; + + CHECK_CLOSED(self); + + /* adjust invalid sizes */ + len = buffer->len; + n = self->string_size - self->pos; + if (len > n) { + len = n; + if (len < 0) + len = 0; + } + + memcpy(buffer->buf, PyBytes_AS_STRING(self->buf) + self->pos, len); + assert(self->pos + len < PY_SSIZE_T_MAX); + assert(len >= 0); + self->pos += len; + + return PyLong_FromSsize_t(len); +} + +/*[clinic input] +_io.BytesIO.truncate + size: Py_ssize_t(accept={int, NoneType}, c_default="self->pos") = None + / + +Truncate the file to at most size bytes. + +Size defaults to the current file position, as returned by tell(). +The current file position is unchanged. Returns the new size. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_truncate_impl(bytesio *self, Py_ssize_t size) +/*[clinic end generated code: output=9ad17650c15fa09b input=423759dd42d2f7c1]*/ +{ + CHECK_CLOSED(self); + CHECK_EXPORTS(self); + + if (size < 0) { + PyErr_Format(PyExc_ValueError, + "negative size value %zd", size); + return NULL; + } + + if (size < self->string_size) { + self->string_size = size; + if (resize_buffer(self, size) < 0) + return NULL; + } + + return PyLong_FromSsize_t(size); +} + +static PyObject * +bytesio_iternext(bytesio *self) +{ + Py_ssize_t n; + + CHECK_CLOSED(self); + + n = scan_eol(self, -1); + + if (n == 0) + return NULL; + + return read_bytes(self, n); +} + +/*[clinic input] +_io.BytesIO.seek + pos: Py_ssize_t + whence: int = 0 + / + +Change stream position. + +Seek to byte offset pos relative to position indicated by whence: + 0 Start of stream (the default). pos should be >= 0; + 1 Current position - pos may be negative; + 2 End of stream - pos usually negative. +Returns the new absolute position. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence) +/*[clinic end generated code: output=c26204a68e9190e4 input=1e875e6ebc652948]*/ +{ + CHECK_CLOSED(self); + + if (pos < 0 && whence == 0) { + PyErr_Format(PyExc_ValueError, + "negative seek value %zd", pos); + return NULL; + } + + /* whence = 0: offset relative to beginning of the string. + whence = 1: offset relative to current position. + whence = 2: offset relative the end of the string. */ + if (whence == 1) { + if (pos > PY_SSIZE_T_MAX - self->pos) { + PyErr_SetString(PyExc_OverflowError, + "new position too large"); + return NULL; + } + pos += self->pos; + } + else if (whence == 2) { + if (pos > PY_SSIZE_T_MAX - self->string_size) { + PyErr_SetString(PyExc_OverflowError, + "new position too large"); + return NULL; + } + pos += self->string_size; + } + else if (whence != 0) { + PyErr_Format(PyExc_ValueError, + "invalid whence (%i, should be 0, 1 or 2)", whence); + return NULL; + } + + if (pos < 0) + pos = 0; + self->pos = pos; + + return PyLong_FromSsize_t(self->pos); +} + +/*[clinic input] +_io.BytesIO.write + b: object + / + +Write bytes to file. + +Return the number of bytes written. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_write(bytesio *self, PyObject *b) +/*[clinic end generated code: output=53316d99800a0b95 input=f5ec7c8c64ed720a]*/ +{ Py_ssize_t n = write_bytes(self, b); - return n >= 0 ? PyLong_FromSsize_t(n) : NULL; -} - -/*[clinic input] -_io.BytesIO.writelines - lines: object - / - -Write lines to the file. - -Note that newlines are not added. lines can be any iterable object -producing bytes-like objects. This is equivalent to calling write() for -each element. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_writelines(bytesio *self, PyObject *lines) -/*[clinic end generated code: output=7f33aa3271c91752 input=e972539176fc8fc1]*/ -{ - PyObject *it, *item; - - CHECK_CLOSED(self); - - it = PyObject_GetIter(lines); - if (it == NULL) - return NULL; - - while ((item = PyIter_Next(it)) != NULL) { + return n >= 0 ? PyLong_FromSsize_t(n) : NULL; +} + +/*[clinic input] +_io.BytesIO.writelines + lines: object + / + +Write lines to the file. + +Note that newlines are not added. lines can be any iterable object +producing bytes-like objects. This is equivalent to calling write() for +each element. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_writelines(bytesio *self, PyObject *lines) +/*[clinic end generated code: output=7f33aa3271c91752 input=e972539176fc8fc1]*/ +{ + PyObject *it, *item; + + CHECK_CLOSED(self); + + it = PyObject_GetIter(lines); + if (it == NULL) + return NULL; + + while ((item = PyIter_Next(it)) != NULL) { Py_ssize_t ret = write_bytes(self, item); - Py_DECREF(item); + Py_DECREF(item); if (ret < 0) { - Py_DECREF(it); - return NULL; - } - } - Py_DECREF(it); - - /* See if PyIter_Next failed */ - if (PyErr_Occurred()) - return NULL; - - Py_RETURN_NONE; -} - -/*[clinic input] -_io.BytesIO.close - -Disable all I/O operations. -[clinic start generated code]*/ - -static PyObject * -_io_BytesIO_close_impl(bytesio *self) -/*[clinic end generated code: output=1471bb9411af84a0 input=37e1f55556e61f60]*/ -{ - CHECK_EXPORTS(self); - Py_CLEAR(self->buf); - Py_RETURN_NONE; -} - -/* Pickling support. - - Note that only pickle protocol 2 and onward are supported since we use - extended __reduce__ API of PEP 307 to make BytesIO instances picklable. - - Providing support for protocol < 2 would require the __reduce_ex__ method - which is notably long-winded when defined properly. - - For BytesIO, the implementation would similar to one coded for - object.__reduce_ex__, but slightly less general. To be more specific, we - could call bytesio_getstate directly and avoid checking for the presence of - a fallback __reduce__ method. However, we would still need a __newobj__ - function to use the efficient instance representation of PEP 307. - */ - -static PyObject * + Py_DECREF(it); + return NULL; + } + } + Py_DECREF(it); + + /* See if PyIter_Next failed */ + if (PyErr_Occurred()) + return NULL; + + Py_RETURN_NONE; +} + +/*[clinic input] +_io.BytesIO.close + +Disable all I/O operations. +[clinic start generated code]*/ + +static PyObject * +_io_BytesIO_close_impl(bytesio *self) +/*[clinic end generated code: output=1471bb9411af84a0 input=37e1f55556e61f60]*/ +{ + CHECK_EXPORTS(self); + Py_CLEAR(self->buf); + Py_RETURN_NONE; +} + +/* Pickling support. + + Note that only pickle protocol 2 and onward are supported since we use + extended __reduce__ API of PEP 307 to make BytesIO instances picklable. + + Providing support for protocol < 2 would require the __reduce_ex__ method + which is notably long-winded when defined properly. + + For BytesIO, the implementation would similar to one coded for + object.__reduce_ex__, but slightly less general. To be more specific, we + could call bytesio_getstate directly and avoid checking for the presence of + a fallback __reduce__ method. However, we would still need a __newobj__ + function to use the efficient instance representation of PEP 307. + */ + +static PyObject * bytesio_getstate(bytesio *self, PyObject *Py_UNUSED(ignored)) -{ - PyObject *initvalue = _io_BytesIO_getvalue_impl(self); - PyObject *dict; - PyObject *state; - - if (initvalue == NULL) - return NULL; - if (self->dict == NULL) { - Py_INCREF(Py_None); - dict = Py_None; - } - else { - dict = PyDict_Copy(self->dict); - if (dict == NULL) { - Py_DECREF(initvalue); - return NULL; - } - } - - state = Py_BuildValue("(OnN)", initvalue, self->pos, dict); - Py_DECREF(initvalue); - return state; -} - -static PyObject * -bytesio_setstate(bytesio *self, PyObject *state) -{ - PyObject *result; - PyObject *position_obj; - PyObject *dict; - Py_ssize_t pos; - - assert(state != NULL); - - /* We allow the state tuple to be longer than 3, because we may need - someday to extend the object's state without breaking - backward-compatibility. */ - if (!PyTuple_Check(state) || PyTuple_GET_SIZE(state) < 3) { - PyErr_Format(PyExc_TypeError, - "%.200s.__setstate__ argument should be 3-tuple, got %.200s", - Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name); - return NULL; - } - CHECK_EXPORTS(self); - /* Reset the object to its default state. This is only needed to handle - the case of repeated calls to __setstate__. */ - self->string_size = 0; - self->pos = 0; - - /* Set the value of the internal buffer. If state[0] does not support the - buffer protocol, bytesio_write will raise the appropriate TypeError. */ - result = _io_BytesIO_write(self, PyTuple_GET_ITEM(state, 0)); - if (result == NULL) - return NULL; - Py_DECREF(result); - - /* Set carefully the position value. Alternatively, we could use the seek - method instead of modifying self->pos directly to better protect the +{ + PyObject *initvalue = _io_BytesIO_getvalue_impl(self); + PyObject *dict; + PyObject *state; + + if (initvalue == NULL) + return NULL; + if (self->dict == NULL) { + Py_INCREF(Py_None); + dict = Py_None; + } + else { + dict = PyDict_Copy(self->dict); + if (dict == NULL) { + Py_DECREF(initvalue); + return NULL; + } + } + + state = Py_BuildValue("(OnN)", initvalue, self->pos, dict); + Py_DECREF(initvalue); + return state; +} + +static PyObject * +bytesio_setstate(bytesio *self, PyObject *state) +{ + PyObject *result; + PyObject *position_obj; + PyObject *dict; + Py_ssize_t pos; + + assert(state != NULL); + + /* We allow the state tuple to be longer than 3, because we may need + someday to extend the object's state without breaking + backward-compatibility. */ + if (!PyTuple_Check(state) || PyTuple_GET_SIZE(state) < 3) { + PyErr_Format(PyExc_TypeError, + "%.200s.__setstate__ argument should be 3-tuple, got %.200s", + Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name); + return NULL; + } + CHECK_EXPORTS(self); + /* Reset the object to its default state. This is only needed to handle + the case of repeated calls to __setstate__. */ + self->string_size = 0; + self->pos = 0; + + /* Set the value of the internal buffer. If state[0] does not support the + buffer protocol, bytesio_write will raise the appropriate TypeError. */ + result = _io_BytesIO_write(self, PyTuple_GET_ITEM(state, 0)); + if (result == NULL) + return NULL; + Py_DECREF(result); + + /* Set carefully the position value. Alternatively, we could use the seek + method instead of modifying self->pos directly to better protect the object internal state against erroneous (or malicious) inputs. */ - position_obj = PyTuple_GET_ITEM(state, 1); - if (!PyLong_Check(position_obj)) { - PyErr_Format(PyExc_TypeError, - "second item of state must be an integer, not %.200s", - Py_TYPE(position_obj)->tp_name); - return NULL; - } - pos = PyLong_AsSsize_t(position_obj); - if (pos == -1 && PyErr_Occurred()) - return NULL; - if (pos < 0) { - PyErr_SetString(PyExc_ValueError, - "position value cannot be negative"); - return NULL; - } - self->pos = pos; - - /* Set the dictionary of the instance variables. */ - dict = PyTuple_GET_ITEM(state, 2); - if (dict != Py_None) { - if (!PyDict_Check(dict)) { - PyErr_Format(PyExc_TypeError, - "third item of state should be a dict, got a %.200s", - Py_TYPE(dict)->tp_name); - return NULL; - } - if (self->dict) { - /* Alternatively, we could replace the internal dictionary - completely. However, it seems more practical to just update it. */ - if (PyDict_Update(self->dict, dict) < 0) - return NULL; - } - else { - Py_INCREF(dict); - self->dict = dict; - } - } - - Py_RETURN_NONE; -} - -static void -bytesio_dealloc(bytesio *self) -{ - _PyObject_GC_UNTRACK(self); - if (self->exports > 0) { - PyErr_SetString(PyExc_SystemError, - "deallocated BytesIO object has exported buffers"); - PyErr_Print(); - } - Py_CLEAR(self->buf); - Py_CLEAR(self->dict); - if (self->weakreflist != NULL) - PyObject_ClearWeakRefs((PyObject *) self); - Py_TYPE(self)->tp_free(self); -} - -static PyObject * -bytesio_new(PyTypeObject *type, PyObject *args, PyObject *kwds) -{ - bytesio *self; - - assert(type != NULL && type->tp_alloc != NULL); - self = (bytesio *)type->tp_alloc(type, 0); - if (self == NULL) - return NULL; - - /* tp_alloc initializes all the fields to zero. So we don't have to - initialize them here. */ - - self->buf = PyBytes_FromStringAndSize(NULL, 0); - if (self->buf == NULL) { - Py_DECREF(self); - return PyErr_NoMemory(); - } - - return (PyObject *)self; -} - -/*[clinic input] -_io.BytesIO.__init__ - initial_bytes as initvalue: object(c_default="NULL") = b'' - -Buffered I/O implementation using an in-memory bytes buffer. -[clinic start generated code]*/ - -static int -_io_BytesIO___init___impl(bytesio *self, PyObject *initvalue) -/*[clinic end generated code: output=65c0c51e24c5b621 input=aac7f31b67bf0fb6]*/ -{ - /* In case, __init__ is called multiple times. */ - self->string_size = 0; - self->pos = 0; - - if (self->exports > 0) { - PyErr_SetString(PyExc_BufferError, - "Existing exports of data: object cannot be re-sized"); - return -1; - } - if (initvalue && initvalue != Py_None) { - if (PyBytes_CheckExact(initvalue)) { - Py_INCREF(initvalue); - Py_XSETREF(self->buf, initvalue); - self->string_size = PyBytes_GET_SIZE(initvalue); - } - else { - PyObject *res; - res = _io_BytesIO_write(self, initvalue); - if (res == NULL) - return -1; - Py_DECREF(res); - self->pos = 0; - } - } - - return 0; -} - -static PyObject * -bytesio_sizeof(bytesio *self, void *unused) -{ - Py_ssize_t res; - - res = _PyObject_SIZE(Py_TYPE(self)); + position_obj = PyTuple_GET_ITEM(state, 1); + if (!PyLong_Check(position_obj)) { + PyErr_Format(PyExc_TypeError, + "second item of state must be an integer, not %.200s", + Py_TYPE(position_obj)->tp_name); + return NULL; + } + pos = PyLong_AsSsize_t(position_obj); + if (pos == -1 && PyErr_Occurred()) + return NULL; + if (pos < 0) { + PyErr_SetString(PyExc_ValueError, + "position value cannot be negative"); + return NULL; + } + self->pos = pos; + + /* Set the dictionary of the instance variables. */ + dict = PyTuple_GET_ITEM(state, 2); + if (dict != Py_None) { + if (!PyDict_Check(dict)) { + PyErr_Format(PyExc_TypeError, + "third item of state should be a dict, got a %.200s", + Py_TYPE(dict)->tp_name); + return NULL; + } + if (self->dict) { + /* Alternatively, we could replace the internal dictionary + completely. However, it seems more practical to just update it. */ + if (PyDict_Update(self->dict, dict) < 0) + return NULL; + } + else { + Py_INCREF(dict); + self->dict = dict; + } + } + + Py_RETURN_NONE; +} + +static void +bytesio_dealloc(bytesio *self) +{ + _PyObject_GC_UNTRACK(self); + if (self->exports > 0) { + PyErr_SetString(PyExc_SystemError, + "deallocated BytesIO object has exported buffers"); + PyErr_Print(); + } + Py_CLEAR(self->buf); + Py_CLEAR(self->dict); + if (self->weakreflist != NULL) + PyObject_ClearWeakRefs((PyObject *) self); + Py_TYPE(self)->tp_free(self); +} + +static PyObject * +bytesio_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + bytesio *self; + + assert(type != NULL && type->tp_alloc != NULL); + self = (bytesio *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + + /* tp_alloc initializes all the fields to zero. So we don't have to + initialize them here. */ + + self->buf = PyBytes_FromStringAndSize(NULL, 0); + if (self->buf == NULL) { + Py_DECREF(self); + return PyErr_NoMemory(); + } + + return (PyObject *)self; +} + +/*[clinic input] +_io.BytesIO.__init__ + initial_bytes as initvalue: object(c_default="NULL") = b'' + +Buffered I/O implementation using an in-memory bytes buffer. +[clinic start generated code]*/ + +static int +_io_BytesIO___init___impl(bytesio *self, PyObject *initvalue) +/*[clinic end generated code: output=65c0c51e24c5b621 input=aac7f31b67bf0fb6]*/ +{ + /* In case, __init__ is called multiple times. */ + self->string_size = 0; + self->pos = 0; + + if (self->exports > 0) { + PyErr_SetString(PyExc_BufferError, + "Existing exports of data: object cannot be re-sized"); + return -1; + } + if (initvalue && initvalue != Py_None) { + if (PyBytes_CheckExact(initvalue)) { + Py_INCREF(initvalue); + Py_XSETREF(self->buf, initvalue); + self->string_size = PyBytes_GET_SIZE(initvalue); + } + else { + PyObject *res; + res = _io_BytesIO_write(self, initvalue); + if (res == NULL) + return -1; + Py_DECREF(res); + self->pos = 0; + } + } + + return 0; +} + +static PyObject * +bytesio_sizeof(bytesio *self, void *unused) +{ + Py_ssize_t res; + + res = _PyObject_SIZE(Py_TYPE(self)); if (self->buf && !SHARED_BUF(self)) { Py_ssize_t s = _PySys_GetSizeOf(self->buf); if (s == -1) { @@ -973,194 +973,194 @@ bytesio_sizeof(bytesio *self, void *unused) } res += s; } - return PyLong_FromSsize_t(res); -} - -static int -bytesio_traverse(bytesio *self, visitproc visit, void *arg) -{ - Py_VISIT(self->dict); - return 0; -} - -static int -bytesio_clear(bytesio *self) -{ - Py_CLEAR(self->dict); - return 0; -} - - -#include "clinic/bytesio.c.h" - -static PyGetSetDef bytesio_getsetlist[] = { - {"closed", (getter)bytesio_get_closed, NULL, - "True if the file is closed."}, - {NULL}, /* sentinel */ -}; - -static struct PyMethodDef bytesio_methods[] = { - _IO_BYTESIO_READABLE_METHODDEF - _IO_BYTESIO_SEEKABLE_METHODDEF - _IO_BYTESIO_WRITABLE_METHODDEF - _IO_BYTESIO_CLOSE_METHODDEF - _IO_BYTESIO_FLUSH_METHODDEF - _IO_BYTESIO_ISATTY_METHODDEF - _IO_BYTESIO_TELL_METHODDEF - _IO_BYTESIO_WRITE_METHODDEF - _IO_BYTESIO_WRITELINES_METHODDEF - _IO_BYTESIO_READ1_METHODDEF - _IO_BYTESIO_READINTO_METHODDEF - _IO_BYTESIO_READLINE_METHODDEF - _IO_BYTESIO_READLINES_METHODDEF - _IO_BYTESIO_READ_METHODDEF - _IO_BYTESIO_GETBUFFER_METHODDEF - _IO_BYTESIO_GETVALUE_METHODDEF - _IO_BYTESIO_SEEK_METHODDEF - _IO_BYTESIO_TRUNCATE_METHODDEF - {"__getstate__", (PyCFunction)bytesio_getstate, METH_NOARGS, NULL}, - {"__setstate__", (PyCFunction)bytesio_setstate, METH_O, NULL}, - {"__sizeof__", (PyCFunction)bytesio_sizeof, METH_NOARGS, NULL}, - {NULL, NULL} /* sentinel */ -}; - -PyTypeObject PyBytesIO_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_io.BytesIO", /*tp_name*/ - sizeof(bytesio), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor)bytesio_dealloc, /*tp_dealloc*/ + return PyLong_FromSsize_t(res); +} + +static int +bytesio_traverse(bytesio *self, visitproc visit, void *arg) +{ + Py_VISIT(self->dict); + return 0; +} + +static int +bytesio_clear(bytesio *self) +{ + Py_CLEAR(self->dict); + return 0; +} + + +#include "clinic/bytesio.c.h" + +static PyGetSetDef bytesio_getsetlist[] = { + {"closed", (getter)bytesio_get_closed, NULL, + "True if the file is closed."}, + {NULL}, /* sentinel */ +}; + +static struct PyMethodDef bytesio_methods[] = { + _IO_BYTESIO_READABLE_METHODDEF + _IO_BYTESIO_SEEKABLE_METHODDEF + _IO_BYTESIO_WRITABLE_METHODDEF + _IO_BYTESIO_CLOSE_METHODDEF + _IO_BYTESIO_FLUSH_METHODDEF + _IO_BYTESIO_ISATTY_METHODDEF + _IO_BYTESIO_TELL_METHODDEF + _IO_BYTESIO_WRITE_METHODDEF + _IO_BYTESIO_WRITELINES_METHODDEF + _IO_BYTESIO_READ1_METHODDEF + _IO_BYTESIO_READINTO_METHODDEF + _IO_BYTESIO_READLINE_METHODDEF + _IO_BYTESIO_READLINES_METHODDEF + _IO_BYTESIO_READ_METHODDEF + _IO_BYTESIO_GETBUFFER_METHODDEF + _IO_BYTESIO_GETVALUE_METHODDEF + _IO_BYTESIO_SEEK_METHODDEF + _IO_BYTESIO_TRUNCATE_METHODDEF + {"__getstate__", (PyCFunction)bytesio_getstate, METH_NOARGS, NULL}, + {"__setstate__", (PyCFunction)bytesio_setstate, METH_O, NULL}, + {"__sizeof__", (PyCFunction)bytesio_sizeof, METH_NOARGS, NULL}, + {NULL, NULL} /* sentinel */ +}; + +PyTypeObject PyBytesIO_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_io.BytesIO", /*tp_name*/ + sizeof(bytesio), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)bytesio_dealloc, /*tp_dealloc*/ 0, /*tp_vectorcall_offset*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ 0, /*tp_as_async*/ - 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 | - Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - _io_BytesIO___init____doc__, /*tp_doc*/ - (traverseproc)bytesio_traverse, /*tp_traverse*/ - (inquiry)bytesio_clear, /*tp_clear*/ - 0, /*tp_richcompare*/ - offsetof(bytesio, weakreflist), /*tp_weaklistoffset*/ - PyObject_SelfIter, /*tp_iter*/ - (iternextfunc)bytesio_iternext, /*tp_iternext*/ - bytesio_methods, /*tp_methods*/ - 0, /*tp_members*/ - bytesio_getsetlist, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - offsetof(bytesio, dict), /*tp_dictoffset*/ - _io_BytesIO___init__, /*tp_init*/ - 0, /*tp_alloc*/ - bytesio_new, /*tp_new*/ -}; - - -/* - * Implementation of the small intermediate object used by getbuffer(). - * getbuffer() returns a memoryview over this object, which should make it - * invisible from Python code. - */ - -static int -bytesiobuf_getbuffer(bytesiobuf *obj, Py_buffer *view, int flags) -{ - bytesio *b = (bytesio *) obj->source; - - if (view == NULL) { - PyErr_SetString(PyExc_BufferError, - "bytesiobuf_getbuffer: view==NULL argument is obsolete"); - return -1; - } - if (SHARED_BUF(b)) { - if (unshare_buffer(b, b->string_size) < 0) - return -1; - } - - /* cannot fail if view != NULL and readonly == 0 */ - (void)PyBuffer_FillInfo(view, (PyObject*)obj, - PyBytes_AS_STRING(b->buf), b->string_size, - 0, flags); - b->exports++; - return 0; -} - -static void -bytesiobuf_releasebuffer(bytesiobuf *obj, Py_buffer *view) -{ - bytesio *b = (bytesio *) obj->source; - b->exports--; -} - -static int -bytesiobuf_traverse(bytesiobuf *self, visitproc visit, void *arg) -{ - Py_VISIT(self->source); - return 0; -} - -static void -bytesiobuf_dealloc(bytesiobuf *self) -{ - /* bpo-31095: UnTrack is needed before calling any callbacks */ - PyObject_GC_UnTrack(self); - Py_CLEAR(self->source); - Py_TYPE(self)->tp_free(self); -} - -static PyBufferProcs bytesiobuf_as_buffer = { - (getbufferproc) bytesiobuf_getbuffer, - (releasebufferproc) bytesiobuf_releasebuffer, -}; - + 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 | + Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + _io_BytesIO___init____doc__, /*tp_doc*/ + (traverseproc)bytesio_traverse, /*tp_traverse*/ + (inquiry)bytesio_clear, /*tp_clear*/ + 0, /*tp_richcompare*/ + offsetof(bytesio, weakreflist), /*tp_weaklistoffset*/ + PyObject_SelfIter, /*tp_iter*/ + (iternextfunc)bytesio_iternext, /*tp_iternext*/ + bytesio_methods, /*tp_methods*/ + 0, /*tp_members*/ + bytesio_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + offsetof(bytesio, dict), /*tp_dictoffset*/ + _io_BytesIO___init__, /*tp_init*/ + 0, /*tp_alloc*/ + bytesio_new, /*tp_new*/ +}; + + +/* + * Implementation of the small intermediate object used by getbuffer(). + * getbuffer() returns a memoryview over this object, which should make it + * invisible from Python code. + */ + +static int +bytesiobuf_getbuffer(bytesiobuf *obj, Py_buffer *view, int flags) +{ + bytesio *b = (bytesio *) obj->source; + + if (view == NULL) { + PyErr_SetString(PyExc_BufferError, + "bytesiobuf_getbuffer: view==NULL argument is obsolete"); + return -1; + } + if (SHARED_BUF(b)) { + if (unshare_buffer(b, b->string_size) < 0) + return -1; + } + + /* cannot fail if view != NULL and readonly == 0 */ + (void)PyBuffer_FillInfo(view, (PyObject*)obj, + PyBytes_AS_STRING(b->buf), b->string_size, + 0, flags); + b->exports++; + return 0; +} + +static void +bytesiobuf_releasebuffer(bytesiobuf *obj, Py_buffer *view) +{ + bytesio *b = (bytesio *) obj->source; + b->exports--; +} + +static int +bytesiobuf_traverse(bytesiobuf *self, visitproc visit, void *arg) +{ + Py_VISIT(self->source); + return 0; +} + +static void +bytesiobuf_dealloc(bytesiobuf *self) +{ + /* bpo-31095: UnTrack is needed before calling any callbacks */ + PyObject_GC_UnTrack(self); + Py_CLEAR(self->source); + Py_TYPE(self)->tp_free(self); +} + +static PyBufferProcs bytesiobuf_as_buffer = { + (getbufferproc) bytesiobuf_getbuffer, + (releasebufferproc) bytesiobuf_releasebuffer, +}; + Py_EXPORTED_SYMBOL PyTypeObject _PyBytesIOBuffer_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_io._BytesIOBuffer", /*tp_name*/ - sizeof(bytesiobuf), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor)bytesiobuf_dealloc, /*tp_dealloc*/ + PyVarObject_HEAD_INIT(NULL, 0) + "_io._BytesIOBuffer", /*tp_name*/ + sizeof(bytesiobuf), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)bytesiobuf_dealloc, /*tp_dealloc*/ 0, /*tp_vectorcall_offset*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ 0, /*tp_as_async*/ - 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*/ - &bytesiobuf_as_buffer, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - (traverseproc)bytesiobuf_traverse, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*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*/ -}; + 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*/ + &bytesiobuf_as_buffer, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + (traverseproc)bytesiobuf_traverse, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*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*/ +}; |