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