Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Added a new "base" type, IOobject for which most of the 

operations are defined.  This will, hopefully clarify
some of the logic.

Added close test to raise proper error when operations
are performed on closed StringIOs.

Added a position argument to the truncate method.

Added a size argument to readline.

Added PyArg_Parse calls for methods that don't take arguments to
make sure they don't take arguments.
This commit is contained in:
Jim Fulton 2000-10-06 19:24:23 +00:00
parent d1229f5651
commit e60de4d309
1 changed files with 359 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

648
Modules/cStringIO.c
View File

@ -85,170 +85,205 @@ static char cStringIO_module_documentation[] =
#include "import.h" #include "import.h"
#include "cStringIO.h" #include "cStringIO.h"
#define UNLESS(E) if(!(E)) #define UNLESS(E) if (!(E))
/* Declarations for objects of type StringO */
typedef struct { /* Declaration for file-like objects that manage data as strings
PyObject_HEAD
char *buf;
int pos, string_size, buf_size, softspace;
} Oobject;
/* Declarations for objects of type StringI */ 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 { typedef struct {
PyObject_HEAD PyObject_HEAD
char *buf; char *buf;
int pos, string_size; int pos, string_size;
} IOobject;
#define IOOOBJECT(O) ((IOobject*)(O))
/* Declarations for objects of type StringO */
typedef struct { /* Subtype of IOobject */
PyObject_HEAD
char *buf;
int pos, string_size;
int buf_size, softspace;
} Oobject;
/* Declarations for objects of type StringI */
typedef struct { /* Subtype of IOobject */
PyObject_HEAD
char *buf;
int pos, string_size;
PyObject *pbuf; PyObject *pbuf;
} Iobject; } Iobject;
static char O_reset__doc__[] = /* IOobject (common) methods */
"reset() -- Reset the file position to the beginning"
static char IO_flush__doc__[] = "flush(): does nothing.";
static int
IO__opencheck(IOobject *self) {
UNLESS (self->buf) {
PyErr_SetString(PyExc_ValueError,
"I/O operation on closed file");
return 0;
}
return 1;
}
static PyObject *
IO_flush(IOobject *self, PyObject *args) {
UNLESS (IO__opencheck(self)) return NULL;
UNLESS (PyArg_ParseTuple(args, ":flush")) return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static char 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 * static PyObject *
O_reset(Oobject *self, PyObject *args) { IO_cgetval(PyObject *self) {
self->pos = 0; UNLESS (IO__opencheck(IOOOBJECT(self))) return NULL;
return PyString_FromStringAndSize(((IOobject*)self)->buf,
Py_INCREF(Py_None); ((IOobject*)self)->pos);
return Py_None;
} }
static char O_tell__doc__[] =
"tell() -- get the current position.";
static PyObject * static PyObject *
O_tell(Oobject *self, PyObject *args) { IO_getval(IOobject *self, PyObject *args) {
return PyInt_FromLong(self->pos); PyObject *use_pos=Py_None;
int s;
UNLESS (IO__opencheck(self)) return NULL;
UNLESS (PyArg_ParseTuple(args,"|O:getval",&use_pos)) return NULL;
if (PyObject_IsTrue(use_pos)) {
s=self->pos;
if (s > self->string_size) s=self->string_size;
}
else
s=self->string_size;
return PyString_FromStringAndSize(self->buf, s);
} }
static char IO_isatty__doc__[] = "isatty(): always returns 0";
static char O_seek__doc__[] =
"seek(position) -- set the current position\n"
"seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF";
static PyObject * static PyObject *
O_seek(Oobject *self, PyObject *args) { IO_isatty(IOobject *self, PyObject *args) {
int position, mode = 0;
UNLESS(PyArg_ParseTuple(args, "i|i:seek", &position, &mode)) { UNLESS (PyArg_ParseTuple(args, ":isatty")) return NULL;
return NULL;
}
if (mode == 2) { return PyInt_FromLong(0);
position += self->string_size;
}
else if (mode == 1) {
position += self->pos;
}
if (position > self->buf_size) {
self->buf_size*=2;
if(self->buf_size <= position) self->buf_size=position+1;
UNLESS(self->buf=(char*)realloc(self->buf,self->buf_size*sizeof(char))) {
self->buf_size=self->pos=0;
return PyErr_NoMemory();
}
}
else if(position < 0) position=0;
self->pos=position;
while(--position >= self->string_size) self->buf[position]=0;
Py_INCREF(Py_None);
return Py_None;
} }
static char O_read__doc__[] = static char IO_read__doc__[] =
"read([s]) -- Read s characters, or the rest of the string" "read([s]) -- Read s characters, or the rest of the string"
; ;
static int static int
O_cread(PyObject *self, char **output, int n) { IO_cread(PyObject *self, char **output, int n) {
int l; int l;
l = ((Oobject*)self)->string_size - ((Oobject*)self)->pos; UNLESS (IO__opencheck(IOOOBJECT(self))) return -1;
if (n < 0 || n > l) { l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
n = l; if (n < 0 || n > l) {
if (n < 0) n=0; n = l;
} if (n < 0) n=0;
}
*output=((Oobject*)self)->buf + ((Oobject*)self)->pos; *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
((Oobject*)self)->pos += n; ((IOobject*)self)->pos += n;
return n; return n;
} }
static PyObject * static PyObject *
O_read(Oobject *self, PyObject *args) { IO_read(IOobject *self, PyObject *args) {
int n = -1; int n = -1;
char *output; char *output;
UNLESS(PyArg_ParseTuple(args, "|i:read", &n)) return NULL; UNLESS (PyArg_ParseTuple(args, "|i:read", &n)) return NULL;
n=O_cread((PyObject*)self,&output,n); if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
return PyString_FromStringAndSize(output, n); return PyString_FromStringAndSize(output, n);
} }
static char IO_readline__doc__[] =
static char O_readline__doc__[] =
"readline() -- Read one line" "readline() -- Read one line"
; ;
static int static int
O_creadline(PyObject *self, char **output) { IO_creadline(PyObject *self, char **output) {
char *n, *s; char *n, *s;
int l; int l;
for (n = ((Oobject*)self)->buf + ((Oobject*)self)->pos, UNLESS (IO__opencheck(IOOOBJECT(self))) return -1;
s = ((Oobject*)self)->buf + ((Oobject*)self)->string_size;
n < s && *n != '\n'; n++); for (n = ((IOobject*)self)->buf + ((IOobject*)self)->pos,
if (n < s) n++; s = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
n < s && *n != '\n'; n++);
*output=((Oobject*)self)->buf + ((Oobject*)self)->pos; if (n < s) n++;
l = n - ((Oobject*)self)->buf - ((Oobject*)self)->pos;
((Oobject*)self)->pos += l; *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
return l; l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos;
((IOobject*)self)->pos += l;
return l;
} }
static PyObject * static PyObject *
O_readline(Oobject *self, PyObject *args) { IO_readline(IOobject *self, PyObject *args) {
int n; int n, m=-1;
char *output; char *output;
n=O_creadline((PyObject*)self,&output); UNLESS (PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
return PyString_FromStringAndSize(output, n);
if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;
if (m >= 0 && m < n) {
m = n - m;
n -= m;
self->pos -= m;
}
return PyString_FromStringAndSize(output, n);
} }
static char O_readlines__doc__[] = static char IO_readlines__doc__[] =
"readlines() -- Read all lines" "readlines() -- Read all lines"
; ;
static PyObject * static PyObject *
O_readlines(Oobject *self, PyObject *args) { IO_readlines(IOobject *self, PyObject *args) {
int n; int n;
char *output; char *output;
PyObject *result, *line; PyObject *result, *line;
int hint = 0, length = 0; int hint = 0, length = 0;
UNLESS(PyArg_ParseTuple(args, "|i:write", &hint)) return NULL; UNLESS (PyArg_ParseTuple(args, "|i:readlines", &hint)) return NULL;
result = PyList_New(0); result = PyList_New(0);
if (!result) if (!result)
return NULL; return NULL;
while(1){ while (1){
n = O_creadline((PyObject*)self,&output); if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
goto err;
if (n == 0) if (n == 0)
break; break;
line = PyString_FromStringAndSize (output, n); line = PyString_FromStringAndSize (output, n);
if (!line){ if (!line)
Py_DECREF (result); goto err;
return NULL;
}
PyList_Append (result, line); PyList_Append (result, line);
Py_DECREF (line); Py_DECREF (line);
length += n; length += n;
@ -256,6 +291,97 @@ O_readlines(Oobject *self, PyObject *args) {
break; break;
} }
return result; return result;
err:
Py_DECREF(result);
return NULL;
}
static char IO_reset__doc__[] =
"reset() -- Reset the file position to the beginning"
;
static PyObject *
IO_reset(IOobject *self, PyObject *args) {
UNLESS (IO__opencheck(self)) return NULL;
UNLESS (PyArg_ParseTuple(args, ":reset")) return NULL;
self->pos = 0;
Py_INCREF(Py_None);
return Py_None;
}
static char IO_tell__doc__[] =
"tell() -- get the current position.";
static PyObject *
IO_tell(IOobject *self, PyObject *args) {
UNLESS (IO__opencheck(self)) return NULL;
UNLESS (PyArg_ParseTuple(args, ":tell")) return NULL;
return PyInt_FromLong(self->pos);
}
static char IO_truncate__doc__[] =
"truncate(): truncate the file at the current position.";
static PyObject *
IO_truncate(IOobject *self, PyObject *args) {
int pos = -1;
UNLESS (IO__opencheck(self)) return NULL;
UNLESS (PyArg_ParseTuple(args, "|i:truncate", &pos)) return NULL;
if (pos < 0) pos = self->pos;
if (self->string_size > pos) self->string_size = pos;
Py_INCREF(Py_None);
return Py_None;
}
/* Read-write object methods */
static char O_seek__doc__[] =
"seek(position) -- set the current position\n"
"seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF";
static PyObject *
O_seek(Oobject *self, PyObject *args) {
int position, mode = 0;
UNLESS (IO__opencheck(IOOOBJECT(self))) return NULL;
UNLESS (PyArg_ParseTuple(args, "i|i:seek", &position, &mode))
return NULL;
if (mode == 2) {
position += self->string_size;
}
else if (mode == 1) {
position += self->pos;
}
if (position > self->buf_size) {
self->buf_size*=2;
if (self->buf_size <= position) self->buf_size=position+1;
UNLESS (self->buf=(char*)
realloc(self->buf,self->buf_size*sizeof(char))) {
self->buf_size=self->pos=0;
return PyErr_NoMemory();
}
}
else if (position < 0) position=0;
self->pos=position;
while (--position >= self->string_size) self->buf[position]=0;
Py_INCREF(Py_None);
return Py_None;
} }
static char O_write__doc__[] = static char O_write__doc__[] =
@ -266,114 +392,66 @@ static char O_write__doc__[] =
static int static int
O_cwrite(PyObject *self, char *c, int l) { O_cwrite(PyObject *self, char *c, int l) {
int newl; int newl;
newl=((Oobject*)self)->pos+l; UNLESS (IO__opencheck(IOOOBJECT(self))) return -1;
if(newl >= ((Oobject*)self)->buf_size) {
((Oobject*)self)->buf_size*=2;
if(((Oobject*)self)->buf_size <= newl) ((Oobject*)self)->buf_size=newl+1;
UNLESS(((Oobject*)self)->buf=
(char*)realloc(((Oobject*)self)->buf,
(((Oobject*)self)->buf_size) *sizeof(char))) {
PyErr_SetString(PyExc_MemoryError,"out of memory");
((Oobject*)self)->buf_size=((Oobject*)self)->pos=0;
return -1;
}
}
memcpy(((Oobject*)((Oobject*)self))->buf+((Oobject*)self)->pos,c,l); newl=((Oobject*)self)->pos+l;
if (newl >= ((Oobject*)self)->buf_size) {
((Oobject*)self)->buf_size*=2;
if (((Oobject*)self)->buf_size <= newl)
((Oobject*)self)->buf_size=newl+1;
UNLESS (((Oobject*)self)->buf=
(char*)realloc(
((Oobject*)self)->buf,
(((Oobject*)self)->buf_size) *sizeof(char))) {
PyErr_SetString(PyExc_MemoryError,"out of memory");
((Oobject*)self)->buf_size=((Oobject*)self)->pos=0;
return -1;
}
}
((Oobject*)self)->pos += l; memcpy(((Oobject*)((Oobject*)self))->buf+((Oobject*)self)->pos,c,l);
if (((Oobject*)self)->string_size < ((Oobject*)self)->pos) { ((Oobject*)self)->pos += l;
((Oobject*)self)->string_size = ((Oobject*)self)->pos;
}
return l; if (((Oobject*)self)->string_size < ((Oobject*)self)->pos) {
((Oobject*)self)->string_size = ((Oobject*)self)->pos;
}
return l;
} }
static PyObject * static PyObject *
O_write(Oobject *self, PyObject *args) { O_write(Oobject *self, PyObject *args) {
PyObject *s; PyObject *s;
char *c; char *c;
int l; int l;
UNLESS(PyArg_ParseTuple(args, "O:write", &s)) return NULL; UNLESS (PyArg_ParseTuple(args, "O:write", &s)) return NULL;
UNLESS(-1 != (l=PyString_Size(s))) return NULL;
UNLESS(c=PyString_AsString(s)) return NULL;
UNLESS(-1 != O_cwrite((PyObject*)self,c,l)) return NULL;
Py_INCREF(Py_None); UNLESS (-1 != (l=PyString_Size(s))) return NULL;
return Py_None; UNLESS (c=PyString_AsString(s)) return NULL;
} if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;
static char O_getval__doc__[] = Py_INCREF(Py_None);
"getvalue([use_pos]) -- Get the string value." return Py_None;
"\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 *
O_getval(Oobject *self, PyObject *args) {
PyObject *use_pos=Py_None;
int s;
use_pos=Py_None;
UNLESS(PyArg_ParseTuple(args,"|O:getval",&use_pos)) return NULL;
if(PyObject_IsTrue(use_pos)) {
s=self->pos;
if (s > self->string_size) s=self->string_size;
}
else
s=self->string_size;
return PyString_FromStringAndSize(self->buf, s);
}
static PyObject *
O_cgetval(PyObject *self) {
return PyString_FromStringAndSize(((Oobject*)self)->buf,
((Oobject*)self)->pos);
}
static char O_truncate__doc__[] =
"truncate(): truncate the file at the current position.";
static PyObject *
O_truncate(Oobject *self, PyObject *args) {
if (self->string_size > self->pos)
self->string_size = self->pos;
Py_INCREF(Py_None);
return Py_None;
}
static char O_isatty__doc__[] = "isatty(): always returns 0";
static PyObject *
O_isatty(Oobject *self, PyObject *args) {
return PyInt_FromLong(0);
} }
static char O_close__doc__[] = "close(): explicitly release resources held."; static char O_close__doc__[] = "close(): explicitly release resources held.";
static PyObject * static PyObject *
O_close(Oobject *self, PyObject *args) { O_close(Oobject *self, PyObject *args) {
if (self->buf != NULL)
free(self->buf);
self->buf = NULL;
self->pos = self->string_size = self->buf_size = 0; UNLESS (PyArg_ParseTuple(args, ":close")) return NULL;
Py_INCREF(Py_None); if (self->buf != NULL) free(self->buf);
return Py_None; self->buf = NULL;
}
static char O_flush__doc__[] = "flush(): does nothing."; self->pos = self->string_size = self->buf_size = 0;
static PyObject * Py_INCREF(Py_None);
O_flush(Oobject *self, PyObject *args) { return Py_None;
Py_INCREF(Py_None);
return Py_None;
} }
@ -381,76 +459,65 @@ static char O_writelines__doc__[] =
"writelines(sequence_of_strings): write each string"; "writelines(sequence_of_strings): write each string";
static PyObject * static PyObject *
O_writelines(Oobject *self, PyObject *args) { O_writelines(Oobject *self, PyObject *args) {
PyObject *string_module = 0; PyObject *tmp = 0;
static PyObject *string_joinfields = 0; static PyObject *string_joinfields = 0;
UNLESS(PyArg_ParseTuple(args, "O:writelines", &args)) { UNLESS (PyArg_ParseTuple(args, "O:writelines", &args)) return NULL;
return NULL;
}
if (!string_joinfields) { if (!string_joinfields) {
UNLESS(string_module = PyImport_ImportModule("string")) { UNLESS (tmp = PyImport_ImportModule("string")) return NULL;
return NULL; string_joinfields=PyObject_GetAttrString(tmp, "joinfields");
} Py_DECREF(tmp);
UNLESS (string_joinfields) return NULL;
}
UNLESS(string_joinfields= if (PyObject_Size(args) < 0) return NULL;
PyObject_GetAttrString(string_module, "joinfields")) {
return NULL;
}
Py_DECREF(string_module); tmp = PyObject_CallFunction(string_joinfields, "Os", args, "");
} UNLESS (tmp) return NULL;
if (PyObject_Size(args) == -1) { args = Py_BuildValue("(O)", tmp);
return NULL; Py_DECREF(tmp);
} UNLESS (args) return NULL;
{ tmp = O_write(self, args);
PyObject *x = PyObject_CallFunction(string_joinfields, Py_DECREF(args);
"Os", args, ""); return tmp;
if (x == NULL)
return NULL;
args = Py_BuildValue("(O)", x);
Py_DECREF(x);
if (args == NULL)
return NULL;
x = O_write(self, args);
Py_DECREF(args);
return x;
}
} }
static struct PyMethodDef O_methods[] = { static struct PyMethodDef O_methods[] = {
{"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__}, /* Common methods: */
{"read", (PyCFunction)O_read, METH_VARARGS, O_read__doc__}, {"flush", (PyCFunction)IO_flush, METH_VARARGS, IO_flush__doc__},
{"readline", (PyCFunction)O_readline, METH_VARARGS, O_readline__doc__}, {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
{"readlines", (PyCFunction)O_readlines, METH_VARARGS, O_readlines__doc__}, {"isatty", (PyCFunction)IO_isatty, METH_VARARGS, IO_isatty__doc__},
{"reset", (PyCFunction)O_reset, METH_VARARGS, O_reset__doc__}, {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
{"seek", (PyCFunction)O_seek, METH_VARARGS, O_seek__doc__}, {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
{"tell", (PyCFunction)O_tell, METH_VARARGS, O_tell__doc__}, {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
{"getvalue", (PyCFunction)O_getval, METH_VARARGS, O_getval__doc__}, {"reset", (PyCFunction)IO_reset, METH_VARARGS, IO_reset__doc__},
{"truncate", (PyCFunction)O_truncate, METH_VARARGS, O_truncate__doc__}, {"tell", (PyCFunction)IO_tell, METH_VARARGS, IO_tell__doc__},
{"isatty", (PyCFunction)O_isatty, METH_VARARGS, O_isatty__doc__}, {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
/* Read-write StringIO specific methods: */
{"close", (PyCFunction)O_close, METH_VARARGS, O_close__doc__}, {"close", (PyCFunction)O_close, METH_VARARGS, O_close__doc__},
{"flush", (PyCFunction)O_flush, METH_VARARGS, O_flush__doc__}, {"seek", (PyCFunction)O_seek, METH_VARARGS, O_seek__doc__},
{"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__},
{"writelines", (PyCFunction)O_writelines, METH_VARARGS, O_writelines__doc__}, {"writelines", (PyCFunction)O_writelines, METH_VARARGS, O_writelines__doc__},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };
static void static void
O_dealloc(Oobject *self) { O_dealloc(Oobject *self) {
if (self->buf != NULL) if (self->buf != NULL)
free(self->buf); free(self->buf);
PyObject_Del(self); PyObject_Del(self);
} }
static PyObject * static PyObject *
O_getattr(Oobject *self, char *name) { O_getattr(Oobject *self, char *name) {
if (strcmp(name, "softspace") == 0) { if (strcmp(name, "softspace") == 0) {
return PyInt_FromLong(self->softspace); return PyInt_FromLong(self->softspace);
} }
return Py_FindMethod(O_methods, (PyObject *)self, name); return Py_FindMethod(O_methods, (PyObject *)self, name);
} }
static int static int
@ -461,7 +528,7 @@ O_setattr(Oobject *self, char *name, PyObject *value) {
return -1; return -1;
} }
x = PyInt_AsLong(value); x = PyInt_AsLong(value);
if (x == -1 && PyErr_Occurred()) if (x < 0 && PyErr_Occurred())
return -1; return -1;
self->softspace = x; self->softspace = x;
return 0; return 0;
@ -498,23 +565,23 @@ static PyTypeObject Otype = {
static PyObject * static PyObject *
newOobject(int size) { newOobject(int size) {
Oobject *self; Oobject *self;
self = PyObject_New(Oobject, &Otype);
if (self == NULL)
return NULL;
self->pos=0;
self->string_size = 0;
self->softspace = 0;
UNLESS(self->buf=malloc(size*sizeof(char))) { self = PyObject_New(Oobject, &Otype);
PyErr_SetString(PyExc_MemoryError,"out of memory"); if (self == NULL)
self->buf_size = 0; return NULL;
return NULL; self->pos=0;
} self->string_size = 0;
self->softspace = 0;
self->buf_size=size; UNLESS (self->buf=malloc(size*sizeof(char))) {
return (PyObject*)self; PyErr_SetString(PyExc_MemoryError,"out of memory");
self->buf_size = 0;
return NULL;
}
self->buf_size=size;
return (PyObject*)self;
} }
/* End of code for StringO objects */ /* End of code for StringO objects */
@ -522,50 +589,53 @@ newOobject(int size) {
static PyObject * static PyObject *
I_close(Iobject *self, PyObject *args) { I_close(Iobject *self, PyObject *args) {
Py_XDECREF(self->pbuf);
self->pbuf = NULL;
self->pos = self->string_size = 0; UNLESS (PyArg_ParseTuple(args, ":close")) return NULL;
Py_INCREF(Py_None); Py_XDECREF(self->pbuf);
return Py_None; self->pbuf = NULL;
self->buf = NULL;
self->pos = self->string_size = 0;
Py_INCREF(Py_None);
return Py_None;
} }
static PyObject * static PyObject *
I_seek(Oobject *self, PyObject *args) { I_seek(Iobject *self, PyObject *args) {
int position, mode = 0; int position, mode = 0;
UNLESS(PyArg_ParseTuple(args, "i|i:seek", &position, &mode)) { UNLESS (IO__opencheck(IOOOBJECT(self))) return NULL;
return NULL; UNLESS (PyArg_ParseTuple(args, "i|i:seek", &position, &mode))
} return NULL;
if (mode == 2) { if (mode == 2) position += self->string_size;
position += self->string_size; else if (mode == 1) position += self->pos;
}
else if (mode == 1) {
position += self->pos;
}
if(position < 0) position=0; if (position < 0) position=0;
self->pos=position;
Py_INCREF(Py_None); self->pos=position;
return Py_None;
Py_INCREF(Py_None);
return Py_None;
} }
static struct PyMethodDef I_methods[] = { static struct PyMethodDef I_methods[] = {
{"read", (PyCFunction)O_read, METH_VARARGS, O_read__doc__}, /* Common methods: */
{"readline", (PyCFunction)O_readline, METH_VARARGS, O_readline__doc__}, {"flush", (PyCFunction)IO_flush, METH_VARARGS, IO_flush__doc__},
{"readlines", (PyCFunction)O_readlines,METH_VARARGS, O_readlines__doc__}, {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
{"reset", (PyCFunction)O_reset, METH_VARARGS, O_reset__doc__}, {"isatty", (PyCFunction)IO_isatty, METH_VARARGS, IO_isatty__doc__},
{"seek", (PyCFunction)I_seek, METH_VARARGS, O_seek__doc__}, {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
{"tell", (PyCFunction)O_tell, METH_VARARGS, O_tell__doc__}, {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
{"getvalue", (PyCFunction)O_getval, METH_VARARGS, O_getval__doc__}, {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
{"truncate", (PyCFunction)O_truncate, METH_VARARGS, O_truncate__doc__}, {"reset", (PyCFunction)IO_reset, METH_VARARGS, IO_reset__doc__},
{"isatty", (PyCFunction)O_isatty, METH_VARARGS, O_isatty__doc__}, {"tell", (PyCFunction)IO_tell, METH_VARARGS, IO_tell__doc__},
{"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
/* Read-only StringIO specific methods: */
{"close", (PyCFunction)I_close, METH_VARARGS, O_close__doc__}, {"close", (PyCFunction)I_close, METH_VARARGS, O_close__doc__},
{"flush", (PyCFunction)O_flush, METH_VARARGS, O_flush__doc__}, {"seek", (PyCFunction)I_seek, METH_VARARGS, O_seek__doc__},
{NULL, NULL} {NULL, NULL}
}; };
@ -622,7 +692,7 @@ newIobject(PyObject *s) {
} }
buf = PyString_AS_STRING(s); buf = PyString_AS_STRING(s);
size = PyString_GET_SIZE(s); size = PyString_GET_SIZE(s);
UNLESS(self = PyObject_New(Iobject, &Itype)) return NULL; UNLESS (self = PyObject_New(Iobject, &Itype)) return NULL;
Py_INCREF(s); Py_INCREF(s);
self->buf=buf; self->buf=buf;
self->string_size=size; self->string_size=size;
@ -644,9 +714,9 @@ static PyObject *
IO_StringIO(PyObject *self, PyObject *args) { IO_StringIO(PyObject *self, PyObject *args) {
PyObject *s=0; PyObject *s=0;
if (!PyArg_ParseTuple(args, "|O:StringIO", &s)) if (!PyArg_ParseTuple(args, "|O:StringIO", &s)) return NULL;
return NULL;
if(s) return newIobject(s); if (s) return newIobject(s);
return newOobject(128); return newOobject(128);
} }
@ -662,10 +732,10 @@ static struct PyMethodDef IO_methods[] = {
/* Initialization function for the module (*must* be called initcStringIO) */ /* Initialization function for the module (*must* be called initcStringIO) */
static struct PycStringIO_CAPI CAPI = { static struct PycStringIO_CAPI CAPI = {
O_cread, IO_cread,
O_creadline, IO_creadline,
O_cwrite, O_cwrite,
O_cgetval, IO_cgetval,
newOobject, newOobject,
newIobject, newIobject,
&Itype, &Itype,
@ -700,5 +770,5 @@ initcStringIO(void) {
PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype); PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
/* Maybe make certain warnings go away */ /* Maybe make certain warnings go away */
if(0) PycString_IMPORT; if (0) PycString_IMPORT;
} }