cStringIO.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.
*/

typedefstruct {
PyObject_HEAD
char*buf;
Py_ssize_tpos, string_size;
} IOobject;

#defineIOOOBJECT(O) ((IOobject*)(O))

/* Declarations for objects of type StringO */

typedefstruct { /* Subtype of IOobject */
PyObject_HEAD
char*buf;
Py_ssize_tpos, string_size;

Py_ssize_tbuf_size;
intsoftspace;
} Oobject;

/* Declarations for objects of type StringI */

typedefstruct { /* Subtype of IOobject */
PyObject_HEAD
char*buf;
Py_ssize_tpos, string_size;
Py_bufferpbuf;
} Iobject;

/* IOobject (common) methods */

PyDoc_STRVAR(IO_flush__doc__, "flush(): does nothing.");

staticint
IO__opencheck(IOobject*self) {
if (!self->buf) {
PyErr_SetString(PyExc_ValueError,
"I/O operation on closed file");
return0;
 }
return1;
}

staticPyObject*
IO_get_closed(IOobject*self, void*closure)
{
PyObject*result=Py_False;

if (self->buf==NULL)
result=Py_True;
Py_INCREF(result);
returnresult;
}

staticPyGetSetDeffile_getsetlist[] = {
 {"closed", (getter)IO_get_closed, NULL, "True if the file is closed"},
 {0},
};

staticPyObject*
IO_flush(IOobject*self, PyObject*unused) {

if (!IO__opencheck(self)) returnNULL;

Py_INCREF(Py_None);
returnPy_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");

staticPyObject*
IO_cgetval(PyObject*self) {
if (!IO__opencheck(IOOOBJECT(self))) returnNULL;
assert(IOOOBJECT(self)->pos >= 0);
returnPyString_FromStringAndSize(((IOobject*)self)->buf,
 ((IOobject*)self)->pos);
}

staticPyObject*
IO_getval(IOobject*self, PyObject*args) {
PyObject*use_pos=Py_None;
intb;
Py_ssize_ts;

if (!IO__opencheck(self)) returnNULL;
if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) returnNULL;

b=PyObject_IsTrue(use_pos);
if (b<0)
returnNULL;
if (b) {
s=self->pos;
if (s>self->string_size) s=self->string_size;
 }
else
s=self->string_size;
assert(self->pos >= 0);
returnPyString_FromStringAndSize(self->buf, s);
}

PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");

staticPyObject*
IO_isatty(IOobject*self, PyObject*unused) {
if (!IO__opencheck(self)) returnNULL;
Py_INCREF(Py_False);
returnPy_False;
}

PyDoc_STRVAR(IO_read__doc__,
"read([s]) -- Read s characters, or the rest of the string");

staticint
IO_cread(PyObject*self, char**output, Py_ssize_tn) {
Py_ssize_tl;

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

staticPyObject*
IO_read(IOobject*self, PyObject*args) {
Py_ssize_tn=-1;
char*output=NULL;

if (!PyArg_ParseTuple(args, "|n:read", &n)) returnNULL;

if ( (n=IO_cread((PyObject*)self,&output,n)) <0) returnNULL;

returnPyString_FromStringAndSize(output, n);
}

PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");

staticint
IO_creadline(PyObject*self, char**output) {
char*n, *start, *end;
Py_ssize_tlen;

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

staticPyObject*
IO_readline(IOobject*self, PyObject*args) {
intn, m=-1;
char*output;

if (args)
if (!PyArg_ParseTuple(args, "|i:readline", &m)) returnNULL;

if( (n=IO_creadline((PyObject*)self,&output)) <0) returnNULL;
if (m >= 0&&m<n) {
m=n-m;
n-=m;
self->pos-=m;
 }
assert(IOOOBJECT(self)->pos >= 0);
returnPyString_FromStringAndSize(output, n);
}

PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");

staticPyObject*
IO_readlines(IOobject*self, PyObject*args) {
intn;
char*output;
PyObject*result, *line;
Py_ssize_thint=0, length=0;

if (!PyArg_ParseTuple(args, "|n:readlines", &hint)) returnNULL;

result=PyList_New(0);
if (!result)
returnNULL;

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;
 }
returnresult;
err:
Py_DECREF(result);
returnNULL;
}

PyDoc_STRVAR(IO_reset__doc__,
"reset() -- Reset the file position to the beginning");

staticPyObject*
IO_reset(IOobject*self, PyObject*unused) {

if (!IO__opencheck(self)) returnNULL;

self->pos=0;

Py_INCREF(Py_None);
returnPy_None;
}

PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");

staticPyObject*
IO_tell(IOobject*self, PyObject*unused) {

if (!IO__opencheck(self)) returnNULL;

assert(self->pos >= 0);
returnPyInt_FromSsize_t(self->pos);
}

PyDoc_STRVAR(IO_truncate__doc__,
"truncate(): truncate the file at the current position.");

staticPyObject*
IO_truncate(IOobject*self, PyObject*args) {
Py_ssize_tpos=-1;

if (!IO__opencheck(self)) returnNULL;
if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) returnNULL;

if (PyTuple_Size(args) ==0) {
/* No argument passed, truncate to current position */
pos=self->pos;
 }

if (pos<0) {
errno=EINVAL;
PyErr_SetFromErrno(PyExc_IOError);
returnNULL;
 }

if (self->string_size>pos) self->string_size=pos;
self->pos=self->string_size;

Py_INCREF(Py_None);
returnPy_None;
}

