Context Navigation

cStringIO.c

Last change on this file 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
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(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
346	static PyObject *
347	O_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
385	PyDoc_STRVAR(O_write__doc__,
386	"write(s) -- Write a string to the file"
387	"\n\nNote (hack:) writing None resets the buffer");
388
389
390	static int
391	O_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
429	static PyObject *
430	O_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
442	PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
443
444	static PyObject *
445	O_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
455	PyDoc_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.");
460	static PyObject *
461	O_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	}
491	static 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
511	static 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
518	static void
519	O_dealloc(Oobject *self) {
520	if (self->buf != NULL)
521	free(self->buf);
522	PyObject_Del(self);
523	}
524
525	PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
526
527	static 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
561	static PyObject *
562	newOobject(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
587	static PyObject *
588	I_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
598	static PyObject *
599	I_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
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	{"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
636	static void
637	I_dealloc(Iobject *self) {
638	Py_XDECREF(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	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
707	PyDoc_STRVAR(IO_StringIO__doc__,
708	"StringIO([s]) -- Return a StringIO-like stream for reading or writing");
709
710	static PyObject *
711	IO_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
722	static 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
731	static 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
745	PyMODINIT_FUNC
746	initcStringIO(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.

Context Navigation

source: python/vendor/Python-2.6.5/Modules/cStringIO.c

Download in other formats: