| #include "Python.h" |
| #include "structmember.h" /* for 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. |
| */ |
| |
| #define CHECK_CLOSED(self) \ |
| if ((self)->buf == NULL) { \ |
| PyErr_SetString(PyExc_ValueError, \ |
| "I/O operation on closed file."); \ |
| return NULL; \ |
| } |
| |
| #define CHECK_EXPORTS(self) \ |
| if ((self)->exports > 0) { \ |
| PyErr_SetString(PyExc_BufferError, \ |
| "Existing exports of data: object cannot be re-sized"); \ |
| 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, *old_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); |
| old_buf = self->buf; |
| self->buf = new_buf; |
| Py_DECREF(old_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. */ |
| static Py_ssize_t |
| write_bytes(bytesio *self, const char *bytes, Py_ssize_t len) |
| { |
| size_t endpos; |
| assert(self->buf != NULL); |
| assert(self->pos >= 0); |
| assert(len >= 0); |
| |
| endpos = (size_t)self->pos + len; |
| if (endpos > (size_t)PyBytes_GET_SIZE(self->buf)) { |
| if (resize_buffer(self, endpos) < 0) |
| return -1; |
| } |
| else if (SHARED_BUF(self)) { |
| if (unshare_buffer(self, Py_MAX(endpos, (size_t)self->string_size)) < 0) |
| return -1; |
| } |
| |
| 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, bytes, 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; |
| } |
| |
| return len; |
| } |
| |
| static PyObject * |
| bytesio_get_closed(bytesio *self) |
| { |
| 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) |
| { |
| 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 as arg: object = None |
| / |
| |
| 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, PyObject *arg) |
| /*[clinic end generated code: output=85dacb535c1e1781 input=cc7ba4a797bb1555]*/ |
| { |
| Py_ssize_t size, n; |
| |
| CHECK_CLOSED(self); |
| |
| if (PyLong_Check(arg)) { |
| size = PyLong_AsSsize_t(arg); |
| if (size == -1 && PyErr_Occurred()) |
| return NULL; |
| } |
| else if (arg == Py_None) { |
| /* Read until EOF is reached, by default. */ |
| size = -1; |
| } |
| else { |
| PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'", |
| Py_TYPE(arg)->tp_name); |
| return NULL; |
| } |
| |
| /* 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: object |
| / |
| |
| 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(bytesio *self, PyObject *size) |
| /*[clinic end generated code: output=16021f5d0ac3d4e2 input=d4f40bb8f2f99418]*/ |
| { |
| return _io_BytesIO_read_impl(self, size); |
| } |
| |
| /*[clinic input] |
| _io.BytesIO.readline |
| size as arg: object = None |
| / |
| |
| 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, PyObject *arg) |
| /*[clinic end generated code: output=1c2115534a4f9276 input=ca31f06de6eab257]*/ |
| { |
| Py_ssize_t size, n; |
| |
| CHECK_CLOSED(self); |
| |
| if (PyLong_Check(arg)) { |
| size = PyLong_AsSsize_t(arg); |
| if (size == -1 && PyErr_Occurred()) |
| return NULL; |
| } |
| else if (arg == Py_None) { |
| /* No size limit, by default. */ |
| size = -1; |
| } |
| else { |
| PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'", |
| Py_TYPE(arg)->tp_name); |
| return NULL; |
| } |
| |
| 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; |
| 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 up to len(buffer) bytes into buffer. |
| |
| Returns number of bytes read (0 for EOF), or None if the object |
| is set not to block as 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=71581f32635c3a31]*/ |
| { |
| 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 as arg: object = 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, PyObject *arg) |
| /*[clinic end generated code: output=81e6be60e67ddd66 input=11ed1966835462ba]*/ |
| { |
| Py_ssize_t size; |
| |
| CHECK_CLOSED(self); |
| CHECK_EXPORTS(self); |
| |
| if (PyLong_Check(arg)) { |
| size = PyLong_AsSsize_t(arg); |
| if (size == -1 && PyErr_Occurred()) |
| return NULL; |
| } |
| else if (arg == Py_None) { |
| /* Truncate to current position if no argument is passed. */ |
| size = self->pos; |
| } |
| else { |
| PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'", |
| Py_TYPE(arg)->tp_name); |
| return NULL; |
| } |
| |
| 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 = 0; |
| Py_buffer buf; |
| |
| CHECK_CLOSED(self); |
| CHECK_EXPORTS(self); |
| |
| if (PyObject_GetBuffer(b, &buf, PyBUF_CONTIG_RO) < 0) |
| return NULL; |
| |
| if (buf.len != 0) |
| n = write_bytes(self, buf.buf, buf.len); |
| |
| PyBuffer_Release(&buf); |
| 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; |
| PyObject *ret; |
| |
| CHECK_CLOSED(self); |
| |
| it = PyObject_GetIter(lines); |
| if (it == NULL) |
| return NULL; |
| |
| while ((item = PyIter_Next(it)) != NULL) { |
| ret = _io_BytesIO_write(self, item); |
| Py_DECREF(item); |
| if (ret == NULL) { |
| Py_DECREF(it); |
| return NULL; |
| } |
| Py_DECREF(ret); |
| } |
| 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 *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) || Py_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 errneous (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)); |
| if (self->buf && !SHARED_BUF(self)) |
| res += _PySys_GetSizeOf(self->buf); |
| 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_print*/ |
| 0, /*tp_getattr*/ |
| 0, /*tp_setattr*/ |
| 0, /*tp_reserved*/ |
| 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) |
| { |
| Py_CLEAR(self->source); |
| Py_TYPE(self)->tp_free(self); |
| } |
| |
| static PyBufferProcs bytesiobuf_as_buffer = { |
| (getbufferproc) bytesiobuf_getbuffer, |
| (releasebufferproc) bytesiobuf_releasebuffer, |
| }; |
| |
| PyTypeObject _PyBytesIOBuffer_Type = { |
| PyVarObject_HEAD_INIT(NULL, 0) |
| "_io._BytesIOBuffer", /*tp_name*/ |
| sizeof(bytesiobuf), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| (destructor)bytesiobuf_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| 0, /*tp_getattr*/ |
| 0, /*tp_setattr*/ |
| 0, /*tp_reserved*/ |
| 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*/ |
| }; |