History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Modules/cStringIO.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Modules/cStringIO.c+745−0
@@ -0,0 +1,745 @@
1
2#include "Python.h"
3#include "import.h"
4#include "cStringIO.h"
5#include "structmember.h"
6
7PyDoc_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
44typedef 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
54typedef 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
65typedef 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
76PyDoc_STRVAR(IO_flush__doc__, "flush(): does nothing.");
77
78static int
79IO__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
88static PyObject *
89IO_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
99static PyGetSetDef file_getsetlist[] = {
100 {"closed", (getter)IO_get_closed, NULL, "True if the file is closed"},
101 {0},
102};
103
104static PyObject *
105IO_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
113PyDoc_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
119static PyObject *
120IO_cgetval(PyObject *self) {
121 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
122 return PyString_FromStringAndSize(((IOobject*)self)->buf,
123 ((IOobject*)self)->pos);
124}
125
126static PyObject *
127IO_getval(IOobject *self, PyObject *args) {
128 PyObject *use_pos=Py_None;
129 Py_ssize_t s;
130
131 if (!IO__opencheck(self)) return NULL;
132 if (!PyArg_UnpackTuple(args,"getval", 0, 1,&use_pos)) return NULL;
133
134 if (PyObject_IsTrue(use_pos)) {
135 s=self->pos;
136 if (s > self->string_size) s=self->string_size;
137 }
138 else
139 s=self->string_size;
140 return PyString_FromStringAndSize(self->buf, s);
141}
142
143PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
144
145static PyObject *
146IO_isatty(IOobject *self, PyObject *unused) {
147 if (!IO__opencheck(self)) return NULL;
148 Py_INCREF(Py_False);
149 return Py_False;
150}
151
152PyDoc_STRVAR(IO_read__doc__,
153"read([s]) -- Read s characters, or the rest of the string");
154
155static int
156IO_cread(PyObject *self, char **output, Py_ssize_t n) {
157 Py_ssize_t l;
158
159 if (!IO__opencheck(IOOOBJECT(self))) return -1;
160 l = ((IOobject*)self)->string_size - ((IOobject*)self)->pos;
161 if (n < 0 || n > l) {
162 n = l;
163 if (n < 0) n=0;
164 }
165
166 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
167 ((IOobject*)self)->pos += n;
168 return n;
169}
170
171static PyObject *
172IO_read(IOobject *self, PyObject *args) {
173 Py_ssize_t n = -1;
174 char *output = NULL;
175
176 if (!PyArg_ParseTuple(args, "|n:read", &n)) return NULL;
177
178 if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
179
180 return PyString_FromStringAndSize(output, n);
181}
182
183PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
184
185static int
186IO_creadline(PyObject *self, char **output) {
187 char *n, *s;
188 Py_ssize_t l;
189
190 if (!IO__opencheck(IOOOBJECT(self))) return -1;
191
192 for (n = ((IOobject*)self)->buf + ((IOobject*)self)->pos,
193 s = ((IOobject*)self)->buf + ((IOobject*)self)->string_size;
194 n < s && *n != '\n'; n++);
195 if (n < s) n++;
196
197 *output=((IOobject*)self)->buf + ((IOobject*)self)->pos;
198 l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos;
199 assert(((IOobject*)self)->pos + l < INT_MAX);
200 ((IOobject*)self)->pos += (int)l;
201 return (int)l;
202}
203
204static PyObject *
205IO_readline(IOobject *self, PyObject *args) {
206 int n, m=-1;
207 char *output;
208
209 if (args)
210 if (!PyArg_ParseTuple(args, "|i:readline", &m)) return NULL;
211
212 if( (n=IO_creadline((PyObject*)self,&output)) < 0) return NULL;
213 if (m >= 0 && m < n) {
214 m = n - m;
215 n -= m;
216 self->pos -= m;
217 }
218 return PyString_FromStringAndSize(output, n);
219}
220
221PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
222
223static PyObject *
224IO_readlines(IOobject *self, PyObject *args) {
225 int n;
226 char *output;
227 PyObject *result, *line;
228 int hint = 0, length = 0;
229
230 if (!PyArg_ParseTuple(args, "|i:readlines", &hint)) return NULL;
231
232 result = PyList_New(0);
233 if (!result)
234 return NULL;
235
236 while (1){
237 if ( (n = IO_creadline((PyObject*)self,&output)) < 0)
238 goto err;
239 if (n == 0)
240 break;
241 line = PyString_FromStringAndSize (output, n);
242 if (!line)
243 goto err;
244 if (PyList_Append (result, line) == -1) {
245 Py_DECREF (line);
246 goto err;
247 }
248 Py_DECREF (line);
249 length += n;
250 if (hint > 0 && length >= hint)
251 break;
252 }
253 return result;
254 err:
255 Py_DECREF(result);
256 return NULL;
257}
258
259PyDoc_STRVAR(IO_reset__doc__,
260"reset() -- Reset the file position to the beginning");
261
262static PyObject *
263IO_reset(IOobject *self, PyObject *unused) {
264
265 if (!IO__opencheck(self)) return NULL;
266
267 self->pos = 0;
268
269 Py_INCREF(Py_None);
270 return Py_None;
271}
272
273PyDoc_STRVAR(IO_tell__doc__, "tell() -- get the current position.");
274
275static PyObject *
276IO_tell(IOobject *self, PyObject *unused) {
277
278 if (!IO__opencheck(self)) return NULL;
279
280 return PyInt_FromSsize_t(self->pos);
281}
282
283PyDoc_STRVAR(IO_truncate__doc__,
284"truncate(): truncate the file at the current position.");
285
286static PyObject *
287IO_truncate(IOobject *self, PyObject *args) {
288 Py_ssize_t pos = -1;
289
290 if (!IO__opencheck(self)) return NULL;
291 if (!PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL;
292 if (pos < 0) pos = self->pos;
293
294 if (self->string_size > pos) self->string_size = pos;
295 self->pos = self->string_size;
296
297 Py_INCREF(Py_None);
298 return Py_None;
299}
300
301static PyObject *
302IO_iternext(Iobject *self)
303{
304 PyObject *next;
305 next = IO_readline((IOobject *)self, NULL);
306 if (!next)
307 return NULL;
308 if (!PyString_GET_SIZE(next)) {
309 Py_DECREF(next);
310 PyErr_SetNone(PyExc_StopIteration);
311 return NULL;
312 }
313 return next;
314}
315
316
317
318
319/* Read-write object methods */
320
321PyDoc_STRVAR(O_seek__doc__,
322"seek(position) -- set the current position\n"
323"seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF");
324
325static PyObject *
326O_seek(Oobject *self, PyObject *args) {
327 Py_ssize_t position;
328 int mode = 0;
329
330 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
331 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
332 return NULL;
333
334 if (mode == 2) {
335 position += self->string_size;
336 }
337 else if (mode == 1) {
338 position += self->pos;
339 }
340
341 if (position > self->buf_size) {
342 self->buf_size*=2;
343 if (self->buf_size <= position) self->buf_size=position+1;
344 self->buf = (char*) realloc(self->buf,self->buf_size);
345 if (!self->buf) {
346 self->buf_size=self->pos=0;
347 return PyErr_NoMemory();
348 }
349 }
350 else if (position < 0) position=0;
351
352 self->pos=position;
353
354 while (--position >= self->string_size) self->buf[position]=0;
355
356 Py_INCREF(Py_None);
357 return Py_None;
358}
359
360PyDoc_STRVAR(O_write__doc__,
361"write(s) -- Write a string to the file"
362"\n\nNote (hack:) writing None resets the buffer");
363
364
365static int
366O_cwrite(PyObject *self, const char *c, Py_ssize_t l) {
367 Py_ssize_t newl;
368 Oobject *oself;
369
370 if (!IO__opencheck(IOOOBJECT(self))) return -1;
371 oself = (Oobject *)self;
372
373 newl = oself->pos+l;
374 if (newl >= oself->buf_size) {
375 oself->buf_size *= 2;
376 if (oself->buf_size <= newl) {
377 assert(newl + 1 < INT_MAX);
378 oself->buf_size = (int)(newl+1);
379 }
380 oself->buf = (char*)realloc(oself->buf, oself->buf_size);
381 if (!oself->buf) {
382 PyErr_SetString(PyExc_MemoryError,"out of memory");
383 oself->buf_size = oself->pos = 0;
384 return -1;
385 }
386 }
387
388 memcpy(oself->buf+oself->pos,c,l);
389
390 assert(oself->pos + l < INT_MAX);
391 oself->pos += (int)l;
392
393 if (oself->string_size < oself->pos) {
394 oself->string_size = oself->pos;
395 }
396
397 return (int)l;
398}
399
400static PyObject *
401O_write(Oobject *self, PyObject *args) {
402 char *c;
403 int l;
404
405 if (!PyArg_ParseTuple(args, "t#:write", &c, &l)) return NULL;
406
407 if (O_cwrite((PyObject*)self,c,l) < 0) return NULL;
408
409 Py_INCREF(Py_None);
410 return Py_None;
411}
412
413PyDoc_STRVAR(O_close__doc__, "close(): explicitly release resources held.");
414
415static PyObject *
416O_close(Oobject *self, PyObject *unused) {
417 if (self->buf != NULL) free(self->buf);
418 self->buf = NULL;
419
420 self->pos = self->string_size = self->buf_size = 0;
421
422 Py_INCREF(Py_None);
423 return Py_None;
424}
425
426PyDoc_STRVAR(O_writelines__doc__,
427"writelines(sequence_of_strings) -> None. Write the strings to the file.\n"
428"\n"
429"Note that newlines are not added. The sequence can be any iterable object\n"
430"producing strings. This is equivalent to calling write() for each string.");
431static PyObject *
432O_writelines(Oobject *self, PyObject *args) {
433 PyObject *it, *s;
434
435 it = PyObject_GetIter(args);
436 if (it == NULL)
437 return NULL;
438 while ((s = PyIter_Next(it)) != NULL) {
439 Py_ssize_t n;
440 char *c;
441 if (PyString_AsStringAndSize(s, &c, &n) == -1) {
442 Py_DECREF(it);
443 Py_DECREF(s);
444 return NULL;
445 }
446 if (O_cwrite((PyObject *)self, c, n) == -1) {
447 Py_DECREF(it);
448 Py_DECREF(s);
449 return NULL;
450 }
451 Py_DECREF(s);
452 }
453
454 Py_DECREF(it);
455
456 /* See if PyIter_Next failed */
457 if (PyErr_Occurred())
458 return NULL;
459
460 Py_RETURN_NONE;
461}
462static struct PyMethodDef O_methods[] = {
463 /* Common methods: */
464 {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
465 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
466 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
467 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
468 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
469 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
470 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
471 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
472 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
473
474 /* Read-write StringIO specific methods: */
475 {"close", (PyCFunction)O_close, METH_NOARGS, O_close__doc__},
476 {"seek", (PyCFunction)O_seek, METH_VARARGS, O_seek__doc__},
477 {"write", (PyCFunction)O_write, METH_VARARGS, O_write__doc__},
478 {"writelines", (PyCFunction)O_writelines, METH_O, O_writelines__doc__},
479 {NULL, NULL} /* sentinel */
480};
481
482static PyMemberDef O_memberlist[] = {
483 {"softspace", T_INT, offsetof(Oobject, softspace), 0,
484 "flag indicating that a space needs to be printed; used by print"},
485 /* getattr(f, "closed") is implemented without this table */
486 {NULL} /* Sentinel */
487};
488
489static void
490O_dealloc(Oobject *self) {
491 if (self->buf != NULL)
492 free(self->buf);
493 PyObject_Del(self);
494}
495
496PyDoc_STRVAR(Otype__doc__, "Simple type for output to strings.");
497
498static PyTypeObject Otype = {
499 PyObject_HEAD_INIT(NULL)
500 0, /*ob_size*/
501 "cStringIO.StringO", /*tp_name*/
502 sizeof(Oobject), /*tp_basicsize*/
503 0, /*tp_itemsize*/
504 /* methods */
505 (destructor)O_dealloc, /*tp_dealloc*/
506 0, /*tp_print*/
507 0, /*tp_getattr */
508 0, /*tp_setattr */
509 0, /*tp_compare*/
510 0, /*tp_repr*/
511 0, /*tp_as_number*/
512 0, /*tp_as_sequence*/
513 0, /*tp_as_mapping*/
514 0, /*tp_hash*/
515 0 , /*tp_call*/
516 0, /*tp_str*/
517 0, /*tp_getattro */
518 0, /*tp_setattro */
519 0, /*tp_as_buffer */
520 Py_TPFLAGS_DEFAULT, /*tp_flags*/
521 Otype__doc__, /*tp_doc */
522 0, /*tp_traverse */
523 0, /*tp_clear */
524 0, /*tp_richcompare */
525 0, /*tp_weaklistoffset */
526 PyObject_SelfIter, /*tp_iter */
527 (iternextfunc)IO_iternext, /*tp_iternext */
528 O_methods, /*tp_methods */
529 O_memberlist, /*tp_members */
530 file_getsetlist, /*tp_getset */
531};
532
533static PyObject *
534newOobject(int size) {
535 Oobject *self;
536
537 self = PyObject_New(Oobject, &Otype);
538 if (self == NULL)
539 return NULL;
540 self->pos=0;
541 self->string_size = 0;
542 self->softspace = 0;
543
544 self->buf = (char *)malloc(size);
545 if (!self->buf) {
546 PyErr_SetString(PyExc_MemoryError,"out of memory");
547 self->buf_size = 0;
548 Py_DECREF(self);
549 return NULL;
550 }
551
552 self->buf_size=size;
553 return (PyObject*)self;
554}
555
556/* End of code for StringO objects */
557/* -------------------------------------------------------- */
558
559static PyObject *
560I_close(Iobject *self, PyObject *unused) {
561 Py_XDECREF(self->pbuf);
562 self->pbuf = NULL;
563 self->buf = NULL;
564
565 self->pos = self->string_size = 0;
566
567 Py_INCREF(Py_None);
568 return Py_None;
569}
570
571static PyObject *
572I_seek(Iobject *self, PyObject *args) {
573 Py_ssize_t position;
574 int mode = 0;
575
576 if (!IO__opencheck(IOOOBJECT(self))) return NULL;
577 if (!PyArg_ParseTuple(args, "n|i:seek", &position, &mode))
578 return NULL;
579
580 if (mode == 2) position += self->string_size;
581 else if (mode == 1) position += self->pos;
582
583 if (position < 0) position=0;
584
585 self->pos=position;
586
587 Py_INCREF(Py_None);
588 return Py_None;
589}
590
591static struct PyMethodDef I_methods[] = {
592 /* Common methods: */
593 {"flush", (PyCFunction)IO_flush, METH_NOARGS, IO_flush__doc__},
594 {"getvalue", (PyCFunction)IO_getval, METH_VARARGS, IO_getval__doc__},
595 {"isatty", (PyCFunction)IO_isatty, METH_NOARGS, IO_isatty__doc__},
596 {"read", (PyCFunction)IO_read, METH_VARARGS, IO_read__doc__},
597 {"readline", (PyCFunction)IO_readline, METH_VARARGS, IO_readline__doc__},
598 {"readlines", (PyCFunction)IO_readlines,METH_VARARGS, IO_readlines__doc__},
599 {"reset", (PyCFunction)IO_reset, METH_NOARGS, IO_reset__doc__},
600 {"tell", (PyCFunction)IO_tell, METH_NOARGS, IO_tell__doc__},
601 {"truncate", (PyCFunction)IO_truncate, METH_VARARGS, IO_truncate__doc__},
602
603 /* Read-only StringIO specific methods: */
604 {"close", (PyCFunction)I_close, METH_NOARGS, O_close__doc__},
605 {"seek", (PyCFunction)I_seek, METH_VARARGS, O_seek__doc__},
606 {NULL, NULL}
607};
608
609static void
610I_dealloc(Iobject *self) {
611 Py_XDECREF(self->pbuf);
612 PyObject_Del(self);
613}
614
615
616PyDoc_STRVAR(Itype__doc__,
617"Simple type for treating strings as input file streams");
618
619static PyTypeObject Itype = {
620 PyObject_HEAD_INIT(NULL)
621 0, /*ob_size*/
622 "cStringIO.StringI", /*tp_name*/
623 sizeof(Iobject), /*tp_basicsize*/
624 0, /*tp_itemsize*/
625 /* methods */
626 (destructor)I_dealloc, /*tp_dealloc*/
627 0, /*tp_print*/
628 0, /* tp_getattr */
629 0, /*tp_setattr*/
630 0, /*tp_compare*/
631 0, /*tp_repr*/
632 0, /*tp_as_number*/
633 0, /*tp_as_sequence*/
634 0, /*tp_as_mapping*/
635 0, /*tp_hash*/
636 0, /*tp_call*/
637 0, /*tp_str*/
638 0, /* tp_getattro */
639 0, /* tp_setattro */
640 0, /* tp_as_buffer */
641 Py_TPFLAGS_DEFAULT, /* tp_flags */
642 Itype__doc__, /* tp_doc */
643 0, /* tp_traverse */
644 0, /* tp_clear */
645 0, /* tp_richcompare */
646 0, /* tp_weaklistoffset */
647 PyObject_SelfIter, /* tp_iter */
648 (iternextfunc)IO_iternext, /* tp_iternext */
649 I_methods, /* tp_methods */
650 0, /* tp_members */
651 file_getsetlist, /* tp_getset */
652};
653
654static PyObject *
655newIobject(PyObject *s) {
656 Iobject *self;
657 char *buf;
658 Py_ssize_t size;
659
660 if (PyObject_AsCharBuffer(s, (const char **)&buf, &size) != 0)
661 return NULL;
662
663 self = PyObject_New(Iobject, &Itype);
664 if (!self) return NULL;
665 Py_INCREF(s);
666 self->buf=buf;
667 self->string_size=size;
668 self->pbuf=s;
669 self->pos=0;
670
671 return (PyObject*)self;
672}
673
674/* End of code for StringI objects */
675/* -------------------------------------------------------- */
676
677
678PyDoc_STRVAR(IO_StringIO__doc__,
679"StringIO([s]) -- Return a StringIO-like stream for reading or writing");
680
681static PyObject *
682IO_StringIO(PyObject *self, PyObject *args) {
683 PyObject *s=0;
684
685 if (!PyArg_UnpackTuple(args, "StringIO", 0, 1, &s)) return NULL;
686
687 if (s) return newIobject(s);
688 return newOobject(128);
689}
690
691/* List of methods defined in the module */
692
693static struct PyMethodDef IO_methods[] = {
694 {"StringIO", (PyCFunction)IO_StringIO,
695 METH_VARARGS, IO_StringIO__doc__},
696 {NULL, NULL} /* sentinel */
697};
698
699
700/* Initialization function for the module (*must* be called initcStringIO) */
701
702static struct PycStringIO_CAPI CAPI = {
703 IO_cread,
704 IO_creadline,
705 O_cwrite,
706 IO_cgetval,
707 newOobject,
708 newIobject,
709 &Itype,
710 &Otype,
711};
712
713#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
714#define PyMODINIT_FUNC void
715#endif
716PyMODINIT_FUNC
717initcStringIO(void) {
718 PyObject *m, *d, *v;
719
720
721 /* Create the module and add the functions */
722 m = Py_InitModule4("cStringIO", IO_methods,
723 cStringIO_module_documentation,
724 (PyObject*)NULL,PYTHON_API_VERSION);
725 if (m == NULL) return;
726
727 /* Add some symbolic constants to the module */
728 d = PyModule_GetDict(m);
729
730 /* Export C API */
731 Itype.ob_type=&PyType_Type;
732 Otype.ob_type=&PyType_Type;
733 if (PyType_Ready(&Otype) < 0) return;
734 if (PyType_Ready(&Itype) < 0) return;
735 PyDict_SetItemString(d,"cStringIO_CAPI",
736 v = PyCObject_FromVoidPtr(&CAPI,NULL));
737 Py_XDECREF(v);
738
739 /* Export Types */
740 PyDict_SetItemString(d,"InputType", (PyObject*)&Itype);
741 PyDict_SetItemString(d,"OutputType", (PyObject*)&Otype);
742
743 /* Maybe make certain warnings go away */
744 if (0) PycString_IMPORT;
745}