--- /dev/null
+#define PY_SSIZE_T_CLEAN\r
+#include "Python.h"\r
+#include "structmember.h"\r
+#include "_iomodule.h"\r
+\r
+/* Implementation note: the buffer is always at least one character longer\r
+ than the enclosed string, for proper functioning of _PyIO_find_line_ending.\r
+*/\r
+\r
+typedef struct {\r
+ PyObject_HEAD\r
+ Py_UNICODE *buf;\r
+ Py_ssize_t pos;\r
+ Py_ssize_t string_size;\r
+ size_t buf_size;\r
+\r
+ char ok; /* initialized? */\r
+ char closed;\r
+ char readuniversal;\r
+ char readtranslate;\r
+ PyObject *decoder;\r
+ PyObject *readnl;\r
+ PyObject *writenl;\r
+ \r
+ PyObject *dict;\r
+ PyObject *weakreflist;\r
+} stringio;\r
+\r
+#define CHECK_INITIALIZED(self) \\r
+ if (self->ok <= 0) { \\r
+ PyErr_SetString(PyExc_ValueError, \\r
+ "I/O operation on uninitialized object"); \\r
+ return NULL; \\r
+ }\r
+\r
+#define CHECK_CLOSED(self) \\r
+ if (self->closed) { \\r
+ PyErr_SetString(PyExc_ValueError, \\r
+ "I/O operation on closed file"); \\r
+ return NULL; \\r
+ }\r
+\r
+PyDoc_STRVAR(stringio_doc,\r
+ "Text I/O implementation using an in-memory buffer.\n"\r
+ "\n"\r
+ "The initial_value argument sets the value of object. The newline\n"\r
+ "argument is like the one of TextIOWrapper's constructor.");\r
+\r
+\r
+/* Internal routine for changing the size, in terms of characters, of the\r
+ buffer of StringIO objects. The caller should ensure that the 'size'\r
+ argument is non-negative. Returns 0 on success, -1 otherwise. */\r
+static int\r
+resize_buffer(stringio *self, size_t size)\r
+{\r
+ /* Here, unsigned types are used to avoid dealing with signed integer\r
+ overflow, which is undefined in C. */\r
+ size_t alloc = self->buf_size;\r
+ Py_UNICODE *new_buf = NULL;\r
+\r
+ assert(self->buf != NULL);\r
+\r
+ /* Reserve one more char for line ending detection. */\r
+ size = size + 1;\r
+ /* For simplicity, stay in the range of the signed type. Anyway, Python\r
+ doesn't allow strings to be longer than this. */\r
+ if (size > PY_SSIZE_T_MAX)\r
+ goto overflow;\r
+\r
+ if (size < alloc / 2) {\r
+ /* Major downsize; resize down to exact size. */\r
+ alloc = size + 1;\r
+ }\r
+ else if (size < alloc) {\r
+ /* Within allocated size; quick exit */\r
+ return 0;\r
+ }\r
+ else if (size <= alloc * 1.125) {\r
+ /* Moderate upsize; overallocate similar to list_resize() */\r
+ alloc = size + (size >> 3) + (size < 9 ? 3 : 6);\r
+ }\r
+ else {\r
+ /* Major upsize; resize up to exact size */\r
+ alloc = size + 1;\r
+ }\r
+\r
+ if (alloc > ((size_t)-1) / sizeof(Py_UNICODE))\r
+ goto overflow;\r
+ new_buf = (Py_UNICODE *)PyMem_Realloc(self->buf,\r
+ alloc * sizeof(Py_UNICODE));\r
+ if (new_buf == NULL) {\r
+ PyErr_NoMemory();\r
+ return -1;\r
+ }\r
+ self->buf_size = alloc;\r
+ self->buf = new_buf;\r
+\r
+ return 0;\r
+\r
+ overflow:\r
+ PyErr_SetString(PyExc_OverflowError,\r
+ "new buffer size too large");\r
+ return -1;\r
+}\r
+\r
+/* Internal routine for writing a whole PyUnicode object to the buffer of a\r
+ StringIO object. Returns 0 on success, or -1 on error. */\r
+static Py_ssize_t\r
+write_str(stringio *self, PyObject *obj)\r
+{\r
+ Py_UNICODE *str;\r
+ Py_ssize_t len;\r
+ PyObject *decoded = NULL;\r
+ assert(self->buf != NULL);\r
+ assert(self->pos >= 0);\r
+\r
+ if (self->decoder != NULL) {\r
+ decoded = _PyIncrementalNewlineDecoder_decode(\r
+ self->decoder, obj, 1 /* always final */);\r
+ }\r
+ else {\r
+ decoded = obj;\r
+ Py_INCREF(decoded);\r
+ }\r
+ if (self->writenl) {\r
+ PyObject *translated = PyUnicode_Replace(\r
+ decoded, _PyIO_str_nl, self->writenl, -1);\r
+ Py_DECREF(decoded);\r
+ decoded = translated;\r
+ }\r
+ if (decoded == NULL)\r
+ return -1;\r
+\r
+ assert(PyUnicode_Check(decoded));\r
+ str = PyUnicode_AS_UNICODE(decoded);\r
+ len = PyUnicode_GET_SIZE(decoded);\r
+\r
+ assert(len >= 0);\r
+\r
+ /* This overflow check is not strictly necessary. However, it avoids us to\r
+ deal with funky things like comparing an unsigned and a signed\r
+ integer. */\r
+ if (self->pos > PY_SSIZE_T_MAX - len) {\r
+ PyErr_SetString(PyExc_OverflowError,\r
+ "new position too large");\r
+ goto fail;\r
+ }\r
+ if (self->pos + len > self->string_size) {\r
+ if (resize_buffer(self, self->pos + len) < 0)\r
+ goto fail;\r
+ }\r
+\r
+ if (self->pos > self->string_size) {\r
+ /* In case of overseek, pad with null bytes the buffer region between\r
+ the end of stream and the current position.\r
+\r
+ 0 lo string_size hi\r
+ | |<---used--->|<----------available----------->|\r
+ | | <--to pad-->|<---to write---> |\r
+ 0 buf position\r
+\r
+ */\r
+ memset(self->buf + self->string_size, '\0',\r
+ (self->pos - self->string_size) * sizeof(Py_UNICODE));\r
+ }\r
+\r
+ /* Copy the data to the internal buffer, overwriting some of the\r
+ existing data if self->pos < self->string_size. */\r
+ memcpy(self->buf + self->pos, str, len * sizeof(Py_UNICODE));\r
+ self->pos += len;\r
+\r
+ /* Set the new length of the internal string if it has changed. */\r
+ if (self->string_size < self->pos) {\r
+ self->string_size = self->pos;\r
+ }\r
+\r
+ Py_DECREF(decoded);\r
+ return 0;\r
+\r
+fail:\r
+ Py_XDECREF(decoded);\r
+ return -1;\r
+}\r
+\r
+PyDoc_STRVAR(stringio_getvalue_doc,\r
+ "Retrieve the entire contents of the object.");\r
+\r
+static PyObject *\r
+stringio_getvalue(stringio *self)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+ return PyUnicode_FromUnicode(self->buf, self->string_size);\r
+}\r
+\r
+PyDoc_STRVAR(stringio_tell_doc,\r
+ "Tell the current file position.");\r
+\r
+static PyObject *\r
+stringio_tell(stringio *self)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+ return PyLong_FromSsize_t(self->pos);\r
+}\r
+\r
+PyDoc_STRVAR(stringio_read_doc,\r
+ "Read at most n characters, returned as a string.\n"\r
+ "\n"\r
+ "If the argument is negative or omitted, read until EOF\n"\r
+ "is reached. Return an empty string at EOF.\n");\r
+\r
+static PyObject *\r
+stringio_read(stringio *self, PyObject *args)\r
+{\r
+ Py_ssize_t size, n;\r
+ Py_UNICODE *output;\r
+ PyObject *arg = Py_None;\r
+\r
+ CHECK_INITIALIZED(self);\r
+ if (!PyArg_ParseTuple(args, "|O:read", &arg))\r
+ return NULL;\r
+ CHECK_CLOSED(self);\r
+\r
+ if (PyNumber_Check(arg)) {\r
+ size = PyNumber_AsSsize_t(arg, PyExc_OverflowError);\r
+ if (size == -1 && PyErr_Occurred())\r
+ return NULL;\r
+ }\r
+ else if (arg == Py_None) {\r
+ /* Read until EOF is reached, by default. */\r
+ size = -1;\r
+ }\r
+ else {\r
+ PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",\r
+ Py_TYPE(arg)->tp_name);\r
+ return NULL;\r
+ }\r
+\r
+ /* adjust invalid sizes */\r
+ n = self->string_size - self->pos;\r
+ if (size < 0 || size > n) {\r
+ size = n;\r
+ if (size < 0)\r
+ size = 0;\r
+ }\r
+\r
+ output = self->buf + self->pos;\r
+ self->pos += size;\r
+ return PyUnicode_FromUnicode(output, size);\r
+}\r
+\r
+/* Internal helper, used by stringio_readline and stringio_iternext */\r
+static PyObject *\r
+_stringio_readline(stringio *self, Py_ssize_t limit)\r
+{\r
+ Py_UNICODE *start, *end, old_char;\r
+ Py_ssize_t len, consumed;\r
+\r
+ /* In case of overseek, return the empty string */\r
+ if (self->pos >= self->string_size)\r
+ return PyUnicode_FromString("");\r
+\r
+ start = self->buf + self->pos;\r
+ if (limit < 0 || limit > self->string_size - self->pos)\r
+ limit = self->string_size - self->pos;\r
+\r
+ end = start + limit;\r
+ old_char = *end;\r
+ *end = '\0';\r
+ len = _PyIO_find_line_ending(\r
+ self->readtranslate, self->readuniversal, self->readnl,\r
+ start, end, &consumed);\r
+ *end = old_char;\r
+ /* If we haven't found any line ending, we just return everything\r
+ (`consumed` is ignored). */\r
+ if (len < 0)\r
+ len = limit;\r
+ self->pos += len;\r
+ return PyUnicode_FromUnicode(start, len);\r
+}\r
+\r
+PyDoc_STRVAR(stringio_readline_doc,\r
+ "Read until newline or EOF.\n"\r
+ "\n"\r
+ "Returns an empty string if EOF is hit immediately.\n");\r
+\r
+static PyObject *\r
+stringio_readline(stringio *self, PyObject *args)\r
+{\r
+ PyObject *arg = Py_None;\r
+ Py_ssize_t limit = -1;\r
+\r
+ CHECK_INITIALIZED(self);\r
+ if (!PyArg_ParseTuple(args, "|O:readline", &arg))\r
+ return NULL;\r
+ CHECK_CLOSED(self);\r
+\r
+ if (PyNumber_Check(arg)) {\r
+ limit = PyNumber_AsSsize_t(arg, PyExc_OverflowError);\r
+ if (limit == -1 && PyErr_Occurred())\r
+ return NULL;\r
+ }\r
+ else if (arg != Py_None) {\r
+ PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",\r
+ Py_TYPE(arg)->tp_name);\r
+ return NULL;\r
+ }\r
+ return _stringio_readline(self, limit);\r
+}\r
+\r
+static PyObject *\r
+stringio_iternext(stringio *self)\r
+{\r
+ PyObject *line;\r
+\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+\r
+ if (Py_TYPE(self) == &PyStringIO_Type) {\r
+ /* Skip method call overhead for speed */\r
+ line = _stringio_readline(self, -1);\r
+ }\r
+ else {\r
+ /* XXX is subclassing StringIO really supported? */\r
+ line = PyObject_CallMethodObjArgs((PyObject *)self,\r
+ _PyIO_str_readline, NULL);\r
+ if (line && !PyUnicode_Check(line)) {\r
+ PyErr_Format(PyExc_IOError,\r
+ "readline() should have returned an str object, "\r
+ "not '%.200s'", Py_TYPE(line)->tp_name);\r
+ Py_DECREF(line);\r
+ return NULL;\r
+ }\r
+ }\r
+\r
+ if (line == NULL)\r
+ return NULL;\r
+\r
+ if (PyUnicode_GET_SIZE(line) == 0) {\r
+ /* Reached EOF */\r
+ Py_DECREF(line);\r
+ return NULL;\r
+ }\r
+\r
+ return line;\r
+}\r
+\r
+PyDoc_STRVAR(stringio_truncate_doc,\r
+ "Truncate size to pos.\n"\r
+ "\n"\r
+ "The pos argument defaults to the current file position, as\n"\r
+ "returned by tell(). The current file position is unchanged.\n"\r
+ "Returns the new absolute position.\n");\r
+\r
+static PyObject *\r
+stringio_truncate(stringio *self, PyObject *args)\r
+{\r
+ Py_ssize_t size;\r
+ PyObject *arg = Py_None;\r
+\r
+ CHECK_INITIALIZED(self);\r
+ if (!PyArg_ParseTuple(args, "|O:truncate", &arg))\r
+ return NULL;\r
+ CHECK_CLOSED(self);\r
+\r
+ if (PyNumber_Check(arg)) {\r
+ size = PyNumber_AsSsize_t(arg, PyExc_OverflowError);\r
+ if (size == -1 && PyErr_Occurred())\r
+ return NULL;\r
+ }\r
+ else if (arg == Py_None) {\r
+ /* Truncate to current position if no argument is passed. */\r
+ size = self->pos;\r
+ }\r
+ else {\r
+ PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",\r
+ Py_TYPE(arg)->tp_name);\r
+ return NULL;\r
+ }\r
+\r
+ if (size < 0) {\r
+ PyErr_Format(PyExc_ValueError,\r
+ "Negative size value %zd", size);\r
+ return NULL;\r
+ }\r
+\r
+ if (size < self->string_size) {\r
+ if (resize_buffer(self, size) < 0)\r
+ return NULL;\r
+ self->string_size = size;\r
+ }\r
+\r
+ return PyLong_FromSsize_t(size);\r
+}\r
+\r
+PyDoc_STRVAR(stringio_seek_doc,\r
+ "Change stream position.\n"\r
+ "\n"\r
+ "Seek to character offset pos relative to position indicated by whence:\n"\r
+ " 0 Start of stream (the default). pos should be >= 0;\n"\r
+ " 1 Current position - pos must be 0;\n"\r
+ " 2 End of stream - pos must be 0.\n"\r
+ "Returns the new absolute position.\n");\r
+\r
+static PyObject *\r
+stringio_seek(stringio *self, PyObject *args)\r
+{\r
+ PyObject *posobj;\r
+ Py_ssize_t pos;\r
+ int mode = 0;\r
+\r
+ CHECK_INITIALIZED(self);\r
+ if (!PyArg_ParseTuple(args, "O|i:seek", &posobj, &mode))\r
+ return NULL;\r
+\r
+ pos = PyNumber_AsSsize_t(posobj, PyExc_OverflowError);\r
+ if (pos == -1 && PyErr_Occurred())\r
+ return NULL;\r
+ \r
+ CHECK_CLOSED(self);\r
+\r
+ if (mode != 0 && mode != 1 && mode != 2) {\r
+ PyErr_Format(PyExc_ValueError,\r
+ "Invalid whence (%i, should be 0, 1 or 2)", mode);\r
+ return NULL;\r
+ }\r
+ else if (pos < 0 && mode == 0) {\r
+ PyErr_Format(PyExc_ValueError,\r
+ "Negative seek position %zd", pos);\r
+ return NULL;\r
+ }\r
+ else if (mode != 0 && pos != 0) {\r
+ PyErr_SetString(PyExc_IOError,\r
+ "Can't do nonzero cur-relative seeks");\r
+ return NULL;\r
+ }\r
+\r
+ /* mode 0: offset relative to beginning of the string.\r
+ mode 1: no change to current position.\r
+ mode 2: change position to end of file. */\r
+ if (mode == 1) {\r
+ pos = self->pos;\r
+ }\r
+ else if (mode == 2) {\r
+ pos = self->string_size;\r
+ }\r
+\r
+ self->pos = pos;\r
+\r
+ return PyLong_FromSsize_t(self->pos);\r
+}\r
+\r
+PyDoc_STRVAR(stringio_write_doc,\r
+ "Write string to file.\n"\r
+ "\n"\r
+ "Returns the number of characters written, which is always equal to\n"\r
+ "the length of the string.\n");\r
+\r
+static PyObject *\r
+stringio_write(stringio *self, PyObject *obj)\r
+{\r
+ Py_ssize_t size;\r
+\r
+ CHECK_INITIALIZED(self);\r
+ if (!PyUnicode_Check(obj)) {\r
+ PyErr_Format(PyExc_TypeError, "unicode argument expected, got '%s'",\r
+ Py_TYPE(obj)->tp_name);\r
+ return NULL;\r
+ }\r
+ CHECK_CLOSED(self);\r
+ size = PyUnicode_GET_SIZE(obj);\r
+\r
+ if (size > 0 && write_str(self, obj) < 0)\r
+ return NULL;\r
+\r
+ return PyLong_FromSsize_t(size);\r
+}\r
+\r
+PyDoc_STRVAR(stringio_close_doc,\r
+ "Close the IO object. Attempting any further operation after the\n"\r
+ "object is closed will raise a ValueError.\n"\r
+ "\n"\r
+ "This method has no effect if the file is already closed.\n");\r
+\r
+static PyObject *\r
+stringio_close(stringio *self)\r
+{\r
+ self->closed = 1;\r
+ /* Free up some memory */\r
+ if (resize_buffer(self, 0) < 0)\r
+ return NULL;\r
+ Py_CLEAR(self->readnl);\r
+ Py_CLEAR(self->writenl);\r
+ Py_CLEAR(self->decoder);\r
+ Py_RETURN_NONE;\r
+}\r
+\r
+static int\r
+stringio_traverse(stringio *self, visitproc visit, void *arg)\r
+{\r
+ Py_VISIT(self->dict);\r
+ return 0;\r
+}\r
+\r
+static int\r
+stringio_clear(stringio *self)\r
+{\r
+ Py_CLEAR(self->dict);\r
+ return 0;\r
+}\r
+\r
+static void\r
+stringio_dealloc(stringio *self)\r
+{\r
+ _PyObject_GC_UNTRACK(self);\r
+ self->ok = 0;\r
+ if (self->buf) {\r
+ PyMem_Free(self->buf);\r
+ self->buf = NULL;\r
+ }\r
+ Py_CLEAR(self->readnl);\r
+ Py_CLEAR(self->writenl);\r
+ Py_CLEAR(self->decoder);\r
+ Py_CLEAR(self->dict);\r
+ if (self->weakreflist != NULL)\r
+ PyObject_ClearWeakRefs((PyObject *) self);\r
+ Py_TYPE(self)->tp_free(self);\r
+}\r
+\r
+static PyObject *\r
+stringio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)\r
+{\r
+ stringio *self;\r
+\r
+ assert(type != NULL && type->tp_alloc != NULL);\r
+ self = (stringio *)type->tp_alloc(type, 0);\r
+ if (self == NULL)\r
+ return NULL;\r
+\r
+ /* tp_alloc initializes all the fields to zero. So we don't have to\r
+ initialize them here. */\r
+\r
+ self->buf = (Py_UNICODE *)PyMem_Malloc(0);\r
+ if (self->buf == NULL) {\r
+ Py_DECREF(self);\r
+ return PyErr_NoMemory();\r
+ }\r
+\r
+ return (PyObject *)self;\r
+}\r
+\r
+static int\r
+stringio_init(stringio *self, PyObject *args, PyObject *kwds)\r
+{\r
+ char *kwlist[] = {"initial_value", "newline", NULL};\r
+ PyObject *value = NULL;\r
+ char *newline = "\n";\r
+\r
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oz:__init__", kwlist,\r
+ &value, &newline))\r
+ return -1;\r
+\r
+ if (newline && newline[0] != '\0'\r
+ && !(newline[0] == '\n' && newline[1] == '\0')\r
+ && !(newline[0] == '\r' && newline[1] == '\0')\r
+ && !(newline[0] == '\r' && newline[1] == '\n' && newline[2] == '\0')) {\r
+ PyErr_Format(PyExc_ValueError,\r
+ "illegal newline value: %s", newline);\r
+ return -1;\r
+ }\r
+ if (value && value != Py_None && !PyUnicode_Check(value)) {\r
+ PyErr_Format(PyExc_TypeError,\r
+ "initial_value must be unicode or None, not %.200s",\r
+ Py_TYPE(value)->tp_name);\r
+ return -1;\r
+ }\r
+\r
+ self->ok = 0;\r
+\r
+ Py_CLEAR(self->readnl);\r
+ Py_CLEAR(self->writenl);\r
+ Py_CLEAR(self->decoder);\r
+\r
+ if (newline) {\r
+ self->readnl = PyString_FromString(newline);\r
+ if (self->readnl == NULL)\r
+ return -1;\r
+ }\r
+ self->readuniversal = (newline == NULL || newline[0] == '\0');\r
+ self->readtranslate = (newline == NULL);\r
+ /* If newline == "", we don't translate anything.\r
+ If newline == "\n" or newline == None, we translate to "\n", which is\r
+ a no-op.\r
+ (for newline == None, TextIOWrapper translates to os.sepline, but it\r
+ is pointless for StringIO)\r
+ */\r
+ if (newline != NULL && newline[0] == '\r') {\r
+ self->writenl = PyUnicode_FromString(newline);\r
+ }\r
+\r
+ if (self->readuniversal) {\r
+ self->decoder = PyObject_CallFunction(\r
+ (PyObject *)&PyIncrementalNewlineDecoder_Type,\r
+ "Oi", Py_None, (int) self->readtranslate);\r
+ if (self->decoder == NULL)\r
+ return -1;\r
+ }\r
+\r
+ /* Now everything is set up, resize buffer to size of initial value,\r
+ and copy it */\r
+ self->string_size = 0;\r
+ if (value && value != Py_None) {\r
+ Py_ssize_t len = PyUnicode_GetSize(value);\r
+ /* This is a heuristic, for newline translation might change\r
+ the string length. */\r
+ if (resize_buffer(self, len) < 0)\r
+ return -1;\r
+ self->pos = 0;\r
+ if (write_str(self, value) < 0)\r
+ return -1;\r
+ }\r
+ else {\r
+ if (resize_buffer(self, 0) < 0)\r
+ return -1;\r
+ }\r
+ self->pos = 0;\r
+\r
+ self->closed = 0;\r
+ self->ok = 1;\r
+ return 0;\r
+}\r
+\r
+/* Properties and pseudo-properties */\r
+\r
+PyDoc_STRVAR(stringio_readable_doc,\r
+"readable() -> bool. Returns True if the IO object can be read.");\r
+\r
+PyDoc_STRVAR(stringio_writable_doc,\r
+"writable() -> bool. Returns True if the IO object can be written.");\r
+\r
+PyDoc_STRVAR(stringio_seekable_doc,\r
+"seekable() -> bool. Returns True if the IO object can be seeked.");\r
+\r
+static PyObject *\r
+stringio_seekable(stringio *self, PyObject *args)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+ Py_RETURN_TRUE;\r
+}\r
+\r
+static PyObject *\r
+stringio_readable(stringio *self, PyObject *args)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+ Py_RETURN_TRUE;\r
+}\r
+\r
+static PyObject *\r
+stringio_writable(stringio *self, PyObject *args)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+ Py_RETURN_TRUE;\r
+}\r
+\r
+/* Pickling support.\r
+\r
+ The implementation of __getstate__ is similar to the one for BytesIO,\r
+ except that we also save the newline parameter. For __setstate__ and unlike\r
+ BytesIO, we call __init__ to restore the object's state. Doing so allows us\r
+ to avoid decoding the complex newline state while keeping the object\r
+ representation compact.\r
+\r
+ See comment in bytesio.c regarding why only pickle protocols and onward are\r
+ supported.\r
+*/\r
+\r
+static PyObject *\r
+stringio_getstate(stringio *self)\r
+{\r
+ PyObject *initvalue = stringio_getvalue(self);\r
+ PyObject *dict;\r
+ PyObject *state;\r
+\r
+ if (initvalue == NULL)\r
+ return NULL;\r
+ if (self->dict == NULL) {\r
+ Py_INCREF(Py_None);\r
+ dict = Py_None;\r
+ }\r
+ else {\r
+ dict = PyDict_Copy(self->dict);\r
+ if (dict == NULL)\r
+ return NULL;\r
+ }\r
+\r
+ state = Py_BuildValue("(OOnN)", initvalue,\r
+ self->readnl ? self->readnl : Py_None,\r
+ self->pos, dict);\r
+ Py_DECREF(initvalue);\r
+ return state;\r
+}\r
+\r
+static PyObject *\r
+stringio_setstate(stringio *self, PyObject *state)\r
+{\r
+ PyObject *initarg;\r
+ PyObject *position_obj;\r
+ PyObject *dict;\r
+ Py_ssize_t pos;\r
+\r
+ assert(state != NULL);\r
+ CHECK_CLOSED(self);\r
+\r
+ /* We allow the state tuple to be longer than 4, because we may need\r
+ someday to extend the object's state without breaking\r
+ backward-compatibility. */\r
+ if (!PyTuple_Check(state) || Py_SIZE(state) < 4) {\r
+ PyErr_Format(PyExc_TypeError,\r
+ "%.200s.__setstate__ argument should be 4-tuple, got %.200s",\r
+ Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name);\r
+ return NULL;\r
+ }\r
+\r
+ /* Initialize the object's state. */\r
+ initarg = PyTuple_GetSlice(state, 0, 2);\r
+ if (initarg == NULL)\r
+ return NULL;\r
+ if (stringio_init(self, initarg, NULL) < 0) {\r
+ Py_DECREF(initarg);\r
+ return NULL;\r
+ }\r
+ Py_DECREF(initarg);\r
+\r
+ /* Restore the buffer state. Even if __init__ did initialize the buffer,\r
+ we have to initialize it again since __init__ may translates the\r
+ newlines in the inital_value string. We clearly do not want that\r
+ because the string value in the state tuple has already been translated\r
+ once by __init__. So we do not take any chance and replace object's\r
+ buffer completely. */\r
+ {\r
+ Py_UNICODE *buf = PyUnicode_AS_UNICODE(PyTuple_GET_ITEM(state, 0));\r
+ Py_ssize_t bufsize = PyUnicode_GET_SIZE(PyTuple_GET_ITEM(state, 0));\r
+ if (resize_buffer(self, bufsize) < 0)\r
+ return NULL;\r
+ memcpy(self->buf, buf, bufsize * sizeof(Py_UNICODE));\r
+ self->string_size = bufsize;\r
+ }\r
+\r
+ /* Set carefully the position value. Alternatively, we could use the seek\r
+ method instead of modifying self->pos directly to better protect the\r
+ object internal state against errneous (or malicious) inputs. */\r
+ position_obj = PyTuple_GET_ITEM(state, 2);\r
+ if (!PyIndex_Check(position_obj)) {\r
+ PyErr_Format(PyExc_TypeError,\r
+ "third item of state must be an integer, got %.200s",\r
+ Py_TYPE(position_obj)->tp_name);\r
+ return NULL;\r
+ }\r
+ pos = PyNumber_AsSsize_t(position_obj, PyExc_OverflowError);\r
+ if (pos == -1 && PyErr_Occurred())\r
+ return NULL;\r
+ if (pos < 0) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "position value cannot be negative");\r
+ return NULL;\r
+ }\r
+ self->pos = pos;\r
+\r
+ /* Set the dictionary of the instance variables. */\r
+ dict = PyTuple_GET_ITEM(state, 3);\r
+ if (dict != Py_None) {\r
+ if (!PyDict_Check(dict)) {\r
+ PyErr_Format(PyExc_TypeError,\r
+ "fourth item of state should be a dict, got a %.200s",\r
+ Py_TYPE(dict)->tp_name);\r
+ return NULL;\r
+ }\r
+ if (self->dict) {\r
+ /* Alternatively, we could replace the internal dictionary\r
+ completely. However, it seems more practical to just update it. */\r
+ if (PyDict_Update(self->dict, dict) < 0)\r
+ return NULL;\r
+ }\r
+ else {\r
+ Py_INCREF(dict);\r
+ self->dict = dict;\r
+ }\r
+ }\r
+\r
+ Py_RETURN_NONE;\r
+}\r
+\r
+\r
+static PyObject *\r
+stringio_closed(stringio *self, void *context)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ return PyBool_FromLong(self->closed);\r
+}\r
+\r
+static PyObject *\r
+stringio_line_buffering(stringio *self, void *context)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+ Py_RETURN_FALSE;\r
+}\r
+\r
+static PyObject *\r
+stringio_newlines(stringio *self, void *context)\r
+{\r
+ CHECK_INITIALIZED(self);\r
+ CHECK_CLOSED(self);\r
+ if (self->decoder == NULL)\r
+ Py_RETURN_NONE;\r
+ return PyObject_GetAttr(self->decoder, _PyIO_str_newlines);\r
+}\r
+\r
+static struct PyMethodDef stringio_methods[] = {\r
+ {"close", (PyCFunction)stringio_close, METH_NOARGS, stringio_close_doc},\r
+ {"getvalue", (PyCFunction)stringio_getvalue, METH_NOARGS, stringio_getvalue_doc},\r
+ {"read", (PyCFunction)stringio_read, METH_VARARGS, stringio_read_doc},\r
+ {"readline", (PyCFunction)stringio_readline, METH_VARARGS, stringio_readline_doc},\r
+ {"tell", (PyCFunction)stringio_tell, METH_NOARGS, stringio_tell_doc},\r
+ {"truncate", (PyCFunction)stringio_truncate, METH_VARARGS, stringio_truncate_doc},\r
+ {"seek", (PyCFunction)stringio_seek, METH_VARARGS, stringio_seek_doc},\r
+ {"write", (PyCFunction)stringio_write, METH_O, stringio_write_doc},\r
+\r
+ {"seekable", (PyCFunction)stringio_seekable, METH_NOARGS, stringio_seekable_doc},\r
+ {"readable", (PyCFunction)stringio_readable, METH_NOARGS, stringio_readable_doc},\r
+ {"writable", (PyCFunction)stringio_writable, METH_NOARGS, stringio_writable_doc},\r
+\r
+ {"__getstate__", (PyCFunction)stringio_getstate, METH_NOARGS},\r
+ {"__setstate__", (PyCFunction)stringio_setstate, METH_O},\r
+ {NULL, NULL} /* sentinel */\r
+};\r
+\r
+static PyGetSetDef stringio_getset[] = {\r
+ {"closed", (getter)stringio_closed, NULL, NULL},\r
+ {"newlines", (getter)stringio_newlines, NULL, NULL},\r
+ /* (following comments straight off of the original Python wrapper:)\r
+ XXX Cruft to support the TextIOWrapper API. This would only\r
+ be meaningful if StringIO supported the buffer attribute.\r
+ Hopefully, a better solution, than adding these pseudo-attributes,\r
+ will be found.\r
+ */\r
+ {"line_buffering", (getter)stringio_line_buffering, NULL, NULL},\r
+ {NULL}\r
+};\r
+\r
+PyTypeObject PyStringIO_Type = {\r
+ PyVarObject_HEAD_INIT(NULL, 0)\r
+ "_io.StringIO", /*tp_name*/\r
+ sizeof(stringio), /*tp_basicsize*/\r
+ 0, /*tp_itemsize*/\r
+ (destructor)stringio_dealloc, /*tp_dealloc*/\r
+ 0, /*tp_print*/\r
+ 0, /*tp_getattr*/\r
+ 0, /*tp_setattr*/\r
+ 0, /*tp_reserved*/\r
+ 0, /*tp_repr*/\r
+ 0, /*tp_as_number*/\r
+ 0, /*tp_as_sequence*/\r
+ 0, /*tp_as_mapping*/\r
+ 0, /*tp_hash*/\r
+ 0, /*tp_call*/\r
+ 0, /*tp_str*/\r
+ 0, /*tp_getattro*/\r
+ 0, /*tp_setattro*/\r
+ 0, /*tp_as_buffer*/\r
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE\r
+ | Py_TPFLAGS_HAVE_GC, /*tp_flags*/\r
+ stringio_doc, /*tp_doc*/\r
+ (traverseproc)stringio_traverse, /*tp_traverse*/\r
+ (inquiry)stringio_clear, /*tp_clear*/\r
+ 0, /*tp_richcompare*/\r
+ offsetof(stringio, weakreflist), /*tp_weaklistoffset*/\r
+ 0, /*tp_iter*/\r
+ (iternextfunc)stringio_iternext, /*tp_iternext*/\r
+ stringio_methods, /*tp_methods*/\r
+ 0, /*tp_members*/\r
+ stringio_getset, /*tp_getset*/\r
+ 0, /*tp_base*/\r
+ 0, /*tp_dict*/\r
+ 0, /*tp_descr_get*/\r
+ 0, /*tp_descr_set*/\r
+ offsetof(stringio, dict), /*tp_dictoffset*/\r
+ (initproc)stringio_init, /*tp_init*/\r
+ 0, /*tp_alloc*/\r
+ stringio_new, /*tp_new*/\r
+};\r
projects / mirror_edk2.git / blobdiff