LCOV - code coverage report
Current view: top level - Modules/_io - stringio.c (source / functions) Hit Total Coverage
Test: CPython lcov report Lines: 0 359 0.0 %
Date: 2017-04-19 Functions: 0 25 0.0 %

          Line data    Source code
       1             : #define PY_SSIZE_T_CLEAN
       2             : #include "Python.h"
       3             : #include "structmember.h"
       4             : #include "_iomodule.h"
       5             : 
       6             : /* Implementation note: the buffer is always at least one character longer
       7             :    than the enclosed string, for proper functioning of _PyIO_find_line_ending.
       8             : */
       9             : 
      10             : typedef struct {
      11             :     PyObject_HEAD
      12             :     Py_UNICODE *buf;
      13             :     Py_ssize_t pos;
      14             :     Py_ssize_t string_size;
      15             :     size_t buf_size;
      16             : 
      17             :     char ok; /* initialized? */
      18             :     char closed;
      19             :     char readuniversal;
      20             :     char readtranslate;
      21             :     PyObject *decoder;
      22             :     PyObject *readnl;
      23             :     PyObject *writenl;
      24             :     
      25             :     PyObject *dict;
      26             :     PyObject *weakreflist;
      27             : } stringio;
      28             : 
      29             : #define CHECK_INITIALIZED(self) \
      30             :     if (self->ok <= 0) { \
      31             :         PyErr_SetString(PyExc_ValueError, \
      32             :             "I/O operation on uninitialized object"); \
      33             :         return NULL; \
      34             :     }
      35             : 
      36             : #define CHECK_CLOSED(self) \
      37             :     if (self->closed) { \
      38             :         PyErr_SetString(PyExc_ValueError, \
      39             :             "I/O operation on closed file"); \
      40             :         return NULL; \
      41             :     }
      42             : 
      43             : PyDoc_STRVAR(stringio_doc,
      44             :     "Text I/O implementation using an in-memory buffer.\n"
      45             :     "\n"
      46             :     "The initial_value argument sets the value of object.  The newline\n"
      47             :     "argument is like the one of TextIOWrapper's constructor.");
      48             : 
      49             : 
      50             : /* Internal routine for changing the size, in terms of characters, of the
      51             :    buffer of StringIO objects.  The caller should ensure that the 'size'
      52             :    argument is non-negative.  Returns 0 on success, -1 otherwise. */
      53             : static int
      54           0 : resize_buffer(stringio *self, size_t size)
      55             : {
      56             :     /* Here, unsigned types are used to avoid dealing with signed integer
      57             :        overflow, which is undefined in C. */
      58           0 :     size_t alloc = self->buf_size;
      59           0 :     Py_UNICODE *new_buf = NULL;
      60             : 
      61             :     assert(self->buf != NULL);
      62             : 
      63             :     /* Reserve one more char for line ending detection. */
      64           0 :     size = size + 1;
      65             :     /* For simplicity, stay in the range of the signed type. Anyway, Python
      66             :        doesn't allow strings to be longer than this. */
      67           0 :     if (size > PY_SSIZE_T_MAX)
      68           0 :         goto overflow;
      69             : 
      70           0 :     if (size < alloc / 2) {
      71             :         /* Major downsize; resize down to exact size. */
      72           0 :         alloc = size + 1;
      73             :     }
      74           0 :     else if (size < alloc) {
      75             :         /* Within allocated size; quick exit */
      76           0 :         return 0;
      77             :     }
      78           0 :     else if (size <= alloc * 1.125) {
      79             :         /* Moderate upsize; overallocate similar to list_resize() */
      80           0 :         alloc = size + (size >> 3) + (size < 9 ? 3 : 6);
      81             :     }
      82             :     else {
      83             :         /* Major upsize; resize up to exact size */
      84           0 :         alloc = size + 1;
      85             :     }
      86             : 
      87           0 :     if (alloc > ((size_t)-1) / sizeof(Py_UNICODE))
      88           0 :         goto overflow;
      89           0 :     new_buf = (Py_UNICODE *)PyMem_Realloc(self->buf,
      90             :                                           alloc * sizeof(Py_UNICODE));
      91           0 :     if (new_buf == NULL) {
      92           0 :         PyErr_NoMemory();
      93           0 :         return -1;
      94             :     }
      95           0 :     self->buf_size = alloc;
      96           0 :     self->buf = new_buf;
      97             : 
      98           0 :     return 0;
      99             : 
     100             :   overflow:
     101           0 :     PyErr_SetString(PyExc_OverflowError,
     102             :                     "new buffer size too large");
     103           0 :     return -1;
     104             : }
     105             : 
     106             : /* Internal routine for writing a whole PyUnicode object to the buffer of a
     107             :    StringIO object. Returns 0 on success, or -1 on error. */
     108             : static Py_ssize_t
     109           0 : write_str(stringio *self, PyObject *obj)
     110             : {
     111             :     Py_UNICODE *str;
     112             :     Py_ssize_t len;
     113           0 :     PyObject *decoded = NULL;
     114             :     assert(self->buf != NULL);
     115             :     assert(self->pos >= 0);
     116             : 
     117           0 :     if (self->decoder != NULL) {
     118           0 :         decoded = _PyIncrementalNewlineDecoder_decode(
     119             :             self->decoder, obj, 1 /* always final */);
     120             :     }
     121             :     else {
     122           0 :         decoded = obj;
     123           0 :         Py_INCREF(decoded);
     124             :     }
     125           0 :     if (self->writenl) {
     126           0 :         PyObject *translated = PyUnicode_Replace(
     127             :             decoded, _PyIO_str_nl, self->writenl, -1);
     128           0 :         Py_DECREF(decoded);
     129           0 :         decoded = translated;
     130             :     }
     131           0 :     if (decoded == NULL)
     132           0 :         return -1;
     133             : 
     134             :     assert(PyUnicode_Check(decoded));
     135           0 :     str = PyUnicode_AS_UNICODE(decoded);
     136           0 :     len = PyUnicode_GET_SIZE(decoded);
     137             : 
     138             :     assert(len >= 0);
     139             : 
     140             :     /* This overflow check is not strictly necessary. However, it avoids us to
     141             :        deal with funky things like comparing an unsigned and a signed
     142             :        integer. */
     143           0 :     if (self->pos > PY_SSIZE_T_MAX - len) {
     144           0 :         PyErr_SetString(PyExc_OverflowError,
     145             :                         "new position too large");
     146           0 :         goto fail;
     147             :     }
     148           0 :     if (self->pos + len > self->string_size) {
     149           0 :         if (resize_buffer(self, self->pos + len) < 0)
     150           0 :             goto fail;
     151             :     }
     152             : 
     153           0 :     if (self->pos > self->string_size) {
     154             :         /* In case of overseek, pad with null bytes the buffer region between
     155             :            the end of stream and the current position.
     156             : 
     157             :           0   lo      string_size                           hi
     158             :           |   |<---used--->|<----------available----------->|
     159             :           |   |            <--to pad-->|<---to write--->    |
     160             :           0   buf                   position
     161             : 
     162             :         */
     163           0 :         memset(self->buf + self->string_size, '\0',
     164           0 :                (self->pos - self->string_size) * sizeof(Py_UNICODE));
     165             :     }
     166             : 
     167             :     /* Copy the data to the internal buffer, overwriting some of the
     168             :        existing data if self->pos < self->string_size. */
     169           0 :     memcpy(self->buf + self->pos, str, len * sizeof(Py_UNICODE));
     170           0 :     self->pos += len;
     171             : 
     172             :     /* Set the new length of the internal string if it has changed. */
     173           0 :     if (self->string_size < self->pos) {
     174           0 :         self->string_size = self->pos;
     175             :     }
     176             : 
     177           0 :     Py_DECREF(decoded);
     178           0 :     return 0;
     179             : 
     180             : fail:
     181           0 :     Py_XDECREF(decoded);
     182           0 :     return -1;
     183             : }
     184             : 
     185             : PyDoc_STRVAR(stringio_getvalue_doc,
     186             :     "Retrieve the entire contents of the object.");
     187             : 
     188             : static PyObject *
     189           0 : stringio_getvalue(stringio *self)
     190             : {
     191           0 :     CHECK_INITIALIZED(self);
     192           0 :     CHECK_CLOSED(self);
     193           0 :     return PyUnicode_FromUnicode(self->buf, self->string_size);
     194             : }
     195             : 
     196             : PyDoc_STRVAR(stringio_tell_doc,
     197             :     "Tell the current file position.");
     198             : 
     199             : static PyObject *
     200           0 : stringio_tell(stringio *self)
     201             : {
     202           0 :     CHECK_INITIALIZED(self);
     203           0 :     CHECK_CLOSED(self);
     204           0 :     return PyLong_FromSsize_t(self->pos);
     205             : }
     206             : 
     207             : PyDoc_STRVAR(stringio_read_doc,
     208             :     "Read at most n characters, returned as a string.\n"
     209             :     "\n"
     210             :     "If the argument is negative or omitted, read until EOF\n"
     211             :     "is reached. Return an empty string at EOF.\n");
     212             : 
     213             : static PyObject *
     214           0 : stringio_read(stringio *self, PyObject *args)
     215             : {
     216             :     Py_ssize_t size, n;
     217             :     Py_UNICODE *output;
     218           0 :     PyObject *arg = Py_None;
     219             : 
     220           0 :     CHECK_INITIALIZED(self);
     221           0 :     if (!PyArg_ParseTuple(args, "|O:read", &arg))
     222           0 :         return NULL;
     223           0 :     CHECK_CLOSED(self);
     224             : 
     225           0 :     if (PyNumber_Check(arg)) {
     226           0 :         size = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
     227           0 :         if (size == -1 && PyErr_Occurred())
     228           0 :             return NULL;
     229             :     }
     230           0 :     else if (arg == Py_None) {
     231             :         /* Read until EOF is reached, by default. */
     232           0 :         size = -1;
     233             :     }
     234             :     else {
     235           0 :         PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",
     236           0 :                      Py_TYPE(arg)->tp_name);
     237           0 :         return NULL;
     238             :     }
     239             : 
     240             :     /* adjust invalid sizes */
     241           0 :     n = self->string_size - self->pos;
     242           0 :     if (size < 0 || size > n) {
     243           0 :         size = n;
     244           0 :         if (size < 0)
     245           0 :             size = 0;
     246             :     }
     247             : 
     248           0 :     output = self->buf + self->pos;
     249           0 :     self->pos += size;
     250           0 :     return PyUnicode_FromUnicode(output, size);
     251             : }
     252             : 
     253             : /* Internal helper, used by stringio_readline and stringio_iternext */
     254             : static PyObject *
     255           0 : _stringio_readline(stringio *self, Py_ssize_t limit)
     256             : {
     257             :     Py_UNICODE *start, *end, old_char;
     258             :     Py_ssize_t len, consumed;
     259             : 
     260             :     /* In case of overseek, return the empty string */
     261           0 :     if (self->pos >= self->string_size)
     262           0 :         return PyUnicode_FromString("");
     263             : 
     264           0 :     start = self->buf + self->pos;
     265           0 :     if (limit < 0 || limit > self->string_size - self->pos)
     266           0 :         limit = self->string_size - self->pos;
     267             : 
     268           0 :     end = start + limit;
     269           0 :     old_char = *end;
     270           0 :     *end = '\0';
     271           0 :     len = _PyIO_find_line_ending(
     272           0 :         self->readtranslate, self->readuniversal, self->readnl,
     273             :         start, end, &consumed);
     274           0 :     *end = old_char;
     275             :     /* If we haven't found any line ending, we just return everything
     276             :        (`consumed` is ignored). */
     277           0 :     if (len < 0)
     278           0 :         len = limit;
     279           0 :     self->pos += len;
     280           0 :     return PyUnicode_FromUnicode(start, len);
     281             : }
     282             : 
     283             : PyDoc_STRVAR(stringio_readline_doc,
     284             :     "Read until newline or EOF.\n"
     285             :     "\n"
     286             :     "Returns an empty string if EOF is hit immediately.\n");
     287             : 
     288             : static PyObject *
     289           0 : stringio_readline(stringio *self, PyObject *args)
     290             : {
     291           0 :     PyObject *arg = Py_None;
     292           0 :     Py_ssize_t limit = -1;
     293             : 
     294           0 :     CHECK_INITIALIZED(self);
     295           0 :     if (!PyArg_ParseTuple(args, "|O:readline", &arg))
     296           0 :         return NULL;
     297           0 :     CHECK_CLOSED(self);
     298             : 
     299           0 :     if (PyNumber_Check(arg)) {
     300           0 :         limit = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
     301           0 :         if (limit == -1 && PyErr_Occurred())
     302           0 :             return NULL;
     303             :     }
     304           0 :     else if (arg != Py_None) {
     305           0 :         PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",
     306           0 :                      Py_TYPE(arg)->tp_name);
     307           0 :         return NULL;
     308             :     }
     309           0 :     return _stringio_readline(self, limit);
     310             : }
     311             : 
     312             : static PyObject *
     313           0 : stringio_iternext(stringio *self)
     314             : {
     315             :     PyObject *line;
     316             : 
     317           0 :     CHECK_INITIALIZED(self);
     318           0 :     CHECK_CLOSED(self);
     319             : 
     320           0 :     if (Py_TYPE(self) == &PyStringIO_Type) {
     321             :         /* Skip method call overhead for speed */
     322           0 :         line = _stringio_readline(self, -1);
     323             :     }
     324             :     else {
     325             :         /* XXX is subclassing StringIO really supported? */
     326           0 :         line = PyObject_CallMethodObjArgs((PyObject *)self,
     327             :                                            _PyIO_str_readline, NULL);
     328           0 :         if (line && !PyUnicode_Check(line)) {
     329           0 :             PyErr_Format(PyExc_IOError,
     330             :                          "readline() should have returned an str object, "
     331           0 :                          "not '%.200s'", Py_TYPE(line)->tp_name);
     332           0 :             Py_DECREF(line);
     333           0 :             return NULL;
     334             :         }
     335             :     }
     336             : 
     337           0 :     if (line == NULL)
     338           0 :         return NULL;
     339             : 
     340           0 :     if (PyUnicode_GET_SIZE(line) == 0) {
     341             :         /* Reached EOF */
     342           0 :         Py_DECREF(line);
     343           0 :         return NULL;
     344             :     }
     345             : 
     346           0 :     return line;
     347             : }
     348             : 
     349             : PyDoc_STRVAR(stringio_truncate_doc,
     350             :     "Truncate size to pos.\n"
     351             :     "\n"
     352             :     "The pos argument defaults to the current file position, as\n"
     353             :     "returned by tell().  The current file position is unchanged.\n"
     354             :     "Returns the new absolute position.\n");
     355             : 
     356             : static PyObject *
     357           0 : stringio_truncate(stringio *self, PyObject *args)
     358             : {
     359             :     Py_ssize_t size;
     360           0 :     PyObject *arg = Py_None;
     361             : 
     362           0 :     CHECK_INITIALIZED(self);
     363           0 :     if (!PyArg_ParseTuple(args, "|O:truncate", &arg))
     364           0 :         return NULL;
     365           0 :     CHECK_CLOSED(self);
     366             : 
     367           0 :     if (PyNumber_Check(arg)) {
     368           0 :         size = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
     369           0 :         if (size == -1 && PyErr_Occurred())
     370           0 :             return NULL;
     371             :     }
     372           0 :     else if (arg == Py_None) {
     373             :         /* Truncate to current position if no argument is passed. */
     374           0 :         size = self->pos;
     375             :     }
     376             :     else {
     377           0 :         PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",
     378           0 :                      Py_TYPE(arg)->tp_name);
     379           0 :         return NULL;
     380             :     }
     381             : 
     382           0 :     if (size < 0) {
     383           0 :         PyErr_Format(PyExc_ValueError,
     384             :                      "Negative size value %zd", size);
     385           0 :         return NULL;
     386             :     }
     387             : 
     388           0 :     if (size < self->string_size) {
     389           0 :         if (resize_buffer(self, size) < 0)
     390           0 :             return NULL;
     391           0 :         self->string_size = size;
     392             :     }
     393             : 
     394           0 :     return PyLong_FromSsize_t(size);
     395             : }
     396             : 
     397             : PyDoc_STRVAR(stringio_seek_doc,
     398             :     "Change stream position.\n"
     399             :     "\n"
     400             :     "Seek to character offset pos relative to position indicated by whence:\n"
     401             :     "    0  Start of stream (the default).  pos should be >= 0;\n"
     402             :     "    1  Current position - pos must be 0;\n"
     403             :     "    2  End of stream - pos must be 0.\n"
     404             :     "Returns the new absolute position.\n");
     405             : 
     406             : static PyObject *
     407           0 : stringio_seek(stringio *self, PyObject *args)
     408             : {
     409             :     PyObject *posobj;
     410             :     Py_ssize_t pos;
     411           0 :     int mode = 0;
     412             : 
     413           0 :     CHECK_INITIALIZED(self);
     414           0 :     if (!PyArg_ParseTuple(args, "O|i:seek", &posobj, &mode))
     415           0 :         return NULL;
     416             : 
     417           0 :     pos = PyNumber_AsSsize_t(posobj, PyExc_OverflowError);
     418           0 :     if (pos == -1 && PyErr_Occurred())
     419           0 :         return NULL;
     420             :     
     421           0 :     CHECK_CLOSED(self);
     422             : 
     423           0 :     if (mode != 0 && mode != 1 && mode != 2) {
     424           0 :         PyErr_Format(PyExc_ValueError,
     425             :                      "Invalid whence (%i, should be 0, 1 or 2)", mode);
     426           0 :         return NULL;
     427             :     }
     428           0 :     else if (pos < 0 && mode == 0) {
     429           0 :         PyErr_Format(PyExc_ValueError,
     430             :                      "Negative seek position %zd", pos);
     431           0 :         return NULL;
     432             :     }
     433           0 :     else if (mode != 0 && pos != 0) {
     434           0 :         PyErr_SetString(PyExc_IOError,
     435             :                         "Can't do nonzero cur-relative seeks");
     436           0 :         return NULL;
     437             :     }
     438             : 
     439             :     /* mode 0: offset relative to beginning of the string.
     440             :        mode 1: no change to current position.
     441             :        mode 2: change position to end of file. */
     442           0 :     if (mode == 1) {
     443           0 :         pos = self->pos;
     444             :     }
     445           0 :     else if (mode == 2) {
     446           0 :         pos = self->string_size;
     447             :     }
     448             : 
     449           0 :     self->pos = pos;
     450             : 
     451           0 :     return PyLong_FromSsize_t(self->pos);
     452             : }
     453             : 
     454             : PyDoc_STRVAR(stringio_write_doc,
     455             :     "Write string to file.\n"
     456             :     "\n"
     457             :     "Returns the number of characters written, which is always equal to\n"
     458             :     "the length of the string.\n");
     459             : 
     460             : static PyObject *
     461           0 : stringio_write(stringio *self, PyObject *obj)
     462             : {
     463             :     Py_ssize_t size;
     464             : 
     465           0 :     CHECK_INITIALIZED(self);
     466           0 :     if (!PyUnicode_Check(obj)) {
     467           0 :         PyErr_Format(PyExc_TypeError, "unicode argument expected, got '%s'",
     468           0 :                      Py_TYPE(obj)->tp_name);
     469           0 :         return NULL;
     470             :     }
     471           0 :     CHECK_CLOSED(self);
     472           0 :     size = PyUnicode_GET_SIZE(obj);
     473             : 
     474           0 :     if (size > 0 && write_str(self, obj) < 0)
     475           0 :         return NULL;
     476             : 
     477           0 :     return PyLong_FromSsize_t(size);
     478             : }
     479             : 
     480             : PyDoc_STRVAR(stringio_close_doc,
     481             :     "Close the IO object. Attempting any further operation after the\n"
     482             :     "object is closed will raise a ValueError.\n"
     483             :     "\n"
     484             :     "This method has no effect if the file is already closed.\n");
     485             : 
     486             : static PyObject *
     487           0 : stringio_close(stringio *self)
     488             : {
     489           0 :     self->closed = 1;
     490             :     /* Free up some memory */
     491           0 :     if (resize_buffer(self, 0) < 0)
     492           0 :         return NULL;
     493           0 :     Py_CLEAR(self->readnl);
     494           0 :     Py_CLEAR(self->writenl);
     495           0 :     Py_CLEAR(self->decoder);
     496           0 :     Py_RETURN_NONE;
     497             : }
     498             : 
     499             : static int
     500           0 : stringio_traverse(stringio *self, visitproc visit, void *arg)
     501             : {
     502           0 :     Py_VISIT(self->dict);
     503           0 :     return 0;
     504             : }
     505             : 
     506             : static int
     507           0 : stringio_clear(stringio *self)
     508             : {
     509           0 :     Py_CLEAR(self->dict);
     510           0 :     return 0;
     511             : }
     512             : 
     513             : static void
     514           0 : stringio_dealloc(stringio *self)
     515             : {
     516           0 :     _PyObject_GC_UNTRACK(self);
     517           0 :     self->ok = 0;
     518           0 :     if (self->buf) {
     519           0 :         PyMem_Free(self->buf);
     520           0 :         self->buf = NULL;
     521             :     }
     522           0 :     Py_CLEAR(self->readnl);
     523           0 :     Py_CLEAR(self->writenl);
     524           0 :     Py_CLEAR(self->decoder);
     525           0 :     Py_CLEAR(self->dict);
     526           0 :     if (self->weakreflist != NULL)
     527           0 :         PyObject_ClearWeakRefs((PyObject *) self);
     528           0 :     Py_TYPE(self)->tp_free(self);
     529           0 : }
     530             : 
     531             : static PyObject *
     532           0 : stringio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     533             : {
     534             :     stringio *self;
     535             : 
     536             :     assert(type != NULL && type->tp_alloc != NULL);
     537           0 :     self = (stringio *)type->tp_alloc(type, 0);
     538           0 :     if (self == NULL)
     539           0 :         return NULL;
     540             : 
     541             :     /* tp_alloc initializes all the fields to zero. So we don't have to
     542             :        initialize them here. */
     543             : 
     544           0 :     self->buf = (Py_UNICODE *)PyMem_Malloc(0);
     545           0 :     if (self->buf == NULL) {
     546           0 :         Py_DECREF(self);
     547           0 :         return PyErr_NoMemory();
     548             :     }
     549             : 
     550           0 :     return (PyObject *)self;
     551             : }
     552             : 
     553             : static int
     554           0 : stringio_init(stringio *self, PyObject *args, PyObject *kwds)
     555             : {
     556           0 :     char *kwlist[] = {"initial_value", "newline", NULL};
     557           0 :     PyObject *value = NULL;
     558           0 :     char *newline = "\n";
     559             : 
     560           0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oz:__init__", kwlist,
     561             :                                      &value, &newline))
     562           0 :         return -1;
     563             : 
     564           0 :     if (newline && newline[0] != '\0'
     565           0 :         && !(newline[0] == '\n' && newline[1] == '\0')
     566           0 :         && !(newline[0] == '\r' && newline[1] == '\0')
     567           0 :         && !(newline[0] == '\r' && newline[1] == '\n' && newline[2] == '\0')) {
     568           0 :         PyErr_Format(PyExc_ValueError,
     569             :                      "illegal newline value: %s", newline);
     570           0 :         return -1;
     571             :     }
     572           0 :     if (value && value != Py_None && !PyUnicode_Check(value)) {
     573           0 :         PyErr_Format(PyExc_TypeError,
     574             :                      "initial_value must be unicode or None, not %.200s",
     575           0 :                      Py_TYPE(value)->tp_name);
     576           0 :         return -1;
     577             :     }
     578             : 
     579           0 :     self->ok = 0;
     580             : 
     581           0 :     Py_CLEAR(self->readnl);
     582           0 :     Py_CLEAR(self->writenl);
     583           0 :     Py_CLEAR(self->decoder);
     584             : 
     585           0 :     if (newline) {
     586           0 :         self->readnl = PyString_FromString(newline);
     587           0 :         if (self->readnl == NULL)
     588           0 :             return -1;
     589             :     }
     590           0 :     self->readuniversal = (newline == NULL || newline[0] == '\0');
     591           0 :     self->readtranslate = (newline == NULL);
     592             :     /* If newline == "", we don't translate anything.
     593             :        If newline == "\n" or newline == None, we translate to "\n", which is
     594             :        a no-op.
     595             :        (for newline == None, TextIOWrapper translates to os.sepline, but it
     596             :        is pointless for StringIO)
     597             :     */
     598           0 :     if (newline != NULL && newline[0] == '\r') {
     599           0 :         self->writenl = PyUnicode_FromString(newline);
     600             :     }
     601             : 
     602           0 :     if (self->readuniversal) {
     603           0 :         self->decoder = PyObject_CallFunction(
     604             :             (PyObject *)&PyIncrementalNewlineDecoder_Type,
     605           0 :             "Oi", Py_None, (int) self->readtranslate);
     606           0 :         if (self->decoder == NULL)
     607           0 :             return -1;
     608             :     }
     609             : 
     610             :     /* Now everything is set up, resize buffer to size of initial value,
     611             :        and copy it */
     612           0 :     self->string_size = 0;
     613           0 :     if (value && value != Py_None) {
     614           0 :         Py_ssize_t len = PyUnicode_GetSize(value);
     615             :         /* This is a heuristic, for newline translation might change
     616             :            the string length. */
     617           0 :         if (resize_buffer(self, len) < 0)
     618           0 :             return -1;
     619           0 :         self->pos = 0;
     620           0 :         if (write_str(self, value) < 0)
     621           0 :             return -1;
     622             :     }
     623             :     else {
     624           0 :         if (resize_buffer(self, 0) < 0)
     625           0 :             return -1;
     626             :     }
     627           0 :     self->pos = 0;
     628             : 
     629           0 :     self->closed = 0;
     630           0 :     self->ok = 1;
     631           0 :     return 0;
     632             : }
     633             : 
     634             : /* Properties and pseudo-properties */
     635             : 
     636             : PyDoc_STRVAR(stringio_readable_doc,
     637             : "readable() -> bool. Returns True if the IO object can be read.");
     638             : 
     639             : PyDoc_STRVAR(stringio_writable_doc,
     640             : "writable() -> bool. Returns True if the IO object can be written.");
     641             : 
     642             : PyDoc_STRVAR(stringio_seekable_doc,
     643             : "seekable() -> bool. Returns True if the IO object can be seeked.");
     644             : 
     645             : static PyObject *
     646           0 : stringio_seekable(stringio *self, PyObject *args)
     647             : {
     648           0 :     CHECK_INITIALIZED(self);
     649           0 :     CHECK_CLOSED(self);
     650           0 :     Py_RETURN_TRUE;
     651             : }
     652             : 
     653             : static PyObject *
     654           0 : stringio_readable(stringio *self, PyObject *args)
     655             : {
     656           0 :     CHECK_INITIALIZED(self);
     657           0 :     CHECK_CLOSED(self);
     658           0 :     Py_RETURN_TRUE;
     659             : }
     660             : 
     661             : static PyObject *
     662           0 : stringio_writable(stringio *self, PyObject *args)
     663             : {
     664           0 :     CHECK_INITIALIZED(self);
     665           0 :     CHECK_CLOSED(self);
     666           0 :     Py_RETURN_TRUE;
     667             : }
     668             : 
     669             : /* Pickling support.
     670             : 
     671             :    The implementation of __getstate__ is similar to the one for BytesIO,
     672             :    except that we also save the newline parameter. For __setstate__ and unlike
     673             :    BytesIO, we call __init__ to restore the object's state. Doing so allows us
     674             :    to avoid decoding the complex newline state while keeping the object
     675             :    representation compact.
     676             : 
     677             :    See comment in bytesio.c regarding why only pickle protocols and onward are
     678             :    supported.
     679             : */
     680             : 
     681             : static PyObject *
     682           0 : stringio_getstate(stringio *self)
     683             : {
     684           0 :     PyObject *initvalue = stringio_getvalue(self);
     685             :     PyObject *dict;
     686             :     PyObject *state;
     687             : 
     688           0 :     if (initvalue == NULL)
     689           0 :         return NULL;
     690           0 :     if (self->dict == NULL) {
     691           0 :         Py_INCREF(Py_None);
     692           0 :         dict = Py_None;
     693             :     }
     694             :     else {
     695           0 :         dict = PyDict_Copy(self->dict);
     696           0 :         if (dict == NULL)
     697           0 :             return NULL;
     698             :     }
     699             : 
     700           0 :     state = Py_BuildValue("(OOnN)", initvalue,
     701           0 :                           self->readnl ? self->readnl : Py_None,
     702             :                           self->pos, dict);
     703           0 :     Py_DECREF(initvalue);
     704           0 :     return state;
     705             : }
     706             : 
     707             : static PyObject *
     708           0 : stringio_setstate(stringio *self, PyObject *state)
     709             : {
     710             :     PyObject *initarg;
     711             :     PyObject *position_obj;
     712             :     PyObject *dict;
     713             :     Py_ssize_t pos;
     714             : 
     715             :     assert(state != NULL);
     716           0 :     CHECK_CLOSED(self);
     717             : 
     718             :     /* We allow the state tuple to be longer than 4, because we may need
     719             :        someday to extend the object's state without breaking
     720             :        backward-compatibility. */
     721           0 :     if (!PyTuple_Check(state) || Py_SIZE(state) < 4) {
     722           0 :         PyErr_Format(PyExc_TypeError,
     723             :                      "%.200s.__setstate__ argument should be 4-tuple, got %.200s",
     724           0 :                      Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name);
     725           0 :         return NULL;
     726             :     }
     727             : 
     728             :     /* Initialize the object's state. */
     729           0 :     initarg = PyTuple_GetSlice(state, 0, 2);
     730           0 :     if (initarg == NULL)
     731           0 :         return NULL;
     732           0 :     if (stringio_init(self, initarg, NULL) < 0) {
     733           0 :         Py_DECREF(initarg);
     734           0 :         return NULL;
     735             :     }
     736           0 :     Py_DECREF(initarg);
     737             : 
     738             :     /* Restore the buffer state. Even if __init__ did initialize the buffer,
     739             :        we have to initialize it again since __init__ may translate the
     740             :        newlines in the initial_value string. We clearly do not want that
     741             :        because the string value in the state tuple has already been translated
     742             :        once by __init__. So we do not take any chance and replace object's
     743             :        buffer completely. */
     744             :     {
     745           0 :         Py_UNICODE *buf = PyUnicode_AS_UNICODE(PyTuple_GET_ITEM(state, 0));
     746           0 :         Py_ssize_t bufsize = PyUnicode_GET_SIZE(PyTuple_GET_ITEM(state, 0));
     747           0 :         if (resize_buffer(self, bufsize) < 0)
     748           0 :             return NULL;
     749           0 :         memcpy(self->buf, buf, bufsize * sizeof(Py_UNICODE));
     750           0 :         self->string_size = bufsize;
     751             :     }
     752             : 
     753             :     /* Set carefully the position value. Alternatively, we could use the seek
     754             :        method instead of modifying self->pos directly to better protect the
     755             :        object internal state against errneous (or malicious) inputs. */
     756           0 :     position_obj = PyTuple_GET_ITEM(state, 2);
     757           0 :     if (!PyIndex_Check(position_obj)) {
     758           0 :         PyErr_Format(PyExc_TypeError,
     759             :                      "third item of state must be an integer, got %.200s",
     760           0 :                      Py_TYPE(position_obj)->tp_name);
     761           0 :         return NULL;
     762             :     }
     763           0 :     pos = PyNumber_AsSsize_t(position_obj, PyExc_OverflowError);
     764           0 :     if (pos == -1 && PyErr_Occurred())
     765           0 :         return NULL;
     766           0 :     if (pos < 0) {
     767           0 :         PyErr_SetString(PyExc_ValueError,
     768             :                         "position value cannot be negative");
     769           0 :         return NULL;
     770             :     }
     771           0 :     self->pos = pos;
     772             : 
     773             :     /* Set the dictionary of the instance variables. */
     774           0 :     dict = PyTuple_GET_ITEM(state, 3);
     775           0 :     if (dict != Py_None) {
     776           0 :         if (!PyDict_Check(dict)) {
     777           0 :             PyErr_Format(PyExc_TypeError,
     778             :                          "fourth item of state should be a dict, got a %.200s",
     779           0 :                          Py_TYPE(dict)->tp_name);
     780           0 :             return NULL;
     781             :         }
     782           0 :         if (self->dict) {
     783             :             /* Alternatively, we could replace the internal dictionary
     784             :                completely. However, it seems more practical to just update it. */
     785           0 :             if (PyDict_Update(self->dict, dict) < 0)
     786           0 :                 return NULL;
     787             :         }
     788             :         else {
     789           0 :             Py_INCREF(dict);
     790           0 :             self->dict = dict;
     791             :         }
     792             :     }
     793             : 
     794           0 :     Py_RETURN_NONE;
     795             : }
     796             : 
     797             : 
     798             : static PyObject *
     799           0 : stringio_closed(stringio *self, void *context)
     800             : {
     801           0 :     CHECK_INITIALIZED(self);
     802           0 :     return PyBool_FromLong(self->closed);
     803             : }
     804             : 
     805             : static PyObject *
     806           0 : stringio_line_buffering(stringio *self, void *context)
     807             : {
     808           0 :     CHECK_INITIALIZED(self);
     809           0 :     CHECK_CLOSED(self);
     810           0 :     Py_RETURN_FALSE;
     811             : }
     812             : 
     813             : static PyObject *
     814           0 : stringio_newlines(stringio *self, void *context)
     815             : {
     816           0 :     CHECK_INITIALIZED(self);
     817           0 :     CHECK_CLOSED(self);
     818           0 :     if (self->decoder == NULL)
     819           0 :         Py_RETURN_NONE;
     820           0 :     return PyObject_GetAttr(self->decoder, _PyIO_str_newlines);
     821             : }
     822             : 
     823             : static struct PyMethodDef stringio_methods[] = {
     824             :     {"close",    (PyCFunction)stringio_close,    METH_NOARGS,  stringio_close_doc},
     825             :     {"getvalue", (PyCFunction)stringio_getvalue, METH_NOARGS,  stringio_getvalue_doc},
     826             :     {"read",     (PyCFunction)stringio_read,     METH_VARARGS, stringio_read_doc},
     827             :     {"readline", (PyCFunction)stringio_readline, METH_VARARGS, stringio_readline_doc},
     828             :     {"tell",     (PyCFunction)stringio_tell,     METH_NOARGS,  stringio_tell_doc},
     829             :     {"truncate", (PyCFunction)stringio_truncate, METH_VARARGS, stringio_truncate_doc},
     830             :     {"seek",     (PyCFunction)stringio_seek,     METH_VARARGS, stringio_seek_doc},
     831             :     {"write",    (PyCFunction)stringio_write,    METH_O,       stringio_write_doc},
     832             : 
     833             :     {"seekable", (PyCFunction)stringio_seekable, METH_NOARGS, stringio_seekable_doc},
     834             :     {"readable", (PyCFunction)stringio_readable, METH_NOARGS, stringio_readable_doc},
     835             :     {"writable", (PyCFunction)stringio_writable, METH_NOARGS, stringio_writable_doc},
     836             : 
     837             :     {"__getstate__", (PyCFunction)stringio_getstate, METH_NOARGS},
     838             :     {"__setstate__", (PyCFunction)stringio_setstate, METH_O},
     839             :     {NULL, NULL}        /* sentinel */
     840             : };
     841             : 
     842             : static PyGetSetDef stringio_getset[] = {
     843             :     {"closed",         (getter)stringio_closed,         NULL, NULL},
     844             :     {"newlines",       (getter)stringio_newlines,       NULL, NULL},
     845             :     /*  (following comments straight off of the original Python wrapper:)
     846             :         XXX Cruft to support the TextIOWrapper API. This would only
     847             :         be meaningful if StringIO supported the buffer attribute.
     848             :         Hopefully, a better solution, than adding these pseudo-attributes,
     849             :         will be found.
     850             :     */
     851             :     {"line_buffering", (getter)stringio_line_buffering, NULL, NULL},
     852             :     {NULL}
     853             : };
     854             : 
     855             : PyTypeObject PyStringIO_Type = {
     856             :     PyVarObject_HEAD_INIT(NULL, 0)
     857             :     "_io.StringIO",                            /*tp_name*/
     858             :     sizeof(stringio),                    /*tp_basicsize*/
     859             :     0,                                         /*tp_itemsize*/
     860             :     (destructor)stringio_dealloc,              /*tp_dealloc*/
     861             :     0,                                         /*tp_print*/
     862             :     0,                                         /*tp_getattr*/
     863             :     0,                                         /*tp_setattr*/
     864             :     0,                                         /*tp_reserved*/
     865             :     0,                                         /*tp_repr*/
     866             :     0,                                         /*tp_as_number*/
     867             :     0,                                         /*tp_as_sequence*/
     868             :     0,                                         /*tp_as_mapping*/
     869             :     0,                                         /*tp_hash*/
     870             :     0,                                         /*tp_call*/
     871             :     0,                                         /*tp_str*/
     872             :     0,                                         /*tp_getattro*/
     873             :     0,                                         /*tp_setattro*/
     874             :     0,                                         /*tp_as_buffer*/
     875             :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
     876             :                        | Py_TPFLAGS_HAVE_GC,   /*tp_flags*/
     877             :     stringio_doc,                              /*tp_doc*/
     878             :     (traverseproc)stringio_traverse,           /*tp_traverse*/
     879             :     (inquiry)stringio_clear,                   /*tp_clear*/
     880             :     0,                                         /*tp_richcompare*/
     881             :     offsetof(stringio, weakreflist),            /*tp_weaklistoffset*/
     882             :     0,                                         /*tp_iter*/
     883             :     (iternextfunc)stringio_iternext,           /*tp_iternext*/
     884             :     stringio_methods,                          /*tp_methods*/
     885             :     0,                                         /*tp_members*/
     886             :     stringio_getset,                           /*tp_getset*/
     887             :     0,                                         /*tp_base*/
     888             :     0,                                         /*tp_dict*/
     889             :     0,                                         /*tp_descr_get*/
     890             :     0,                                         /*tp_descr_set*/
     891             :     offsetof(stringio, dict),                  /*tp_dictoffset*/
     892             :     (initproc)stringio_init,                   /*tp_init*/
     893             :     0,                                         /*tp_alloc*/
     894             :     stringio_new,                              /*tp_new*/
     895             : };

Generated by: LCOV version 1.10