AppPkg/Applications/Python/Python-2.7.10/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     Py_buffer pbuf;
  70 } Iobject;
  71
  72 /* IOobject (common) methods */
  73
  74 PyDoc_STRVAR(IO_flush__doc__, "flush(): does nothing.");
  75
  76 static int
  77 IO__opencheck(IOobject *self) {
  78     if (!self->buf) {
  79         PyErr_SetString(PyExc_ValueError,
  80                         "I/O operation on closed file");
  81         return 0;
  82     }
  83     return 1;
  84 }
  85
  86 static PyObject *
  87 IO_get_closed(IOobject *self, void *closure)
  88 {
  89     PyObject *result = Py_False;
  90
  91     if (self->buf == NULL)
  92         result = Py_True;
  93     Py_INCREF(result);
  94     return result;
  95 }
  96
  97 static PyGetSetDef file_getsetlist[] = {
  98     {"closed", (getter)IO_get_closed, NULL, "True if the file is closed"},
  99     {0},
 100 };
 101
 102 static PyObject *
 103 IO_flush(IOobject *self, PyObject *unused) {
 104
 105     if (!IO__opencheck(self)) return NULL;
 106
 107     Py_INCREF(Py_None);
 108     return Py_None;
 109 }
 110
 111 PyDoc_STRVAR(IO_getval__doc__,
 112 "getvalue([use_pos]) -- Get the string value."
 113 "\n"
 114 "If use_pos is specified and is a true value, then the string returned\n"
 115 "will include only the text up to the current file position.\n");
 116
 117 static PyObject *
 118 IO_cgetval(PyObject *self) {
 119     if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 120     assert(IOOOBJECT(self)->pos >= 0);
 121     return PyString_FromStringAndSize(((IOobject*)self)->buf,
 122                                       ((IOobject*)self)->pos);
 123 }
 124
 125 static PyObject *
 126 IO_getval(IOobject *self, PyObject *args) {
 127     PyObject *use_pos=Py_None;
 128     int b;
 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     b = PyObject_IsTrue(use_pos);
 135     if (b < 0)
 136         return NULL;
 137     if (b) {
 138               s=self->pos;
 139               if (s > self->string_size) s=self->string_size;
 140     }
 141     else
 142               s=self->string_size;
 143     assert(self->pos >= 0);
 144     return PyString_FromStringAndSize(self->buf, s);
 145 }
 146
 147 PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
 148
 149 static PyObject *
 150 IO_isatty(IOobject *self, PyObject *unused) {
 151     if (!IO__opencheck(self)) return NULL;
 152     Py_INCREF(Py_False);
 153     return Py_False;
 154 }
 155
 156 PyDoc_STRVAR(IO_read__doc__,
 157 "read([s]) -- Read s characters, or the rest of the string");
 158
 159 static int
 160 IO_cread(PyObject *self, char **output, Py_ssize_t  n) {
 161     Py_ssize_t l;
 162
 163     if (!IO__opencheck(IOOOBJECT(self))) return -1;
 164     assert(IOOOBJECT(self)->pos >= 0);
 165     assert(IOOOBJECT(self)->string_size >= 0);
 166     l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
 167     if (n < 0 || n > l) {
 168         n = l;
 169         if (n < 0) n=0;
 170     }
 171     if (n > INT_MAX) {
 172         PyErr_SetString(PyExc_OverflowError,
 173                         "length too large");
 174         return -1;
 175     }
 176
 177     *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
 178     ((IOobject*)self)->pos += n;
 179     return (int)n;
 180 }
 181
 182 static PyObject *
 183 IO_read(IOobject *self, PyObject *args) {
 184     Py_ssize_t n = -1;
 185     char *output = NULL;
 186
 187     if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;
 188
 189     if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
 190
 191     return PyString_FromStringAndSize(output, n);
 192 }
 193
 194 PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
 195
 196 static int
 197 IO_creadline(PyObject *self, char **output) {
 198     char *n, *start, *end;
 199     Py_ssize_t len;
 200
 201     if (!IO__opencheck(IOOOBJECT(self))) return -1;
 202
 203     n = start = ((IOobject*)self)->buf + ((IOobject*)self)->pos;
 204     end = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
 205     while (n < end && *n != '\n')
 206         n++;
 207
 208     if (n < end) n++;
 209
 210     len = n - start;
 211     if (len > INT_MAX)
 212         len = INT_MAX;
 213
 214     *output=start;
 215
 216     assert(IOOOBJECT(self)->pos <= PY_SSIZE_T_MAX - len);
 217     assert(IOOOBJECT(self)->pos >= 0);
 218     assert(IOOOBJECT(self)->string_size >= 0);
 219
 220     ((IOobject*)self)->pos += len;
 221     return (int)len;
 222 }
 223
 224 static PyObject *
 225 IO_readline(IOobject *self, PyObject *args) {
 226     int n, m=-1;
 227     char *output;
 228
 229     if (args)
 230         if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
 231
 232     if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;
 233     if (m >= 0 && m < n) {
 234         m = n - m;
 235         n -= m;
 236         self->pos -= m;
 237     }
 238     assert(IOOOBJECT(self)->pos >= 0);
 239     return PyString_FromStringAndSize(output, n);
 240 }
 241
 242 PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
 243
 244 static PyObject *
 245 IO_readlines(IOobject *self, PyObject *args) {
 246     int n;
 247     char *output;
 248     PyObject *result, *line;
 249     Py_ssize_t hint = 0, length = 0;
 250
 251     if (!PyArg_ParseTuple(args, "|n:readlines", &hint)) return NULL;
 252
 253     result = PyList_New(0);
 254     if (!result)
 255         return NULL;
 256
 257     while (1){
 258         if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
 259             goto err;
 260         if (n == 0)
 261             break;
 262         line = PyString_FromStringAndSize (output, n);
 263         if (!line)
 264             goto err;
 265         if (PyList_Append (result, line) == -1) {
 266             Py_DECREF (line);
 267             goto err;
 268         }
 269         Py_DECREF (line);
 270         length += n;
 271         if (hint > 0 && length >= hint)
 272             break;
 273     }
 274     return result;
 275  err:
 276     Py_DECREF(result);
 277     return NULL;
 278 }
 279
 280 PyDoc_STRVAR(IO_reset__doc__,
 281 "reset() -- Reset the file position to the beginning");
 282
 283 static PyObject *
 284 IO_reset(IOobject *self, PyObject *unused) {
 285
 286     if (!IO__opencheck(self)) return NULL;
 287
 288     self->pos = 0;
 289
 290     Py_INCREF(Py_None);
 291     return Py_None;
 292 }
 293
 294 PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
 295
 296 static PyObject *
 297 IO_tell(IOobject *self, PyObject *unused) {
 298
 299     if (!IO__opencheck(self)) return NULL;
 300
 301     assert(self->pos >= 0);
 302     return PyInt_FromSsize_t(self->pos);
 303 }
 304
 305 PyDoc_STRVAR(IO_truncate__doc__,
 306 "truncate(): truncate the file at the current position.");
 307
 308 static PyObject *
 309 IO_truncate(IOobject *self, PyObject *args) {
 310     Py_ssize_t pos = -1;
 311
 312     if (!IO__opencheck(self)) return NULL;
 313     if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;
 314
 315     if (PyTuple_Size(args) == 0) {
 316         /* No argument passed, truncate to current position */
 317         pos = self->pos;
 318     }
 319
 320     if (pos < 0) {
 321         errno = EINVAL;
 322         PyErr_SetFromErrno(PyExc_IOError);
 323         return NULL;
 324     }
 325
 326     if (self->string_size > pos) self->string_size = pos;
 327     self->pos = self->string_size;
 328
 329     Py_INCREF(Py_None);
 330     return Py_None;
 331 }
 332
 333 static PyObject *
 334 IO_iternext(Iobject *self)
 335 {
 336     PyObject *next;
 337     next = IO_readline((IOobject *)self, NULL);
 338     if (!next)
 339         return NULL;
 340     if (!PyString_GET_SIZE(next)) {
 341         Py_DECREF(next);
 342         PyErr_SetNone(PyExc_StopIteration);
 343         return NULL;
 344     }
 345     return next;
 346 }
 347
 348
 349
 350
 351 /* Read-write object methods */
 352
 353 PyDoc_STRVAR(IO_seek__doc__,
 354 "seek(position)       -- set the current position\n"
 355 "seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
 356
 357 static PyObject *
 358 IO_seek(Iobject *self, PyObject *args) {
 359     Py_ssize_t position;
 360     int mode = 0;
 361
 362     if (!IO__opencheck(IOOOBJECT(self))) return NULL;
 363     if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
 364         return NULL;
 365
 366     if (mode == 2) {
 367         position += self->string_size;
 368     }
 369     else if (mode == 1) {
 370         position += self->pos;
 371     }
 372
 373     if (position < 0) position=0;
 374
 375     self->pos=position;
 376
 377     Py_INCREF(Py_None);
 378     return Py_None;
 379 }
 380
 381 PyDoc_STRVAR(O_write__doc__,
 382 "write(s) -- Write a string to the file"
 383 "\n\nNote (hack:) writing None resets the buffer");
 384
 385
 386 static int
 387 O_cwrite(PyObject *self, const char *c, Py_ssize_t  len) {
 388     Py_ssize_t newpos;
 389     Oobject *oself;
 390     char *newbuf;
 391
 392     if (!IO__opencheck(IOOOBJECT(self))) return -1;
 393     oself = (Oobject *)self;
 394
 395     if (len > INT_MAX) {
 396         PyErr_SetString(PyExc_OverflowError,
 397                         "length too large");
 398         return -1;
 399     }
 400     assert(len >= 0);
 401     if (oself->pos >= PY_SSIZE_T_MAX - len) {
 402         PyErr_SetString(PyExc_OverflowError,
 403                         "new position too large");
 404         return -1;
 405     }
 406     newpos = oself->pos + len;
 407     if (newpos >= oself->buf_size) {
 408         size_t newsize = oself->buf_size;
 409         newsize *= 2;
 410         if (newsize <= (size_t)newpos || newsize > PY_SSIZE_T_MAX) {
 411             assert(newpos < PY_SSIZE_T_MAX - 1);
 412             newsize = newpos + 1;
 413         }
 414         newbuf = (char*)realloc(oself->buf, newsize);
 415         if (!newbuf) {
 416             PyErr_SetString(PyExc_MemoryError,"out of memory");
 417             return -1;
 418         }
 419         oself->buf_size = (Py_ssize_t)newsize;
 420         oself->buf = newbuf;
 421     }
 422
 423     if (oself->string_size < oself->pos) {
 424         /* In case of overseek, pad with null bytes the buffer region between
 425            the end of stream and the current position.
 426
 427           0   lo      string_size                           hi
 428           |   |<---used--->|<----------available----------->|
 429           |   |            <--to pad-->|<---to write--->    |
 430           0   buf                   position
 431         */
 432         memset(oself->buf + oself->string_size, '\0',
 433                (oself->pos - oself->string_size) * sizeof(char));
 434     }
 435
 436     memcpy(oself->buf + oself->pos, c, len);
 437
 438     oself->pos = newpos;
 439
 440     if (oself->string_size < oself->pos) {
 441         oself->string_size = oself->pos;
 442     }
 443
 444     return (int)len;
 445 }
 446
 447 static PyObject *
 448 O_write(Oobject *self, PyObject *args) {
 449     Py_buffer buf;
 450     int result;
 451
 452     if (!PyArg_ParseTuple(args, "s*:write", &buf)) return NULL;
 453
 454     result = O_cwrite((PyObject*)self, buf.buf, buf.len);
 455     PyBuffer_Release(&buf);
 456     if (result < 0) return NULL;
 457
 458     Py_INCREF(Py_None);
 459     return Py_None;
 460 }
 461
 462 PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
 463
 464 static PyObject *
 465 O_close(Oobject *self, PyObject *unused) {
 466     if (self->buf != NULL) free(self->buf);
 467     self->buf = NULL;
 468
 469     self->pos = self->string_size = self->buf_size = 0;
 470
 471     Py_INCREF(Py_None);
 472     return Py_None;
 473 }
 474
 475 PyDoc_STRVAR(O_writelines__doc__,
 476 "writelines(sequence_of_strings) -> None.  Write the strings to the file.\n"
 477 "\n"
 478 "Note that newlines are not added.  The sequence can be any iterable object\n"
 479 "producing strings. This is equivalent to calling write() for each string.");
 480 static PyObject *
 481 O_writelines(Oobject *self, PyObject *args) {
 482     PyObject *it, *s;
 483
 484     it = PyObject_GetIter(args);
 485     if (it == NULL)
 486         return NULL;
 487     while ((s = PyIter_Next(it)) != NULL) {
 488         Py_ssize_t n;
 489         char *c;
 490         if (PyString_AsStringAndSize(s, &c, &n) == -1) {
 491             Py_DECREF(it);
 492             Py_DECREF(s);
 493             return NULL;
 494         }
 495         if (O_cwrite((PyObject *)self, c, n) == -1) {
 496             Py_DECREF(it);
 497             Py_DECREF(s);
 498             return NULL;
 499            }
 500            Py_DECREF(s);
 501        }
 502
 503        Py_DECREF(it);
 504
 505        /* See if PyIter_Next failed */
 506        if (PyErr_Occurred())
 507            return NULL;
 508
 509        Py_RETURN_NONE;
 510 }
 511 static struct PyMethodDef O_methods[] = {
 512   /* Common methods: */
 513   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},
 514   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},
 515   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},
 516   {"read",      (PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},
 517   {"readline",  (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
 518   {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
 519   {"reset",     (PyCFunction)IO_reset,    METH_NOARGS,  IO_reset__doc__},
 520   {"seek",      (PyCFunction)IO_seek,     METH_VARARGS, IO_seek__doc__},
 521   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},
 522   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
 523
 524   /* Read-write StringIO specific  methods: */
 525   {"close",      (PyCFunction)O_close,      METH_NOARGS,  O_close__doc__},
 526   {"write",      (PyCFunction)O_write,      METH_VARARGS, O_write__doc__},
 527   {"writelines", (PyCFunction)O_writelines, METH_O,       O_writelines__doc__},
 528   {NULL,         NULL}          /* sentinel */
 529 };
 530
 531 static PyMemberDef O_memberlist[] = {
 532     {"softspace",       T_INT,  offsetof(Oobject, softspace),   0,
 533      "flag indicating that a space needs to be printed; used by print"},
 534      /* getattr(f, "closed") is implemented without this table */
 535     {NULL} /* Sentinel */
 536 };
 537
 538 static void
 539 O_dealloc(Oobject *self) {
 540     if (self->buf != NULL)
 541         free(self->buf);
 542     PyObject_Del(self);
 543 }
 544
 545 PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
 546
 547 static PyTypeObject Otype = {
 548   PyVarObject_HEAD_INIT(NULL, 0)
 549   "cStringIO.StringO",          /*tp_name*/
 550   sizeof(Oobject),              /*tp_basicsize*/
 551   0,                            /*tp_itemsize*/
 552   /* methods */
 553   (destructor)O_dealloc,        /*tp_dealloc*/
 554   0,                            /*tp_print*/
 555   0,                            /*tp_getattr */
 556   0,                            /*tp_setattr */
 557   0,                            /*tp_compare*/
 558   0,                            /*tp_repr*/
 559   0,                            /*tp_as_number*/
 560   0,                            /*tp_as_sequence*/
 561   0,                            /*tp_as_mapping*/
 562   0,                            /*tp_hash*/
 563   0     ,                       /*tp_call*/
 564   0,                            /*tp_str*/
 565   0,                            /*tp_getattro */
 566   0,                            /*tp_setattro */
 567   0,                            /*tp_as_buffer */
 568   Py_TPFLAGS_DEFAULT,           /*tp_flags*/
 569   Otype__doc__,                 /*tp_doc */
 570   0,                            /*tp_traverse */
 571   0,                            /*tp_clear */
 572   0,                            /*tp_richcompare */
 573   0,                            /*tp_weaklistoffset */
 574   PyObject_SelfIter,            /*tp_iter */
 575   (iternextfunc)IO_iternext,    /*tp_iternext */
 576   O_methods,                    /*tp_methods */
 577   O_memberlist,                 /*tp_members */
 578   file_getsetlist,              /*tp_getset */
 579 };
 580
 581 static PyObject *
 582 newOobject(int  size) {
 583     Oobject *self;
 584
 585     self = PyObject_New(Oobject, &Otype);
 586     if (self == NULL)
 587         return NULL;
 588     self->pos=0;
 589     self->string_size = 0;
 590     self->softspace = 0;
 591
 592     self->buf = (char *)malloc(size);
 593     if (!self->buf) {
 594               PyErr_SetString(PyExc_MemoryError,"out of memory");
 595               self->buf_size = 0;
 596               Py_DECREF(self);
 597               return NULL;
 598       }
 599
 600     self->buf_size=size;
 601     return (PyObject*)self;
 602 }
 603
 604 /* End of code for StringO objects */
 605 /* -------------------------------------------------------- */
 606
 607 static PyObject *
 608 I_close(Iobject *self, PyObject *unused) {
 609     PyBuffer_Release(&self->pbuf);
 610     self->buf = NULL;
 611
 612     self->pos = self->string_size = 0;
 613
 614     Py_INCREF(Py_None);
 615     return Py_None;
 616 }
 617
 618 static struct PyMethodDef I_methods[] = {
 619   /* Common methods: */
 620   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},
 621   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},
 622   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},
 623   {"read",      (PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},
 624   {"readline",  (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
 625   {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
 626   {"reset",     (PyCFunction)IO_reset,    METH_NOARGS,  IO_reset__doc__},
 627   {"seek",      (PyCFunction)IO_seek,     METH_VARARGS, IO_seek__doc__},
 628   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},
 629   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
 630
 631   /* Read-only StringIO specific  methods: */
 632   {"close",     (PyCFunction)I_close,    METH_NOARGS,  O_close__doc__},
 633   {NULL,        NULL}
 634 };
 635
 636 static void
 637 I_dealloc(Iobject *self) {
 638   PyBuffer_Release(&self->pbuf);
 639   PyObject_Del(self);
 640 }
 641
 642
 643 PyDoc_STRVAR(Itype__doc__,
 644 "Simple type for treating strings as input file streams");
 645
 646 static PyTypeObject Itype = {
 647   PyVarObject_HEAD_INIT(NULL, 0)
 648   "cStringIO.StringI",                  /*tp_name*/
 649   sizeof(Iobject),                      /*tp_basicsize*/
 650   0,                                    /*tp_itemsize*/
 651   /* methods */
 652   (destructor)I_dealloc,                /*tp_dealloc*/
 653   0,                                    /*tp_print*/
 654   0,                                    /* tp_getattr */
 655   0,                                    /*tp_setattr*/
 656   0,                                    /*tp_compare*/
 657   0,                                    /*tp_repr*/
 658   0,                                    /*tp_as_number*/
 659   0,                                    /*tp_as_sequence*/
 660   0,                                    /*tp_as_mapping*/
 661   0,                                    /*tp_hash*/
 662   0,                                    /*tp_call*/
 663   0,                                    /*tp_str*/
 664   0,                                    /* tp_getattro */
 665   0,                                    /* tp_setattro */
 666   0,                                    /* tp_as_buffer */
 667   Py_TPFLAGS_DEFAULT,                   /* tp_flags */
 668   Itype__doc__,                         /* tp_doc */
 669   0,                                    /* tp_traverse */
 670   0,                                    /* tp_clear */
 671   0,                                    /* tp_richcompare */
 672   0,                                    /* tp_weaklistoffset */
 673   PyObject_SelfIter,                    /* tp_iter */
 674   (iternextfunc)IO_iternext,            /* tp_iternext */
 675   I_methods,                            /* tp_methods */
 676   0,                                    /* tp_members */
 677   file_getsetlist,                      /* tp_getset */
 678 };
 679
 680 static PyObject *
 681 newIobject(PyObject *s) {
 682   Iobject *self;
 683   Py_buffer buf;
 684   PyObject *args;
 685   int result;
 686
 687   args = Py_BuildValue("(O)", s);
 688   if (args == NULL)
 689       return NULL;
 690   result = PyArg_ParseTuple(args, "s*:StringIO", &buf);
 691   Py_DECREF(args);
 692   if (!result)
 693       return NULL;
 694
 695   self = PyObject_New(Iobject, &Itype);
 696   if (!self) {
 697       PyBuffer_Release(&buf);
 698       return NULL;
 699   }
 700   self->buf=buf.buf;
 701   self->string_size=buf.len;
 702   self->pbuf=buf;
 703   self->pos=0;
 704
 705   return (PyObject*)self;
 706 }
 707
 708 /* End of code for StringI objects */
 709 /* -------------------------------------------------------- */
 710
 711
 712 PyDoc_STRVAR(IO_StringIO__doc__,
 713 "StringIO([s]) -- Return a StringIO-like stream for reading or writing");
 714
 715 static PyObject *
 716 IO_StringIO(PyObject *self, PyObject *args) {
 717   PyObject *s=0;
 718
 719   if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
 720
 721   if (s) return newIobject(s);
 722   return newOobject(128);
 723 }
 724
 725 /* List of methods defined in the module */
 726
 727 static struct PyMethodDef IO_methods[] = {
 728   {"StringIO",  (PyCFunction)IO_StringIO,
 729    METH_VARARGS,        IO_StringIO__doc__},
 730   {NULL,                NULL}           /* sentinel */
 731 };
 732
 733
 734 /* Initialization function for the module (*must* be called initcStringIO) */
 735
 736 static struct PycStringIO_CAPI CAPI = {
 737   IO_cread,
 738   IO_creadline,
 739   O_cwrite,
 740   IO_cgetval,
 741   newOobject,
 742   newIobject,
 743   &Itype,
 744   &Otype,
 745 };
 746
 747 #ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
 748 #define PyMODINIT_FUNC void
 749 #endif
 750 PyMODINIT_FUNC
 751 initcStringIO(void) {
 752   PyObject *m, *d, *v;
 753
 754
 755   /* Create the module and add the functions */
 756   m = Py_InitModule4("cStringIO", IO_methods,
 757                      cStringIO_module_documentation,
 758                      (PyObject*)NULL,PYTHON_API_VERSION);
 759   if (m == NULL) return;
 760
 761   /* Add some symbolic constants to the module */
 762   d = PyModule_GetDict(m);
 763
 764   /* Export C API */
 765   Py_TYPE(&Itype)=&PyType_Type;
 766   Py_TYPE(&Otype)=&PyType_Type;
 767   if (PyType_Ready(&Otype) < 0) return;
 768   if (PyType_Ready(&Itype) < 0) return;
 769   v = PyCapsule_New(&CAPI, PycStringIO_CAPSULE_NAME, NULL);
 770   PyDict_SetItemString(d,"cStringIO_CAPI", v);
 771   Py_XDECREF(v);
 772
 773   /* Export Types */
 774   PyDict_SetItemString(d,"InputType",  (PyObject*)&Itype);
 775   PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
 776
 777   /* Maybe make certain warnings go away */
 778   if (0) PycString_IMPORT;
 779 }