#include "Python.h"

#include "import.h"

#include "cStringIO.h"

#include "structmember.h"

PyDoc_STRVAR(cStringIO_module_documentation,

"cStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp\n");

typedef struct {

PyObject_HEAD

char *buf;

Py_ssize_t pos, string_size;

} IOobject;

#define IOOOBJECT(O) ((IOobject*)(O))

typedef struct { /* Subtype of IOobject */

PyObject_HEAD

char *buf;

Py_ssize_t pos, string_size;

Py_ssize_t buf_size;

int softspace;

} Oobject;

typedef struct { /* Subtype of IOobject */

PyObject_HEAD

char *buf;

Py_ssize_t pos, string_size;

Py_buffer pbuf;

} Iobject;

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__,

"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;

}

PyDoc_STRVAR(IO_seek__doc__,

"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__,

"\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

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__,

"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;

}

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;

}

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);

}

static struct PyMethodDef IO_methods[] = {

{"StringIO", (PyCFunction)IO_StringIO,

METH_VARARGS, IO_StringIO__doc__},

{NULL, NULL} /* sentinel */

};

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

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;

}