blob: 8fbb4f9af644c6b43a2cd53039cb82214f4622ed [file] [log] [blame]
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001
2#include "Python.h"
3#include "import.h"
4#include "cStringIO.h"
Raymond Hettinger352f9472003-04-24 15:50:11 +00005#include "structmember.h"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00006
7PyDoc_STRVAR(cStringIO_module_documentation,
Guido van Rossum049cd901996-12-05 23:30:48 +00008"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"
Fred Drakeaef10002000-06-19 13:17:41 +000012"full generality of StringIO, but it provides enough for most\n"
Thomas Wouters7e474022000-07-16 12:04:32 +000013"applications and is especially useful in conjunction with the\n"
Guido van Rossum049cd901996-12-05 23:30:48 +000014"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"
Jeremy Hyltonb189b072002-03-08 17:17:33 +000023" value=an_output_stream.getvalue()\n"
Guido van Rossum049cd901996-12-05 23:30:48 +000024"\n"
25" an_input_stream=StringIO(a_string)\n"
26" spam=an_input_stream.readline()\n"
27" spam=an_input_stream.read(5)\n"
Guido van Rossum7d9b4131998-11-25 16:17:32 +000028" an_input_stream.seek(0) # OK, start over\n"
Guido van Rossum049cd901996-12-05 23:30:48 +000029" 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"
Guido van Rossum142eeb81997-08-13 03:14:41 +000033"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000034"cStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp\n");
Guido van Rossum049cd901996-12-05 23:30:48 +000035
Jim Fultone60de4d2000-10-06 19:24:23 +000036/* Declaration for file-like objects that manage data as strings
Guido van Rossum049cd901996-12-05 23:30:48 +000037
Jim Fultone60de4d2000-10-06 19:24:23 +000038 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*/
Guido van Rossum049cd901996-12-05 23:30:48 +000043
44typedef struct {
45 PyObject_HEAD
46 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +000047 Py_ssize_t pos, string_size;
Jim Fultone60de4d2000-10-06 19:24:23 +000048} IOobject;
49
50#define IOOOBJECT(O) ((IOobject*)(O))
51
Skip Montanaroe1388282003-08-11 13:15:11 +000052/* Declarations for objects of type StringO */
Jim Fultone60de4d2000-10-06 19:24:23 +000053
54typedef struct { /* Subtype of IOobject */
55 PyObject_HEAD
56 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +000057 Py_ssize_t pos, string_size;
Jim Fultone60de4d2000-10-06 19:24:23 +000058
Martin v. Löwis18e16552006-02-15 17:27:45 +000059 Py_ssize_t buf_size;
60 int softspace;
Jim Fultone60de4d2000-10-06 19:24:23 +000061} Oobject;
62
63/* Declarations for objects of type StringI */
64
65typedef struct { /* Subtype of IOobject */
66 PyObject_HEAD
67 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +000068 Py_ssize_t pos, string_size;
Marc-André Lemburge47df7a2001-09-24 17:34:52 +000069 /* We store a reference to the object here in order to keep
70 the buffer alive during the lifetime of the Iobject. */
Guido van Rossum049cd901996-12-05 23:30:48 +000071 PyObject *pbuf;
72} Iobject;
73
Jim Fultone60de4d2000-10-06 19:24:23 +000074/* IOobject (common) methods */
75
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000076PyDoc_STRVAR(IO_flush__doc__, "flush(): does nothing.");
Jim Fultone60de4d2000-10-06 19:24:23 +000077
78static int
79IO__opencheck(IOobject *self) {
Martin v. Löwis5df2e612006-03-01 23:10:49 +000080 if (!self->buf) {
Jim Fultone60de4d2000-10-06 19:24:23 +000081 PyErr_SetString(PyExc_ValueError,
82 "I/O operation on closed file");
83 return 0;
84 }
85 return 1;
86}
87
88static PyObject *
Raymond Hettinger5475f232003-08-08 12:20:03 +000089IO_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 *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000105IO_flush(IOobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000106
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000107 if (!IO__opencheck(self)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000108
109 Py_INCREF(Py_None);
110 return Py_None;
111}
112
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000113PyDoc_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");
Guido van Rossum049cd901996-12-05 23:30:48 +0000118
119static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000120IO_cgetval(PyObject *self) {
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000121 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
Martin v. Löwis73c01d42008-02-14 11:26:18 +0000122 assert(IOOOBJECT(self)->pos >= 0);
Jim Fultone60de4d2000-10-06 19:24:23 +0000123 return PyString_FromStringAndSize(((IOobject*)self)->buf,
124 ((IOobject*)self)->pos);
Guido van Rossum049cd901996-12-05 23:30:48 +0000125}
126
Guido van Rossum049cd901996-12-05 23:30:48 +0000127static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000128IO_getval(IOobject *self, PyObject *args) {
129 PyObject *use_pos=Py_None;
Martin v. Löwisad0a4622006-02-16 14:30:23 +0000130 Py_ssize_t s;
Jim Fultone60de4d2000-10-06 19:24:23 +0000131
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000132 if (!IO__opencheck(self)) return NULL;
133 if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000134
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;
Martin v. Löwis73c01d42008-02-14 11:26:18 +0000141 assert(self->pos >= 0);
Jim Fultone60de4d2000-10-06 19:24:23 +0000142 return PyString_FromStringAndSize(self->buf, s);
Guido van Rossum049cd901996-12-05 23:30:48 +0000143}
144
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000145PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
Guido van Rossum049cd901996-12-05 23:30:48 +0000146
147static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000148IO_isatty(IOobject *self, PyObject *unused) {
Walter Dörwald197e8322006-03-15 22:13:13 +0000149 if (!IO__opencheck(self)) return NULL;
150 Py_INCREF(Py_False);
Guido van Rossum674deb22002-09-01 15:06:28 +0000151 return Py_False;
Guido van Rossum049cd901996-12-05 23:30:48 +0000152}
153
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000154PyDoc_STRVAR(IO_read__doc__,
155"read([s]) -- Read s characters, or the rest of the string");
Guido van Rossum049cd901996-12-05 23:30:48 +0000156
157static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000158IO_cread(PyObject *self, char **output, Py_ssize_t n) {
Martin v. Löwisad0a4622006-02-16 14:30:23 +0000159 Py_ssize_t l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000160
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000161 if (!IO__opencheck(IOOOBJECT(self))) return -1;
Martin v. Löwis73c01d42008-02-14 11:26:18 +0000162 assert(IOOOBJECT(self)->pos >= 0);
163 assert(IOOOBJECT(self)->string_size >= 0);
Jim Fultone60de4d2000-10-06 19:24:23 +0000164 l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
165 if (n < 0 || n > l) {
166 n = l;
167 if (n < 0) n=0;
168 }
Guido van Rossum049cd901996-12-05 23:30:48 +0000169
Jim Fultone60de4d2000-10-06 19:24:23 +0000170 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
171 ((IOobject*)self)->pos += n;
172 return n;
Guido van Rossum049cd901996-12-05 23:30:48 +0000173}
174
175static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000176IO_read(IOobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000177 Py_ssize_t n = -1;
Thomas Woutersf86d1e82006-03-01 22:15:15 +0000178 char *output = NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000179
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000180 if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000181
Jim Fultone60de4d2000-10-06 19:24:23 +0000182 if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000183
Jim Fultone60de4d2000-10-06 19:24:23 +0000184 return PyString_FromStringAndSize(output, n);
Guido van Rossum049cd901996-12-05 23:30:48 +0000185}
186
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000187PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
Guido van Rossum049cd901996-12-05 23:30:48 +0000188
189static int
Jim Fultone60de4d2000-10-06 19:24:23 +0000190IO_creadline(PyObject *self, char **output) {
191 char *n, *s;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000192 Py_ssize_t l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000193
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000194 if (!IO__opencheck(IOOOBJECT(self))) return -1;
Jim Fultone60de4d2000-10-06 19:24:23 +0000195
196 for (n = ((IOobject*)self)->buf + ((IOobject*)self)->pos,
197 s = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
198 n < s && *n != '\n'; n++);
Martin v. Löwis73c01d42008-02-14 11:26:18 +0000199
Jim Fultone60de4d2000-10-06 19:24:23 +0000200 if (n < s) n++;
201
202 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
203 l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos;
Martin v. Löwis73c01d42008-02-14 11:26:18 +0000204
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;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000210 return (int)l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000211}
212
213static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000214IO_readline(IOobject *self, PyObject *args) {
215 int n, m=-1;
216 char *output;
Guido van Rossum049cd901996-12-05 23:30:48 +0000217
Raymond Hettinger352f9472003-04-24 15:50:11 +0000218 if (args)
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000219 if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000220
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 }
Martin v. Löwis73c01d42008-02-14 11:26:18 +0000227 assert(IOOOBJECT(self)->pos >= 0);
Jim Fultone60de4d2000-10-06 19:24:23 +0000228 return PyString_FromStringAndSize(output, n);
Guido van Rossum049cd901996-12-05 23:30:48 +0000229}
230
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000231PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000232
233static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000234IO_readlines(IOobject *self, PyObject *args) {
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000235 int n;
236 char *output;
237 PyObject *result, *line;
238 int hint = 0, length = 0;
239
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000240 if (!PyArg_ParseTuple(args, "|i:readlines", &hint)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000241
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000242 result = PyList_New(0);
243 if (!result)
244 return NULL;
245
Jim Fultone60de4d2000-10-06 19:24:23 +0000246 while (1){
247 if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
248 goto err;
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000249 if (n == 0)
250 break;
251 line = PyString_FromStringAndSize (output, n);
Jim Fultone60de4d2000-10-06 19:24:23 +0000252 if (!line)
253 goto err;
Michael W. Hudson10402a32005-09-22 09:19:01 +0000254 if (PyList_Append (result, line) == -1) {
255 Py_DECREF (line);
256 goto err;
257 }
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000258 Py_DECREF (line);
259 length += n;
260 if (hint > 0 && length >= hint)
261 break;
262 }
263 return result;
Jim Fultone60de4d2000-10-06 19:24:23 +0000264 err:
265 Py_DECREF(result);
266 return NULL;
267}
268
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000269PyDoc_STRVAR(IO_reset__doc__,
270"reset() -- Reset the file position to the beginning");
Jim Fultone60de4d2000-10-06 19:24:23 +0000271
272static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000273IO_reset(IOobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000274
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000275 if (!IO__opencheck(self)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000276
277 self->pos = 0;
278
279 Py_INCREF(Py_None);
280 return Py_None;
281}
282
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000283PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
Jim Fultone60de4d2000-10-06 19:24:23 +0000284
285static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000286IO_tell(IOobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000287
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000288 if (!IO__opencheck(self)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000289
Martin v. Löwis73c01d42008-02-14 11:26:18 +0000290 assert(self->pos >= 0);
Martin v. Löwisad0a4622006-02-16 14:30:23 +0000291 return PyInt_FromSsize_t(self->pos);
Jim Fultone60de4d2000-10-06 19:24:23 +0000292}
293
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000294PyDoc_STRVAR(IO_truncate__doc__,
295"truncate(): truncate the file at the current position.");
Jim Fultone60de4d2000-10-06 19:24:23 +0000296
297static PyObject *
298IO_truncate(IOobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000299 Py_ssize_t pos = -1;
Jim Fultone60de4d2000-10-06 19:24:23 +0000300
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000301 if (!IO__opencheck(self)) return NULL;
302 if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000303 if (pos < 0) pos = self->pos;
304
305 if (self->string_size > pos) self->string_size = pos;
Tim Peters037b3ee2004-08-21 06:55:43 +0000306 self->pos = self->string_size;
Jim Fultone60de4d2000-10-06 19:24:23 +0000307
308 Py_INCREF(Py_None);
309 return Py_None;
310}
311
Raymond Hettinger352f9472003-04-24 15:50:11 +0000312static PyObject *
313IO_iternext(Iobject *self)
314{
315 PyObject *next;
316 next = IO_readline((IOobject *)self, NULL);
317 if (!next)
318 return NULL;
319 if (!PyString_GET_SIZE(next)) {
320 Py_DECREF(next);
321 PyErr_SetNone(PyExc_StopIteration);
322 return NULL;
323 }
324 return next;
325}
326
Jim Fultone60de4d2000-10-06 19:24:23 +0000327
328
329
330/* Read-write object methods */
331
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000332PyDoc_STRVAR(O_seek__doc__,
Jim Fultone60de4d2000-10-06 19:24:23 +0000333"seek(position) -- set the current position\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000334"seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
Jim Fultone60de4d2000-10-06 19:24:23 +0000335
336static PyObject *
337O_seek(Oobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000338 Py_ssize_t position;
339 int mode = 0;
Jim Fultone60de4d2000-10-06 19:24:23 +0000340
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000341 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
342 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
Jim Fultone60de4d2000-10-06 19:24:23 +0000343 return NULL;
344
345 if (mode == 2) {
346 position += self->string_size;
347 }
348 else if (mode == 1) {
349 position += self->pos;
350 }
351
352 if (position > self->buf_size) {
Kristján Valur Jónsson5e4e31f2007-04-21 12:46:49 +0000353 char *newbuf;
Jim Fultone60de4d2000-10-06 19:24:23 +0000354 self->buf_size*=2;
355 if (self->buf_size <= position) self->buf_size=position+1;
Kristján Valur Jónsson5e4e31f2007-04-21 12:46:49 +0000356 newbuf = (char*) realloc(self->buf,self->buf_size);
357 if (!newbuf) {
358 free(self->buf);
359 self->buf = 0;
Jim Fultone60de4d2000-10-06 19:24:23 +0000360 self->buf_size=self->pos=0;
361 return PyErr_NoMemory();
362 }
Kristján Valur Jónsson5e4e31f2007-04-21 12:46:49 +0000363 self->buf = newbuf;
Jim Fultone60de4d2000-10-06 19:24:23 +0000364 }
365 else if (position < 0) position=0;
366
367 self->pos=position;
368
369 while (--position >= self->string_size) self->buf[position]=0;
370
371 Py_INCREF(Py_None);
372 return Py_None;
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000373}
374
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000375PyDoc_STRVAR(O_write__doc__,
Guido van Rossum049cd901996-12-05 23:30:48 +0000376"write(s) -- Write a string to the file"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000377"\n\nNote (hack:) writing None resets the buffer");
Guido van Rossum049cd901996-12-05 23:30:48 +0000378
379
380static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000381O_cwrite(PyObject *self, const char *c, Py_ssize_t l) {
382 Py_ssize_t newl;
Guido van Rossum2f098122001-12-07 20:20:28 +0000383 Oobject *oself;
Kristján Valur Jónsson5e4e31f2007-04-21 12:46:49 +0000384 char *newbuf;
Guido van Rossum55702f81997-01-06 22:57:52 +0000385
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000386 if (!IO__opencheck(IOOOBJECT(self))) return -1;
Guido van Rossum2f098122001-12-07 20:20:28 +0000387 oself = (Oobject *)self;
Guido van Rossum049cd901996-12-05 23:30:48 +0000388
Guido van Rossum2f098122001-12-07 20:20:28 +0000389 newl = oself->pos+l;
390 if (newl >= oself->buf_size) {
391 oself->buf_size *= 2;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000392 if (oself->buf_size <= newl) {
393 assert(newl + 1 < INT_MAX);
394 oself->buf_size = (int)(newl+1);
395 }
Kristján Valur Jónsson5e4e31f2007-04-21 12:46:49 +0000396 newbuf = (char*)realloc(oself->buf, oself->buf_size);
397 if (!newbuf) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000398 PyErr_SetString(PyExc_MemoryError,"out of memory");
Kristján Valur Jónsson5e4e31f2007-04-21 12:46:49 +0000399 free(oself->buf);
400 oself->buf = 0;
Guido van Rossum2f098122001-12-07 20:20:28 +0000401 oself->buf_size = oself->pos = 0;
Jim Fultone60de4d2000-10-06 19:24:23 +0000402 return -1;
403 }
Kristján Valur Jónsson5e4e31f2007-04-21 12:46:49 +0000404 oself->buf = newbuf;
Jim Fultone60de4d2000-10-06 19:24:23 +0000405 }
Guido van Rossum049cd901996-12-05 23:30:48 +0000406
Guido van Rossum2f098122001-12-07 20:20:28 +0000407 memcpy(oself->buf+oself->pos,c,l);
Guido van Rossum049cd901996-12-05 23:30:48 +0000408
Martin v. Löwis18e16552006-02-15 17:27:45 +0000409 assert(oself->pos + l < INT_MAX);
410 oself->pos += (int)l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000411
Guido van Rossum2f098122001-12-07 20:20:28 +0000412 if (oself->string_size < oself->pos) {
413 oself->string_size = oself->pos;
414 }
Jim Fultone60de4d2000-10-06 19:24:23 +0000415
Martin v. Löwis18e16552006-02-15 17:27:45 +0000416 return (int)l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000417}
418
419static PyObject *
Guido van Rossum154417e1997-04-09 17:35:33 +0000420O_write(Oobject *self, PyObject *args) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000421 char *c;
422 int l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000423
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000424 if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000425
Jim Fultone60de4d2000-10-06 19:24:23 +0000426 if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000427
Jim Fultone60de4d2000-10-06 19:24:23 +0000428 Py_INCREF(Py_None);
429 return Py_None;
Guido van Rossum049cd901996-12-05 23:30:48 +0000430}
431
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000432PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
Guido van Rossum049cd901996-12-05 23:30:48 +0000433
434static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000435O_close(Oobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000436 if (self->buf != NULL) free(self->buf);
437 self->buf = NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000438
Jim Fultone60de4d2000-10-06 19:24:23 +0000439 self->pos = self->string_size = self->buf_size = 0;
Guido van Rossum049cd901996-12-05 23:30:48 +0000440
Jim Fultone60de4d2000-10-06 19:24:23 +0000441 Py_INCREF(Py_None);
442 return Py_None;
Guido van Rossum049cd901996-12-05 23:30:48 +0000443}
444
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000445PyDoc_STRVAR(O_writelines__doc__,
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000446"writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
447"\n"
448"Note that newlines are not added. The sequence can be any iterable object\n"
449"producing strings. This is equivalent to calling write() for each string.");
Guido van Rossum049cd901996-12-05 23:30:48 +0000450static PyObject *
Guido van Rossum154417e1997-04-09 17:35:33 +0000451O_writelines(Oobject *self, PyObject *args) {
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000452 PyObject *it, *s;
453
454 it = PyObject_GetIter(args);
455 if (it == NULL)
Raymond Hettingerbc72c5a2004-02-27 10:30:49 +0000456 return NULL;
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000457 while ((s = PyIter_Next(it)) != NULL) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000458 Py_ssize_t n;
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000459 char *c;
460 if (PyString_AsStringAndSize(s, &c, &n) == -1) {
461 Py_DECREF(it);
462 Py_DECREF(s);
463 return NULL;
464 }
465 if (O_cwrite((PyObject *)self, c, n) == -1) {
466 Py_DECREF(it);
467 Py_DECREF(s);
468 return NULL;
Michael W. Hudson10402a32005-09-22 09:19:01 +0000469 }
470 Py_DECREF(s);
471 }
Guido van Rossum049cd901996-12-05 23:30:48 +0000472
Michael W. Hudson10402a32005-09-22 09:19:01 +0000473 Py_DECREF(it);
474
475 /* See if PyIter_Next failed */
476 if (PyErr_Occurred())
477 return NULL;
478
479 Py_RETURN_NONE;
480}
Guido van Rossum049cd901996-12-05 23:30:48 +0000481static struct PyMethodDef O_methods[] = {
Jim Fultone60de4d2000-10-06 19:24:23 +0000482 /* Common methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000483 {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000484 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000485 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000486 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
487 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
488 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000489 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
490 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000491 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
492
493 /* Read-write StringIO specific methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000494 {"close", (PyCFunction)O_close, METH_NOARGS, O_close__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000495 {"seek", (PyCFunction)O_seek, METH_VARARGS, O_seek__doc__},
496 {"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000497 {"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__},
Guido van Rossum476e49f1998-12-15 21:43:15 +0000498 {NULL, NULL} /* sentinel */
Guido van Rossum049cd901996-12-05 23:30:48 +0000499};
500
Raymond Hettinger352f9472003-04-24 15:50:11 +0000501static PyMemberDef O_memberlist[] = {
502 {"softspace", T_INT, offsetof(Oobject, softspace), 0,
503 "flag indicating that a space needs to be printed; used by print"},
Raymond Hettinger5475f232003-08-08 12:20:03 +0000504 /* getattr(f, "closed") is implemented without this table */
Raymond Hettinger352f9472003-04-24 15:50:11 +0000505 {NULL} /* Sentinel */
506};
507
Guido van Rossum049cd901996-12-05 23:30:48 +0000508static void
Guido van Rossum154417e1997-04-09 17:35:33 +0000509O_dealloc(Oobject *self) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000510 if (self->buf != NULL)
511 free(self->buf);
512 PyObject_Del(self);
Guido van Rossum049cd901996-12-05 23:30:48 +0000513}
514
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000515PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
Guido van Rossum049cd901996-12-05 23:30:48 +0000516
517static PyTypeObject Otype = {
Guido van Rossum154417e1997-04-09 17:35:33 +0000518 PyObject_HEAD_INIT(NULL)
Raymond Hettinger352f9472003-04-24 15:50:11 +0000519 0, /*ob_size*/
Skip Montanaroeb2f0612003-08-11 14:51:15 +0000520 "cStringIO.StringO", /*tp_name*/
Guido van Rossum154417e1997-04-09 17:35:33 +0000521 sizeof(Oobject), /*tp_basicsize*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000522 0, /*tp_itemsize*/
Guido van Rossum154417e1997-04-09 17:35:33 +0000523 /* methods */
524 (destructor)O_dealloc, /*tp_dealloc*/
Georg Brandld37ac692006-03-30 11:58:57 +0000525 0, /*tp_print*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000526 0, /*tp_getattr */
527 0, /*tp_setattr */
Georg Brandld37ac692006-03-30 11:58:57 +0000528 0, /*tp_compare*/
529 0, /*tp_repr*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000530 0, /*tp_as_number*/
531 0, /*tp_as_sequence*/
532 0, /*tp_as_mapping*/
Georg Brandld37ac692006-03-30 11:58:57 +0000533 0, /*tp_hash*/
534 0 , /*tp_call*/
535 0, /*tp_str*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000536 0, /*tp_getattro */
537 0, /*tp_setattro */
538 0, /*tp_as_buffer */
539 Py_TPFLAGS_DEFAULT, /*tp_flags*/
540 Otype__doc__, /*tp_doc */
541 0, /*tp_traverse */
542 0, /*tp_clear */
543 0, /*tp_richcompare */
544 0, /*tp_weaklistoffset */
545 PyObject_SelfIter, /*tp_iter */
546 (iternextfunc)IO_iternext, /*tp_iternext */
547 O_methods, /*tp_methods */
Raymond Hettinger5475f232003-08-08 12:20:03 +0000548 O_memberlist, /*tp_members */
549 file_getsetlist, /*tp_getset */
Guido van Rossum049cd901996-12-05 23:30:48 +0000550};
551
Guido van Rossum142eeb81997-08-13 03:14:41 +0000552static PyObject *
553newOobject(int size) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000554 Oobject *self;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000555
Jim Fultone60de4d2000-10-06 19:24:23 +0000556 self = PyObject_New(Oobject, &Otype);
557 if (self == NULL)
558 return NULL;
559 self->pos=0;
560 self->string_size = 0;
561 self->softspace = 0;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000562
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000563 self->buf = (char *)malloc(size);
564 if (!self->buf) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000565 PyErr_SetString(PyExc_MemoryError,"out of memory");
566 self->buf_size = 0;
Hye-Shik Chang4af5c8c2006-03-07 15:39:21 +0000567 Py_DECREF(self);
Jim Fultone60de4d2000-10-06 19:24:23 +0000568 return NULL;
569 }
570
571 self->buf_size=size;
572 return (PyObject*)self;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000573}
574
Skip Montanaroe1388282003-08-11 13:15:11 +0000575/* End of code for StringO objects */
Guido van Rossum049cd901996-12-05 23:30:48 +0000576/* -------------------------------------------------------- */
577
578static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000579I_close(Iobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000580 Py_XDECREF(self->pbuf);
581 self->pbuf = NULL;
582 self->buf = NULL;
583
584 self->pos = self->string_size = 0;
585
586 Py_INCREF(Py_None);
587 return Py_None;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000588}
589
590static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000591I_seek(Iobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000592 Py_ssize_t position;
593 int mode = 0;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000594
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000595 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
596 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
Jim Fultone60de4d2000-10-06 19:24:23 +0000597 return NULL;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000598
Jim Fultone60de4d2000-10-06 19:24:23 +0000599 if (mode == 2) position += self->string_size;
600 else if (mode == 1) position += self->pos;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000601
Jim Fultone60de4d2000-10-06 19:24:23 +0000602 if (position < 0) position=0;
Guido van Rossum049cd901996-12-05 23:30:48 +0000603
Jim Fultone60de4d2000-10-06 19:24:23 +0000604 self->pos=position;
605
606 Py_INCREF(Py_None);
607 return Py_None;
Guido van Rossum049cd901996-12-05 23:30:48 +0000608}
609
610static struct PyMethodDef I_methods[] = {
Jim Fultone60de4d2000-10-06 19:24:23 +0000611 /* Common methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000612 {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000613 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000614 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000615 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
616 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
617 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000618 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
619 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000620 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
621
622 /* Read-only StringIO specific methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000623 {"close", (PyCFunction)I_close, METH_NOARGS, O_close__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000624 {"seek", (PyCFunction)I_seek, METH_VARARGS, O_seek__doc__},
Guido van Rossum476e49f1998-12-15 21:43:15 +0000625 {NULL, NULL}
Guido van Rossum049cd901996-12-05 23:30:48 +0000626};
627
Guido van Rossum049cd901996-12-05 23:30:48 +0000628static void
Guido van Rossum154417e1997-04-09 17:35:33 +0000629I_dealloc(Iobject *self) {
Guido van Rossum15a40391997-09-03 00:09:26 +0000630 Py_XDECREF(self->pbuf);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000631 PyObject_Del(self);
Guido van Rossum049cd901996-12-05 23:30:48 +0000632}
633
Barry Warsaw3e8be722001-09-22 04:36:49 +0000634
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000635PyDoc_STRVAR(Itype__doc__,
636"Simple type for treating strings as input file streams");
Guido van Rossum049cd901996-12-05 23:30:48 +0000637
638static PyTypeObject Itype = {
Guido van Rossum154417e1997-04-09 17:35:33 +0000639 PyObject_HEAD_INIT(NULL)
Barry Warsaw3e8be722001-09-22 04:36:49 +0000640 0, /*ob_size*/
Skip Montanaroeb2f0612003-08-11 14:51:15 +0000641 "cStringIO.StringI", /*tp_name*/
Barry Warsaw3e8be722001-09-22 04:36:49 +0000642 sizeof(Iobject), /*tp_basicsize*/
643 0, /*tp_itemsize*/
Guido van Rossum154417e1997-04-09 17:35:33 +0000644 /* methods */
Barry Warsaw3e8be722001-09-22 04:36:49 +0000645 (destructor)I_dealloc, /*tp_dealloc*/
Georg Brandld37ac692006-03-30 11:58:57 +0000646 0, /*tp_print*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000647 0, /* tp_getattr */
Georg Brandld37ac692006-03-30 11:58:57 +0000648 0, /*tp_setattr*/
649 0, /*tp_compare*/
650 0, /*tp_repr*/
Barry Warsaw3e8be722001-09-22 04:36:49 +0000651 0, /*tp_as_number*/
652 0, /*tp_as_sequence*/
653 0, /*tp_as_mapping*/
Georg Brandld37ac692006-03-30 11:58:57 +0000654 0, /*tp_hash*/
655 0, /*tp_call*/
656 0, /*tp_str*/
Barry Warsaw3e8be722001-09-22 04:36:49 +0000657 0, /* tp_getattro */
658 0, /* tp_setattro */
659 0, /* tp_as_buffer */
660 Py_TPFLAGS_DEFAULT, /* tp_flags */
661 Itype__doc__, /* tp_doc */
662 0, /* tp_traverse */
663 0, /* tp_clear */
664 0, /* tp_richcompare */
665 0, /* tp_weaklistoffset */
Raymond Hettinger352f9472003-04-24 15:50:11 +0000666 PyObject_SelfIter, /* tp_iter */
667 (iternextfunc)IO_iternext, /* tp_iternext */
Raymond Hettinger5475f232003-08-08 12:20:03 +0000668 I_methods, /* tp_methods */
669 0, /* tp_members */
670 file_getsetlist, /* tp_getset */
Guido van Rossum049cd901996-12-05 23:30:48 +0000671};
672
Guido van Rossum142eeb81997-08-13 03:14:41 +0000673static PyObject *
674newIobject(PyObject *s) {
675 Iobject *self;
676 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000677 Py_ssize_t size;
Jeremy Hylton127b2ef2000-04-12 22:04:01 +0000678
Georg Brandlde469d62007-08-08 13:50:04 +0000679 if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) {
Georg Brandleb4b7382007-08-08 13:03:45 +0000680 PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found",
681 s->ob_type->tp_name);
682 return NULL;
683 }
Georg Brandl3c487092006-10-12 09:47:17 +0000684
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000685 self = PyObject_New(Iobject, &Itype);
686 if (!self) return NULL;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000687 Py_INCREF(s);
688 self->buf=buf;
689 self->string_size=size;
690 self->pbuf=s;
691 self->pos=0;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000692
693 return (PyObject*)self;
694}
695
Guido van Rossum049cd901996-12-05 23:30:48 +0000696/* End of code for StringI objects */
697/* -------------------------------------------------------- */
698
699
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000700PyDoc_STRVAR(IO_StringIO__doc__,
701"StringIO([s]) -- Return a StringIO-like stream for reading or writing");
Guido van Rossum049cd901996-12-05 23:30:48 +0000702
703static PyObject *
Guido van Rossum154417e1997-04-09 17:35:33 +0000704IO_StringIO(PyObject *self, PyObject *args) {
Guido van Rossum049cd901996-12-05 23:30:48 +0000705 PyObject *s=0;
706
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000707 if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000708
709 if (s) return newIobject(s);
Guido van Rossum154417e1997-04-09 17:35:33 +0000710 return newOobject(128);
Guido van Rossum049cd901996-12-05 23:30:48 +0000711}
712
713/* List of methods defined in the module */
714
715static struct PyMethodDef IO_methods[] = {
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +0000716 {"StringIO", (PyCFunction)IO_StringIO,
717 METH_VARARGS, IO_StringIO__doc__},
Guido van Rossum55702f81997-01-06 22:57:52 +0000718 {NULL, NULL} /* sentinel */
Guido van Rossum049cd901996-12-05 23:30:48 +0000719};
720
721
722/* Initialization function for the module (*must* be called initcStringIO) */
723
Guido van Rossum154417e1997-04-09 17:35:33 +0000724static struct PycStringIO_CAPI CAPI = {
Jim Fultone60de4d2000-10-06 19:24:23 +0000725 IO_cread,
726 IO_creadline,
Guido van Rossum154417e1997-04-09 17:35:33 +0000727 O_cwrite,
Jim Fultone60de4d2000-10-06 19:24:23 +0000728 IO_cgetval,
Guido van Rossum154417e1997-04-09 17:35:33 +0000729 newOobject,
730 newIobject,
731 &Itype,
732 &Otype,
733};
734
Mark Hammondfe51c6d2002-08-02 02:27:13 +0000735#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
736#define PyMODINIT_FUNC void
Guido van Rossum476e49f1998-12-15 21:43:15 +0000737#endif
Mark Hammondfe51c6d2002-08-02 02:27:13 +0000738PyMODINIT_FUNC
Thomas Wouters58d05102000-07-24 14:43:35 +0000739initcStringIO(void) {
Guido van Rossum9efe8ef1997-09-03 18:19:40 +0000740 PyObject *m, *d, *v;
Guido van Rossum049cd901996-12-05 23:30:48 +0000741
Guido van Rossum154417e1997-04-09 17:35:33 +0000742
Guido van Rossum049cd901996-12-05 23:30:48 +0000743 /* Create the module and add the functions */
744 m = Py_InitModule4("cStringIO", IO_methods,
745 cStringIO_module_documentation,
746 (PyObject*)NULL,PYTHON_API_VERSION);
Neal Norwitz1ac754f2006-01-19 06:09:39 +0000747 if (m == NULL) return;
Guido van Rossum049cd901996-12-05 23:30:48 +0000748
749 /* Add some symbolic constants to the module */
750 d = PyModule_GetDict(m);
Guido van Rossum049cd901996-12-05 23:30:48 +0000751
Guido van Rossum55702f81997-01-06 22:57:52 +0000752 /* Export C API */
Guido van Rossum154417e1997-04-09 17:35:33 +0000753 Itype.ob_type=&PyType_Type;
754 Otype.ob_type=&PyType_Type;
Raymond Hettinger352f9472003-04-24 15:50:11 +0000755 if (PyType_Ready(&Otype) < 0) return;
756 if (PyType_Ready(&Itype) < 0) return;
Guido van Rossum9efe8ef1997-09-03 18:19:40 +0000757 PyDict_SetItemString(d,"cStringIO_CAPI",
758 v = PyCObject_FromVoidPtr(&CAPI,NULL));
759 Py_XDECREF(v);
Guido van Rossum154417e1997-04-09 17:35:33 +0000760
761 /* Export Types */
Guido van Rossum049cd901996-12-05 23:30:48 +0000762 PyDict_SetItemString(d,"InputType", (PyObject*)&Itype);
763 PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
Guido van Rossum142eeb81997-08-13 03:14:41 +0000764
765 /* Maybe make certain warnings go away */
Jim Fultone60de4d2000-10-06 19:24:23 +0000766 if (0) PycString_IMPORT;
Guido van Rossum049cd901996-12-05 23:30:48 +0000767}