source: python/trunk/Modules/cStringIO.c@ 389

Last change on this file since 389 was 2, checked in by Yuri Dario, 15 years ago

Initial import for vendor code.
  • Property svn:eol-style set to native
File size: 20.3 KB
Line 
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 assert(IOOOBJECT(self)->pos >= 0);
123 return PyString_FromStringAndSize(((IOobject*)self)->buf,
124 ((IOobject*)self)->pos);
125}
126
127static PyObject *
128IO_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
145PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
146
147static PyObject *
148IO_isatty(IOobject *self, PyObject *unused) {
149 if (!IO__opencheck(self)) return NULL;
150 Py_INCREF(Py_False);
151 return Py_False;
152}
153
154PyDoc_STRVAR(IO_read__doc__,
155"read([s]) -- Read s characters, or the rest of the string");
156
157static int
158IO_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
175static PyObject *
176IO_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
187PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
188
189static int
190IO_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
213static PyObject *
214IO_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
231PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
232
233static PyObject *
234IO_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
269PyDoc_STRVAR(IO_reset__doc__,
270"reset() -- Reset the file position to the beginning");
271
272static PyObject *
273IO_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
283PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
284
285static PyObject *
286IO_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
294PyDoc_STRVAR(IO_truncate__doc__,
295"truncate(): truncate the file at the current position.");
296
297static PyObject *
298IO_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
322static PyObject *
323IO_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
342PyDoc_STRVAR(O_seek__doc__,
343"seek(position) -- set the current position\n"
344"seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
345
346static PyObject *
347O_seek(Oobject *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 > self->buf_size) {
363 char *newbuf;
364 self->buf_size*=2;
365 if (self->buf_size <= position) self->buf_size=position+1;
366 newbuf = (char*) realloc(self->buf,self->buf_size);
367 if (!newbuf) {
368 free(self->buf);
369 self->buf = 0;
370 self->buf_size=self->pos=0;
371 return PyErr_NoMemory();
372 }
373 self->buf = newbuf;
374 }
375 else if (position < 0) position=0;
376
377 self->pos=position;
378
379 while (--position >= self->string_size) self->buf[position]=0;
380
381 Py_INCREF(Py_None);
382 return Py_None;
383}
384
385PyDoc_STRVAR(O_write__doc__,
386"write(s) -- Write a string to the file"
387"\n\nNote (hack:) writing None resets the buffer");
388
389
390static int
391O_cwrite(PyObject *self, const char *c, Py_ssize_t l) {
392 Py_ssize_t newl;
393 Oobject *oself;
394 char *newbuf;
395
396 if (!IO__opencheck(IOOOBJECT(self))) return -1;
397 oself = (Oobject *)self;
398
399 newl = oself->pos+l;
400 if (newl >= oself->buf_size) {
401 oself->buf_size *= 2;
402 if (oself->buf_size <= newl) {
403 assert(newl + 1 < INT_MAX);
404 oself->buf_size = (int)(newl+1);
405 }
406 newbuf = (char*)realloc(oself->buf, oself->buf_size);
407 if (!newbuf) {
408 PyErr_SetString(PyExc_MemoryError,"out of memory");
409 free(oself->buf);
410 oself->buf = 0;
411 oself->buf_size = oself->pos = 0;
412 return -1;
413 }
414 oself->buf = newbuf;
415 }
416
417 memcpy(oself->buf+oself->pos,c,l);
418
419 assert(oself->pos + l < INT_MAX);
420 oself->pos += (int)l;
421
422 if (oself->string_size < oself->pos) {
423 oself->string_size = oself->pos;
424 }
425
426 return (int)l;
427}
428
429static PyObject *
430O_write(Oobject *self, PyObject *args) {
431 char *c;
432 int l;
433
434 if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL;
435
436 if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;
437
438 Py_INCREF(Py_None);
439 return Py_None;
440}
441
442PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
443
444static PyObject *
445O_close(Oobject *self, PyObject *unused) {
446 if (self->buf != NULL) free(self->buf);
447 self->buf = NULL;
448
449 self->pos = self->string_size = self->buf_size = 0;
450
451 Py_INCREF(Py_None);
452 return Py_None;
453}
454
455PyDoc_STRVAR(O_writelines__doc__,
456"writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
457"\n"
458"Note that newlines are not added. The sequence can be any iterable object\n"
459"producing strings. This is equivalent to calling write() for each string.");
460static PyObject *
461O_writelines(Oobject *self, PyObject *args) {
462 PyObject *it, *s;
463
464 it = PyObject_GetIter(args);
465 if (it == NULL)
466 return NULL;
467 while ((s = PyIter_Next(it)) != NULL) {
468 Py_ssize_t n;
469 char *c;
470 if (PyString_AsStringAndSize(s, &c, &n) == -1) {
471 Py_DECREF(it);
472 Py_DECREF(s);
473 return NULL;
474 }
475 if (O_cwrite((PyObject *)self, c, n) == -1) {
476 Py_DECREF(it);
477 Py_DECREF(s);
478 return NULL;
479 }
480 Py_DECREF(s);
481 }
482
483 Py_DECREF(it);
484
485 /* See if PyIter_Next failed */
486 if (PyErr_Occurred())
487 return NULL;
488
489 Py_RETURN_NONE;
490}
491static struct PyMethodDef O_methods[] = {
492 /* Common methods: */
493 {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
494 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
495 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
496 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
497 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
498 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
499 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
500 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
501 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
502
503 /* Read-write StringIO specific methods: */
504 {"close", (PyCFunction)O_close, METH_NOARGS, O_close__doc__},
505 {"seek", (PyCFunction)O_seek, METH_VARARGS, O_seek__doc__},
506 {"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__},
507 {"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__},
508 {NULL, NULL} /* sentinel */
509};
510
511static PyMemberDef O_memberlist[] = {
512 {"softspace", T_INT, offsetof(Oobject, softspace), 0,
513 "flag indicating that a space needs to be printed; used by print"},
514 /* getattr(f, "closed") is implemented without this table */
515 {NULL} /* Sentinel */
516};
517
518static void
519O_dealloc(Oobject *self) {
520 if (self->buf != NULL)
521 free(self->buf);
522 PyObject_Del(self);
523}
524
525PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
526
527static PyTypeObject Otype = {
528 PyVarObject_HEAD_INIT(NULL, 0)
529 "cStringIO.StringO", /*tp_name*/
530 sizeof(Oobject), /*tp_basicsize*/
531 0, /*tp_itemsize*/
532 /* methods */
533 (destructor)O_dealloc, /*tp_dealloc*/
534 0, /*tp_print*/
535 0, /*tp_getattr */
536 0, /*tp_setattr */
537 0, /*tp_compare*/
538 0, /*tp_repr*/
539 0, /*tp_as_number*/
540 0, /*tp_as_sequence*/
541 0, /*tp_as_mapping*/
542 0, /*tp_hash*/
543 0 , /*tp_call*/
544 0, /*tp_str*/
545 0, /*tp_getattro */
546 0, /*tp_setattro */
547 0, /*tp_as_buffer */
548 Py_TPFLAGS_DEFAULT, /*tp_flags*/
549 Otype__doc__, /*tp_doc */
550 0, /*tp_traverse */
551 0, /*tp_clear */
552 0, /*tp_richcompare */
553 0, /*tp_weaklistoffset */
554 PyObject_SelfIter, /*tp_iter */
555 (iternextfunc)IO_iternext, /*tp_iternext */
556 O_methods, /*tp_methods */
557 O_memberlist, /*tp_members */
558 file_getsetlist, /*tp_getset */
559};
560
561static PyObject *
562newOobject(int size) {
563 Oobject *self;
564
565 self = PyObject_New(Oobject, &Otype);
566 if (self == NULL)
567 return NULL;
568 self->pos=0;
569 self->string_size = 0;
570 self->softspace = 0;
571
572 self->buf = (char *)malloc(size);
573 if (!self->buf) {
574 PyErr_SetString(PyExc_MemoryError,"out of memory");
575 self->buf_size = 0;
576 Py_DECREF(self);
577 return NULL;
578 }
579
580 self->buf_size=size;
581 return (PyObject*)self;
582}
583
584/* End of code for StringO objects */
585/* -------------------------------------------------------- */
586
587static PyObject *
588I_close(Iobject *self, PyObject *unused) {
589 Py_CLEAR(self->pbuf);
590 self->buf = NULL;
591
592 self->pos = self->string_size = 0;
593
594 Py_INCREF(Py_None);
595 return Py_None;
596}
597
598static PyObject *
599I_seek(Iobject *self, PyObject *args) {
600 Py_ssize_t position;
601 int mode = 0;
602
603 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
604 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
605 return NULL;
606
607 if (mode == 2) position += self->string_size;
608 else if (mode == 1) position += self->pos;
609
610 if (position < 0) position=0;
611
612 self->pos=position;
613
614 Py_INCREF(Py_None);
615 return Py_None;
616}
617
618static 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 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
628 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
629
630 /* Read-only StringIO specific methods: */
631 {"close", (PyCFunction)I_close, METH_NOARGS, O_close__doc__},
632 {"seek", (PyCFunction)I_seek, METH_VARARGS, O_seek__doc__},
633 {NULL, NULL}
634};
635
636static void
637I_dealloc(Iobject *self) {
638 Py_XDECREF(self->pbuf);
639 PyObject_Del(self);
640}
641
642
643PyDoc_STRVAR(Itype__doc__,
644"Simple type for treating strings as input file streams");
645
646static 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
680static PyObject *
681newIobject(PyObject *s) {
682 Iobject *self;
683 char *buf;
684 Py_ssize_t size;
685
686 if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) {
687 PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found",
688 s->ob_type->tp_name);
689 return NULL;
690 }
691
692 self = PyObject_New(Iobject, &Itype);
693 if (!self) return NULL;
694 Py_INCREF(s);
695 self->buf=buf;
696 self->string_size=size;
697 self->pbuf=s;
698 self->pos=0;
699
700 return (PyObject*)self;
701}
702
703/* End of code for StringI objects */
704/* -------------------------------------------------------- */
705
706
707PyDoc_STRVAR(IO_StringIO__doc__,
708"StringIO([s]) -- Return a StringIO-like stream for reading or writing");
709
710static PyObject *
711IO_StringIO(PyObject *self, PyObject *args) {
712 PyObject *s=0;
713
714 if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
715
716 if (s) return newIobject(s);
717 return newOobject(128);
718}
719
720/* List of methods defined in the module */
721
722static struct PyMethodDef IO_methods[] = {
723 {"StringIO", (PyCFunction)IO_StringIO,
724 METH_VARARGS, IO_StringIO__doc__},
725 {NULL, NULL} /* sentinel */
726};
727
728
729/* Initialization function for the module (*must* be called initcStringIO) */
730
731static struct PycStringIO_CAPI CAPI = {
732 IO_cread,
733 IO_creadline,
734 O_cwrite,
735 IO_cgetval,
736 newOobject,
737 newIobject,
738 &Itype,
739 &Otype,
740};
741
742#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
743#define PyMODINIT_FUNC void
744#endif
745PyMODINIT_FUNC
746initcStringIO(void) {
747 PyObject *m, *d, *v;
748
749
750 /* Create the module and add the functions */
751 m = Py_InitModule4("cStringIO", IO_methods,
752 cStringIO_module_documentation,
753 (PyObject*)NULL,PYTHON_API_VERSION);
754 if (m == NULL) return;
755
756 /* Add some symbolic constants to the module */
757 d = PyModule_GetDict(m);
758
759 /* Export C API */
760 Py_TYPE(&Itype)=&PyType_Type;
761 Py_TYPE(&Otype)=&PyType_Type;
762 if (PyType_Ready(&Otype) < 0) return;
763 if (PyType_Ready(&Itype) < 0) return;
764 PyDict_SetItemString(d,"cStringIO_CAPI",
765 v = PyCObject_FromVoidPtr(&CAPI,NULL));
766 Py_XDECREF(v);
767
768 /* Export Types */
769 PyDict_SetItemString(d,"InputType", (PyObject*)&Itype);
770 PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
771
772 /* Maybe make certain warnings go away */
773 if (0) PycString_IMPORT;
774}
Note: See TracBrowser for help on using the repository browser.