|
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 } |