779 lines
21 KiB
C
779 lines
21 KiB
C
|
|
#include "Python.h"
|
|
#include "import.h"
|
|
#include "cStringIO.h"
|
|
#include "structmember.h"
|
|
|
|
PyDoc_STRVAR(cStringIO_module_documentation,
|
|
"A simple fast partial StringIO replacement.\n"
|
|
"\n"
|
|
"This module provides a simple useful replacement for\n"
|
|
"the StringIO module that is written in C. It does not provide the\n"
|
|
"full generality of StringIO, but it provides enough for most\n"
|
|
"applications and is especially useful in conjunction with the\n"
|
|
"pickle module.\n"
|
|
"\n"
|
|
"Usage:\n"
|
|
"\n"
|
|
" from cStringIO import StringIO\n"
|
|
"\n"
|
|
" an_output_stream=StringIO()\n"
|
|
" an_output_stream.write(some_stuff)\n"
|
|
" ...\n"
|
|
" value=an_output_stream.getvalue()\n"
|
|
"\n"
|
|
" an_input_stream=StringIO(a_string)\n"
|
|
" spam=an_input_stream.readline()\n"
|
|
" spam=an_input_stream.read(5)\n"
|
|
" an_input_stream.seek(0) # OK, start over\n"
|
|
" spam=an_input_stream.read() # and read it all\n"
|
|
" \n"
|
|
"If someone else wants to provide a more complete implementation,\n"
|
|
"go for it. :-) \n"
|
|
"\n"
|
|
"cStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp\n");
|
|
|
|
/* Declaration for file-like objects that manage data as strings
|
|
|
|
The IOobject type should be though of as a common base type for
|
|
Iobjects, which provide input (read-only) StringIO objects and
|
|
Oobjects, which provide read-write objects. Most of the methods
|
|
depend only on common data.
|
|
*/
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
char *buf;
|
|
Py_ssize_t pos, string_size;
|
|
} IOobject;
|
|
|
|
#define IOOOBJECT(O) ((IOobject*)(O))
|
|
|
|
/* Declarations for objects of type StringO */
|
|
|
|
typedef struct { /* Subtype of IOobject */
|
|
PyObject_HEAD
|
|
char *buf;
|
|
Py_ssize_t pos, string_size;
|
|
|
|
Py_ssize_t buf_size;
|
|
int softspace;
|
|
} Oobject;
|
|
|
|
/* Declarations for objects of type StringI */
|
|
|
|
typedef struct { /* Subtype of IOobject */
|
|
PyObject_HEAD
|
|
char *buf;
|
|
Py_ssize_t pos, string_size;
|
|
Py_buffer pbuf;
|
|
} Iobject;
|
|
|
|
/* IOobject (common) methods */
|
|
|
|
PyDoc_STRVAR(IO_flush__doc__, "flush(): does nothing.");
|
|
|
|
static int
|
|
IO__opencheck(IOobject *self) {
|
|
if (!self->buf) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"I/O operation on closed file");
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static PyObject *
|
|
IO_get_closed(IOobject *self, void *closure)
|
|
{
|
|
PyObject *result = Py_False;
|
|
|
|
if (self->buf == NULL)
|
|
result = Py_True;
|
|
Py_INCREF(result);
|
|
return result;
|
|
}
|
|
|
|
static PyGetSetDef file_getsetlist[] = {
|
|
{"closed", (getter)IO_get_closed, NULL, "True if the file is closed"},
|
|
{0},
|
|
};
|
|
|
|
static PyObject *
|
|
IO_flush(IOobject *self, PyObject *unused) {
|
|
|
|
if (!IO__opencheck(self)) return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_getval__doc__,
|
|
"getvalue([use_pos]) -- Get the string value."
|
|
"\n"
|
|
"If use_pos is specified and is a true value, then the string returned\n"
|
|
"will include only the text up to the current file position.\n");
|
|
|
|
static PyObject *
|
|
IO_cgetval(PyObject *self) {
|
|
if (!IO__opencheck(IOOOBJECT(self))) return NULL;
|
|
assert(IOOOBJECT(self)->pos >= 0);
|
|
return PyString_FromStringAndSize(((IOobject*)self)->buf,
|
|
((IOobject*)self)->pos);
|
|
}
|
|
|
|
static PyObject *
|
|
IO_getval(IOobject *self, PyObject *args) {
|
|
PyObject *use_pos=Py_None;
|
|
int b;
|
|
Py_ssize_t s;
|
|
|
|
if (!IO__opencheck(self)) return NULL;
|
|
if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL;
|
|
|
|
b = PyObject_IsTrue(use_pos);
|
|
if (b < 0)
|
|
return NULL;
|
|
if (b) {
|
|
s=self->pos;
|
|
if (s > self->string_size) s=self->string_size;
|
|
}
|
|
else
|
|
s=self->string_size;
|
|
assert(self->pos >= 0);
|
|
return PyString_FromStringAndSize(self->buf, s);
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
|
|
|
|
static PyObject *
|
|
IO_isatty(IOobject *self, PyObject *unused) {
|
|
if (!IO__opencheck(self)) return NULL;
|
|
Py_INCREF(Py_False);
|
|
return Py_False;
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_read__doc__,
|
|
"read([s]) -- Read s characters, or the rest of the string");
|
|
|
|
static int
|
|
IO_cread(PyObject *self, char **output, Py_ssize_t n) {
|
|
Py_ssize_t l;
|
|
|
|
if (!IO__opencheck(IOOOBJECT(self))) return -1;
|
|
assert(IOOOBJECT(self)->pos >= 0);
|
|
assert(IOOOBJECT(self)->string_size >= 0);
|
|
l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
|
|
if (n < 0 || n > l) {
|
|
n = l;
|
|
if (n < 0) n=0;
|
|
}
|
|
if (n > INT_MAX) {
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
"length too large");
|
|
return -1;
|
|
}
|
|
|
|
*output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
|
|
((IOobject*)self)->pos += n;
|
|
return (int)n;
|
|
}
|
|
|
|
static PyObject *
|
|
IO_read(IOobject *self, PyObject *args) {
|
|
Py_ssize_t n = -1;
|
|
char *output = NULL;
|
|
|
|
if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;
|
|
|
|
if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
|
|
|
|
return PyString_FromStringAndSize(output, n);
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
|
|
|
|
static int
|
|
IO_creadline(PyObject *self, char **output) {
|
|
char *n, *start, *end;
|
|
Py_ssize_t len;
|
|
|
|
if (!IO__opencheck(IOOOBJECT(self))) return -1;
|
|
|
|
n = start = ((IOobject*)self)->buf + ((IOobject*)self)->pos;
|
|
end = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
|
|
while (n < end && *n != '\n')
|
|
n++;
|
|
|
|
if (n < end) n++;
|
|
|
|
len = n - start;
|
|
if (len > INT_MAX)
|
|
len = INT_MAX;
|
|
|
|
*output=start;
|
|
|
|
assert(IOOOBJECT(self)->pos <= PY_SSIZE_T_MAX - len);
|
|
assert(IOOOBJECT(self)->pos >= 0);
|
|
assert(IOOOBJECT(self)->string_size >= 0);
|
|
|
|
((IOobject*)self)->pos += len;
|
|
return (int)len;
|
|
}
|
|
|
|
static PyObject *
|
|
IO_readline(IOobject *self, PyObject *args) {
|
|
int n, m=-1;
|
|
char *output;
|
|
|
|
if (args)
|
|
if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
|
|
|
|
if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;
|
|
if (m >= 0 && m < n) {
|
|
m = n - m;
|
|
n -= m;
|
|
self->pos -= m;
|
|
}
|
|
assert(IOOOBJECT(self)->pos >= 0);
|
|
return PyString_FromStringAndSize(output, n);
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
|
|
|
|
static PyObject *
|
|
IO_readlines(IOobject *self, PyObject *args) {
|
|
int n;
|
|
char *output;
|
|
PyObject *result, *line;
|
|
Py_ssize_t hint = 0, length = 0;
|
|
|
|
if (!PyArg_ParseTuple(args, "|n:readlines", &hint)) return NULL;
|
|
|
|
result = PyList_New(0);
|
|
if (!result)
|
|
return NULL;
|
|
|
|
while (1){
|
|
if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
|
|
goto err;
|
|
if (n == 0)
|
|
break;
|
|
line = PyString_FromStringAndSize (output, n);
|
|
if (!line)
|
|
goto err;
|
|
if (PyList_Append (result, line) == -1) {
|
|
Py_DECREF (line);
|
|
goto err;
|
|
}
|
|
Py_DECREF (line);
|
|
length += n;
|
|
if (hint > 0 && length >= hint)
|
|
break;
|
|
}
|
|
return result;
|
|
err:
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_reset__doc__,
|
|
"reset() -- Reset the file position to the beginning");
|
|
|
|
static PyObject *
|
|
IO_reset(IOobject *self, PyObject *unused) {
|
|
|
|
if (!IO__opencheck(self)) return NULL;
|
|
|
|
self->pos = 0;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
|
|
|
|
static PyObject *
|
|
IO_tell(IOobject *self, PyObject *unused) {
|
|
|
|
if (!IO__opencheck(self)) return NULL;
|
|
|
|
assert(self->pos >= 0);
|
|
return PyInt_FromSsize_t(self->pos);
|
|
}
|
|
|
|
PyDoc_STRVAR(IO_truncate__doc__,
|
|
"truncate(): truncate the file at the current position.");
|
|
|
|
static PyObject *
|
|
IO_truncate(IOobject *self, PyObject *args) {
|
|
Py_ssize_t pos = -1;
|
|
|
|
if (!IO__opencheck(self)) return NULL;
|
|
if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;
|
|
|
|
if (PyTuple_Size(args) == 0) {
|
|
/* No argument passed, truncate to current position */
|
|
pos = self->pos;
|
|
}
|
|
|
|
if (pos < 0) {
|
|
errno = EINVAL;
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
return NULL;
|
|
}
|
|
|
|
if (self->string_size > pos) self->string_size = pos;
|
|
self->pos = self->string_size;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
IO_iternext(Iobject *self)
|
|
{
|
|
PyObject *next;
|
|
next = IO_readline((IOobject *)self, NULL);
|
|
if (!next)
|
|
return NULL;
|
|
if (!PyString_GET_SIZE(next)) {
|
|
Py_DECREF(next);
|
|
PyErr_SetNone(PyExc_StopIteration);
|
|
return NULL;
|
|
}
|
|
return next;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read-write object methods */
|
|
|
|
PyDoc_STRVAR(IO_seek__doc__,
|
|
"seek(position) -- set the current position\n"
|
|
"seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
|
|
|
|
static PyObject *
|
|
IO_seek(Iobject *self, PyObject *args) {
|
|
Py_ssize_t position;
|
|
int mode = 0;
|
|
|
|
if (!IO__opencheck(IOOOBJECT(self))) return NULL;
|
|
if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
|
|
return NULL;
|
|
|
|
if (mode == 2) {
|
|
position += self->string_size;
|
|
}
|
|
else if (mode == 1) {
|
|
position += self->pos;
|
|
}
|
|
|
|
if (position < 0) position=0;
|
|
|
|
self->pos=position;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
PyDoc_STRVAR(O_write__doc__,
|
|
"write(s) -- Write a string to the file"
|
|
"\n\nNote (hack:) writing None resets the buffer");
|
|
|
|
|
|
static int
|
|
O_cwrite(PyObject *self, const char *c, Py_ssize_t len) {
|
|
Py_ssize_t newpos;
|
|
Oobject *oself;
|
|
char *newbuf;
|
|
|
|
if (!IO__opencheck(IOOOBJECT(self))) return -1;
|
|
oself = (Oobject *)self;
|
|
|
|
if (len > INT_MAX) {
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
"length too large");
|
|
return -1;
|
|
}
|
|
assert(len >= 0);
|
|
if (oself->pos >= PY_SSIZE_T_MAX - len) {
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
"new position too large");
|
|
return -1;
|
|
}
|
|
newpos = oself->pos + len;
|
|
if (newpos >= oself->buf_size) {
|
|
size_t newsize = oself->buf_size;
|
|
newsize *= 2;
|
|
if (newsize <= (size_t)newpos || newsize > PY_SSIZE_T_MAX) {
|
|
assert(newpos < PY_SSIZE_T_MAX - 1);
|
|
newsize = newpos + 1;
|
|
}
|
|
newbuf = (char*)realloc(oself->buf, newsize);
|
|
if (!newbuf) {
|
|
PyErr_SetString(PyExc_MemoryError,"out of memory");
|
|
return -1;
|
|
}
|
|
oself->buf_size = (Py_ssize_t)newsize;
|
|
oself->buf = newbuf;
|
|
}
|
|
|
|
if (oself->string_size < oself->pos) {
|
|
/* In case of overseek, pad with null bytes the buffer region between
|
|
the end of stream and the current position.
|
|
|
|
0 lo string_size hi
|
|
| |<---used--->|<----------available----------->|
|
|
| | <--to pad-->|<---to write---> |
|
|
0 buf position
|
|
*/
|
|
memset(oself->buf + oself->string_size, '\0',
|
|
(oself->pos - oself->string_size) * sizeof(char));
|
|
}
|
|
|
|
memcpy(oself->buf + oself->pos, c, len);
|
|
|
|
oself->pos = newpos;
|
|
|
|
if (oself->string_size < oself->pos) {
|
|
oself->string_size = oself->pos;
|
|
}
|
|
|
|
return (int)len;
|
|
}
|
|
|
|
static PyObject *
|
|
O_write(Oobject *self, PyObject *args) {
|
|
Py_buffer buf;
|
|
int result;
|
|
|
|
if (!PyArg_ParseTuple(args, "s*:write", &buf)) return NULL;
|
|
|
|
result = O_cwrite((PyObject*)self, buf.buf, buf.len);
|
|
PyBuffer_Release(&buf);
|
|
if (result < 0) return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
|
|
|
|
static PyObject *
|
|
O_close(Oobject *self, PyObject *unused) {
|
|
if (self->buf != NULL) free(self->buf);
|
|
self->buf = NULL;
|
|
|
|
self->pos = self->string_size = self->buf_size = 0;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
PyDoc_STRVAR(O_writelines__doc__,
|
|
"writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
|
|
"\n"
|
|
"Note that newlines are not added. The sequence can be any iterable object\n"
|
|
"producing strings. This is equivalent to calling write() for each string.");
|
|
static PyObject *
|
|
O_writelines(Oobject *self, PyObject *args) {
|
|
PyObject *it, *s;
|
|
|
|
it = PyObject_GetIter(args);
|
|
if (it == NULL)
|
|
return NULL;
|
|
while ((s = PyIter_Next(it)) != NULL) {
|
|
Py_ssize_t n;
|
|
char *c;
|
|
if (PyString_AsStringAndSize(s, &c, &n) == -1) {
|
|
Py_DECREF(it);
|
|
Py_DECREF(s);
|
|
return NULL;
|
|
}
|
|
if (O_cwrite((PyObject *)self, c, n) == -1) {
|
|
Py_DECREF(it);
|
|
Py_DECREF(s);
|
|
return NULL;
|
|
}
|
|
Py_DECREF(s);
|
|
}
|
|
|
|
Py_DECREF(it);
|
|
|
|
/* See if PyIter_Next failed */
|
|
if (PyErr_Occurred())
|
|
return NULL;
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
static struct PyMethodDef O_methods[] = {
|
|
/* Common methods: */
|
|
{"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
|
|
{"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
|
|
{"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
|
|
{"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
|
|
{"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
|
|
{"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
|
|
{"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
|
|
{"seek", (PyCFunction)IO_seek, METH_VARARGS, IO_seek__doc__},
|
|
{"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
|
|
{"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
|
|
|
|
/* Read-write StringIO specific methods: */
|
|
{"close", (PyCFunction)O_close, METH_NOARGS, O_close__doc__},
|
|
{"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__},
|
|
{"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
static PyMemberDef O_memberlist[] = {
|
|
{"softspace", T_INT, offsetof(Oobject, softspace), 0,
|
|
"flag indicating that a space needs to be printed; used by print"},
|
|
/* getattr(f, "closed") is implemented without this table */
|
|
{NULL} /* Sentinel */
|
|
};
|
|
|
|
static void
|
|
O_dealloc(Oobject *self) {
|
|
if (self->buf != NULL)
|
|
free(self->buf);
|
|
PyObject_Del(self);
|
|
}
|
|
|
|
PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
|
|
|
|
static PyTypeObject Otype = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"cStringIO.StringO", /*tp_name*/
|
|
sizeof(Oobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor)O_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr */
|
|
0, /*tp_setattr */
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0 , /*tp_call*/
|
|
0, /*tp_str*/
|
|
0, /*tp_getattro */
|
|
0, /*tp_setattro */
|
|
0, /*tp_as_buffer */
|
|
Py_TPFLAGS_DEFAULT, /*tp_flags*/
|
|
Otype__doc__, /*tp_doc */
|
|
0, /*tp_traverse */
|
|
0, /*tp_clear */
|
|
0, /*tp_richcompare */
|
|
0, /*tp_weaklistoffset */
|
|
PyObject_SelfIter, /*tp_iter */
|
|
(iternextfunc)IO_iternext, /*tp_iternext */
|
|
O_methods, /*tp_methods */
|
|
O_memberlist, /*tp_members */
|
|
file_getsetlist, /*tp_getset */
|
|
};
|
|
|
|
static PyObject *
|
|
newOobject(int size) {
|
|
Oobject *self;
|
|
|
|
self = PyObject_New(Oobject, &Otype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
self->pos=0;
|
|
self->string_size = 0;
|
|
self->softspace = 0;
|
|
|
|
self->buf = (char *)malloc(size);
|
|
if (!self->buf) {
|
|
PyErr_SetString(PyExc_MemoryError,"out of memory");
|
|
self->buf_size = 0;
|
|
Py_DECREF(self);
|
|
return NULL;
|
|
}
|
|
|
|
self->buf_size=size;
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
/* End of code for StringO objects */
|
|
/* -------------------------------------------------------- */
|
|
|
|
static PyObject *
|
|
I_close(Iobject *self, PyObject *unused) {
|
|
PyBuffer_Release(&self->pbuf);
|
|
self->buf = NULL;
|
|
|
|
self->pos = self->string_size = 0;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef I_methods[] = {
|
|
/* Common methods: */
|
|
{"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
|
|
{"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
|
|
{"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
|
|
{"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
|
|
{"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
|
|
{"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
|
|
{"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
|
|
{"seek", (PyCFunction)IO_seek, METH_VARARGS, IO_seek__doc__},
|
|
{"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
|
|
{"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
|
|
|
|
/* Read-only StringIO specific methods: */
|
|
{"close", (PyCFunction)I_close, METH_NOARGS, O_close__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static void
|
|
I_dealloc(Iobject *self) {
|
|
PyBuffer_Release(&self->pbuf);
|
|
PyObject_Del(self);
|
|
}
|
|
|
|
|
|
PyDoc_STRVAR(Itype__doc__,
|
|
"Simple type for treating strings as input file streams");
|
|
|
|
static PyTypeObject Itype = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"cStringIO.StringI", /*tp_name*/
|
|
sizeof(Iobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor)I_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /* tp_getattr */
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, /*tp_call*/
|
|
0, /*tp_str*/
|
|
0, /* tp_getattro */
|
|
0, /* tp_setattro */
|
|
0, /* tp_as_buffer */
|
|
Py_TPFLAGS_DEFAULT, /* tp_flags */
|
|
Itype__doc__, /* tp_doc */
|
|
0, /* tp_traverse */
|
|
0, /* tp_clear */
|
|
0, /* tp_richcompare */
|
|
0, /* tp_weaklistoffset */
|
|
PyObject_SelfIter, /* tp_iter */
|
|
(iternextfunc)IO_iternext, /* tp_iternext */
|
|
I_methods, /* tp_methods */
|
|
0, /* tp_members */
|
|
file_getsetlist, /* tp_getset */
|
|
};
|
|
|
|
static PyObject *
|
|
newIobject(PyObject *s) {
|
|
Iobject *self;
|
|
Py_buffer buf;
|
|
PyObject *args;
|
|
int result;
|
|
|
|
args = Py_BuildValue("(O)", s);
|
|
if (args == NULL)
|
|
return NULL;
|
|
result = PyArg_ParseTuple(args, "s*:StringIO", &buf);
|
|
Py_DECREF(args);
|
|
if (!result)
|
|
return NULL;
|
|
|
|
self = PyObject_New(Iobject, &Itype);
|
|
if (!self) {
|
|
PyBuffer_Release(&buf);
|
|
return NULL;
|
|
}
|
|
self->buf=buf.buf;
|
|
self->string_size=buf.len;
|
|
self->pbuf=buf;
|
|
self->pos=0;
|
|
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
/* End of code for StringI objects */
|
|
/* -------------------------------------------------------- */
|
|
|
|
|
|
PyDoc_STRVAR(IO_StringIO__doc__,
|
|
"StringIO([s]) -- Return a StringIO-like stream for reading or writing");
|
|
|
|
static PyObject *
|
|
IO_StringIO(PyObject *self, PyObject *args) {
|
|
PyObject *s=0;
|
|
|
|
if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
|
|
|
|
if (s) return newIobject(s);
|
|
return newOobject(128);
|
|
}
|
|
|
|
/* List of methods defined in the module */
|
|
|
|
static struct PyMethodDef IO_methods[] = {
|
|
{"StringIO", (PyCFunction)IO_StringIO,
|
|
METH_VARARGS, IO_StringIO__doc__},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
/* Initialization function for the module (*must* be called initcStringIO) */
|
|
|
|
static struct PycStringIO_CAPI CAPI = {
|
|
IO_cread,
|
|
IO_creadline,
|
|
O_cwrite,
|
|
IO_cgetval,
|
|
newOobject,
|
|
newIobject,
|
|
&Itype,
|
|
&Otype,
|
|
};
|
|
|
|
#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
|
|
#define PyMODINIT_FUNC void
|
|
#endif
|
|
PyMODINIT_FUNC
|
|
initcStringIO(void) {
|
|
PyObject *m, *d, *v;
|
|
|
|
|
|
/* Create the module and add the functions */
|
|
m = Py_InitModule4("cStringIO", IO_methods,
|
|
cStringIO_module_documentation,
|
|
(PyObject*)NULL,PYTHON_API_VERSION);
|
|
if (m == NULL) return;
|
|
|
|
/* Add some symbolic constants to the module */
|
|
d = PyModule_GetDict(m);
|
|
|
|
/* Export C API */
|
|
Py_TYPE(&Itype)=&PyType_Type;
|
|
Py_TYPE(&Otype)=&PyType_Type;
|
|
if (PyType_Ready(&Otype) < 0) return;
|
|
if (PyType_Ready(&Itype) < 0) return;
|
|
v = PyCapsule_New(&CAPI, PycStringIO_CAPSULE_NAME, NULL);
|
|
PyDict_SetItemString(d,"cStringIO_CAPI", v);
|
|
Py_XDECREF(v);
|
|
|
|
/* Export Types */
|
|
PyDict_SetItemString(d,"InputType", (PyObject*)&Itype);
|
|
PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
|
|
|
|
/* Maybe make certain warnings go away */
|
|
if (0) PycString_IMPORT;
|
|
}
|