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_XDECREF(self->pbuf);
 579         self->pbuf = NULL;
 580         self->buf = NULL;
 581
 582         self->pos = self->string_size = 0;
 583
 584         Py_INCREF(Py_None);
 585         return Py_None;
 586 }
 587
 588 static PyObject *
 589 I_seek(Iobject *self, PyObject *args) {
 590         Py_ssize_t position;
 591         int mode = 0;
 592
 593         if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 594         if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
 595                 return NULL;
 596
 597         if (mode == 2) position += self->string_size;
 598         else if (mode == 1) position += self->pos;
 599
 600         if (position < 0) position=0;
 601
 602         self->pos=position;
 603
 604         Py_INCREF(Py_None);
 605         return Py_None;
 606 }
 607
 608 static struct PyMethodDef I_methods[] = {
 609   /* Common methods: */
 610   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},
 611   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},
 612   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},
 613   {"read",      (PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},
 614   {"readline",  (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
 615   {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
 616   {"reset",     (PyCFunction)IO_reset,    METH_NOARGS,  IO_reset__doc__},
 617   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},
 618   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
 619
 620   /* Read-only StringIO specific  methods: */
 621   {"close",     (PyCFunction)I_close,    METH_NOARGS,  O_close__doc__},
 622   {"seek",      (PyCFunction)I_seek,     METH_VARARGS, O_seek__doc__},
 623   {NULL,        NULL}
 624 };
 625
 626 static void
 627 I_dealloc(Iobject *self) {
 628   Py_XDECREF(self->pbuf);
 629   PyObject_Del(self);
 630 }
 631
 632
 633 PyDoc_STRVAR(Itype__doc__,
 634 "Simple type for treating strings as input file streams");
 635
 636 static PyTypeObject Itype = {
 637   PyVarObject_HEAD_INIT(NULL, 0)
 638   "cStringIO.StringI",                  /*tp_name*/
 639   sizeof(Iobject),                      /*tp_basicsize*/
 640   0,                                    /*tp_itemsize*/
 641   /* methods */
 642   (destructor)I_dealloc,                /*tp_dealloc*/
 643   0,                                    /*tp_print*/
 644   0,                                    /* tp_getattr */
 645   0,                                    /*tp_setattr*/
 646   0,                                    /*tp_compare*/
 647   0,                                    /*tp_repr*/
 648   0,                                    /*tp_as_number*/
 649   0,                                    /*tp_as_sequence*/
 650   0,                                    /*tp_as_mapping*/
 651   0,                                    /*tp_hash*/
 652   0,                                    /*tp_call*/
 653   0,                                    /*tp_str*/
 654   0,                                    /* tp_getattro */
 655   0,                                    /* tp_setattro */
 656   0,                                    /* tp_as_buffer */
 657   Py_TPFLAGS_DEFAULT,                   /* tp_flags */
 658   Itype__doc__,                         /* tp_doc */
 659   0,                                    /* tp_traverse */
 660   0,                                    /* tp_clear */
 661   0,                                    /* tp_richcompare */
 662   0,                                    /* tp_weaklistoffset */
 663   PyObject_SelfIter,                    /* tp_iter */
 664   (iternextfunc)IO_iternext,            /* tp_iternext */
 665   I_methods,                            /* tp_methods */
 666   0,                                    /* tp_members */
 667   file_getsetlist,                      /* tp_getset */
 668 };
 669
 670 static PyObject *
 671 newIobject(PyObject *s) {
 672   Iobject *self;
 673   char *buf;
 674   Py_ssize_t size;
 675
 676   if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) {
 677     PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found",
 678                  s->ob_type->tp_name);
 679     return NULL;
 680   }
 681
 682   self = PyObject_New(Iobject, &Itype);
 683   if (!self) return NULL;
 684   Py_INCREF(s);
 685   self->buf=buf;
 686   self->string_size=size;
 687   self->pbuf=s;
 688   self->pos=0;
 689
 690   return (PyObject*)self;
 691 }
 692
 693 /* End of code for StringI objects */
 694 /* -------------------------------------------------------- */
 695
 696
 697 PyDoc_STRVAR(IO_StringIO__doc__,
 698 "StringIO([s]) -- Return a StringIO-like stream for reading or writing");
 699
 700 static PyObject *
 701 IO_StringIO(PyObject *self, PyObject *args) {
 702   PyObject *s=0;
 703
 704   if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
 705
 706   if (s) return newIobject(s);
 707   return newOobject(128);
 708 }
 709
 710 /* List of methods defined in the module */
 711
 712 static struct PyMethodDef IO_methods[] = {
 713   {"StringIO",  (PyCFunction)IO_StringIO,
 714    METH_VARARGS,        IO_StringIO__doc__},
 715   {NULL,                NULL}           /* sentinel */
 716 };
 717
 718
 719 /* Initialization function for the module (*must* be called initcStringIO) */
 720
 721 static struct PycStringIO_CAPI CAPI = {
 722   IO_cread,
 723   IO_creadline,
 724   O_cwrite,
 725   IO_cgetval,
 726   newOobject,
 727   newIobject,
 728   &Itype,
 729   &Otype,
 730 };
 731
 732 #ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
 733 #define PyMODINIT_FUNC void
 734 #endif
 735 PyMODINIT_FUNC
 736 initcStringIO(void) {
 737   PyObject *m, *d, *v;
 738
 739
 740   /* Create the module and add the functions */
 741   m = Py_InitModule4("cStringIO", IO_methods,
 742                      cStringIO_module_documentation,
 743                      (PyObject*)NULL,PYTHON_API_VERSION);
 744   if (m == NULL) return;
 745
 746   /* Add some symbolic constants to the module */
 747   d = PyModule_GetDict(m);
 748
 749   /* Export C API */
 750   Py_TYPE(&Itype)=&PyType_Type;
 751   Py_TYPE(&Otype)=&PyType_Type;
 752   if (PyType_Ready(&Otype) < 0) return;
 753   if (PyType_Ready(&Itype) < 0) return;
 754   PyDict_SetItemString(d,"cStringIO_CAPI",
 755                        v = PyCObject_FromVoidPtr(&CAPI,NULL));
 756   Py_XDECREF(v);
 757
 758   /* Export Types */
 759   PyDict_SetItemString(d,"InputType",  (PyObject*)&Itype);
 760   PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
 761
 762   /* Maybe make certain warnings go away */
 763   if (0) PycString_IMPORT;
 764 }