Modules/cStringIO.c

   1
   2 #include "Python.h"
   3 #include "import.h"
   4 #include "cStringIO.h"
   5 #include "structmember.h"
   6
   7 PyDoc_STRVAR(cStringIO_module_documentation,
   8 "A simple fast partial StringIO replacement.\n"
   9 "\n"
  10 "This module provides a simple useful replacement for\n"
  11 "the StringIO module that is written in C.  It does not provide the\n"
  12 "full generality of StringIO, but it provides enough for most\n"
  13 "applications and is especially useful in conjunction with the\n"
  14 "pickle module.\n"
  15 "\n"
  16 "Usage:\n"
  17 "\n"
  18 "  from cStringIO import StringIO\n"
  19 "\n"
  20 "  an_output_stream=StringIO()\n"
  21 "  an_output_stream.write(some_stuff)\n"
  22 "  ...\n"
  23 "  value=an_output_stream.getvalue()\n"
  24 "\n"
  25 "  an_input_stream=StringIO(a_string)\n"
  26 "  spam=an_input_stream.readline()\n"
  27 "  spam=an_input_stream.read(5)\n"
  28 "  an_input_stream.seek(0)           # OK, start over\n"
  29 "  spam=an_input_stream.read()       # and read it all\n"
  30 "  \n"
  31 "If someone else wants to provide a more complete implementation,\n"
  32 "go for it. :-)  \n"
  33 "\n"
  34 "cStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp\n");
  35
  36 /* Declaration for file-like objects that manage data as strings
  37
  38    The IOobject type should be though of as a common base type for
  39    Iobjects, which provide input (read-only) StringIO objects and
  40    Oobjects, which provide read-write objects.  Most of the methods
  41    depend only on common data.
  42 */
  43
  44 typedef struct {
  45   PyObject_HEAD
  46   char *buf;
  47   Py_ssize_t pos, string_size;
  48 } IOobject;
  49
  50 #define IOOOBJECT(O) ((IOobject*)(O))
  51
  52 /* Declarations for objects of type StringO */
  53
  54 typedef struct { /* Subtype of IOobject */
  55   PyObject_HEAD
  56   char *buf;
  57   Py_ssize_t pos, string_size;
  58
  59   Py_ssize_t buf_size;
  60   int softspace;
  61 } Oobject;
  62
  63 /* Declarations for objects of type StringI */
  64
  65 typedef struct { /* Subtype of IOobject */
  66   PyObject_HEAD
  67   char *buf;
  68   Py_ssize_t pos, string_size;
  69   /* We store a reference to the object here in order to keep
  70      the buffer alive during the lifetime of the Iobject. */
  71   PyObject *pbuf;
  72 } Iobject;
  73
  74 /* IOobject (common) methods */
  75
  76 PyDoc_STRVAR(IO_flush__doc__, "flush(): does nothing.");
  77
  78 static int
  79 IO__opencheck(IOobject *self) {
  80         if (!self->buf) {
  81                 PyErr_SetString(PyExc_ValueError,
  82                                 "I/O operation on closed file");
  83                 return 0;
  84         }
  85         return 1;
  86 }
  87
  88 static PyObject *
  89 IO_get_closed(IOobject *self, void *closure)
  90 {
  91         PyObject *result = Py_False;
  92
  93         if (self->buf == NULL)
  94                 result = Py_True;
  95         Py_INCREF(result);
  96         return result;
  97 }
  98
  99 static PyGetSetDef file_getsetlist[] = {
 100         {"closed", (getter)IO_get_closed, NULL, "True if the file is closed"},
 101         {0},
 102 };
 103
 104 static PyObject *
 105 IO_flush(IOobject *self, PyObject *unused) {
 106
 107         if (!IO__opencheck(self)) return NULL;
 108
 109         Py_INCREF(Py_None);
 110         return Py_None;
 111 }
 112
 113 PyDoc_STRVAR(IO_getval__doc__,
 114 "getvalue([use_pos]) -- Get the string value."
 115 "\n"
 116 "If use_pos is specified and is a true value, then the string returned\n"
 117 "will include only the text up to the current file position.\n");
 118
 119 static PyObject *
 120 IO_cgetval(PyObject *self) {
 121         if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 122         return PyString_FromStringAndSize(((IOobject*)self)->buf,
 123                                           ((IOobject*)self)->pos);
 124 }
 125
 126 static PyObject *
 127 IO_getval(IOobject *self, PyObject *args) {
 128         PyObject *use_pos=Py_None;
 129         Py_ssize_t s;
 130
 131         if (!IO__opencheck(self)) return NULL;
 132         if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL;
 133
 134         if (PyObject_IsTrue(use_pos)) {
 135                   s=self->pos;
 136                   if (s > self->string_size) s=self->string_size;
 137         }
 138         else
 139                   s=self->string_size;
 140         return PyString_FromStringAndSize(self->buf, s);
 141 }
 142
 143 PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
 144
 145 static PyObject *
 146 IO_isatty(IOobject *self, PyObject *unused) {
 147         if (!IO__opencheck(self)) return NULL;
 148         Py_INCREF(Py_False);
 149         return Py_False;
 150 }
 151
 152 PyDoc_STRVAR(IO_read__doc__,
 153 "read([s]) -- Read s characters, or the rest of the string");
 154
 155 static int
 156 IO_cread(PyObject *self, char **output, Py_ssize_t  n) {
 157         Py_ssize_t l;
 158
 159         if (!IO__opencheck(IOOOBJECT(self))) return -1;
 160         l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
 161         if (n < 0 || n > l) {
 162                 n = l;
 163                 if (n < 0) n=0;
 164         }
 165
 166         *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
 167         ((IOobject*)self)->pos += n;
 168         return n;
 169 }
 170
 171 static PyObject *
 172 IO_read(IOobject *self, PyObject *args) {
 173         Py_ssize_t n = -1;
 174         char *output = NULL;
 175
 176         if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;
 177
 178         if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
 179
 180         return PyString_FromStringAndSize(output, n);
 181 }
 182
 183 PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
 184
 185 static int
 186 IO_creadline(PyObject *self, char **output) {
 187         char *n, *s;
 188         Py_ssize_t l;
 189
 190         if (!IO__opencheck(IOOOBJECT(self))) return -1;
 191
 192         for (n = ((IOobject*)self)->buf + ((IOobject*)self)->pos,
 193                s = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
 194              n < s && *n != '\n'; n++);
 195         if (n < s) n++;
 196
 197         *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
 198         l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos;
 199         assert(((IOobject*)self)->pos + l < INT_MAX);
 200         ((IOobject*)self)->pos += (int)l;
 201         return (int)l;
 202 }
 203
 204 static PyObject *
 205 IO_readline(IOobject *self, PyObject *args) {
 206         int n, m=-1;
 207         char *output;
 208
 209         if (args)
 210                 if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
 211
 212         if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;
 213         if (m >= 0 && m < n) {
 214                 m = n - m;
 215                 n -= m;
 216                 self->pos -= m;
 217         }
 218         return PyString_FromStringAndSize(output, n);
 219 }
 220
 221 PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
 222
 223 static PyObject *
 224 IO_readlines(IOobject *self, PyObject *args) {
 225         int n;
 226         char *output;
 227         PyObject *result, *line;
 228         int hint = 0, length = 0;
 229
 230         if (!PyArg_ParseTuple(args, "|i:readlines", &hint)) return NULL;
 231
 232         result = PyList_New(0);
 233         if (!result)
 234                 return NULL;
 235
 236         while (1){
 237                 if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
 238                         goto err;
 239                 if (n == 0)
 240                         break;
 241                 line = PyString_FromStringAndSize (output, n);
 242                 if (!line)
 243                         goto err;
 244                 if (PyList_Append (result, line) == -1) {
 245                         Py_DECREF (line);
 246                         goto err;
 247                 }
 248                 Py_DECREF (line);
 249                 length += n;
 250                 if (hint > 0 && length >= hint)
 251                         break;
 252         }
 253         return result;
 254  err:
 255         Py_DECREF(result);
 256         return NULL;
 257 }
 258
 259 PyDoc_STRVAR(IO_reset__doc__,
 260 "reset() -- Reset the file position to the beginning");
 261
 262 static PyObject *
 263 IO_reset(IOobject *self, PyObject *unused) {
 264
 265         if (!IO__opencheck(self)) return NULL;
 266
 267         self->pos = 0;
 268
 269         Py_INCREF(Py_None);
 270         return Py_None;
 271 }
 272
 273 PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
 274
 275 static PyObject *
 276 IO_tell(IOobject *self, PyObject *unused) {
 277
 278         if (!IO__opencheck(self)) return NULL;
 279
 280         return PyInt_FromSsize_t(self->pos);
 281 }
 282
 283 PyDoc_STRVAR(IO_truncate__doc__,
 284 "truncate(): truncate the file at the current position.");
 285
 286 static PyObject *
 287 IO_truncate(IOobject *self, PyObject *args) {
 288         Py_ssize_t pos = -1;
 289
 290         if (!IO__opencheck(self)) return NULL;
 291         if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;
 292
 293         if (PyTuple_Size(args) == 0) {
 294                 /* No argument passed, truncate to current position */
 295                 pos = self->pos;
 296         }
 297
 298         if (pos < 0) {
 299                 errno = EINVAL;
 300                 PyErr_SetFromErrno(PyExc_IOError);
 301                 return NULL;
 302         }
 303
 304         if (self->string_size > pos) self->string_size = pos;
 305         self->pos = self->string_size;
 306
 307         Py_INCREF(Py_None);
 308         return Py_None;
 309 }
 310
 311 static PyObject *
 312 IO_iternext(Iobject *self)
 313 {
 314         PyObject *next;
 315         next = IO_readline((IOobject *)self, NULL);
 316         if (!next)
 317                 return NULL;
 318         if (!PyString_GET_SIZE(next)) {
 319                 Py_DECREF(next);
 320                 PyErr_SetNone(PyExc_StopIteration);
 321                 return NULL;
 322         }
 323         return next;
 324 }
 325
 326
 327
 328
 329 /* Read-write object methods */
 330
 331 PyDoc_STRVAR(O_seek__doc__,
 332 "seek(position)       -- set the current position\n"
 333 "seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
 334
 335 static PyObject *
 336 O_seek(Oobject *self, PyObject *args) {
 337         Py_ssize_t position;
 338         int mode = 0;
 339
 340         if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 341         if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
 342                 return NULL;
 343
 344         if (mode == 2) {
 345                 position += self->string_size;
 346         }
 347         else if (mode == 1) {
 348                 position += self->pos;
 349         }
 350
 351         if (position > self->buf_size) {
 352                   char *newbuf;
 353                   self->buf_size*=2;
 354                   if (self->buf_size <= position) self->buf_size=position+1;
 355                   newbuf = (char*) realloc(self->buf,self->buf_size);
 356                   if (!newbuf) {
 357                       free(self->buf);
 358                       self->buf = 0;
 359                       self->buf_size=self->pos=0;
 360                       return PyErr_NoMemory();
 361                     }
 362                   self->buf = newbuf;
 363           }
 364         else if (position < 0) position=0;
 365
 366         self->pos=position;
 367
 368         while (--position >= self->string_size) self->buf[position]=0;
 369
 370         Py_INCREF(Py_None);
 371         return Py_None;
 372 }
 373
 374 PyDoc_STRVAR(O_write__doc__,
 375 "write(s) -- Write a string to the file"
 376 "\n\nNote (hack:) writing None resets the buffer");
 377
 378
 379 static int
 380 O_cwrite(PyObject *self, const char *c, Py_ssize_t  l) {
 381         Py_ssize_t newl;
 382         Oobject *oself;
 383         char *newbuf;
 384
 385         if (!IO__opencheck(IOOOBJECT(self))) return -1;
 386         oself = (Oobject *)self;
 387
 388         newl = oself->pos+l;
 389         if (newl >= oself->buf_size) {
 390             oself->buf_size *= 2;
 391             if (oself->buf_size <= newl) {
 392                     assert(newl + 1 < INT_MAX);
 393                     oself->buf_size = (int)(newl+1);
 394             }
 395             newbuf = (char*)realloc(oself->buf, oself->buf_size);
 396             if (!newbuf) {
 397                     PyErr_SetString(PyExc_MemoryError,"out of memory");
 398                     free(oself->buf);
 399                     oself->buf = 0;
 400                     oself->buf_size = oself->pos = 0;
 401                     return -1;
 402               }
 403             oself->buf = newbuf;
 404           }
 405
 406         memcpy(oself->buf+oself->pos,c,l);
 407
 408         assert(oself->pos + l < INT_MAX);
 409         oself->pos += (int)l;
 410
 411         if (oself->string_size < oself->pos) {
 412             oself->string_size = oself->pos;
 413         }
 414
 415         return (int)l;
 416 }
 417
 418 static PyObject *
 419 O_write(Oobject *self, PyObject *args) {
 420         char *c;
 421         int l;
 422
 423         if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL;
 424
 425         if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;
 426
 427         Py_INCREF(Py_None);
 428         return Py_None;
 429 }
 430
 431 PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
 432
 433 static PyObject *
 434 O_close(Oobject *self, PyObject *unused) {
 435         if (self->buf != NULL) free(self->buf);
 436         self->buf = NULL;
 437
 438         self->pos = self->string_size = self->buf_size = 0;
 439
 440         Py_INCREF(Py_None);
 441         return Py_None;
 442 }
 443
 444 PyDoc_STRVAR(O_writelines__doc__,
 445 "writelines(sequence_of_strings) -> None.  Write the strings to the file.\n"
 446 "\n"
 447 "Note that newlines are not added.  The sequence can be any iterable object\n"
 448 "producing strings. This is equivalent to calling write() for each string.");
 449 static PyObject *
 450 O_writelines(Oobject *self, PyObject *args) {
 451         PyObject *it, *s;
 452
 453         it = PyObject_GetIter(args);
 454         if (it == NULL)
 455                 return NULL;
 456         while ((s = PyIter_Next(it)) != NULL) {
 457                 Py_ssize_t n;
 458                 char *c;
 459                 if (PyString_AsStringAndSize(s, &c, &n) == -1) {
 460                         Py_DECREF(it);
 461                         Py_DECREF(s);
 462                         return NULL;
 463                 }
 464                 if (O_cwrite((PyObject *)self, c, n) == -1) {
 465                         Py_DECREF(it);
 466                         Py_DECREF(s);
 467                         return NULL;
 468                }
 469                Py_DECREF(s);
 470        }
 471
 472        Py_DECREF(it);
 473
 474        /* See if PyIter_Next failed */
 475        if (PyErr_Occurred())
 476                return NULL;
 477
 478        Py_RETURN_NONE;
 479 }
 480 static struct PyMethodDef O_methods[] = {
 481   /* Common methods: */
 482   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},
 483   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},
 484   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},
 485   {"read",      (PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},
 486   {"readline",  (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
 487   {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
 488   {"reset",     (PyCFunction)IO_reset,    METH_NOARGS,  IO_reset__doc__},
 489   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},
 490   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
 491
 492   /* Read-write StringIO specific  methods: */
 493   {"close",      (PyCFunction)O_close,      METH_NOARGS,  O_close__doc__},
 494   {"seek",       (PyCFunction)O_seek,       METH_VARARGS, O_seek__doc__},
 495   {"write",      (PyCFunction)O_write,      METH_VARARGS, O_write__doc__},
 496   {"writelines", (PyCFunction)O_writelines, METH_O,       O_writelines__doc__},
 497   {NULL,         NULL}          /* sentinel */
 498 };
 499
 500 static PyMemberDef O_memberlist[] = {
 501         {"softspace",   T_INT,  offsetof(Oobject, softspace),   0,
 502          "flag indicating that a space needs to be printed; used by print"},
 503          /* getattr(f, "closed") is implemented without this table */
 504         {NULL} /* Sentinel */
 505 };
 506
 507 static void
 508 O_dealloc(Oobject *self) {
 509         if (self->buf != NULL)
 510                 free(self->buf);
 511         PyObject_Del(self);
 512 }
 513
 514 PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
 515
 516 static PyTypeObject Otype = {
 517   PyVarObject_HEAD_INIT(NULL, 0)
 518   "cStringIO.StringO",          /*tp_name*/
 519   sizeof(Oobject),              /*tp_basicsize*/
 520   0,                            /*tp_itemsize*/
 521   /* methods */
 522   (destructor)O_dealloc,        /*tp_dealloc*/
 523   0,                            /*tp_print*/
 524   0,                            /*tp_getattr */
 525   0,                            /*tp_setattr */
 526   0,                            /*tp_compare*/
 527   0,                            /*tp_repr*/
 528   0,                            /*tp_as_number*/
 529   0,                            /*tp_as_sequence*/
 530   0,                            /*tp_as_mapping*/
 531   0,                            /*tp_hash*/
 532   0     ,                       /*tp_call*/
 533   0,                            /*tp_str*/
 534   0,                            /*tp_getattro */
 535   0,                            /*tp_setattro */
 536   0,                            /*tp_as_buffer */
 537   Py_TPFLAGS_DEFAULT,           /*tp_flags*/
 538   Otype__doc__,                 /*tp_doc */
 539   0,                            /*tp_traverse */
 540   0,                            /*tp_clear */
 541   0,                            /*tp_richcompare */
 542   0,                            /*tp_weaklistoffset */
 543   PyObject_SelfIter,            /*tp_iter */
 544   (iternextfunc)IO_iternext,    /*tp_iternext */
 545   O_methods,                    /*tp_methods */
 546   O_memberlist,                 /*tp_members */
 547   file_getsetlist,              /*tp_getset */
 548 };
 549
 550 static PyObject *
 551 newOobject(int  size) {
 552         Oobject *self;
 553
 554         self = PyObject_New(Oobject, &Otype);
 555         if (self == NULL)
 556                 return NULL;
 557         self->pos=0;
 558         self->string_size = 0;
 559         self->softspace = 0;
 560
 561         self->buf = (char *)malloc(size);
 562         if (!self->buf) {
 563                   PyErr_SetString(PyExc_MemoryError,"out of memory");
 564                   self->buf_size = 0;
 565                   Py_DECREF(self);
 566                   return NULL;
 567           }
 568
 569         self->buf_size=size;
 570         return (PyObject*)self;
 571 }
 572
 573 /* End of code for StringO objects */
 574 /* -------------------------------------------------------- */
 575
 576 static PyObject *
 577 I_close(Iobject *self, PyObject *unused) {
 578         Py_CLEAR(self->pbuf);
 579         self->buf = NULL;
 580
 581         self->pos = self->string_size = 0;
 582
 583         Py_INCREF(Py_None);
 584         return Py_None;
 585 }
 586
 587 static PyObject *
 588 I_seek(Iobject *self, PyObject *args) {
 589         Py_ssize_t position;
 590         int mode = 0;
 591
 592         if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 593         if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
 594                 return NULL;
 595
 596         if (mode == 2) position += self->string_size;
 597         else if (mode == 1) position += self->pos;
 598
 599         if (position < 0) position=0;
 600
 601         self->pos=position;
 602
 603         Py_INCREF(Py_None);
 604         return Py_None;
 605 }
 606
 607 static struct PyMethodDef I_methods[] = {
 608   /* Common methods: */
 609   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},
 610   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},
 611   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},
 612   {"read",      (PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},
 613   {"readline",  (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
 614   {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
 615   {"reset",     (PyCFunction)IO_reset,    METH_NOARGS,  IO_reset__doc__},
 616   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},
 617   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
 618
 619   /* Read-only StringIO specific  methods: */
 620   {"close",     (PyCFunction)I_close,    METH_NOARGS,  O_close__doc__},
 621   {"seek",      (PyCFunction)I_seek,     METH_VARARGS, O_seek__doc__},
 622   {NULL,        NULL}
 623 };
 624
 625 static void
 626 I_dealloc(Iobject *self) {
 627   Py_XDECREF(self->pbuf);
 628   PyObject_Del(self);
 629 }
 630
 631
 632 PyDoc_STRVAR(Itype__doc__,
 633 "Simple type for treating strings as input file streams");
 634
 635 static PyTypeObject Itype = {
 636   PyVarObject_HEAD_INIT(NULL, 0)
 637   "cStringIO.StringI",                  /*tp_name*/
 638   sizeof(Iobject),                      /*tp_basicsize*/
 639   0,                                    /*tp_itemsize*/
 640   /* methods */
 641   (destructor)I_dealloc,                /*tp_dealloc*/
 642   0,                                    /*tp_print*/
 643   0,                                    /* tp_getattr */
 644   0,                                    /*tp_setattr*/
 645   0,                                    /*tp_compare*/
 646   0,                                    /*tp_repr*/
 647   0,                                    /*tp_as_number*/
 648   0,                                    /*tp_as_sequence*/
 649   0,                                    /*tp_as_mapping*/
 650   0,                                    /*tp_hash*/
 651   0,                                    /*tp_call*/
 652   0,                                    /*tp_str*/
 653   0,                                    /* tp_getattro */
 654   0,                                    /* tp_setattro */
 655   0,                                    /* tp_as_buffer */
 656   Py_TPFLAGS_DEFAULT,                   /* tp_flags */
 657   Itype__doc__,                         /* tp_doc */
 658   0,                                    /* tp_traverse */
 659   0,                                    /* tp_clear */
 660   0,                                    /* tp_richcompare */
 661   0,                                    /* tp_weaklistoffset */
 662   PyObject_SelfIter,                    /* tp_iter */
 663   (iternextfunc)IO_iternext,            /* tp_iternext */
 664   I_methods,                            /* tp_methods */
 665   0,                                    /* tp_members */
 666   file_getsetlist,                      /* tp_getset */
 667 };
 668
 669 static PyObject *
 670 newIobject(PyObject *s) {
 671   Iobject *self;
 672   char *buf;
 673   Py_ssize_t size;
 674
 675   if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) {
 676     PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found",
 677                  s->ob_type->tp_name);
 678     return NULL;
 679   }
 680
 681   self = PyObject_New(Iobject, &Itype);
 682   if (!self) return NULL;
 683   Py_INCREF(s);
 684   self->buf=buf;
 685   self->string_size=size;
 686   self->pbuf=s;
 687   self->pos=0;
 688
 689   return (PyObject*)self;
 690 }
 691
 692 /* End of code for StringI objects */
 693 /* -------------------------------------------------------- */
 694
 695
 696 PyDoc_STRVAR(IO_StringIO__doc__,
 697 "StringIO([s]) -- Return a StringIO-like stream for reading or writing");
 698
 699 static PyObject *
 700 IO_StringIO(PyObject *self, PyObject *args) {
 701   PyObject *s=0;
 702
 703   if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
 704
 705   if (s) return newIobject(s);
 706   return newOobject(128);
 707 }
 708
 709 /* List of methods defined in the module */
 710
 711 static struct PyMethodDef IO_methods[] = {
 712   {"StringIO",  (PyCFunction)IO_StringIO,
 713    METH_VARARGS,        IO_StringIO__doc__},
 714   {NULL,                NULL}           /* sentinel */
 715 };
 716
 717
 718 /* Initialization function for the module (*must* be called initcStringIO) */
 719
 720 static struct PycStringIO_CAPI CAPI = {
 721   IO_cread,
 722   IO_creadline,
 723   O_cwrite,
 724   IO_cgetval,
 725   newOobject,
 726   newIobject,
 727   &Itype,
 728   &Otype,
 729 };
 730
 731 #ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
 732 #define PyMODINIT_FUNC void
 733 #endif
 734 PyMODINIT_FUNC
 735 initcStringIO(void) {
 736   PyObject *m, *d, *v;
 737
 738
 739   /* Create the module and add the functions */
 740   m = Py_InitModule4("cStringIO", IO_methods,
 741                      cStringIO_module_documentation,
 742                      (PyObject*)NULL,PYTHON_API_VERSION);
 743   if (m == NULL) return;
 744
 745   /* Add some symbolic constants to the module */
 746   d = PyModule_GetDict(m);
 747
 748   /* Export C API */
 749   Py_TYPE(&Itype)=&PyType_Type;
 750   Py_TYPE(&Otype)=&PyType_Type;
 751   if (PyType_Ready(&Otype) < 0) return;
 752   if (PyType_Ready(&Itype) < 0) return;
 753   PyDict_SetItemString(d,"cStringIO_CAPI",
 754                        v = PyCObject_FromVoidPtr(&CAPI,NULL));
 755   Py_XDECREF(v);
 756
 757   /* Export Types */
 758   PyDict_SetItemString(d,"InputType",  (PyObject*)&Itype);
 759   PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
 760
 761   /* Maybe make certain warnings go away */
 762   if (0) PycString_IMPORT;
 763 }