staticPyObject*
IO_iternext(Iobject*self)
{
PyObject*next;
next=IO_readline((IOobject*)self, NULL);
if (!next)
returnNULL;
if (!PyString_GET_SIZE(next)) {
Py_DECREF(next);
PyErr_SetNone(PyExc_StopIteration);
returnNULL;
 }
returnnext;
}




/* 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");

staticPyObject*
IO_seek(Iobject*self, PyObject*args) {
Py_ssize_tposition;
intmode=0;

if (!IO__opencheck(IOOOBJECT(self))) returnNULL;
if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
returnNULL;

if (mode==2) {
position+=self->string_size;
 }
elseif (mode==1) {
position+=self->pos;
 }

if (position<0) position=0;

self->pos=position;

Py_INCREF(Py_None);
returnPy_None;
}

PyDoc_STRVAR(O_write__doc__,
"write(s) -- Write a string to the file"
"\n\nNote (hack:) writing None resets the buffer");


staticint
O_cwrite(PyObject*self, constchar*c, Py_ssize_tlen) {
Py_ssize_tnewpos;
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_tnewsize=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;
}

staticPyObject*
O_write(Oobject*self, PyObject*args) {
Py_bufferbuf;
intresult;

if (!PyArg_ParseTuple(args, "s*:write", &buf)) returnNULL;

result=O_cwrite((PyObject*)self, buf.buf, buf.len);
PyBuffer_Release(&buf);
if (result<0) returnNULL;

Py_INCREF(Py_None);
returnPy_None;
}

PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");

staticPyObject*
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);
returnPy_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.");
staticPyObject*
O_writelines(Oobject*self, PyObject*args) {
PyObject*it, *s;

it=PyObject_GetIter(args);
if (it==NULL)
returnNULL;
while ((s=PyIter_Next(it)) !=NULL) {
Py_ssize_tn;
char*c;
if (PyString_AsStringAndSize(s, &c, &n) ==-1) {
Py_DECREF(it);
Py_DECREF(s);
returnNULL;
 }
if (O_cwrite((PyObject*)self, c, n) ==-1) {
Py_DECREF(it);
Py_DECREF(s);
returnNULL;
 }
Py_DECREF(s);
 }

Py_DECREF(it);

/* See if PyIter_Next failed */
if (PyErr_Occurred())
returnNULL;

Py_RETURN_NONE;
}
staticstructPyMethodDefO_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 */
};

staticPyMemberDefO_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 */
};

staticvoid
O_dealloc(Oobject*self) {
if (self->buf!=NULL)
free(self->buf);
PyObject_Del(self);
}

PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");

staticPyTypeObjectOtype= {
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 */
};

staticPyObject*
newOobject(intsize) {
Oobject*self;

self=PyObject_New(Oobject, &Otype);
if (self==NULL)
returnNULL;
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);
returnNULL;
 }

self->buf_size=size;
return (PyObject*)self;
}

/* End of code for StringO objects */
/* -------------------------------------------------------- */

staticPyObject*
I_close(Iobject*self, PyObject*unused) {
PyBuffer_Release(&self->pbuf);
self->buf=NULL;

self->pos=self->string_size=0;

Py_INCREF(Py_None);
returnPy_None;
}

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

staticvoid
I_dealloc(Iobject*self) {
PyBuffer_Release(&self->pbuf);
PyObject_Del(self);
}


PyDoc_STRVAR(Itype__doc__,
"Simple type for treating strings as input file streams");

staticPyTypeObjectItype= {
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 */
};

staticPyObject*
newIobject(PyObject*s) {
Iobject*self;
Py_bufferbuf;
PyObject*args;
intresult;

args=Py_BuildValue("(O)", s);
if (args==NULL)
returnNULL;
result=PyArg_ParseTuple(args, "s*:StringIO", &buf);
Py_DECREF(args);
if (!result)
returnNULL;

self=PyObject_New(Iobject, &Itype);
if (!self) {
PyBuffer_Release(&buf);
returnNULL;
 }
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");

staticPyObject*
IO_StringIO(PyObject*self, PyObject*args) {
PyObject*s=0;

if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) returnNULL;

if (s) returnnewIobject(s);
returnnewOobject(128);
}

/* List of methods defined in the module */

staticstructPyMethodDefIO_methods[] = {
 {"StringIO", (PyCFunction)IO_StringIO,
METH_VARARGS, IO_StringIO__doc__},
 {NULL, NULL} /* sentinel */
};


/* Initialization function for the module (*must* be called initcStringIO) */

staticstructPycStringIO_CAPICAPI= {
IO_cread,
IO_creadline,
O_cwrite,
IO_cgetval,
newOobject,
newIobject,
&Itype,
&Otype,
};

#ifndefPyMODINIT_FUNC/* declarations for DLL import/export */
#definePyMODINIT_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;
}