1 

     2 #include "Python.h"

     3 #include "import.h"

     4 #include "cStringIO.h"

     5 #include "structmember.h"

     6 

     7 PyDoc_STRVAR(cStringIO_module_documentation,

     8 "A simple fast partial StringIO replacement.\n"

     9 "\n"

    10 "This module provides a simple useful replacement for\n"

    11 "the StringIO module that is written in C.  It does not provide the\n"

    12 "full generality of StringIO, but it provides enough for most\n"

    13 "applications and is especially useful in conjunction with the\n"

    14 "pickle module.\n"

    15 "\n"

    16 "Usage:\n"

    17 "\n"

    18 "  from cStringIO import StringIO\n"

    19 "\n"

    20 "  an_output_stream=StringIO()\n"

    21 "  an_output_stream.write(some_stuff)\n"

    22 "  ...\n"

    23 "  value=an_output_stream.getvalue()\n"

    24 "\n"

    25 "  an_input_stream=StringIO(a_string)\n"

    26 "  spam=an_input_stream.readline()\n"

    27 "  spam=an_input_stream.read(5)\n"

    28 "  an_input_stream.seek(0)           # OK, start over\n"

    29 "  spam=an_input_stream.read()       # and read it all\n"

    30 "  \n"

    31 "If someone else wants to provide a more complete implementation,\n"

    32 "go for it. :-)  \n"

    33 "\n"

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

    35 

    36 /* Declaration for file-like objects that manage data as strings 

    37 

    38    The IOobject type should be though of as a common base type for

    39    Iobjects, which provide input (read-only) StringIO objects and

    40    Oobjects, which provide read-write objects.  Most of the methods

    41    depend only on common data.

    42 */

    43 

    44 typedef struct {

    45   PyObject_HEAD

    46   char *buf;

    47   Py_ssize_t pos, string_size;

    48 } IOobject;

    49 

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

    51 

    52 /* Declarations for objects of type StringO */

    53 

    54 typedef struct { /* Subtype of IOobject */

    55   PyObject_HEAD

    56   char *buf;

    57   Py_ssize_t pos, string_size;

    58 

    59   Py_ssize_t buf_size;

    60   int softspace;

    61 } Oobject;

    62 

    63 /* Declarations for objects of type StringI */

    64 

    65 typedef struct { /* Subtype of IOobject */

    66   PyObject_HEAD

    67   char *buf;

    68   Py_ssize_t pos, string_size;

    69   /* We store a reference to the object here in order to keep

    70      the buffer alive during the lifetime of the Iobject. */

    71   PyObject *pbuf;

    72 } Iobject;

    73 

    74 /* IOobject (common) methods */

    75 

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

    77 

    78 static int

    79 IO__opencheck(IOobject *self) {

    80         if (!self->buf) {

    81                 PyErr_SetString(PyExc_ValueError,

    82                                 "I/O operation on closed file");

    83                 return 0;

    84         }

    85         return 1;

    86 }

    87 

    88 static PyObject *

    89 IO_get_closed(IOobject *self, void *closure)

    90 {

    91 	PyObject *result = Py_False;

    92 

    93 	if (self->buf == NULL)

    94 		result = Py_True;

    95 	Py_INCREF(result);

    96 	return result;

    97 }

    98 

    99 static PyGetSetDef file_getsetlist[] = {

   100 	{"closed", (getter)IO_get_closed, NULL, "True if the file is closed"},

   101 	{0},

   102 };

   103 

   104 static PyObject *

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

   106 

   107         if (!IO__opencheck(self)) return NULL;

   108 

   109         Py_INCREF(Py_None);

   110         return Py_None;

   111 }

   112 

   113 PyDoc_STRVAR(IO_getval__doc__,

   114 "getvalue([use_pos]) -- Get the string value."

   115 "\n"

   116 "If use_pos is specified and is a true value, then the string returned\n"

   117 "will include only the text up to the current file position.\n");

   118 

   119 static PyObject *

   120 IO_cgetval(PyObject *self) {

   121         if (!IO__opencheck(IOOOBJECT(self))) return NULL;

   122         assert(IOOOBJECT(self)->pos >= 0);

   123         return PyString_FromStringAndSize(((IOobject*)self)->buf,

   124                                           ((IOobject*)self)->pos);

   125 }

   126 

   127 static PyObject *

   128 IO_getval(IOobject *self, PyObject *args) {

   129         PyObject *use_pos=Py_None;

   130         Py_ssize_t s;

   131 

   132         if (!IO__opencheck(self)) return NULL;

   133         if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL;

   134 

   135         if (PyObject_IsTrue(use_pos)) {

   136                   s=self->pos;

   137                   if (s > self->string_size) s=self->string_size;

   138         }

   139         else

   140                   s=self->string_size;

   141         assert(self->pos >= 0);

   142         return PyString_FromStringAndSize(self->buf, s);

   143 }

   144 

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

   146 

   147 static PyObject *

   148 IO_isatty(IOobject *self, PyObject *unused) {

   149         if (!IO__opencheck(self)) return NULL;

   150         Py_INCREF(Py_False);

   151         return Py_False;

   152 }

   153 

   154 PyDoc_STRVAR(IO_read__doc__,

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

   156 

   157 static int

   158 IO_cread(PyObject *self, char **output, Py_ssize_t  n) {

   159         Py_ssize_t l;

   160 

   161         if (!IO__opencheck(IOOOBJECT(self))) return -1;

   162         assert(IOOOBJECT(self)->pos >= 0);

   163         assert(IOOOBJECT(self)->string_size >= 0);

   164         l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;  

   165         if (n < 0 || n > l) {

   166                 n = l;

   167                 if (n < 0) n=0;

   168         }

   169 

   170         *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;

   171         ((IOobject*)self)->pos += n;

   172         return n;

   173 }

   174 

   175 static PyObject *

   176 IO_read(IOobject *self, PyObject *args) {

   177         Py_ssize_t n = -1;

   178         char *output = NULL;

   179 

   180         if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;

   181 

   182         if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;

   183 

   184         return PyString_FromStringAndSize(output, n);

   185 }

   186 

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

   188 

   189 static int

   190 IO_creadline(PyObject *self, char **output) {

   191         char *n, *s;

   192         Py_ssize_t l;

   193 

   194         if (!IO__opencheck(IOOOBJECT(self))) return -1;

   195 

   196         for (n = ((IOobject*)self)->buf + ((IOobject*)self)->pos,

   197                s = ((IOobject*)self)->buf + ((IOobject*)self)->string_size; 

   198              n < s && *n != '\n'; n++);

   199 

   200         if (n < s) n++;

   201 

   202         *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;

   203         l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos;

   204 

   205         assert(IOOOBJECT(self)->pos <= PY_SSIZE_T_MAX - l);

   206         assert(IOOOBJECT(self)->pos >= 0);

   207         assert(IOOOBJECT(self)->string_size >= 0);

   208 

   209         ((IOobject*)self)->pos += l;

   210         return (int)l;

   211 }

   212 

   213 static PyObject *

   214 IO_readline(IOobject *self, PyObject *args) {

   215         int n, m=-1;

   216         char *output;

   217 

   218         if (args)

   219                 if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;

   220 

   221         if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;

   222         if (m >= 0 && m < n) {

   223                 m = n - m;

   224                 n -= m;

   225                 self->pos -= m;

   226         }

   227         assert(IOOOBJECT(self)->pos >= 0);

   228         return PyString_FromStringAndSize(output, n);

   229 }

   230 

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

   232 

   233 static PyObject *

   234 IO_readlines(IOobject *self, PyObject *args) {

   235 	int n;

   236 	char *output;

   237 	PyObject *result, *line;

   238         int hint = 0, length = 0;

   239 	

   240         if (!PyArg_ParseTuple(args, "|i:readlines", &hint)) return NULL;

   241 

   242 	result = PyList_New(0);

   243 	if (!result)

   244 		return NULL;

   245 

   246 	while (1){

   247 		if ( (n = IO_creadline((PyObject*)self,&output)) < 0)

   248                         goto err;

   249 		if (n == 0)

   250 			break;

   251 		line = PyString_FromStringAndSize (output, n);

   252 		if (!line) 

   253                         goto err;

   254 		if (PyList_Append (result, line) == -1) {

   255 			Py_DECREF (line);

   256 			goto err;

   257 		}

   258 		Py_DECREF (line);

   259                 length += n;

   260                 if (hint > 0 && length >= hint)

   261 			break;

   262 	}

   263 	return result;

   264  err:

   265         Py_DECREF(result);

   266         return NULL;

   267 }

   268 

   269 PyDoc_STRVAR(IO_reset__doc__,

   270 "reset() -- Reset the file position to the beginning");

   271 

   272 static PyObject *

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

   274 

   275         if (!IO__opencheck(self)) return NULL;

   276 

   277         self->pos = 0;

   278 

   279         Py_INCREF(Py_None);

   280         return Py_None;

   281 }

   282 

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

   284 

   285 static PyObject *

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

   287 

   288         if (!IO__opencheck(self)) return NULL;

   289 

   290         assert(self->pos >= 0);

   291         return PyInt_FromSsize_t(self->pos);

   292 }

   293 

   294 PyDoc_STRVAR(IO_truncate__doc__,

   295 "truncate(): truncate the file at the current position.");

   296 

   297 static PyObject *

   298 IO_truncate(IOobject *self, PyObject *args) {

   299         Py_ssize_t pos = -1;

   300 	

   301         if (!IO__opencheck(self)) return NULL;

   302         if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;

   303 

   304 	if (PyTuple_Size(args) == 0) {

   305 		/* No argument passed, truncate to current position */

   306 		pos = self->pos;

   307 	}

   308 

   309         if (pos < 0) {

   310 		errno = EINVAL;

   311 		PyErr_SetFromErrno(PyExc_IOError);

   312 		return NULL;

   313 	}

   314 

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

   316         self->pos = self->string_size;

   317 

   318         Py_INCREF(Py_None);

   319         return Py_None;

   320 }

   321 

   322 static PyObject *

   323 IO_iternext(Iobject *self)

   324 {

   325 	PyObject *next;

   326 	next = IO_readline((IOobject *)self, NULL);

   327 	if (!next)

   328 		return NULL;

   329 	if (!PyString_GET_SIZE(next)) {

   330 		Py_DECREF(next);

   331 		PyErr_SetNone(PyExc_StopIteration);

   332 		return NULL;

   333 	}

   334 	return next;

   335 }

   336 

   337 

   338 

   339 

   340 /* Read-write object methods */

   341 

   342 PyDoc_STRVAR(O_seek__doc__,

   343 "seek(position)       -- set the current position\n"

   344 "seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");

   345 

   346 static PyObject *

   347 O_seek(Oobject *self, PyObject *args) {

   348 	Py_ssize_t position;

   349 	int mode = 0;

   350 

   351         if (!IO__opencheck(IOOOBJECT(self))) return NULL;

   352         if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode)) 

   353                 return NULL;

   354 

   355         if (mode == 2) {

   356                 position += self->string_size;

   357         }

   358         else if (mode == 1) {

   359                 position += self->pos;

   360         }

   361 

   362         if (position > self->buf_size) {

   363                   char *newbuf;

   364                   self->buf_size*=2;

   365                   if (self->buf_size <= position) self->buf_size=position+1;

   366 		  newbuf = (char*) realloc(self->buf,self->buf_size);

   367                   if (!newbuf) {

   368                       free(self->buf);

   369                       self->buf = 0;

   370                       self->buf_size=self->pos=0;

   371                       return PyErr_NoMemory();

   372                     }

   373                   self->buf = newbuf;

   374           }

   375         else if (position < 0) position=0;

   376 

   377         self->pos=position;

   378 

   379         while (--position >= self->string_size) self->buf[position]=0;

   380 

   381         Py_INCREF(Py_None);

   382         return Py_None;

   383 }

   384 

   385 PyDoc_STRVAR(O_write__doc__,

   386 "write(s) -- Write a string to the file"

   387 "\n\nNote (hack:) writing None resets the buffer");

   388 

   389 

   390 static int

   391 O_cwrite(PyObject *self, const char *c, Py_ssize_t  l) {

   392         Py_ssize_t newl;

   393         Oobject *oself;

   394         char *newbuf;

   395 

   396         if (!IO__opencheck(IOOOBJECT(self))) return -1;

   397         oself = (Oobject *)self;

   398 

   399         newl = oself->pos+l;

   400         if (newl >= oself->buf_size) {

   401             oself->buf_size *= 2;

   402             if (oself->buf_size <= newl) {

   403 		    assert(newl + 1 < INT_MAX);

   404                     oself->buf_size = (int)(newl+1);

   405 	    }

   406             newbuf = (char*)realloc(oself->buf, oself->buf_size);

   407 	    if (!newbuf) {

   408                     PyErr_SetString(PyExc_MemoryError,"out of memory");

   409                     free(oself->buf);

   410                     oself->buf = 0;

   411                     oself->buf_size = oself->pos = 0;

   412                     return -1;

   413               }

   414             oself->buf = newbuf;

   415           }

   416 

   417         memcpy(oself->buf+oself->pos,c,l);

   418 

   419 	assert(oself->pos + l < INT_MAX);

   420         oself->pos += (int)l;

   421 

   422         if (oself->string_size < oself->pos) {

   423             oself->string_size = oself->pos;

   424         }

   425 

   426         return (int)l;

   427 }

   428 

   429 static PyObject *

   430 O_write(Oobject *self, PyObject *args) {

   431         char *c;

   432         int l;

   433 

   434         if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL;

   435 

   436         if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;

   437 

   438         Py_INCREF(Py_None);

   439         return Py_None;

   440 }

   441 

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

   443 

   444 static PyObject *

   445 O_close(Oobject *self, PyObject *unused) {

   446         if (self->buf != NULL) free(self->buf);

   447         self->buf = NULL;

   448 

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

   450 

   451         Py_INCREF(Py_None);

   452         return Py_None;

   453 }

   454 

   455 PyDoc_STRVAR(O_writelines__doc__,

   456 "writelines(sequence_of_strings) -> None.  Write the strings to the file.\n"

   457 "\n"

   458 "Note that newlines are not added.  The sequence can be any iterable object\n"

   459 "producing strings. This is equivalent to calling write() for each string.");

   460 static PyObject *

   461 O_writelines(Oobject *self, PyObject *args) {

   462 	PyObject *it, *s;

   463 	

   464 	it = PyObject_GetIter(args);

   465 	if (it == NULL)

   466 		return NULL;

   467 	while ((s = PyIter_Next(it)) != NULL) {

   468 		Py_ssize_t n;

   469 		char *c;

   470 		if (PyString_AsStringAndSize(s, &c, &n) == -1) {

   471 			Py_DECREF(it);

   472 			Py_DECREF(s);

   473 			return NULL;

   474 		}

   475 		if (O_cwrite((PyObject *)self, c, n) == -1) {

   476 			Py_DECREF(it);

   477 			Py_DECREF(s);

   478 			return NULL;

   479                }

   480                Py_DECREF(s);

   481        }

   482 

   483        Py_DECREF(it);

   484 

   485        /* See if PyIter_Next failed */

   486        if (PyErr_Occurred())

   487                return NULL;

   488 

   489        Py_RETURN_NONE;

   490 }

   491 static struct PyMethodDef O_methods[] = {

   492   /* Common methods: */

   493   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},

   494   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},

   495   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},

   496   {"read",	(PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},

   497   {"readline",	(PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},

   498   {"readlines",	(PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},

   499   {"reset",	(PyCFunction)IO_reset,	  METH_NOARGS,  IO_reset__doc__},

   500   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},

   501   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},

   502 

   503   /* Read-write StringIO specific  methods: */

   504   {"close",      (PyCFunction)O_close,      METH_NOARGS,  O_close__doc__},

   505   {"seek",       (PyCFunction)O_seek,       METH_VARARGS, O_seek__doc__},

   506   {"write",	 (PyCFunction)O_write,      METH_VARARGS, O_write__doc__},

   507   {"writelines", (PyCFunction)O_writelines, METH_O,	  O_writelines__doc__},

   508   {NULL,	 NULL}		/* sentinel */

   509 };

   510 

   511 static PyMemberDef O_memberlist[] = {

   512 	{"softspace",	T_INT,	offsetof(Oobject, softspace),	0,

   513 	 "flag indicating that a space needs to be printed; used by print"},

   514 	 /* getattr(f, "closed") is implemented without this table */

   515 	{NULL} /* Sentinel */

   516 };

   517 

   518 static void

   519 O_dealloc(Oobject *self) {

   520         if (self->buf != NULL)

   521                 free(self->buf);

   522         PyObject_Del(self);

   523 }

   524 

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

   526 

   527 static PyTypeObject Otype = {

   528   PyVarObject_HEAD_INIT(NULL, 0)

   529   "cStringIO.StringO",   	/*tp_name*/

   530   sizeof(Oobject),       	/*tp_basicsize*/

   531   0,	       			/*tp_itemsize*/

   532   /* methods */

   533   (destructor)O_dealloc,	/*tp_dealloc*/

   534   0,				/*tp_print*/

   535   0,		 		/*tp_getattr */

   536   0,		 		/*tp_setattr */

   537   0,				/*tp_compare*/

   538   0,				/*tp_repr*/

   539   0,				/*tp_as_number*/

   540   0,				/*tp_as_sequence*/

   541   0,				/*tp_as_mapping*/

   542   0,				/*tp_hash*/

   543   0	,			/*tp_call*/

   544   0,				/*tp_str*/

   545   0,				/*tp_getattro */

   546   0,				/*tp_setattro */

   547   0,				/*tp_as_buffer */

   548   Py_TPFLAGS_DEFAULT,		/*tp_flags*/

   549   Otype__doc__, 		/*tp_doc */

   550   0,				/*tp_traverse */

   551   0,				/*tp_clear */

   552   0,				/*tp_richcompare */

   553   0,				/*tp_weaklistoffset */

   554   PyObject_SelfIter,		/*tp_iter */

   555   (iternextfunc)IO_iternext,	/*tp_iternext */

   556   O_methods,			/*tp_methods */

   557   O_memberlist,			/*tp_members */

   558   file_getsetlist,		/*tp_getset */

   559 };

   560 

   561 static PyObject *

   562 newOobject(int  size) {

   563         Oobject *self;

   564 

   565         self = PyObject_New(Oobject, &Otype);

   566         if (self == NULL)

   567                 return NULL;

   568         self->pos=0;

   569         self->string_size = 0;

   570         self->softspace = 0;

   571 

   572         self->buf = (char *)malloc(size);

   573 	if (!self->buf) {

   574                   PyErr_SetString(PyExc_MemoryError,"out of memory");

   575                   self->buf_size = 0;

   576                   Py_DECREF(self);

   577                   return NULL;

   578           }

   579 

   580         self->buf_size=size;

   581         return (PyObject*)self;

   582 }

   583 

   584 /* End of code for StringO objects */

   585 /* -------------------------------------------------------- */

   586 

   587 static PyObject *

   588 I_close(Iobject *self, PyObject *unused) {

   589         Py_CLEAR(self->pbuf);

   590         self->buf = NULL;

   591 

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

   593 

   594         Py_INCREF(Py_None);

   595         return Py_None;

   596 }

   597 

   598 static PyObject *

   599 I_seek(Iobject *self, PyObject *args) {

   600         Py_ssize_t position;

   601 	int mode = 0;

   602 

   603         if (!IO__opencheck(IOOOBJECT(self))) return NULL;

   604         if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode)) 

   605                 return NULL;

   606 

   607         if (mode == 2) position += self->string_size;

   608         else if (mode == 1) position += self->pos;

   609 

   610         if (position < 0) position=0;

   611 

   612         self->pos=position;

   613 

   614         Py_INCREF(Py_None);

   615         return Py_None;

   616 }

   617 

   618 static struct PyMethodDef I_methods[] = {

   619   /* Common methods: */

   620   {"flush",     (PyCFunction)IO_flush,    METH_NOARGS,  IO_flush__doc__},

   621   {"getvalue",  (PyCFunction)IO_getval,   METH_VARARGS, IO_getval__doc__},

   622   {"isatty",    (PyCFunction)IO_isatty,   METH_NOARGS,  IO_isatty__doc__},

   623   {"read",	(PyCFunction)IO_read,     METH_VARARGS, IO_read__doc__},

   624   {"readline",	(PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},

   625   {"readlines",	(PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},

   626   {"reset",	(PyCFunction)IO_reset,	  METH_NOARGS,  IO_reset__doc__},

   627   {"tell",      (PyCFunction)IO_tell,     METH_NOARGS,  IO_tell__doc__},

   628   {"truncate",  (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},

   629 

   630   /* Read-only StringIO specific  methods: */

   631   {"close",     (PyCFunction)I_close,    METH_NOARGS,  O_close__doc__},

   632   {"seek",      (PyCFunction)I_seek,     METH_VARARGS, O_seek__doc__},  

   633   {NULL,	NULL}

   634 };

   635 

   636 static void

   637 I_dealloc(Iobject *self) {

   638   Py_XDECREF(self->pbuf);

   639   PyObject_Del(self);

   640 }

   641 

   642 

   643 PyDoc_STRVAR(Itype__doc__,

   644 "Simple type for treating strings as input file streams");

   645 

   646 static PyTypeObject Itype = {

   647   PyVarObject_HEAD_INIT(NULL, 0)

   648   "cStringIO.StringI",			/*tp_name*/

   649   sizeof(Iobject),			/*tp_basicsize*/

   650   0,					/*tp_itemsize*/

   651   /* methods */

   652   (destructor)I_dealloc,		/*tp_dealloc*/

   653   0,					/*tp_print*/

   654   0,		 			/* tp_getattr */

   655   0,					/*tp_setattr*/

   656   0,					/*tp_compare*/

   657   0,					/*tp_repr*/

   658   0,					/*tp_as_number*/

   659   0,					/*tp_as_sequence*/

   660   0,					/*tp_as_mapping*/

   661   0,					/*tp_hash*/

   662   0,					/*tp_call*/

   663   0,					/*tp_str*/

   664   0,					/* tp_getattro */

   665   0,					/* tp_setattro */

   666   0,					/* tp_as_buffer */

   667   Py_TPFLAGS_DEFAULT,			/* tp_flags */

   668   Itype__doc__,				/* tp_doc */

   669   0,					/* tp_traverse */

   670   0,					/* tp_clear */

   671   0,					/* tp_richcompare */

   672   0,					/* tp_weaklistoffset */

   673   PyObject_SelfIter,			/* tp_iter */

   674   (iternextfunc)IO_iternext,		/* tp_iternext */

   675   I_methods,				/* tp_methods */

   676   0,					/* tp_members */

   677   file_getsetlist,			/* tp_getset */

   678 };

   679 

   680 static PyObject *

   681 newIobject(PyObject *s) {

   682   Iobject *self;

   683   char *buf;

   684   Py_ssize_t size;

   685 

   686   if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) {

   687     PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found",

   688                  s->ob_type->tp_name);

   689     return NULL;

   690   }

   691 

   692   self = PyObject_New(Iobject, &Itype);

   693   if (!self) return NULL;

   694   Py_INCREF(s);

   695   self->buf=buf;

   696   self->string_size=size;

   697   self->pbuf=s;

   698   self->pos=0;

   699   

   700   return (PyObject*)self;

   701 }

   702 

   703 /* End of code for StringI objects */

   704 /* -------------------------------------------------------- */

   705 

   706 

   707 PyDoc_STRVAR(IO_StringIO__doc__,

   708 "StringIO([s]) -- Return a StringIO-like stream for reading or writing");

   709 

   710 static PyObject *

   711 IO_StringIO(PyObject *self, PyObject *args) {

   712   PyObject *s=0;

   713 

   714   if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;

   715 

   716   if (s) return newIobject(s);

   717   return newOobject(128);

   718 }

   719 

   720 /* List of methods defined in the module */

   721 

   722 static struct PyMethodDef IO_methods[] = {

   723   {"StringIO",	(PyCFunction)IO_StringIO,	

   724    METH_VARARGS,	IO_StringIO__doc__},

   725   {NULL,		NULL}		/* sentinel */

   726 };

   727 

   728 

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

   730 

   731 static struct PycStringIO_CAPI CAPI = {

   732   IO_cread,

   733   IO_creadline,

   734   O_cwrite,

   735   IO_cgetval,

   736   newOobject,

   737   newIobject,

   738   &Itype,

   739   &Otype,

   740 };

   741 

   742 #ifndef PyMODINIT_FUNC	/* declarations for DLL import/export */

   743 #define PyMODINIT_FUNC void

   744 #endif

   745 PyMODINIT_FUNC

   746 initcStringIO(void) {

   747   PyObject *m, *d, *v;

   748 

   749 

   750   /* Create the module and add the functions */

   751   m = Py_InitModule4("cStringIO", IO_methods,

   752 		     cStringIO_module_documentation,

   753 		     (PyObject*)NULL,PYTHON_API_VERSION);

   754   if (m == NULL) return;

   755 

   756   /* Add some symbolic constants to the module */

   757   d = PyModule_GetDict(m);

   758   

   759   /* Export C API */

   760   Py_TYPE(&Itype)=&PyType_Type;

   761   Py_TYPE(&Otype)=&PyType_Type;

   762   if (PyType_Ready(&Otype) < 0) return;

   763   if (PyType_Ready(&Itype) < 0) return;

   764   PyDict_SetItemString(d,"cStringIO_CAPI",

   765 		       v = PyCObject_FromVoidPtr(&CAPI,NULL));

   766   Py_XDECREF(v);

   767 

   768   /* Export Types */

   769   PyDict_SetItemString(d,"InputType",  (PyObject*)&Itype);

   770   PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);

   771 

   772   /* Maybe make certain warnings go away */

   773   if (0) PycString_IMPORT;

   774 }