home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 4 / AACD04.ISO / AACD / Programming / Python / Source / Modules / cStringIO.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-08  |  16.8 KB  |  665 lines
  1. /*
  2.  * $Id: cStringIO.c,v 2.16 1999/02/08 17:03:27 guido Exp $
  3.  * 
  4.  * Copyright (c) 1996-1998, Digital Creations, Fredericksburg, VA, USA.  
  5.  * All rights reserved.
  6.  * 
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions are
  9.  * met:
  10.  * 
  11.  *   o Redistributions of source code must retain the above copyright
  12.  *     notice, this list of conditions, and the disclaimer that follows.
  13.  * 
  14.  *   o Redistributions in binary form must reproduce the above copyright
  15.  *     notice, this list of conditions, and the following disclaimer in
  16.  *     the documentation and/or other materials provided with the
  17.  *     distribution.
  18.  * 
  19.  *   o All advertising materials mentioning features or use of this
  20.  *     software must display the following acknowledgement:
  21.  * 
  22.  *       This product includes software developed by Digital Creations
  23.  *       and its contributors.
  24.  * 
  25.  *   o Neither the name of Digital Creations nor the names of its
  26.  *     contributors may be used to endorse or promote products derived
  27.  *     from this software without specific prior written permission.
  28.  * 
  29.  * 
  30.  * THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS
  31.  * IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  32.  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  33.  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL
  34.  * CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  35.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  36.  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  37.  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  38.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  39.  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  40.  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  41.  * DAMAGE.
  42.  * 
  43.  # 
  44.  # If you have questions regarding this software, contact:
  45.  #
  46.  #   Digital Creations, L.C.
  47.  #   910 Princess Ann Street
  48.  #   Fredericksburge, Virginia  22401
  49.  #
  50.  #   info@digicool.com
  51.  #
  52.  #   (540) 371-6909
  53.  */
  54. static char cStringIO_module_documentation[] = 
  55. "A simple fast partial StringIO replacement.\n"
  56. "\n"
  57. "This module provides a simple useful replacement for\n"
  58. "the StringIO module that is written in C.  It does not provide the\n"
  59. "full generality if StringIO, but it provides anough for most\n"
  60. "applications and is especially useful in conjuction with the\n"
  61. "pickle module.\n"
  62. "\n"
  63. "Usage:\n"
  64. "\n"
  65. "  from cStringIO import StringIO\n"
  66. "\n"
  67. "  an_output_stream=StringIO()\n"
  68. "  an_output_stream.write(some_stuff)\n"
  69. "  ...\n"
  70. "  value=an_output_stream.getvalue() # str(an_output_stream) works too!\n"
  71. "\n"
  72. "  an_input_stream=StringIO(a_string)\n"
  73. "  spam=an_input_stream.readline()\n"
  74. "  spam=an_input_stream.read(5)\n"
  75. "  an_input_stream.seek(0)           # OK, start over\n"
  76. "  spam=an_input_stream.read()       # and read it all\n"
  77. "  \n"
  78. "If someone else wants to provide a more complete implementation,\n"
  79. "go for it. :-)  \n"
  80. "\n"
  81. "$Id: cStringIO.c,v 2.16 1999/02/08 17:03:27 guido Exp $\n"
  82. ;
  83.  
  84. #include "Python.h"
  85. #include "import.h"
  86. #include "cStringIO.h"
  87.  
  88. #define UNLESS(E) if(!(E))
  89.  
  90. /* Declarations for objects of type StringO */
  91.  
  92. typedef struct {
  93.   PyObject_HEAD
  94.   char *buf;
  95.   int pos, string_size, buf_size, softspace;
  96. } Oobject;
  97.  
  98. /* Declarations for objects of type StringI */
  99.  
  100. typedef struct {
  101.   PyObject_HEAD
  102.   char *buf;
  103.   int pos, string_size;
  104.   PyObject *pbuf;
  105. } Iobject;
  106.  
  107. static char O_reset__doc__[] = 
  108. "reset() -- Reset the file position to the beginning"
  109. ;
  110.  
  111. static PyObject *
  112. O_reset(Oobject *self, PyObject *args) {
  113.   self->pos = 0;
  114.  
  115.   Py_INCREF(Py_None);
  116.   return Py_None;
  117. }
  118.  
  119.  
  120. static char O_tell__doc__[] =
  121. "tell() -- get the current position.";
  122.  
  123. static PyObject *
  124. O_tell(Oobject *self, PyObject *args) {
  125.   return PyInt_FromLong(self->pos);
  126. }
  127.  
  128.  
  129. static char O_seek__doc__[] =
  130. "seek(position)       -- set the current position\n"
  131. "seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF";
  132.  
  133. static PyObject *
  134. O_seek(Oobject *self, PyObject *args) {
  135.   int position, mode = 0;
  136.  
  137.   UNLESS(PyArg_ParseTuple(args, "i|i", &position, &mode)) {
  138.     return NULL;
  139.   }
  140.  
  141.   if (mode == 2) {
  142.     position += self->string_size;
  143.   }
  144.   else if (mode == 1) {
  145.     position += self->pos;
  146.   }
  147.  
  148.   if (position > self->buf_size) {
  149.       self->buf_size*=2;
  150.       if(self->buf_size <= position) self->buf_size=position+1;
  151.       UNLESS(self->buf=(char*)realloc(self->buf,self->buf_size*sizeof(char))) {
  152.       self->buf_size=self->pos=0;
  153.       return PyErr_NoMemory();
  154.     }
  155.     }
  156.   else if(position < 0) position=0;
  157.   
  158.   self->pos=position;
  159.  
  160.   while(--position >= self->string_size) self->buf[position]=0;
  161.  
  162.   Py_INCREF(Py_None);
  163.   return Py_None;
  164. }
  165.  
  166. static char O_read__doc__[] = 
  167. "read([s]) -- Read s characters, or the rest of the string"
  168. ;
  169.  
  170. static int
  171. O_cread(PyObject *self, char **output, int  n) {
  172.   int l;
  173.  
  174.   l = ((Oobject*)self)->string_size - ((Oobject*)self)->pos;  
  175.   if (n < 0 || n > l) {
  176.     n = l;
  177.     if (n < 0) n=0;
  178.   }
  179.  
  180.   *output=((Oobject*)self)->buf + ((Oobject*)self)->pos;
  181.   ((Oobject*)self)->pos += n;
  182.   return n;
  183. }
  184.  
  185. static PyObject *
  186. O_read(Oobject *self, PyObject *args) {
  187.   int n = -1;
  188.   char *output;
  189.  
  190.   UNLESS(PyArg_ParseTuple(args, "|i", &n)) return NULL;
  191.  
  192.   n=O_cread((PyObject*)self,&output,n);
  193.  
  194.   return PyString_FromStringAndSize(output, n);
  195. }
  196.  
  197.  
  198. static char O_readline__doc__[] = 
  199. "readline() -- Read one line"
  200. ;
  201.  
  202. static int
  203. O_creadline(PyObject *self, char **output) {
  204.   char *n, *s;
  205.   int l;
  206.  
  207.   for (n = ((Oobject*)self)->buf + ((Oobject*)self)->pos,
  208.      s = ((Oobject*)self)->buf + ((Oobject*)self)->string_size; 
  209.        n < s && *n != '\n'; n++);
  210.   if (n < s) n++;
  211.  
  212.   *output=((Oobject*)self)->buf + ((Oobject*)self)->pos;
  213.   l = n - ((Oobject*)self)->buf - ((Oobject*)self)->pos;
  214.   ((Oobject*)self)->pos += l;
  215.   return l;
  216. }
  217.  
  218. static PyObject *
  219. O_readline(Oobject *self, PyObject *args) {
  220.   int n;
  221.   char *output;
  222.  
  223.   n=O_creadline((PyObject*)self,&output);
  224.   return PyString_FromStringAndSize(output, n);
  225. }
  226.  
  227. static char O_write__doc__[] = 
  228. "write(s) -- Write a string to the file"
  229. "\n\nNote (hack:) writing None resets the buffer"
  230. ;
  231.  
  232.  
  233. static int
  234. O_cwrite(PyObject *self, char *c, int  l) {
  235.   int newl;
  236.  
  237.   newl=((Oobject*)self)->pos+l;
  238.   if(newl >= ((Oobject*)self)->buf_size) {
  239.       ((Oobject*)self)->buf_size*=2;
  240.       if(((Oobject*)self)->buf_size <= newl) ((Oobject*)self)->buf_size=newl+1;
  241.       UNLESS(((Oobject*)self)->buf=
  242.          (char*)realloc(((Oobject*)self)->buf,
  243.                 (((Oobject*)self)->buf_size) *sizeof(char))) {
  244.       PyErr_SetString(PyExc_MemoryError,"out of memory");
  245.       ((Oobject*)self)->buf_size=((Oobject*)self)->pos=0;
  246.       return -1;
  247.     }
  248.     }
  249.  
  250.   memcpy(((Oobject*)((Oobject*)self))->buf+((Oobject*)self)->pos,c,l);
  251.  
  252.   ((Oobject*)self)->pos += l;
  253.  
  254.   if (((Oobject*)self)->string_size < ((Oobject*)self)->pos) {
  255.       ((Oobject*)self)->string_size = ((Oobject*)self)->pos;
  256.     }
  257.  
  258.   return l;
  259. }
  260.  
  261. static PyObject *
  262. O_write(Oobject *self, PyObject *args) {
  263.   PyObject *s;
  264.   char *c;
  265.   int l;
  266.  
  267.   UNLESS(PyArg_ParseTuple(args, "O", &s)) return NULL;
  268.   UNLESS(-1 != (l=PyString_Size(s))) return NULL;
  269.   UNLESS(c=PyString_AsString(s)) return NULL;
  270.   UNLESS(-1 != O_cwrite((PyObject*)self,c,l)) return NULL;
  271.  
  272.   Py_INCREF(Py_None);
  273.   return Py_None;
  274. }
  275.  
  276. static char O_getval__doc__[] = 
  277.    "getvalue([use_pos]) -- Get the string value."
  278.    "\n"
  279.    "If use_pos is specified and is a true value, then the string returned\n"
  280.    "will include only the text up to the current file position.\n"
  281. ;
  282.  
  283. static PyObject *
  284. O_getval(Oobject *self, PyObject *args) {
  285.   PyObject *use_pos=Py_None;
  286.   int s;
  287.  
  288.   use_pos=Py_None;
  289.   UNLESS(PyArg_ParseTuple(args,"|O",&use_pos)) return NULL;
  290.   if(PyObject_IsTrue(use_pos)) {
  291.       s=self->pos;
  292.       if (s > self->string_size) s=self->string_size;
  293.   }
  294.   else
  295.       s=self->string_size;
  296.   return PyString_FromStringAndSize(self->buf, s);
  297. }
  298.  
  299. static PyObject *
  300. O_cgetval(PyObject *self) {
  301.   return PyString_FromStringAndSize(((Oobject*)self)->buf,
  302.                     ((Oobject*)self)->pos);
  303. }
  304.  
  305. static char O_truncate__doc__[] = 
  306. "truncate(): truncate the file at the current position.";
  307.  
  308. static PyObject *
  309. O_truncate(Oobject *self, PyObject *args) {
  310.   if (self->string_size > self->pos)
  311.       self->string_size = self->pos;
  312.   Py_INCREF(Py_None);
  313.   return Py_None;
  314. }
  315.  
  316. static char O_isatty__doc__[] = "isatty(): always returns 0";
  317.  
  318. static PyObject *
  319. O_isatty(Oobject *self, PyObject *args) {
  320.   return PyInt_FromLong(0);
  321. }
  322.  
  323. static char O_close__doc__[] = "close(): explicitly release resources held.";
  324.  
  325. static PyObject *
  326. O_close(Oobject *self, PyObject *args) {
  327.   if (self->buf != NULL)
  328.     free(self->buf);
  329.   self->buf = NULL;
  330.  
  331.   self->pos = self->string_size = self->buf_size = 0;
  332.  
  333.   Py_INCREF(Py_None);
  334.   return Py_None;
  335. }
  336.  
  337. static char O_flush__doc__[] = "flush(): does nothing.";
  338.  
  339. static PyObject *
  340. O_flush(Oobject *self, PyObject *args) {
  341.   Py_INCREF(Py_None);
  342.   return Py_None;
  343. }
  344.  
  345.  
  346. static char O_writelines__doc__[] =
  347. "writelines(sequence_of_strings): write each string";
  348. static PyObject *
  349. O_writelines(Oobject *self, PyObject *args) {
  350.   PyObject *string_module = 0;
  351.   static PyObject *string_joinfields = 0;
  352.  
  353.   UNLESS(PyArg_ParseTuple(args, "O", &args)) {
  354.     return NULL;
  355.   }
  356.  
  357.   if (!string_joinfields) {
  358.     UNLESS(string_module = PyImport_ImportModule("string")) {
  359.       return NULL;
  360.     }
  361.  
  362.     UNLESS(string_joinfields=
  363.         PyObject_GetAttrString(string_module, "joinfields")) {
  364.       return NULL;
  365.     }
  366.  
  367.     Py_DECREF(string_module);
  368.   }
  369.  
  370.   if (PyObject_Length(args) == -1) {
  371.     return NULL;
  372.   }
  373.  
  374.   {
  375.       PyObject *x = PyObject_CallFunction(string_joinfields,
  376.                           "Os", args, "");
  377.       if (x == NULL)
  378.           return NULL;
  379.       args = Py_BuildValue("(O)", x);
  380.       Py_DECREF(x);
  381.       if (args == NULL)
  382.           return NULL;
  383.       x = O_write(self, args);
  384.       Py_DECREF(args);
  385.       return x;
  386.   }
  387. }
  388.  
  389. static struct PyMethodDef O_methods[] = {
  390.   {"write",     (PyCFunction)O_write,      METH_VARARGS, O_write__doc__},
  391.   {"read",       (PyCFunction)O_read,       METH_VARARGS, O_read__doc__},
  392.   {"readline",   (PyCFunction)O_readline,   METH_VARARGS, O_readline__doc__},
  393.   {"reset",      (PyCFunction)O_reset,      METH_VARARGS, O_reset__doc__},
  394.   {"seek",       (PyCFunction)O_seek,       METH_VARARGS, O_seek__doc__},
  395.   {"tell",       (PyCFunction)O_tell,       METH_VARARGS, O_tell__doc__},
  396.   {"getvalue",   (PyCFunction)O_getval,     METH_VARARGS, O_getval__doc__},
  397.   {"truncate",   (PyCFunction)O_truncate,   METH_VARARGS, O_truncate__doc__},
  398.   {"isatty",     (PyCFunction)O_isatty,     METH_VARARGS, O_isatty__doc__},
  399.   {"close",      (PyCFunction)O_close,      METH_VARARGS, O_close__doc__},
  400.   {"flush",      (PyCFunction)O_flush,      METH_VARARGS, O_flush__doc__},
  401.   {"writelines", (PyCFunction)O_writelines, METH_VARARGS, O_writelines__doc__},
  402.   {NULL,     NULL}        /* sentinel */
  403. };
  404.  
  405.  
  406. static void
  407. O_dealloc(Oobject *self) {
  408.   if (self->buf != NULL)
  409.     free(self->buf);
  410.   PyMem_DEL(self);
  411. }
  412.  
  413. static PyObject *
  414. O_getattr(Oobject *self, char *name) {
  415.   if (strcmp(name, "softspace") == 0) {
  416.       return PyInt_FromLong(self->softspace);
  417.   }
  418.   return Py_FindMethod(O_methods, (PyObject *)self, name);
  419. }
  420.  
  421. static int
  422. O_setattr(Oobject *self, char *name, PyObject *value) {
  423.     long x;
  424.     if (strcmp(name, "softspace") != 0) {
  425.         PyErr_SetString(PyExc_AttributeError, name);
  426.         return -1;
  427.     }
  428.     x = PyInt_AsLong(value);
  429.     if (x == -1 && PyErr_Occurred())
  430.         return -1;
  431.     self->softspace = x;
  432.     return 0;
  433. }
  434.  
  435. static char Otype__doc__[] = 
  436. "Simple type for output to strings."
  437. ;
  438.  
  439. static PyTypeObject Otype = {
  440.   PyObject_HEAD_INIT(NULL)
  441.   0,                   /*ob_size*/
  442.   "StringO",             /*tp_name*/
  443.   sizeof(Oobject),           /*tp_basicsize*/
  444.   0,                   /*tp_itemsize*/
  445.   /* methods */
  446.   (destructor)O_dealloc,    /*tp_dealloc*/
  447.   (printfunc)0,        /*tp_print*/
  448.   (getattrfunc)O_getattr,    /*tp_getattr*/
  449.   (setattrfunc)O_setattr,    /*tp_setattr*/
  450.   (cmpfunc)0,        /*tp_compare*/
  451.   (reprfunc)0,        /*tp_repr*/
  452.   0,            /*tp_as_number*/
  453.   0,            /*tp_as_sequence*/
  454.   0,            /*tp_as_mapping*/
  455.   (hashfunc)0,        /*tp_hash*/
  456.   (ternaryfunc)0,        /*tp_call*/
  457.   (reprfunc)0,        /*tp_str*/
  458.   
  459.   /* Space for future expansion */
  460.   0L,0L,0L,0L,
  461.   Otype__doc__         /* Documentation string */
  462. };
  463.  
  464. static PyObject *
  465. newOobject(int  size) {
  466.   Oobject *self;
  467.     
  468.   self = PyObject_NEW(Oobject, &Otype);
  469.   if (self == NULL)
  470.     return NULL;
  471.   self->pos=0;
  472.   self->string_size = 0;
  473.   self->softspace = 0;
  474.  
  475.   UNLESS(self->buf=malloc(size*sizeof(char))) {
  476.       PyErr_SetString(PyExc_MemoryError,"out of memory");
  477.       self->buf_size = 0;
  478.       return NULL;
  479.     }
  480.  
  481.   self->buf_size=size;
  482.   return (PyObject*)self;
  483. }
  484.  
  485. /* End of code for StringO objects */
  486. /* -------------------------------------------------------- */
  487.  
  488. static PyObject *
  489. I_close(Iobject *self, PyObject *args) {
  490.   Py_XDECREF(self->pbuf);
  491.   self->pbuf = NULL;
  492.  
  493.   self->pos = self->string_size = 0;
  494.  
  495.   Py_INCREF(Py_None);
  496.   return Py_None;
  497. }
  498.  
  499. static PyObject *
  500. I_seek(Oobject *self, PyObject *args) {
  501.   int position, mode = 0;
  502.  
  503.   UNLESS(PyArg_ParseTuple(args, "i|i", &position, &mode)) {
  504.     return NULL;
  505.   }
  506.  
  507.   if (mode == 2) {
  508.     position += self->string_size;
  509.   }
  510.   else if (mode == 1) {
  511.     position += self->pos;
  512.   }
  513.  
  514.   if(position < 0) position=0;
  515.   
  516.   self->pos=position;
  517.  
  518.   Py_INCREF(Py_None);
  519.   return Py_None;
  520. }
  521.  
  522. static struct PyMethodDef I_methods[] = {
  523.   {"read",    (PyCFunction)O_read,     METH_VARARGS, O_read__doc__},
  524.   {"readline",    (PyCFunction)O_readline, METH_VARARGS, O_readline__doc__},
  525.   {"reset",    (PyCFunction)O_reset,     METH_VARARGS, O_reset__doc__},
  526.   {"seek",      (PyCFunction)I_seek,     METH_VARARGS, O_seek__doc__},  
  527.   {"tell",      (PyCFunction)O_tell,     METH_VARARGS, O_tell__doc__},
  528.   {"getvalue",  (PyCFunction)O_getval,   METH_VARARGS, O_getval__doc__},
  529.   {"truncate",  (PyCFunction)O_truncate, METH_VARARGS, O_truncate__doc__},
  530.   {"isatty",    (PyCFunction)O_isatty,   METH_VARARGS, O_isatty__doc__},
  531.   {"close",     (PyCFunction)I_close,    METH_VARARGS, O_close__doc__},
  532.   {"flush",     (PyCFunction)O_flush,    METH_VARARGS, O_flush__doc__},
  533.   {NULL,    NULL}
  534. };
  535.  
  536. static void
  537. I_dealloc(Iobject *self) {
  538.   Py_XDECREF(self->pbuf);
  539.   PyMem_DEL(self);
  540. }
  541.  
  542. static PyObject *
  543. I_getattr(Iobject *self, char *name) {
  544.   return Py_FindMethod(I_methods, (PyObject *)self, name);
  545. }
  546.  
  547. static char Itype__doc__[] = 
  548. "Simple type for treating strings as input file streams"
  549. ;
  550.  
  551. static PyTypeObject Itype = {
  552.   PyObject_HEAD_INIT(NULL)
  553.   0,                   /*ob_size*/
  554.   "StringI",               /*tp_name*/
  555.   sizeof(Iobject),           /*tp_basicsize*/
  556.   0,                   /*tp_itemsize*/
  557.   /* methods */
  558.   (destructor)I_dealloc,    /*tp_dealloc*/
  559.   (printfunc)0,        /*tp_print*/
  560.   (getattrfunc)I_getattr,    /*tp_getattr*/
  561.   (setattrfunc)0,        /*tp_setattr*/
  562.   (cmpfunc)0,        /*tp_compare*/
  563.   (reprfunc)0,        /*tp_repr*/
  564.   0,            /*tp_as_number*/
  565.   0,            /*tp_as_sequence*/
  566.   0,            /*tp_as_mapping*/
  567.   (hashfunc)0,        /*tp_hash*/
  568.   (ternaryfunc)0,        /*tp_call*/
  569.   (reprfunc)0,        /*tp_str*/
  570.   
  571.   /* Space for future expansion */
  572.   0L,0L,0L,0L,
  573.   Itype__doc__         /* Documentation string */
  574. };
  575.  
  576. static PyObject *
  577. newIobject(PyObject *s) {
  578.   Iobject *self;
  579.   char *buf;
  580.   int size;
  581.     
  582.   UNLESS(buf=PyString_AsString(s)) return NULL;
  583.   UNLESS(-1 != (size=PyString_Size(s))) return NULL;
  584.   UNLESS(self = PyObject_NEW(Iobject, &Itype)) return NULL;
  585.   Py_INCREF(s);
  586.   self->buf=buf;
  587.   self->string_size=size;
  588.   self->pbuf=s;
  589.   self->pos=0;
  590.   
  591.   return (PyObject*)self;
  592. }
  593.  
  594. /* End of code for StringI objects */
  595. /* -------------------------------------------------------- */
  596.  
  597.  
  598. static char IO_StringIO__doc__[] =
  599. "StringIO([s]) -- Return a StringIO-like stream for reading or writing"
  600. ;
  601.  
  602. static PyObject *
  603. IO_StringIO(PyObject *self, PyObject *args) {
  604.   PyObject *s=0;
  605.  
  606.   UNLESS(PyArg_ParseTuple(args, "|O", &s)) return NULL;
  607.   if(s) return newIobject(s);
  608.   return newOobject(128);
  609. }
  610.  
  611. /* List of methods defined in the module */
  612.  
  613. static struct PyMethodDef IO_methods[] = {
  614.   {"StringIO",    (PyCFunction)IO_StringIO,    1,    IO_StringIO__doc__},
  615.   {NULL,        NULL}        /* sentinel */
  616. };
  617.  
  618.  
  619. /* Initialization function for the module (*must* be called initcStringIO) */
  620.  
  621. static struct PycStringIO_CAPI CAPI = {
  622.   O_cread,
  623.   O_creadline,
  624.   O_cwrite,
  625.   O_cgetval,
  626.   newOobject,
  627.   newIobject,
  628.   &Itype,
  629.   &Otype,
  630. };
  631.  
  632. #ifndef DL_EXPORT    /* declarations for DLL import/export */
  633. #define DL_EXPORT(RTYPE) RTYPE
  634. #endif
  635. DL_EXPORT(void)
  636. initcStringIO() {
  637.   PyObject *m, *d, *v;
  638.  
  639.  
  640.   /* Create the module and add the functions */
  641.   m = Py_InitModule4("cStringIO", IO_methods,
  642.              cStringIO_module_documentation,
  643.              (PyObject*)NULL,PYTHON_API_VERSION);
  644.  
  645.   /* Add some symbolic constants to the module */
  646.   d = PyModule_GetDict(m);
  647.   
  648.   /* Export C API */
  649.   Itype.ob_type=&PyType_Type;
  650.   Otype.ob_type=&PyType_Type;
  651.   PyDict_SetItemString(d,"cStringIO_CAPI",
  652.                v = PyCObject_FromVoidPtr(&CAPI,NULL));
  653.   Py_XDECREF(v);
  654.  
  655.   /* Export Types */
  656.   PyDict_SetItemString(d,"InputType",  (PyObject*)&Itype);
  657.   PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
  658.  
  659.   /* Maybe make certain warnings go away */
  660.   if(0) PycString_IMPORT;
  661.   
  662.   /* Check for errors */
  663.   if (PyErr_Occurred()) Py_FatalError("can't initialize module cStringIO");
  664. }
  665.