diff options
| -rw-r--r-- | Include/cStringIO.h | 130 | ||||
| -rw-r--r-- | Modules/cStringIO.c | 678 |
2 files changed, 808 insertions, 0 deletions
diff --git a/Include/cStringIO.h b/Include/cStringIO.h new file mode 100644 index 0000000..0f7a56d --- /dev/null +++ b/Include/cStringIO.h @@ -0,0 +1,130 @@ +#ifndef CSTRINGIO_INCLUDED +#define CSTRINGIO_INCLUDED +/* + + $Id$ + + cStringIO C API + + Copyright + + Copyright 1996 Digital Creations, L.C., 910 Princess Anne + Street, Suite 300, Fredericksburg, Virginia 22401 U.S.A. All + rights reserved. Copyright in this software is owned by DCLC, + unless otherwise indicated. Permission to use, copy and + distribute this software is hereby granted, provided that the + above copyright notice appear in all copies and that both that + copyright notice and this permission notice appear. Note that + any product, process or technology described in this software + may be the subject of other Intellectual Property rights + reserved by Digital Creations, L.C. and are not licensed + hereunder. + + Trademarks + + Digital Creations & DCLC, are trademarks of Digital Creations, L.C.. + All other trademarks are owned by their respective companies. + + No Warranty + + The software is provided "as is" without warranty of any kind, + either express or implied, including, but not limited to, the + implied warranties of merchantability, fitness for a particular + purpose, or non-infringement. This software could include + technical inaccuracies or typographical errors. Changes are + periodically made to the software; these changes will be + incorporated in new editions of the software. DCLC may make + improvements and/or changes in this software at any time + without notice. + + Limitation Of Liability + + In no event will DCLC be liable for direct, indirect, special, + incidental, economic, cover, or consequential damages arising + out of the use of or inability to use this software even if + advised of the possibility of such damages. Some states do not + allow the exclusion or limitation of implied warranties or + limitation of liability for incidental or consequential + damages, so the above limitation or exclusion may not apply to + you. + + If you have questions regarding this software, + contact: + + info@digicool.com + Digital Creations L.C. + + (540) 371-6909 + + + This header provides access to cStringIO objects from C. + Functions are provided for calling cStringIO objects and + macros are provided for testing whether you have cStringIO + objects. + + Before calling any of the functions or macros, you must initialize + the routines with: + + PycStringIO_IMPORT + + This would typically be done in your init function. + + $Log$ + Revision 2.1 1996/12/05 23:30:48 guido + Jim F's brainchild + + +*/ + + +/* Basic fuctions to manipulate cStringIO objects from C */ + +/* Read a string. If the last argument is -1, the remainder will be read. */ +static int(*PycStringIO_cread)(PyObject *, char **, int)=NULL; + +/* Read a line */ +static int(*PycStringIO_creadline)(PyObject *, char **)=NULL; + +/* Write a string */ +static int(*PycStringIO_cwrite)(PyObject *, char *, int)=NULL; + +/* Get the cStringIO object as a Python string */ +static PyObject(*PycStringIO_cgetvalue)(PyObject *)=NULL; + +/* Create a new output object */ +static PyObject(*PycStringIO_NewOutput)(void)=NULL; + +/* Create an input object from a Python string */ +static PyObject(*PycStringIO_NewInput)(PyObject *)=NULL; + +/* The Python types for cStringIO input and output objects. + Note that you can do input on an output object. +*/ +static PyObject *PycStringIO_InputType=NULL, *PycStringIO_OutputType=NULL; + +/* These can be used to test if you have one */ +#define PycStringIO_InputCheck(O) ((O)->ob_type==PycStringIO_InputType) +#define PycStringIO_OutputCheck(O) ((O)->ob_type==PycStringIO_OutputType) + +/* The following is used to implement PycString_IMPORT: */ +static PyObject *PycStringIO_Module=NULL, *PycStringIO_CObject=NULL; + +#define IMPORT_C_OBJECT(N) \ + if((PycStringIO_CObject=PyObject_GetAttrString(PycStringIO_Module, #N))) { \ + PycStringIO_ ## N = PyCObject_AsVoidPtr(PycStringIO_CObject); \ + Py_DECREF(PycStringIO_CObject); } + +#define PycString_IMPORT \ + if((PycStringIO_Module=PyImport_ImportModule("cStringIO"))) { \ + PycStringIO_InputType=PyObject_GetAttrString(PycStringIO_Module, \ + "InputType"); \ + PycStringIO_OutputType=PyObject_GetAttrString(PycStringIO_Module, \ + "OutputType"); \ + IMPORT_C_OBJECT(cread); \ + IMPORT_C_OBJECT(creadline); \ + IMPORT_C_OBJECT(cwrite); \ + IMPORT_C_OBJECT(NewInput); \ + IMPORT_C_OBJECT(NewOutput); \ + IMPORT_C_OBJECT(cgetvalue); } + +#endif /* CSTRINGIO_INCLUDED */ diff --git a/Modules/cStringIO.c b/Modules/cStringIO.c new file mode 100644 index 0000000..e9f8033 --- /dev/null +++ b/Modules/cStringIO.c @@ -0,0 +1,678 @@ +/* + + $Id$ + + A simple fast partial StringIO replacement. + + + + Copyright + + Copyright 1996 Digital Creations, L.C., 910 Princess Anne + Street, Suite 300, Fredericksburg, Virginia 22401 U.S.A. All + rights reserved. Copyright in this software is owned by DCLC, + unless otherwise indicated. Permission to use, copy and + distribute this software is hereby granted, provided that the + above copyright notice appear in all copies and that both that + copyright notice and this permission notice appear. Note that + any product, process or technology described in this software + may be the subject of other Intellectual Property rights + reserved by Digital Creations, L.C. and are not licensed + hereunder. + + Trademarks + + Digital Creations & DCLC, are trademarks of Digital Creations, L.C.. + All other trademarks are owned by their respective companies. + + No Warranty + + The software is provided "as is" without warranty of any kind, + either express or implied, including, but not limited to, the + implied warranties of merchantability, fitness for a particular + purpose, or non-infringement. This software could include + technical inaccuracies or typographical errors. Changes are + periodically made to the software; these changes will be + incorporated in new editions of the software. DCLC may make + improvements and/or changes in this software at any time + without notice. + + Limitation Of Liability + + In no event will DCLC be liable for direct, indirect, special, + incidental, economic, cover, or consequential damages arising + out of the use of or inability to use this software even if + advised of the possibility of such damages. Some states do not + allow the exclusion or limitation of implied warranties or + limitation of liability for incidental or consequential + damages, so the above limitation or exclusion may not apply to + you. + + If you have questions regarding this software, + contact: + + Jim Fulton, jim@digicool.com + Digital Creations L.C. + + (540) 371-6909 + + + $Log$ + Revision 2.1 1996/12/05 23:30:40 guido + Jim F's brainchild + + Revision 1.6 1996/10/15 18:42:07 jim + Added lots of casts to make warnings go away. + + Revision 1.5 1996/10/11 21:03:42 jim + *** empty log message *** + + Revision 1.4 1996/10/11 21:02:15 jim + *** empty log message *** + + Revision 1.3 1996/10/07 20:51:38 chris + *** empty log message *** + + Revision 1.2 1996/07/18 13:08:34 jfulton + *** empty log message *** + + Revision 1.1 1996/07/15 17:06:33 jfulton + Initial version. + + +*/ +static char 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 if StringIO, but it provides anough for most\n" +"applications and is especially useful in conjuction 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() # str(an_output_stream) works too!\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.reset() # OK, start over, note no seek yet\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" +; + +#include "Python.h" +#include "import.h" + +static PyObject *ErrorObject; + +#define ASSIGN(V,E) {PyObject *__e; __e=(E); Py_XDECREF(V); (V)=__e;} +#define UNLESS(E) if(!(E)) +#define UNLESS_ASSIGN(V,E) ASSIGN(V,E) UNLESS(V) +#define Py_ASSIGN(P,E) if(!PyObject_AssignExpression(&(P),(E))) return NULL + +/* ----------------------------------------------------- */ + +/* Declarations for objects of type StringO */ + +typedef struct { + PyObject_HEAD + char *buf; + int pos, string_size, buf_size, closed; +} Oobject; + +staticforward PyTypeObject Otype; + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type StringI */ + +typedef struct { + PyObject_HEAD + char *buf; + int pos, string_size, closed; + PyObject *pbuf; +} Iobject; + +staticforward PyTypeObject Itype; + + + +/* ---------------------------------------------------------------- */ + +static char O_reset__doc__[] = +"reset() -- Reset the file position to the beginning" +; + +static PyObject * +O_reset(Oobject *self, PyObject *args) +{ + self->pos = 0; + + Py_INCREF(Py_None); + return Py_None; +} + + +static char O_tell__doc__[] = +"tell() -- get the current position."; + +static PyObject * +O_tell(Oobject *self, PyObject *args) +{ + return PyInt_FromLong(self->pos); +} + + +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(PyArg_ParseTuple(args, "i|i", &position, &mode)) + { + return NULL; + } + + if (mode == 2) + { + position += self->string_size; + } + else if (mode == 1) + { + position += self->pos; + } + + self->pos = (position > self->string_size ? self->string_size : + (position < 0 ? 0 : position)); + + return PyInt_FromLong(self->pos); +} + +static char O_read__doc__[] = +"read([s]) -- Read s characters, or the rest of the string" +; + +static int +O_cread(Oobject *self, char **output, int n) +{ + int l; + + l = self->string_size - self->pos; + if (n < 0 || n > l) + { + n = l; + } + + *output=self->buf + self->pos; + self->pos += n; + return n; +} + +static PyObject * +O_read(Oobject *self, PyObject *args) +{ + int n = -1; + char *output; + + UNLESS(PyArg_ParseTuple(args, "|i", &n)) return NULL; + + n=O_cread(self,&output,n); + + return PyString_FromStringAndSize(output, n); +} + + +static char O_readline__doc__[] = +"readline() -- Read one line" +; + +static int +O_creadline(Oobject *self, char **output) +{ + char *n, *s; + int l; + + for (n = self->buf + self->pos, s = self->buf + self->string_size; + n < s && *n != '\n'; n++); + if (n < s) n++; + + *output=self->buf + self->pos; + l = n - self->buf - self->pos; + self->pos += l; + return l; +} + +static PyObject * +O_readline(Oobject *self, PyObject *args) +{ + int n; + char *output; + + n=O_creadline(self,&output); + return PyString_FromStringAndSize(output, n); +} + +static char O_write__doc__[] = +"write(s) -- Write a string to the file" +"\n\nNote (hack:) writing None resets the buffer" +; + + +static int +O_cwrite(Oobject *self, char *c, int l) +{ + int newl; + newl=self->pos+l; + if(newl > self->buf_size) + { + self->buf_size*=2; + if(self->buf_size < newl) self->buf_size=newl; + UNLESS(self->buf=(char*)realloc(self->buf, self->buf_size*sizeof(char))) + { + PyErr_SetString(PyExc_MemoryError,"out of memory"); + self->buf_size=self->pos=0; + return -1; + } + } + + memcpy(self->buf+self->pos,c,l); + + self->pos += l; + + if (self->string_size < self->pos) + { + self->string_size = self->pos; + } + + return l; +} + +static PyObject * +O_write(Oobject *self, PyObject *args) +{ + PyObject *s; + char *c; + int l; + + UNLESS(PyArg_Parse(args, "O", &s)) return NULL; + if(s!=Py_None) + { + UNLESS(-1 != (l=PyString_Size(s))) return NULL; + UNLESS(c=PyString_AsString(s)) return NULL; + UNLESS(-1 != O_cwrite(self,c,l)) return NULL; + } + else + { + self->pos=0; + self->string_size = 0; + } + + Py_INCREF(self); + return (PyObject *)self; +} + +static PyObject * +O_repr(self) + Oobject *self; +{ + return PyString_FromStringAndSize(self->buf,self->string_size); +} + +static PyObject * +O_getval(self,args) + Oobject *self; + PyObject *args; +{ + return PyString_FromStringAndSize(self->buf,self->pos); +} + +static char O_truncate__doc__[] = +"truncate(): truncate the file at the current position."; + +static PyObject * +O_truncate(self, args) + Oobject *self; + PyObject *args; +{ + 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(self, args) + Oobject *self; + PyObject *args; +{ + return PyInt_FromLong(0); +} + +static char O_close__doc__[] = "close(): explicitly release resources held."; + +static PyObject * +O_close(self, args) + Oobject *self; + PyObject *args; +{ + free(self->buf); + + self->pos = self->string_size = self->buf_size = 0; + self->closed = 1; + + Py_INCREF(Py_None); + return Py_None; +} + +static char O_flush__doc__[] = "flush(): does nothing."; + +static PyObject * +O_flush(self, args) + Oobject *self; + PyObject *args; +{ + Py_INCREF(Py_None); + return Py_None; +} + + +static char O_writelines__doc__[] = "blah"; +static PyObject * +O_writelines(self, args) + Oobject *self; + PyObject *args; +{ + PyObject *string_module = 0; + static PyObject *string_joinfields = 0; + + UNLESS(PyArg_Parse(args, "O", args)) + { + return NULL; + } + + if (!string_joinfields) + { + UNLESS(string_module = PyImport_ImportModule("string")) + { + return NULL; + } + + UNLESS(string_joinfields= + PyObject_GetAttrString(string_module, "joinfields")) + { + return NULL; + } + + Py_DECREF(string_module); + } + + if (PyObject_Length(args) == -1) + { + return NULL; + } + + return O_write(self, + PyObject_CallFunction(string_joinfields, "Os", args, "")); +} + +static struct PyMethodDef O_methods[] = { + {"read", (PyCFunction)O_read, 1, O_read__doc__}, + {"readline", (PyCFunction)O_readline, 0, O_readline__doc__}, + {"write", (PyCFunction)O_write, 0, O_write__doc__}, + {"reset", (PyCFunction)O_reset, 0, O_reset__doc__}, + {"seek", (PyCFunction)O_seek, 1, O_seek__doc__}, + {"tell", (PyCFunction)O_tell, 0, O_tell__doc__}, + {"getvalue", (PyCFunction)O_getval, 0, "getvalue() -- Get the string value"}, + {"truncate", (PyCFunction)O_truncate, 0, O_truncate__doc__}, + {"isatty", (PyCFunction)O_isatty, 0, O_isatty__doc__}, + {"close", (PyCFunction)O_close, 0, O_close__doc__}, + {"flush", (PyCFunction)O_flush, 0, O_flush__doc__}, + {"writelines", (PyCFunction)O_writelines, 0, O_writelines__doc__}, + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +static Oobject * +newOobject(int size) +{ + Oobject *self; + + self = PyObject_NEW(Oobject, &Otype); + if (self == NULL) + return NULL; + self->pos=0; + self->closed = 0; + self->string_size = 0; + + UNLESS(self->buf=malloc(size*sizeof(char))) + { + PyErr_SetString(PyExc_MemoryError,"out of memory"); + self->buf_size = 0; + return NULL; + } + + self->buf_size=size; + return self; +} + + +static void +O_dealloc(self) + Oobject *self; +{ + free(self->buf); + PyMem_DEL(self); +} + +static PyObject * +O_getattr(self, name) + Oobject *self; + char *name; +{ + return Py_FindMethod(O_methods, (PyObject *)self, name); +} + +static char Otype__doc__[] = +"Simple type for output to strings." +; + +static PyTypeObject Otype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "StringO", /*tp_name*/ + sizeof(Oobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)O_dealloc, /*tp_dealloc*/ + (printfunc)0, /*tp_print*/ + (getattrfunc)O_getattr, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc)0, /*tp_compare*/ + (reprfunc)O_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc)0, /*tp_hash*/ + (ternaryfunc)0, /*tp_call*/ + (reprfunc)0, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Otype__doc__ /* Documentation string */ +}; + +/* End of code for StringO objects */ +/* -------------------------------------------------------- */ + +static PyObject * +I_close(self, args) + Iobject *self; + PyObject *args; +{ + Py_DECREF(self->pbuf); + + self->pos = self->string_size = 0; + self->closed = 1; + + Py_INCREF(Py_None); + return Py_None; +} + +static struct PyMethodDef I_methods[] = { + {"read", (PyCFunction)O_read, 1, O_read__doc__}, + {"readline", (PyCFunction)O_readline, 0, O_readline__doc__}, + {"reset", (PyCFunction)O_reset, 0, O_reset__doc__}, + {"seek", (PyCFunction)O_seek, 1, O_seek__doc__}, + {"tell", (PyCFunction)O_tell, 0, O_tell__doc__}, + {"truncate", (PyCFunction)O_truncate, 0, O_truncate__doc__}, + {"isatty", (PyCFunction)O_isatty, 0, O_isatty__doc__}, + {"close", (PyCFunction)I_close, 0, O_close__doc__}, + {"flush", (PyCFunction)O_flush, 0, O_flush__doc__}, + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +static Iobject * +newIobject(PyObject *s) +{ + Iobject *self; + char *buf; + int size; + + UNLESS(buf=PyString_AsString(s)) return NULL; + UNLESS(-1 != (size=PyString_Size(s))) return NULL; + UNLESS(self = PyObject_NEW(Iobject, &Itype)) return NULL; + Py_INCREF(s); + self->buf=buf; + self->string_size=size; + self->pbuf=s; + self->pos=0; + self->closed = 0; + + return self; +} + + +static void +I_dealloc(self) + Iobject *self; +{ + Py_DECREF(self->pbuf); + PyMem_DEL(self); +} + +static PyObject * +I_getattr(self, name) + Iobject *self; + char *name; +{ + return Py_FindMethod(I_methods, (PyObject *)self, name); +} + +static char Itype__doc__[] = +"Simple type for treating strings as input file streams" +; + +static PyTypeObject Itype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "StringI", /*tp_name*/ + sizeof(Iobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)I_dealloc, /*tp_dealloc*/ + (printfunc)0, /*tp_print*/ + (getattrfunc)I_getattr, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc)0, /*tp_compare*/ + (reprfunc)0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc)0, /*tp_hash*/ + (ternaryfunc)0, /*tp_call*/ + (reprfunc)0, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Itype__doc__ /* Documentation string */ +}; + +/* End of code for StringI objects */ +/* -------------------------------------------------------- */ + + +static char IO_StringIO__doc__[] = +"StringIO([s]) -- Return a StringIO-like stream for reading or writing" +; + +static PyObject * +IO_StringIO(self, args) + PyObject *self; /* Not used */ + PyObject *args; +{ + PyObject *s=0; + + UNLESS(PyArg_ParseTuple(args, "|O", &s)) return NULL; + if(s) return (PyObject *)newIobject(s); + return (PyObject *)newOobject(128); +} + +/* List of methods defined in the module */ + +static struct PyMethodDef IO_methods[] = { + {"StringIO", (PyCFunction)IO_StringIO, 1, IO_StringIO__doc__}, + {NULL, NULL} /* sentinel */ +}; + + +/* Initialization function for the module (*must* be called initcStringIO) */ + +void +initcStringIO() +{ + PyObject *m, *d; + + /* Create the module and add the functions */ + m = Py_InitModule4("cStringIO", IO_methods, + cStringIO_module_documentation, + (PyObject*)NULL,PYTHON_API_VERSION); + + /* Add some symbolic constants to the module */ + d = PyModule_GetDict(m); + ErrorObject = PyString_FromString("cStringIO.error"); + PyDict_SetItemString(d, "error", ErrorObject); + + PyDict_SetItemString(d,"cread", PyCObject_FromVoidPtr(O_cread,NULL)); + PyDict_SetItemString(d,"creadline", PyCObject_FromVoidPtr(O_creadline,NULL)); + PyDict_SetItemString(d,"cwrite", PyCObject_FromVoidPtr(O_cwrite,NULL)); + PyDict_SetItemString(d,"cgetvalue", PyCObject_FromVoidPtr(O_getval,NULL)); + PyDict_SetItemString(d,"NewInput", PyCObject_FromVoidPtr(newIobject,NULL)); + PyDict_SetItemString(d,"NewOutput", PyCObject_FromVoidPtr(newOobject,NULL)); + + PyDict_SetItemString(d,"InputType", (PyObject*)&Itype); + PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype); + + + /* Check for errors */ + if (PyErr_Occurred()) + Py_FatalError("can't initialize module cStringIO"); +} |