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