Line data Source code
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 : Py_buffer pbuf;
70 : } Iobject;
71 :
72 : /* IOobject (common) methods */
73 :
74 : PyDoc_STRVAR(IO_flush__doc__, "flush(): does nothing.");
75 :
76 : static int
77 0 : IO__opencheck(IOobject *self) {
78 0 : if (!self->buf) {
79 0 : PyErr_SetString(PyExc_ValueError,
80 : "I/O operation on closed file");
81 0 : return 0;
82 : }
83 0 : return 1;
84 : }
85 :
86 : static PyObject *
87 0 : IO_get_closed(IOobject *self, void *closure)
88 : {
89 0 : PyObject *result = Py_False;
90 :
91 0 : if (self->buf == NULL)
92 0 : result = Py_True;
93 0 : Py_INCREF(result);
94 0 : return result;
95 : }
96 :
97 : static PyGetSetDef file_getsetlist[] = {
98 : {"closed", (getter)IO_get_closed, NULL, "True if the file is closed"},
99 : {0},
100 : };
101 :
102 : static PyObject *
103 0 : IO_flush(IOobject *self, PyObject *unused) {
104 :
105 0 : if (!IO__opencheck(self)) return NULL;
106 :
107 0 : Py_INCREF(Py_None);
108 0 : return Py_None;
109 : }
110 :
111 : PyDoc_STRVAR(IO_getval__doc__,
112 : "getvalue([use_pos]) -- Get the string value."
113 : "\n"
114 : "If use_pos is specified and is a true value, then the string returned\n"
115 : "will include only the text up to the current file position.\n");
116 :
117 : static PyObject *
118 0 : IO_cgetval(PyObject *self) {
119 0 : if (!IO__opencheck(IOOOBJECT(self))) return NULL;
120 : assert(IOOOBJECT(self)->pos >= 0);
121 0 : return PyString_FromStringAndSize(((IOobject*)self)->buf,
122 : ((IOobject*)self)->pos);
123 : }
124 :
125 : static PyObject *
126 0 : IO_getval(IOobject *self, PyObject *args) {
127 0 : PyObject *use_pos=Py_None;
128 : int b;
129 : Py_ssize_t s;
130 :
131 0 : if (!IO__opencheck(self)) return NULL;
132 0 : if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL;
133 :
134 0 : b = PyObject_IsTrue(use_pos);
135 0 : if (b < 0)
136 0 : return NULL;
137 0 : if (b) {
138 0 : s=self->pos;
139 0 : if (s > self->string_size) s=self->string_size;
140 : }
141 : else
142 0 : s=self->string_size;
143 : assert(self->pos >= 0);
144 0 : return PyString_FromStringAndSize(self->buf, s);
145 : }
146 :
147 : PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
148 :
149 : static PyObject *
150 0 : IO_isatty(IOobject *self, PyObject *unused) {
151 0 : if (!IO__opencheck(self)) return NULL;
152 0 : Py_INCREF(Py_False);
153 0 : return Py_False;
154 : }
155 :
156 : PyDoc_STRVAR(IO_read__doc__,
157 : "read([s]) -- Read s characters, or the rest of the string");
158 :
159 : static int
160 0 : IO_cread(PyObject *self, char **output, Py_ssize_t n) {
161 : Py_ssize_t l;
162 :
163 0 : if (!IO__opencheck(IOOOBJECT(self))) return -1;
164 : assert(IOOOBJECT(self)->pos >= 0);
165 : assert(IOOOBJECT(self)->string_size >= 0);
166 0 : l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
167 0 : if (n < 0 || n > l) {
168 0 : n = l;
169 0 : if (n < 0) n=0;
170 : }
171 0 : if (n > INT_MAX) {
172 0 : PyErr_SetString(PyExc_OverflowError,
173 : "length too large");
174 0 : return -1;
175 : }
176 :
177 0 : *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
178 0 : ((IOobject*)self)->pos += n;
179 0 : return (int)n;
180 : }
181 :
182 : static PyObject *
183 0 : IO_read(IOobject *self, PyObject *args) {
184 0 : Py_ssize_t n = -1;
185 0 : char *output = NULL;
186 :
187 0 : if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;
188 :
189 0 : if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
190 :
191 0 : return PyString_FromStringAndSize(output, n);
192 : }
193 :
194 : PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
195 :
196 : static int
197 0 : IO_creadline(PyObject *self, char **output) {
198 : char *n, *start, *end;
199 : Py_ssize_t len;
200 :
201 0 : if (!IO__opencheck(IOOOBJECT(self))) return -1;
202 :
203 0 : n = start = ((IOobject*)self)->buf + ((IOobject*)self)->pos;
204 0 : end = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
205 0 : while (n < end && *n != '\n')
206 0 : n++;
207 :
208 0 : if (n < end) n++;
209 :
210 0 : len = n - start;
211 0 : if (len > INT_MAX)
212 0 : len = INT_MAX;
213 :
214 0 : *output=start;
215 :
216 : assert(IOOOBJECT(self)->pos <= PY_SSIZE_T_MAX - len);
217 : assert(IOOOBJECT(self)->pos >= 0);
218 : assert(IOOOBJECT(self)->string_size >= 0);
219 :
220 0 : ((IOobject*)self)->pos += len;
221 0 : return (int)len;
222 : }
223 :
224 : static PyObject *
225 0 : IO_readline(IOobject *self, PyObject *args) {
226 0 : int n, m=-1;
227 : char *output;
228 :
229 0 : if (args)
230 0 : if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
231 :
232 0 : if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;
233 0 : if (m >= 0 && m < n) {
234 0 : m = n - m;
235 0 : n -= m;
236 0 : self->pos -= m;
237 : }
238 : assert(IOOOBJECT(self)->pos >= 0);
239 0 : return PyString_FromStringAndSize(output, n);
240 : }
241 :
242 : PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
243 :
244 : static PyObject *
245 0 : IO_readlines(IOobject *self, PyObject *args) {
246 : int n;
247 : char *output;
248 : PyObject *result, *line;
249 0 : Py_ssize_t hint = 0, length = 0;
250 :
251 0 : if (!PyArg_ParseTuple(args, "|n:readlines", &hint)) return NULL;
252 :
253 0 : result = PyList_New(0);
254 0 : if (!result)
255 0 : return NULL;
256 :
257 : while (1){
258 0 : if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
259 0 : goto err;
260 0 : if (n == 0)
261 0 : break;
262 0 : line = PyString_FromStringAndSize (output, n);
263 0 : if (!line)
264 0 : goto err;
265 0 : if (PyList_Append (result, line) == -1) {
266 0 : Py_DECREF (line);
267 0 : goto err;
268 : }
269 0 : Py_DECREF (line);
270 0 : length += n;
271 0 : if (hint > 0 && length >= hint)
272 0 : break;
273 0 : }
274 0 : return result;
275 : err:
276 0 : Py_DECREF(result);
277 0 : return NULL;
278 : }
279 :
280 : PyDoc_STRVAR(IO_reset__doc__,
281 : "reset() -- Reset the file position to the beginning");
282 :
283 : static PyObject *
284 0 : IO_reset(IOobject *self, PyObject *unused) {
285 :
286 0 : if (!IO__opencheck(self)) return NULL;
287 :
288 0 : self->pos = 0;
289 :
290 0 : Py_INCREF(Py_None);
291 0 : return Py_None;
292 : }
293 :
294 : PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
295 :
296 : static PyObject *
297 0 : IO_tell(IOobject *self, PyObject *unused) {
298 :
299 0 : if (!IO__opencheck(self)) return NULL;
300 :
301 : assert(self->pos >= 0);
302 0 : return PyInt_FromSsize_t(self->pos);
303 : }
304 :
305 : PyDoc_STRVAR(IO_truncate__doc__,
306 : "truncate(): truncate the file at the current position.");
307 :
308 : static PyObject *
309 0 : IO_truncate(IOobject *self, PyObject *args) {
310 0 : Py_ssize_t pos = -1;
311 :
312 0 : if (!IO__opencheck(self)) return NULL;
313 0 : if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;
314 :
315 0 : if (PyTuple_Size(args) == 0) {
316 : /* No argument passed, truncate to current position */
317 0 : pos = self->pos;
318 : }
319 :
320 0 : if (pos < 0) {
321 0 : errno = EINVAL;
322 0 : PyErr_SetFromErrno(PyExc_IOError);
323 0 : return NULL;
324 : }
325 :
326 0 : if (self->string_size > pos) self->string_size = pos;
327 0 : self->pos = self->string_size;
328 :
329 0 : Py_INCREF(Py_None);
330 0 : return Py_None;
331 : }
332 :
333 : static PyObject *
334 0 : IO_iternext(Iobject *self)
335 : {
336 : PyObject *next;
337 0 : next = IO_readline((IOobject *)self, NULL);
338 0 : if (!next)
339 0 : return NULL;
340 0 : if (!PyString_GET_SIZE(next)) {
341 0 : Py_DECREF(next);
342 0 : PyErr_SetNone(PyExc_StopIteration);
343 0 : return NULL;
344 : }
345 0 : return next;
346 : }
347 :
348 :
349 :
350 :
351 : /* Read-write object methods */
352 :
353 : PyDoc_STRVAR(IO_seek__doc__,
354 : "seek(position) -- set the current position\n"
355 : "seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
356 :
357 : static PyObject *
358 0 : IO_seek(Iobject *self, PyObject *args) {
359 : Py_ssize_t position;
360 0 : int mode = 0;
361 :
362 0 : if (!IO__opencheck(IOOOBJECT(self))) return NULL;
363 0 : if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
364 0 : return NULL;
365 :
366 0 : if (mode == 2) {
367 0 : position += self->string_size;
368 : }
369 0 : else if (mode == 1) {
370 0 : position += self->pos;
371 : }
372 :
373 0 : if (position < 0) position=0;
374 :
375 0 : self->pos=position;
376 :
377 0 : Py_INCREF(Py_None);
378 0 : return Py_None;
379 : }
380 :
381 : PyDoc_STRVAR(O_write__doc__,
382 : "write(s) -- Write a string to the file"
383 : "\n\nNote (hack:) writing None resets the buffer");
384 :
385 :
386 : static int
387 0 : O_cwrite(PyObject *self, const char *c, Py_ssize_t len) {
388 : Py_ssize_t newpos;
389 : Oobject *oself;
390 : char *newbuf;
391 :
392 0 : if (!IO__opencheck(IOOOBJECT(self))) return -1;
393 0 : oself = (Oobject *)self;
394 :
395 0 : if (len > INT_MAX) {
396 0 : PyErr_SetString(PyExc_OverflowError,
397 : "length too large");
398 0 : return -1;
399 : }
400 : assert(len >= 0);
401 0 : if (oself->pos >= PY_SSIZE_T_MAX - len) {
402 0 : PyErr_SetString(PyExc_OverflowError,
403 : "new position too large");
404 0 : return -1;
405 : }
406 0 : newpos = oself->pos + len;
407 0 : if (newpos >= oself->buf_size) {
408 0 : size_t newsize = oself->buf_size;
409 0 : newsize *= 2;
410 0 : if (newsize <= (size_t)newpos || newsize > PY_SSIZE_T_MAX) {
411 : assert(newpos < PY_SSIZE_T_MAX - 1);
412 0 : newsize = newpos + 1;
413 : }
414 0 : newbuf = (char*)realloc(oself->buf, newsize);
415 0 : if (!newbuf) {
416 0 : PyErr_SetString(PyExc_MemoryError,"out of memory");
417 0 : return -1;
418 : }
419 0 : oself->buf_size = (Py_ssize_t)newsize;
420 0 : oself->buf = newbuf;
421 : }
422 :
423 0 : if (oself->string_size < oself->pos) {
424 : /* In case of overseek, pad with null bytes the buffer region between
425 : the end of stream and the current position.
426 :
427 : 0 lo string_size hi
428 : | |<---used--->|<----------available----------->|
429 : | | <--to pad-->|<---to write---> |
430 : 0 buf position
431 : */
432 0 : memset(oself->buf + oself->string_size, '\0',
433 0 : (oself->pos - oself->string_size) * sizeof(char));
434 : }
435 :
436 0 : memcpy(oself->buf + oself->pos, c, len);
437 :
438 0 : oself->pos = newpos;
439 :
440 0 : if (oself->string_size < oself->pos) {
441 0 : oself->string_size = oself->pos;
442 : }
443 :
444 0 : return (int)len;
445 : }
446 :
447 : static PyObject *
448 0 : O_write(Oobject *self, PyObject *args) {
449 : Py_buffer buf;
450 : int result;
451 :
452 0 : if (!PyArg_ParseTuple(args, "s*:write", &buf)) return NULL;
453 :
454 0 : result = O_cwrite((PyObject*)self, buf.buf, buf.len);
455 0 : PyBuffer_Release(&buf);
456 0 : if (result < 0) return NULL;
457 :
458 0 : Py_INCREF(Py_None);
459 0 : return Py_None;
460 : }
461 :
462 : PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
463 :
464 : static PyObject *
465 0 : O_close(Oobject *self, PyObject *unused) {
466 0 : if (self->buf != NULL) free(self->buf);
467 0 : self->buf = NULL;
468 :
469 0 : self->pos = self->string_size = self->buf_size = 0;
470 :
471 0 : Py_INCREF(Py_None);
472 0 : return Py_None;
473 : }
474 :
475 : PyDoc_STRVAR(O_writelines__doc__,
476 : "writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
477 : "\n"
478 : "Note that newlines are not added. The sequence can be any iterable object\n"
479 : "producing strings. This is equivalent to calling write() for each string.");
480 : static PyObject *
481 0 : O_writelines(Oobject *self, PyObject *args) {
482 : PyObject *it, *s;
483 :
484 0 : it = PyObject_GetIter(args);
485 0 : if (it == NULL)
486 0 : return NULL;
487 0 : while ((s = PyIter_Next(it)) != NULL) {
488 : Py_ssize_t n;
489 : char *c;
490 0 : if (PyString_AsStringAndSize(s, &c, &n) == -1) {
491 0 : Py_DECREF(it);
492 0 : Py_DECREF(s);
493 0 : return NULL;
494 : }
495 0 : if (O_cwrite((PyObject *)self, c, n) == -1) {
496 0 : Py_DECREF(it);
497 0 : Py_DECREF(s);
498 0 : return NULL;
499 : }
500 0 : Py_DECREF(s);
501 : }
502 :
503 0 : Py_DECREF(it);
504 :
505 : /* See if PyIter_Next failed */
506 0 : if (PyErr_Occurred())
507 0 : return NULL;
508 :
509 0 : Py_RETURN_NONE;
510 : }
511 : static struct PyMethodDef O_methods[] = {
512 : /* Common methods: */
513 : {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
514 : {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
515 : {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
516 : {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
517 : {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
518 : {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
519 : {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
520 : {"seek", (PyCFunction)IO_seek, METH_VARARGS, IO_seek__doc__},
521 : {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
522 : {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
523 :
524 : /* Read-write StringIO specific methods: */
525 : {"close", (PyCFunction)O_close, METH_NOARGS, O_close__doc__},
526 : {"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__},
527 : {"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__},
528 : {NULL, NULL} /* sentinel */
529 : };
530 :
531 : static PyMemberDef O_memberlist[] = {
532 : {"softspace", T_INT, offsetof(Oobject, softspace), 0,
533 : "flag indicating that a space needs to be printed; used by print"},
534 : /* getattr(f, "closed") is implemented without this table */
535 : {NULL} /* Sentinel */
536 : };
537 :
538 : static void
539 0 : O_dealloc(Oobject *self) {
540 0 : if (self->buf != NULL)
541 0 : free(self->buf);
542 0 : PyObject_Del(self);
543 0 : }
544 :
545 : PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
546 :
547 : static PyTypeObject Otype = {
548 : PyVarObject_HEAD_INIT(NULL, 0)
549 : "cStringIO.StringO", /*tp_name*/
550 : sizeof(Oobject), /*tp_basicsize*/
551 : 0, /*tp_itemsize*/
552 : /* methods */
553 : (destructor)O_dealloc, /*tp_dealloc*/
554 : 0, /*tp_print*/
555 : 0, /*tp_getattr */
556 : 0, /*tp_setattr */
557 : 0, /*tp_compare*/
558 : 0, /*tp_repr*/
559 : 0, /*tp_as_number*/
560 : 0, /*tp_as_sequence*/
561 : 0, /*tp_as_mapping*/
562 : 0, /*tp_hash*/
563 : 0 , /*tp_call*/
564 : 0, /*tp_str*/
565 : 0, /*tp_getattro */
566 : 0, /*tp_setattro */
567 : 0, /*tp_as_buffer */
568 : Py_TPFLAGS_DEFAULT, /*tp_flags*/
569 : Otype__doc__, /*tp_doc */
570 : 0, /*tp_traverse */
571 : 0, /*tp_clear */
572 : 0, /*tp_richcompare */
573 : 0, /*tp_weaklistoffset */
574 : PyObject_SelfIter, /*tp_iter */
575 : (iternextfunc)IO_iternext, /*tp_iternext */
576 : O_methods, /*tp_methods */
577 : O_memberlist, /*tp_members */
578 : file_getsetlist, /*tp_getset */
579 : };
580 :
581 : static PyObject *
582 0 : newOobject(int size) {
583 : Oobject *self;
584 :
585 0 : self = PyObject_New(Oobject, &Otype);
586 0 : if (self == NULL)
587 0 : return NULL;
588 0 : self->pos=0;
589 0 : self->string_size = 0;
590 0 : self->softspace = 0;
591 :
592 0 : self->buf = (char *)malloc(size);
593 0 : if (!self->buf) {
594 0 : PyErr_SetString(PyExc_MemoryError,"out of memory");
595 0 : self->buf_size = 0;
596 0 : Py_DECREF(self);
597 0 : return NULL;
598 : }
599 :
600 0 : self->buf_size=size;
601 0 : return (PyObject*)self;
602 : }
603 :
604 : /* End of code for StringO objects */
605 : /* -------------------------------------------------------- */
606 :
607 : static PyObject *
608 0 : I_close(Iobject *self, PyObject *unused) {
609 0 : PyBuffer_Release(&self->pbuf);
610 0 : self->buf = NULL;
611 :
612 0 : self->pos = self->string_size = 0;
613 :
614 0 : Py_INCREF(Py_None);
615 0 : 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 : {"seek", (PyCFunction)IO_seek, METH_VARARGS, IO_seek__doc__},
628 : {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
629 : {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
630 :
631 : /* Read-only StringIO specific methods: */
632 : {"close", (PyCFunction)I_close, METH_NOARGS, O_close__doc__},
633 : {NULL, NULL}
634 : };
635 :
636 : static void
637 0 : I_dealloc(Iobject *self) {
638 0 : PyBuffer_Release(&self->pbuf);
639 0 : PyObject_Del(self);
640 0 : }
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 0 : newIobject(PyObject *s) {
682 : Iobject *self;
683 : Py_buffer buf;
684 : PyObject *args;
685 : int result;
686 :
687 0 : args = Py_BuildValue("(O)", s);
688 0 : if (args == NULL)
689 0 : return NULL;
690 0 : result = PyArg_ParseTuple(args, "s*:StringIO", &buf);
691 0 : Py_DECREF(args);
692 0 : if (!result)
693 0 : return NULL;
694 :
695 0 : self = PyObject_New(Iobject, &Itype);
696 0 : if (!self) {
697 0 : PyBuffer_Release(&buf);
698 0 : return NULL;
699 : }
700 0 : self->buf=buf.buf;
701 0 : self->string_size=buf.len;
702 0 : self->pbuf=buf;
703 0 : self->pos=0;
704 :
705 0 : return (PyObject*)self;
706 : }
707 :
708 : /* End of code for StringI objects */
709 : /* -------------------------------------------------------- */
710 :
711 :
712 : PyDoc_STRVAR(IO_StringIO__doc__,
713 : "StringIO([s]) -- Return a StringIO-like stream for reading or writing");
714 :
715 : static PyObject *
716 0 : IO_StringIO(PyObject *self, PyObject *args) {
717 0 : PyObject *s=0;
718 :
719 0 : if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
720 :
721 0 : if (s) return newIobject(s);
722 0 : return newOobject(128);
723 : }
724 :
725 : /* List of methods defined in the module */
726 :
727 : static struct PyMethodDef IO_methods[] = {
728 : {"StringIO", (PyCFunction)IO_StringIO,
729 : METH_VARARGS, IO_StringIO__doc__},
730 : {NULL, NULL} /* sentinel */
731 : };
732 :
733 :
734 : /* Initialization function for the module (*must* be called initcStringIO) */
735 :
736 : static struct PycStringIO_CAPI CAPI = {
737 : IO_cread,
738 : IO_creadline,
739 : O_cwrite,
740 : IO_cgetval,
741 : newOobject,
742 : newIobject,
743 : &Itype,
744 : &Otype,
745 : };
746 :
747 : #ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
748 : #define PyMODINIT_FUNC void
749 : #endif
750 : PyMODINIT_FUNC
751 3 : initcStringIO(void) {
752 : PyObject *m, *d, *v;
753 :
754 :
755 : /* Create the module and add the functions */
756 3 : m = Py_InitModule4("cStringIO", IO_methods,
757 : cStringIO_module_documentation,
758 : (PyObject*)NULL,PYTHON_API_VERSION);
759 3 : if (m == NULL) return;
760 :
761 : /* Add some symbolic constants to the module */
762 3 : d = PyModule_GetDict(m);
763 :
764 : /* Export C API */
765 3 : Py_TYPE(&Itype)=&PyType_Type;
766 3 : Py_TYPE(&Otype)=&PyType_Type;
767 3 : if (PyType_Ready(&Otype) < 0) return;
768 3 : if (PyType_Ready(&Itype) < 0) return;
769 3 : v = PyCapsule_New(&CAPI, PycStringIO_CAPSULE_NAME, NULL);
770 3 : PyDict_SetItemString(d,"cStringIO_CAPI", v);
771 3 : Py_XDECREF(v);
772 :
773 : /* Export Types */
774 3 : PyDict_SetItemString(d,"InputType", (PyObject*)&Itype);
775 3 : PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
776 :
777 : /* Maybe make certain warnings go away */
778 : if (0) PycString_IMPORT;
779 : }
|
