mirror of https://github.com/python/cpython.git
679 lines
16 KiB
C
679 lines
16 KiB
C
|
/*
|
||
|
|
||
|
$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");
|
||
|
}
|