blob: 4debb7263bdf8a00489b2b153f14972ba6e6de0a [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;
Jim Fultone60de4d2000-10-06 19:24:23 +0000122 return PyString_FromStringAndSize(((IOobject*)self)->buf,
123 ((IOobject*)self)->pos);
Guido van Rossum049cd901996-12-05 23:30:48 +0000124}
125
Guido van Rossum049cd901996-12-05 23:30:48 +0000126static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000127IO_getval(IOobject *self, PyObject *args) {
128 PyObject *use_pos=Py_None;
Martin v. Löwisad0a4622006-02-16 14:30:23 +0000129 Py_ssize_t s;
Jim Fultone60de4d2000-10-06 19:24:23 +0000130
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000131 if (!IO__opencheck(self)) return NULL;
132 if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000133
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);
Guido van Rossum049cd901996-12-05 23:30:48 +0000141}
142
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000143PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
Guido van Rossum049cd901996-12-05 23:30:48 +0000144
145static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000146IO_isatty(IOobject *self, PyObject *unused) {
Walter Dörwald197e8322006-03-15 22:13:13 +0000147 if (!IO__opencheck(self)) return NULL;
148 Py_INCREF(Py_False);
Guido van Rossum674deb22002-09-01 15:06:28 +0000149 return Py_False;
Guido van Rossum049cd901996-12-05 23:30:48 +0000150}
151
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000152PyDoc_STRVAR(IO_read__doc__,
153"read([s]) -- Read s characters, or the rest of the string");
Guido van Rossum049cd901996-12-05 23:30:48 +0000154
155static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000156IO_cread(PyObject *self, char **output, Py_ssize_t n) {
Martin v. Löwisad0a4622006-02-16 14:30:23 +0000157 Py_ssize_t l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000158
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000159 if (!IO__opencheck(IOOOBJECT(self))) return -1;
Jim Fultone60de4d2000-10-06 19:24:23 +0000160 l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
161 if (n < 0 || n > l) {
162 n = l;
163 if (n < 0) n=0;
164 }
Guido van Rossum049cd901996-12-05 23:30:48 +0000165
Jim Fultone60de4d2000-10-06 19:24:23 +0000166 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
167 ((IOobject*)self)->pos += n;
168 return n;
Guido van Rossum049cd901996-12-05 23:30:48 +0000169}
170
171static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000172IO_read(IOobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000173 Py_ssize_t n = -1;
Thomas Woutersf86d1e82006-03-01 22:15:15 +0000174 char *output = NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000175
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000176 if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000177
Jim Fultone60de4d2000-10-06 19:24:23 +0000178 if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000179
Jim Fultone60de4d2000-10-06 19:24:23 +0000180 return PyString_FromStringAndSize(output, n);
Guido van Rossum049cd901996-12-05 23:30:48 +0000181}
182
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000183PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
Guido van Rossum049cd901996-12-05 23:30:48 +0000184
185static int
Jim Fultone60de4d2000-10-06 19:24:23 +0000186IO_creadline(PyObject *self, char **output) {
187 char *n, *s;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000188 Py_ssize_t l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000189
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000190 if (!IO__opencheck(IOOOBJECT(self))) return -1;
Jim Fultone60de4d2000-10-06 19:24:23 +0000191
192 for (n = ((IOobject*)self)->buf + ((IOobject*)self)->pos,
193 s = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
194 n < s && *n != '\n'; n++);
195 if (n < s) n++;
196
197 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
198 l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000199 assert(((IOobject*)self)->pos + l < INT_MAX);
200 ((IOobject*)self)->pos += (int)l;
201 return (int)l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000202}
203
204static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000205IO_readline(IOobject *self, PyObject *args) {
206 int n, m=-1;
207 char *output;
Guido van Rossum049cd901996-12-05 23:30:48 +0000208
Raymond Hettinger352f9472003-04-24 15:50:11 +0000209 if (args)
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000210 if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000211
212 if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;
213 if (m >= 0 && m < n) {
214 m = n - m;
215 n -= m;
216 self->pos -= m;
217 }
218 return PyString_FromStringAndSize(output, n);
Guido van Rossum049cd901996-12-05 23:30:48 +0000219}
220
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000221PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000222
223static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000224IO_readlines(IOobject *self, PyObject *args) {
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000225 int n;
226 char *output;
227 PyObject *result, *line;
228 int hint = 0, length = 0;
229
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000230 if (!PyArg_ParseTuple(args, "|i:readlines", &hint)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000231
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000232 result = PyList_New(0);
233 if (!result)
234 return NULL;
235
Jim Fultone60de4d2000-10-06 19:24:23 +0000236 while (1){
237 if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
238 goto err;
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000239 if (n == 0)
240 break;
241 line = PyString_FromStringAndSize (output, n);
Jim Fultone60de4d2000-10-06 19:24:23 +0000242 if (!line)
243 goto err;
Michael W. Hudson10402a32005-09-22 09:19:01 +0000244 if (PyList_Append (result, line) == -1) {
245 Py_DECREF (line);
246 goto err;
247 }
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000248 Py_DECREF (line);
249 length += n;
250 if (hint > 0 && length >= hint)
251 break;
252 }
253 return result;
Jim Fultone60de4d2000-10-06 19:24:23 +0000254 err:
255 Py_DECREF(result);
256 return NULL;
257}
258
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000259PyDoc_STRVAR(IO_reset__doc__,
260"reset() -- Reset the file position to the beginning");
Jim Fultone60de4d2000-10-06 19:24:23 +0000261
262static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000263IO_reset(IOobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000264
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000265 if (!IO__opencheck(self)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000266
267 self->pos = 0;
268
269 Py_INCREF(Py_None);
270 return Py_None;
271}
272
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000273PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
Jim Fultone60de4d2000-10-06 19:24:23 +0000274
275static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000276IO_tell(IOobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000277
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000278 if (!IO__opencheck(self)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000279
Martin v. Löwisad0a4622006-02-16 14:30:23 +0000280 return PyInt_FromSsize_t(self->pos);
Jim Fultone60de4d2000-10-06 19:24:23 +0000281}
282
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000283PyDoc_STRVAR(IO_truncate__doc__,
284"truncate(): truncate the file at the current position.");
Jim Fultone60de4d2000-10-06 19:24:23 +0000285
286static PyObject *
287IO_truncate(IOobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000288 Py_ssize_t pos = -1;
Jim Fultone60de4d2000-10-06 19:24:23 +0000289
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000290 if (!IO__opencheck(self)) return NULL;
291 if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000292 if (pos < 0) pos = self->pos;
293
294 if (self->string_size > pos) self->string_size = pos;
Tim Peters037b3ee2004-08-21 06:55:43 +0000295 self->pos = self->string_size;
Jim Fultone60de4d2000-10-06 19:24:23 +0000296
297 Py_INCREF(Py_None);
298 return Py_None;
299}
300
Raymond Hettinger352f9472003-04-24 15:50:11 +0000301static PyObject *
302IO_iternext(Iobject *self)
303{
304 PyObject *next;
305 next = IO_readline((IOobject *)self, NULL);
306 if (!next)
307 return NULL;
308 if (!PyString_GET_SIZE(next)) {
309 Py_DECREF(next);
310 PyErr_SetNone(PyExc_StopIteration);
311 return NULL;
312 }
313 return next;
314}
315
Jim Fultone60de4d2000-10-06 19:24:23 +0000316
317
318
319/* Read-write object methods */
320
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000321PyDoc_STRVAR(O_seek__doc__,
Jim Fultone60de4d2000-10-06 19:24:23 +0000322"seek(position) -- set the current position\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000323"seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
Jim Fultone60de4d2000-10-06 19:24:23 +0000324
325static PyObject *
326O_seek(Oobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000327 Py_ssize_t position;
328 int mode = 0;
Jim Fultone60de4d2000-10-06 19:24:23 +0000329
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000330 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
331 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
Jim Fultone60de4d2000-10-06 19:24:23 +0000332 return NULL;
333
334 if (mode == 2) {
335 position += self->string_size;
336 }
337 else if (mode == 1) {
338 position += self->pos;
339 }
340
341 if (position > self->buf_size) {
342 self->buf_size*=2;
343 if (self->buf_size <= position) self->buf_size=position+1;
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000344 self->buf = (char*) realloc(self->buf,self->buf_size);
345 if (!self->buf) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000346 self->buf_size=self->pos=0;
347 return PyErr_NoMemory();
348 }
349 }
350 else if (position < 0) position=0;
351
352 self->pos=position;
353
354 while (--position >= self->string_size) self->buf[position]=0;
355
356 Py_INCREF(Py_None);
357 return Py_None;
Martin v. Löwisc912a3a2000-09-19 11:06:46 +0000358}
359
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000360PyDoc_STRVAR(O_write__doc__,
Guido van Rossum049cd901996-12-05 23:30:48 +0000361"write(s) -- Write a string to the file"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000362"\n\nNote (hack:) writing None resets the buffer");
Guido van Rossum049cd901996-12-05 23:30:48 +0000363
364
365static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000366O_cwrite(PyObject *self, const char *c, Py_ssize_t l) {
367 Py_ssize_t newl;
Guido van Rossum2f098122001-12-07 20:20:28 +0000368 Oobject *oself;
Guido van Rossum55702f81997-01-06 22:57:52 +0000369
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000370 if (!IO__opencheck(IOOOBJECT(self))) return -1;
Guido van Rossum2f098122001-12-07 20:20:28 +0000371 oself = (Oobject *)self;
Guido van Rossum049cd901996-12-05 23:30:48 +0000372
Guido van Rossum2f098122001-12-07 20:20:28 +0000373 newl = oself->pos+l;
374 if (newl >= oself->buf_size) {
375 oself->buf_size *= 2;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000376 if (oself->buf_size <= newl) {
377 assert(newl + 1 < INT_MAX);
378 oself->buf_size = (int)(newl+1);
379 }
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000380 oself->buf = (char*)realloc(oself->buf, oself->buf_size);
381 if (!oself->buf) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000382 PyErr_SetString(PyExc_MemoryError,"out of memory");
Guido van Rossum2f098122001-12-07 20:20:28 +0000383 oself->buf_size = oself->pos = 0;
Jim Fultone60de4d2000-10-06 19:24:23 +0000384 return -1;
385 }
386 }
Guido van Rossum049cd901996-12-05 23:30:48 +0000387
Guido van Rossum2f098122001-12-07 20:20:28 +0000388 memcpy(oself->buf+oself->pos,c,l);
Guido van Rossum049cd901996-12-05 23:30:48 +0000389
Martin v. Löwis18e16552006-02-15 17:27:45 +0000390 assert(oself->pos + l < INT_MAX);
391 oself->pos += (int)l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000392
Guido van Rossum2f098122001-12-07 20:20:28 +0000393 if (oself->string_size < oself->pos) {
394 oself->string_size = oself->pos;
395 }
Jim Fultone60de4d2000-10-06 19:24:23 +0000396
Martin v. Löwis18e16552006-02-15 17:27:45 +0000397 return (int)l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000398}
399
400static PyObject *
Guido van Rossum154417e1997-04-09 17:35:33 +0000401O_write(Oobject *self, PyObject *args) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000402 char *c;
403 int l;
Guido van Rossum049cd901996-12-05 23:30:48 +0000404
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000405 if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000406
Jim Fultone60de4d2000-10-06 19:24:23 +0000407 if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000408
Jim Fultone60de4d2000-10-06 19:24:23 +0000409 Py_INCREF(Py_None);
410 return Py_None;
Guido van Rossum049cd901996-12-05 23:30:48 +0000411}
412
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000413PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
Guido van Rossum049cd901996-12-05 23:30:48 +0000414
415static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000416O_close(Oobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000417 if (self->buf != NULL) free(self->buf);
418 self->buf = NULL;
Guido van Rossum049cd901996-12-05 23:30:48 +0000419
Jim Fultone60de4d2000-10-06 19:24:23 +0000420 self->pos = self->string_size = self->buf_size = 0;
Guido van Rossum049cd901996-12-05 23:30:48 +0000421
Jim Fultone60de4d2000-10-06 19:24:23 +0000422 Py_INCREF(Py_None);
423 return Py_None;
Guido van Rossum049cd901996-12-05 23:30:48 +0000424}
425
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000426PyDoc_STRVAR(O_writelines__doc__,
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000427"writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
428"\n"
429"Note that newlines are not added. The sequence can be any iterable object\n"
430"producing strings. This is equivalent to calling write() for each string.");
Guido van Rossum049cd901996-12-05 23:30:48 +0000431static PyObject *
Guido van Rossum154417e1997-04-09 17:35:33 +0000432O_writelines(Oobject *self, PyObject *args) {
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000433 PyObject *it, *s;
434
435 it = PyObject_GetIter(args);
436 if (it == NULL)
Raymond Hettingerbc72c5a2004-02-27 10:30:49 +0000437 return NULL;
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000438 while ((s = PyIter_Next(it)) != NULL) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000439 Py_ssize_t n;
Raymond Hettinger6ec09962004-03-08 18:17:31 +0000440 char *c;
441 if (PyString_AsStringAndSize(s, &c, &n) == -1) {
442 Py_DECREF(it);
443 Py_DECREF(s);
444 return NULL;
445 }
446 if (O_cwrite((PyObject *)self, c, n) == -1) {
447 Py_DECREF(it);
448 Py_DECREF(s);
449 return NULL;
Michael W. Hudson10402a32005-09-22 09:19:01 +0000450 }
451 Py_DECREF(s);
452 }
Guido van Rossum049cd901996-12-05 23:30:48 +0000453
Michael W. Hudson10402a32005-09-22 09:19:01 +0000454 Py_DECREF(it);
455
456 /* See if PyIter_Next failed */
457 if (PyErr_Occurred())
458 return NULL;
459
460 Py_RETURN_NONE;
461}
Guido van Rossum049cd901996-12-05 23:30:48 +0000462static struct PyMethodDef O_methods[] = {
Jim Fultone60de4d2000-10-06 19:24:23 +0000463 /* Common methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000464 {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000465 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000466 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000467 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
468 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
469 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000470 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
471 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000472 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
473
474 /* Read-write StringIO specific methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000475 {"close", (PyCFunction)O_close, METH_NOARGS, O_close__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000476 {"seek", (PyCFunction)O_seek, METH_VARARGS, O_seek__doc__},
477 {"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000478 {"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__},
Guido van Rossum476e49f1998-12-15 21:43:15 +0000479 {NULL, NULL} /* sentinel */
Guido van Rossum049cd901996-12-05 23:30:48 +0000480};
481
Raymond Hettinger352f9472003-04-24 15:50:11 +0000482static PyMemberDef O_memberlist[] = {
483 {"softspace", T_INT, offsetof(Oobject, softspace), 0,
484 "flag indicating that a space needs to be printed; used by print"},
Raymond Hettinger5475f232003-08-08 12:20:03 +0000485 /* getattr(f, "closed") is implemented without this table */
Raymond Hettinger352f9472003-04-24 15:50:11 +0000486 {NULL} /* Sentinel */
487};
488
Guido van Rossum049cd901996-12-05 23:30:48 +0000489static void
Guido van Rossum154417e1997-04-09 17:35:33 +0000490O_dealloc(Oobject *self) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000491 if (self->buf != NULL)
492 free(self->buf);
493 PyObject_Del(self);
Guido van Rossum049cd901996-12-05 23:30:48 +0000494}
495
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000496PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
Guido van Rossum049cd901996-12-05 23:30:48 +0000497
498static PyTypeObject Otype = {
Guido van Rossum154417e1997-04-09 17:35:33 +0000499 PyObject_HEAD_INIT(NULL)
Raymond Hettinger352f9472003-04-24 15:50:11 +0000500 0, /*ob_size*/
Skip Montanaroeb2f0612003-08-11 14:51:15 +0000501 "cStringIO.StringO", /*tp_name*/
Guido van Rossum154417e1997-04-09 17:35:33 +0000502 sizeof(Oobject), /*tp_basicsize*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000503 0, /*tp_itemsize*/
Guido van Rossum154417e1997-04-09 17:35:33 +0000504 /* methods */
505 (destructor)O_dealloc, /*tp_dealloc*/
Georg Brandld37ac692006-03-30 11:58:57 +0000506 0, /*tp_print*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000507 0, /*tp_getattr */
508 0, /*tp_setattr */
Georg Brandld37ac692006-03-30 11:58:57 +0000509 0, /*tp_compare*/
510 0, /*tp_repr*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000511 0, /*tp_as_number*/
512 0, /*tp_as_sequence*/
513 0, /*tp_as_mapping*/
Georg Brandld37ac692006-03-30 11:58:57 +0000514 0, /*tp_hash*/
515 0 , /*tp_call*/
516 0, /*tp_str*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000517 0, /*tp_getattro */
518 0, /*tp_setattro */
519 0, /*tp_as_buffer */
520 Py_TPFLAGS_DEFAULT, /*tp_flags*/
521 Otype__doc__, /*tp_doc */
522 0, /*tp_traverse */
523 0, /*tp_clear */
524 0, /*tp_richcompare */
525 0, /*tp_weaklistoffset */
526 PyObject_SelfIter, /*tp_iter */
527 (iternextfunc)IO_iternext, /*tp_iternext */
528 O_methods, /*tp_methods */
Raymond Hettinger5475f232003-08-08 12:20:03 +0000529 O_memberlist, /*tp_members */
530 file_getsetlist, /*tp_getset */
Guido van Rossum049cd901996-12-05 23:30:48 +0000531};
532
Guido van Rossum142eeb81997-08-13 03:14:41 +0000533static PyObject *
534newOobject(int size) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000535 Oobject *self;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000536
Jim Fultone60de4d2000-10-06 19:24:23 +0000537 self = PyObject_New(Oobject, &Otype);
538 if (self == NULL)
539 return NULL;
540 self->pos=0;
541 self->string_size = 0;
542 self->softspace = 0;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000543
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000544 self->buf = (char *)malloc(size);
545 if (!self->buf) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000546 PyErr_SetString(PyExc_MemoryError,"out of memory");
547 self->buf_size = 0;
Hye-Shik Chang4af5c8c2006-03-07 15:39:21 +0000548 Py_DECREF(self);
Jim Fultone60de4d2000-10-06 19:24:23 +0000549 return NULL;
550 }
551
552 self->buf_size=size;
553 return (PyObject*)self;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000554}
555
Skip Montanaroe1388282003-08-11 13:15:11 +0000556/* End of code for StringO objects */
Guido van Rossum049cd901996-12-05 23:30:48 +0000557/* -------------------------------------------------------- */
558
559static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000560I_close(Iobject *self, PyObject *unused) {
Jim Fultone60de4d2000-10-06 19:24:23 +0000561 Py_XDECREF(self->pbuf);
562 self->pbuf = NULL;
563 self->buf = NULL;
564
565 self->pos = self->string_size = 0;
566
567 Py_INCREF(Py_None);
568 return Py_None;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000569}
570
571static PyObject *
Jim Fultone60de4d2000-10-06 19:24:23 +0000572I_seek(Iobject *self, PyObject *args) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000573 Py_ssize_t position;
574 int mode = 0;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000575
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000576 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
577 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
Jim Fultone60de4d2000-10-06 19:24:23 +0000578 return NULL;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000579
Jim Fultone60de4d2000-10-06 19:24:23 +0000580 if (mode == 2) position += self->string_size;
581 else if (mode == 1) position += self->pos;
Guido van Rossum476e49f1998-12-15 21:43:15 +0000582
Jim Fultone60de4d2000-10-06 19:24:23 +0000583 if (position < 0) position=0;
Guido van Rossum049cd901996-12-05 23:30:48 +0000584
Jim Fultone60de4d2000-10-06 19:24:23 +0000585 self->pos=position;
586
587 Py_INCREF(Py_None);
588 return Py_None;
Guido van Rossum049cd901996-12-05 23:30:48 +0000589}
590
591static struct PyMethodDef I_methods[] = {
Jim Fultone60de4d2000-10-06 19:24:23 +0000592 /* Common methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000593 {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000594 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000595 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000596 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
597 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
598 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000599 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
600 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000601 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
602
603 /* Read-only StringIO specific methods: */
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000604 {"close", (PyCFunction)I_close, METH_NOARGS, O_close__doc__},
Jim Fultone60de4d2000-10-06 19:24:23 +0000605 {"seek", (PyCFunction)I_seek, METH_VARARGS, O_seek__doc__},
Guido van Rossum476e49f1998-12-15 21:43:15 +0000606 {NULL, NULL}
Guido van Rossum049cd901996-12-05 23:30:48 +0000607};
608
Guido van Rossum049cd901996-12-05 23:30:48 +0000609static void
Guido van Rossum154417e1997-04-09 17:35:33 +0000610I_dealloc(Iobject *self) {
Guido van Rossum15a40391997-09-03 00:09:26 +0000611 Py_XDECREF(self->pbuf);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000612 PyObject_Del(self);
Guido van Rossum049cd901996-12-05 23:30:48 +0000613}
614
Barry Warsaw3e8be722001-09-22 04:36:49 +0000615
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000616PyDoc_STRVAR(Itype__doc__,
617"Simple type for treating strings as input file streams");
Guido van Rossum049cd901996-12-05 23:30:48 +0000618
619static PyTypeObject Itype = {
Guido van Rossum154417e1997-04-09 17:35:33 +0000620 PyObject_HEAD_INIT(NULL)
Barry Warsaw3e8be722001-09-22 04:36:49 +0000621 0, /*ob_size*/
Skip Montanaroeb2f0612003-08-11 14:51:15 +0000622 "cStringIO.StringI", /*tp_name*/
Barry Warsaw3e8be722001-09-22 04:36:49 +0000623 sizeof(Iobject), /*tp_basicsize*/
624 0, /*tp_itemsize*/
Guido van Rossum154417e1997-04-09 17:35:33 +0000625 /* methods */
Barry Warsaw3e8be722001-09-22 04:36:49 +0000626 (destructor)I_dealloc, /*tp_dealloc*/
Georg Brandld37ac692006-03-30 11:58:57 +0000627 0, /*tp_print*/
Raymond Hettinger352f9472003-04-24 15:50:11 +0000628 0, /* tp_getattr */
Georg Brandld37ac692006-03-30 11:58:57 +0000629 0, /*tp_setattr*/
630 0, /*tp_compare*/
631 0, /*tp_repr*/
Barry Warsaw3e8be722001-09-22 04:36:49 +0000632 0, /*tp_as_number*/
633 0, /*tp_as_sequence*/
634 0, /*tp_as_mapping*/
Georg Brandld37ac692006-03-30 11:58:57 +0000635 0, /*tp_hash*/
636 0, /*tp_call*/
637 0, /*tp_str*/
Barry Warsaw3e8be722001-09-22 04:36:49 +0000638 0, /* tp_getattro */
639 0, /* tp_setattro */
640 0, /* tp_as_buffer */
641 Py_TPFLAGS_DEFAULT, /* tp_flags */
642 Itype__doc__, /* tp_doc */
643 0, /* tp_traverse */
644 0, /* tp_clear */
645 0, /* tp_richcompare */
646 0, /* tp_weaklistoffset */
Raymond Hettinger352f9472003-04-24 15:50:11 +0000647 PyObject_SelfIter, /* tp_iter */
648 (iternextfunc)IO_iternext, /* tp_iternext */
Raymond Hettinger5475f232003-08-08 12:20:03 +0000649 I_methods, /* tp_methods */
650 0, /* tp_members */
651 file_getsetlist, /* tp_getset */
Guido van Rossum049cd901996-12-05 23:30:48 +0000652};
653
Guido van Rossum142eeb81997-08-13 03:14:41 +0000654static PyObject *
655newIobject(PyObject *s) {
656 Iobject *self;
657 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000658 Py_ssize_t size;
Jeremy Hylton127b2ef2000-04-12 22:04:01 +0000659
Marc-André Lemburge47df7a2001-09-24 17:34:52 +0000660 if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) {
661 PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found",
Jeremy Hylton127b2ef2000-04-12 22:04:01 +0000662 s->ob_type->tp_name);
663 return NULL;
664 }
Martin v. Löwis5df2e612006-03-01 23:10:49 +0000665 self = PyObject_New(Iobject, &Itype);
666 if (!self) return NULL;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000667 Py_INCREF(s);
668 self->buf=buf;
669 self->string_size=size;
670 self->pbuf=s;
671 self->pos=0;
Guido van Rossum142eeb81997-08-13 03:14:41 +0000672
673 return (PyObject*)self;
674}
675
Guido van Rossum049cd901996-12-05 23:30:48 +0000676/* End of code for StringI objects */
677/* -------------------------------------------------------- */
678
679
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000680PyDoc_STRVAR(IO_StringIO__doc__,
681"StringIO([s]) -- Return a StringIO-like stream for reading or writing");
Guido van Rossum049cd901996-12-05 23:30:48 +0000682
683static PyObject *
Guido van Rossum154417e1997-04-09 17:35:33 +0000684IO_StringIO(PyObject *self, PyObject *args) {
Guido van Rossum049cd901996-12-05 23:30:48 +0000685 PyObject *s=0;
686
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000687 if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
Jim Fultone60de4d2000-10-06 19:24:23 +0000688
689 if (s) return newIobject(s);
Guido van Rossum154417e1997-04-09 17:35:33 +0000690 return newOobject(128);
Guido van Rossum049cd901996-12-05 23:30:48 +0000691}
692
693/* List of methods defined in the module */
694
695static struct PyMethodDef IO_methods[] = {
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +0000696 {"StringIO", (PyCFunction)IO_StringIO,
697 METH_VARARGS, IO_StringIO__doc__},
Guido van Rossum55702f81997-01-06 22:57:52 +0000698 {NULL, NULL} /* sentinel */
Guido van Rossum049cd901996-12-05 23:30:48 +0000699};
700
701
702/* Initialization function for the module (*must* be called initcStringIO) */
703
Guido van Rossum154417e1997-04-09 17:35:33 +0000704static struct PycStringIO_CAPI CAPI = {
Jim Fultone60de4d2000-10-06 19:24:23 +0000705 IO_cread,
706 IO_creadline,
Guido van Rossum154417e1997-04-09 17:35:33 +0000707 O_cwrite,
Jim Fultone60de4d2000-10-06 19:24:23 +0000708 IO_cgetval,
Guido van Rossum154417e1997-04-09 17:35:33 +0000709 newOobject,
710 newIobject,
711 &Itype,
712 &Otype,
713};
714
Mark Hammondfe51c6d2002-08-02 02:27:13 +0000715#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
716#define PyMODINIT_FUNC void
Guido van Rossum476e49f1998-12-15 21:43:15 +0000717#endif
Mark Hammondfe51c6d2002-08-02 02:27:13 +0000718PyMODINIT_FUNC
Thomas Wouters58d05102000-07-24 14:43:35 +0000719initcStringIO(void) {
Guido van Rossum9efe8ef1997-09-03 18:19:40 +0000720 PyObject *m, *d, *v;
Guido van Rossum049cd901996-12-05 23:30:48 +0000721
Guido van Rossum154417e1997-04-09 17:35:33 +0000722
Guido van Rossum049cd901996-12-05 23:30:48 +0000723 /* Create the module and add the functions */
724 m = Py_InitModule4("cStringIO", IO_methods,
725 cStringIO_module_documentation,
726 (PyObject*)NULL,PYTHON_API_VERSION);
Neal Norwitz1ac754f2006-01-19 06:09:39 +0000727 if (m == NULL) return;
Guido van Rossum049cd901996-12-05 23:30:48 +0000728
729 /* Add some symbolic constants to the module */
730 d = PyModule_GetDict(m);
Guido van Rossum049cd901996-12-05 23:30:48 +0000731
Guido van Rossum55702f81997-01-06 22:57:52 +0000732 /* Export C API */
Guido van Rossum154417e1997-04-09 17:35:33 +0000733 Itype.ob_type=&PyType_Type;
734 Otype.ob_type=&PyType_Type;
Raymond Hettinger352f9472003-04-24 15:50:11 +0000735 if (PyType_Ready(&Otype) < 0) return;
736 if (PyType_Ready(&Itype) < 0) return;
Guido van Rossum9efe8ef1997-09-03 18:19:40 +0000737 PyDict_SetItemString(d,"cStringIO_CAPI",
738 v = PyCObject_FromVoidPtr(&CAPI,NULL));
739 Py_XDECREF(v);
Guido van Rossum154417e1997-04-09 17:35:33 +0000740
741 /* Export Types */
Guido van Rossum049cd901996-12-05 23:30:48 +0000742 PyDict_SetItemString(d,"InputType", (PyObject*)&Itype);
743 PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
Guido van Rossum142eeb81997-08-13 03:14:41 +0000744
745 /* Maybe make certain warnings go away */
Jim Fultone60de4d2000-10-06 19:24:23 +0000746 if (0) PycString_IMPORT;
Guido van Rossum049cd901996-12-05 23:30:48 +0000747}