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