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