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         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         Py_ssize_t position;
 328         int mode = 0;
 329
 330         if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 331         if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
 332                 return NULL;
 333
 334         if (mode == 2) {
 335                 position += self->string_size;
 336         }
 337         else if (mode == 1) {
 338                 position += self->pos;
 339         }
 340
 341         if (position > self->buf_size) {
 342                   self->buf_size*=2;
 343                   if (self->buf_size <= position) self->buf_size=position+1;
 344                   self->buf = (char*) realloc(self->buf,self->buf_size);
 345                   if (!self->buf) {
 346                       self->buf_size=self->pos=0;
 347                       return PyErr_NoMemory();
 348                     }
 349           }
 350         else if (position < 0) position=0;
 351
 352         self->pos=position;
 353
 354         while (--position >= self->string_size) self->buf[position]=0;
 355
 356         Py_INCREF(Py_None);
 357         return Py_None;
 358 }
 359
 360 PyDoc_STRVAR(O_write__doc__,
 361 "write(s) -- Write a string to the file"
 362 "\n\nNote (hack:) writing None resets the buffer");
 363
 364
 365 static int
 366 O_cwrite(PyObject *self, const char *c, Py_ssize_t  l) {
 367         Py_ssize_t newl;
 368         Oobject *oself;
 369
 370         if (!IO__opencheck(IOOOBJECT(self))) return -1;
 371         oself = (Oobject *)self;
 372
 373         newl = oself->pos+l;
 374         if (newl >= oself->buf_size) {
 375             oself->buf_size *= 2;
 376             if (oself->buf_size <= newl) {
 377                     assert(newl + 1 < INT_MAX);
 378                     oself->buf_size = (int)(newl+1);
 379             }
 380             oself->buf = (char*)realloc(oself->buf, oself->buf_size);
 381             if (!oself->buf) {
 382                     PyErr_SetString(PyExc_MemoryError,"out of memory");
 383                     oself->buf_size = oself->pos = 0;
 384                     return -1;
 385               }
 386           }
 387
 388         memcpy(oself->buf+oself->pos,c,l);
 389
 390         assert(oself->pos + l < INT_MAX);
 391         oself->pos += (int)l;
 392
 393         if (oself->string_size < oself->pos) {
 394             oself->string_size = oself->pos;
 395         }
 396
 397         return (int)l;
 398 }
 399
 400 static PyObject *
 401 O_write(Oobject *self, PyObject *args) {
 402         char *c;
 403         int l;
 404
 405         if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL;
 406
 407         if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;
 408
 409         Py_INCREF(Py_None);
 410         return Py_None;
 411 }
 412
 413 PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
 414
 415 static PyObject *
 416 O_close(Oobject *self, PyObject *unused) {
 417         if (self->buf != NULL) free(self->buf);
 418         self->buf = NULL;
 419
 420         self->pos = self->string_size = self->buf_size = 0;
 421
 422         Py_INCREF(Py_None);
 423         return Py_None;
 424 }
 425
 426 PyDoc_STRVAR(O_writelines__doc__,
 427 "writelines(sequence_of_strings) -> None.  Write the strings to the file.\n"
 428 "\n"
 429 "Note that newlines are not added.  The sequence can be any iterable object\n"
 430 "producing strings. This is equivalent to calling write() for each string.");
 431 static PyObject *
 432 O_writelines(Oobject *self, PyObject *args) {
 433         PyObject *it, *s;
 434
 435         it = PyObject_GetIter(args);
 436         if (it == NULL)
 437                 return NULL;
 438         while ((s = PyIter_Next(it)) != NULL) {
 439                 Py_ssize_t n;
 440                 char *c;
 441                 if (PyString_AsStringAndSize(s, &c, &n) == -1) {
 442                         Py_DECREF(it);
 443                         Py_DECREF(s);
 444                         return NULL;
 445                 }
 446                 if (O_cwrite((PyObject *)self, c, n) == -1) {
 447                         Py_DECREF(it);
 448                         Py_DECREF(s);
 449                         return NULL;
 450                }
 451                Py_DECREF(s);
 452        }
 453
 454        Py_DECREF(it);
 455
 456        /* See if PyIter_Next failed */
 457        if (PyErr_Occurred())
 458                return NULL;
 459
 460        Py_RETURN_NONE;
 461 }
 462 static struct PyMethodDef O_methods[] = {
 463   /* Common methods: */
 464   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},
 465   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},
 466   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},
 467   {"read",      (PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},
 468   {"readline",  (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
 469   {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
 470   {"reset",     (PyCFunction)IO_reset,    METH_NOARGS,  IO_reset__doc__},
 471   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},
 472   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
 473
 474   /* Read-write StringIO specific  methods: */
 475   {"close",      (PyCFunction)O_close,      METH_NOARGS,  O_close__doc__},
 476   {"seek",       (PyCFunction)O_seek,       METH_VARARGS, O_seek__doc__},
 477   {"write",      (PyCFunction)O_write,      METH_VARARGS, O_write__doc__},
 478   {"writelines", (PyCFunction)O_writelines, METH_O,       O_writelines__doc__},
 479   {NULL,         NULL}          /* sentinel */
 480 };
 481
 482 static PyMemberDef O_memberlist[] = {
 483         {"softspace",   T_INT,  offsetof(Oobject, softspace),   0,
 484          "flag indicating that a space needs to be printed; used by print"},
 485          /* getattr(f, "closed") is implemented without this table */
 486         {NULL} /* Sentinel */
 487 };
 488
 489 static void
 490 O_dealloc(Oobject *self) {
 491         if (self->buf != NULL)
 492                 free(self->buf);
 493         PyObject_Del(self);
 494 }
 495
 496 PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
 497
 498 static PyTypeObject Otype = {
 499   PyObject_HEAD_INIT(NULL)
 500   0,                            /*ob_size*/
 501   "cStringIO.StringO",          /*tp_name*/
 502   sizeof(Oobject),              /*tp_basicsize*/
 503   0,                            /*tp_itemsize*/
 504   /* methods */
 505   (destructor)O_dealloc,        /*tp_dealloc*/
 506   0,                            /*tp_print*/
 507   0,                            /*tp_getattr */
 508   0,                            /*tp_setattr */
 509   0,                            /*tp_compare*/
 510   0,                            /*tp_repr*/
 511   0,                            /*tp_as_number*/
 512   0,                            /*tp_as_sequence*/
 513   0,                            /*tp_as_mapping*/
 514   0,                            /*tp_hash*/
 515   0     ,                       /*tp_call*/
 516   0,                            /*tp_str*/
 517   0,                            /*tp_getattro */
 518   0,                            /*tp_setattro */
 519   0,                            /*tp_as_buffer */
 520   Py_TPFLAGS_DEFAULT,           /*tp_flags*/
 521   Otype__doc__,                 /*tp_doc */
 522   0,                            /*tp_traverse */
 523   0,                            /*tp_clear */
 524   0,                            /*tp_richcompare */
 525   0,                            /*tp_weaklistoffset */
 526   PyObject_SelfIter,            /*tp_iter */
 527   (iternextfunc)IO_iternext,    /*tp_iternext */
 528   O_methods,                    /*tp_methods */
 529   O_memberlist,                 /*tp_members */
 530   file_getsetlist,              /*tp_getset */
 531 };
 532
 533 static PyObject *
 534 newOobject(int  size) {
 535         Oobject *self;
 536
 537         self = PyObject_New(Oobject, &Otype);
 538         if (self == NULL)
 539                 return NULL;
 540         self->pos=0;
 541         self->string_size = 0;
 542         self->softspace = 0;
 543
 544         self->buf = (char *)malloc(size);
 545         if (!self->buf) {
 546                   PyErr_SetString(PyExc_MemoryError,"out of memory");
 547                   self->buf_size = 0;
 548                   Py_DECREF(self);
 549                   return NULL;
 550           }
 551
 552         self->buf_size=size;
 553         return (PyObject*)self;
 554 }
 555
 556 /* End of code for StringO objects */
 557 /* -------------------------------------------------------- */
 558
 559 static PyObject *
 560 I_close(Iobject *self, PyObject *unused) {
 561         Py_XDECREF(self->pbuf);
 562         self->pbuf = NULL;
 563         self->buf = NULL;
 564
 565         self->pos = self->string_size = 0;
 566
 567         Py_INCREF(Py_None);
 568         return Py_None;
 569 }
 570
 571 static PyObject *
 572 I_seek(Iobject *self, PyObject *args) {
 573         Py_ssize_t position;
 574         int mode = 0;
 575
 576         if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 577         if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
 578                 return NULL;
 579
 580         if (mode == 2) position += self->string_size;
 581         else if (mode == 1) position += self->pos;
 582
 583         if (position < 0) position=0;
 584
 585         self->pos=position;
 586
 587         Py_INCREF(Py_None);
 588         return Py_None;
 589 }
 590
 591 static struct PyMethodDef I_methods[] = {
 592   /* Common methods: */
 593   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},
 594   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},
 595   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},
 596   {"read",      (PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},
 597   {"readline",  (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
 598   {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
 599   {"reset",     (PyCFunction)IO_reset,    METH_NOARGS,  IO_reset__doc__},
 600   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},
 601   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
 602
 603   /* Read-only StringIO specific  methods: */
 604   {"close",     (PyCFunction)I_close,    METH_NOARGS,  O_close__doc__},
 605   {"seek",      (PyCFunction)I_seek,     METH_VARARGS, O_seek__doc__},
 606   {NULL,        NULL}
 607 };
 608
 609 static void
 610 I_dealloc(Iobject *self) {
 611   Py_XDECREF(self->pbuf);
 612   PyObject_Del(self);
 613 }
 614
 615
 616 PyDoc_STRVAR(Itype__doc__,
 617 "Simple type for treating strings as input file streams");
 618
 619 static PyTypeObject Itype = {
 620   PyObject_HEAD_INIT(NULL)
 621   0,                                    /*ob_size*/
 622   "cStringIO.StringI",                  /*tp_name*/
 623   sizeof(Iobject),                      /*tp_basicsize*/
 624   0,                                    /*tp_itemsize*/
 625   /* methods */
 626   (destructor)I_dealloc,                /*tp_dealloc*/
 627   0,                                    /*tp_print*/
 628   0,                                    /* tp_getattr */
 629   0,                                    /*tp_setattr*/
 630   0,                                    /*tp_compare*/
 631   0,                                    /*tp_repr*/
 632   0,                                    /*tp_as_number*/
 633   0,                                    /*tp_as_sequence*/
 634   0,                                    /*tp_as_mapping*/
 635   0,                                    /*tp_hash*/
 636   0,                                    /*tp_call*/
 637   0,                                    /*tp_str*/
 638   0,                                    /* tp_getattro */
 639   0,                                    /* tp_setattro */
 640   0,                                    /* tp_as_buffer */
 641   Py_TPFLAGS_DEFAULT,                   /* tp_flags */
 642   Itype__doc__,                         /* tp_doc */
 643   0,                                    /* tp_traverse */
 644   0,                                    /* tp_clear */
 645   0,                                    /* tp_richcompare */
 646   0,                                    /* tp_weaklistoffset */
 647   PyObject_SelfIter,                    /* tp_iter */
 648   (iternextfunc)IO_iternext,            /* tp_iternext */
 649   I_methods,                            /* tp_methods */
 650   0,                                    /* tp_members */
 651   file_getsetlist,                      /* tp_getset */
 652 };
 653
 654 static PyObject *
 655 newIobject(PyObject *s) {
 656   Iobject *self;
 657   char *buf;
 658   Py_ssize_t size;
 659
 660   if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) {
 661       PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found",
 662                    s->ob_type->tp_name);
 663       return NULL;
 664   }
 665   self = PyObject_New(Iobject, &Itype);
 666   if (!self) return NULL;
 667   Py_INCREF(s);
 668   self->buf=buf;
 669   self->string_size=size;
 670   self->pbuf=s;
 671   self->pos=0;
 672
 673   return (PyObject*)self;
 674 }
 675
 676 /* End of code for StringI objects */
 677 /* -------------------------------------------------------- */
 678
 679
 680 PyDoc_STRVAR(IO_StringIO__doc__,
 681 "StringIO([s]) -- Return a StringIO-like stream for reading or writing");
 682
 683 static PyObject *
 684 IO_StringIO(PyObject *self, PyObject *args) {
 685   PyObject *s=0;
 686
 687   if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
 688
 689   if (s) return newIobject(s);
 690   return newOobject(128);
 691 }
 692
 693 /* List of methods defined in the module */
 694
 695 static struct PyMethodDef IO_methods[] = {
 696   {"StringIO",  (PyCFunction)IO_StringIO,
 697    METH_VARARGS,        IO_StringIO__doc__},
 698   {NULL,                NULL}           /* sentinel */
 699 };
 700
 701
 702 /* Initialization function for the module (*must* be called initcStringIO) */
 703
 704 static struct PycStringIO_CAPI CAPI = {
 705   IO_cread,
 706   IO_creadline,
 707   O_cwrite,
 708   IO_cgetval,
 709   newOobject,
 710   newIobject,
 711   &Itype,
 712   &Otype,
 713 };
 714
 715 #ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
 716 #define PyMODINIT_FUNC void
 717 #endif
 718 PyMODINIT_FUNC
 719 initcStringIO(void) {
 720   PyObject *m, *d, *v;
 721
 722
 723   /* Create the module and add the functions */
 724   m = Py_InitModule4("cStringIO", IO_methods,
 725                      cStringIO_module_documentation,
 726                      (PyObject*)NULL,PYTHON_API_VERSION);
 727   if (m == NULL) return;
 728
 729   /* Add some symbolic constants to the module */
 730   d = PyModule_GetDict(m);
 731
 732   /* Export C API */
 733   Itype.ob_type=&PyType_Type;
 734   Otype.ob_type=&PyType_Type;
 735   if (PyType_Ready(&Otype) < 0) return;
 736   if (PyType_Ready(&Itype) < 0) return;
 737   PyDict_SetItemString(d,"cStringIO_CAPI",
 738                        v = PyCObject_FromVoidPtr(&CAPI,NULL));
 739   Py_XDECREF(v);
 740
 741   /* Export Types */
 742   PyDict_SetItemString(d,"InputType",  (PyObject*)&Itype);
 743   PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
 744
 745   /* Maybe make certain warnings go away */
 746   if (0) PycString_IMPORT;
 747 }