Modules/cStringIO.c

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