[Python-checkins] r73385 - in python/branches/py3k/Modules/_io: _iomodule.c _iomodule.h bufferedio.c bytesio.c fileio.c iobase.c stringio.c textio.c
benjamin.peterson
python-checkins at python.org
Fri Jun 12 04:07:12 CEST 2009
Author: benjamin.peterson
Date: Fri Jun 12 04:07:12 2009
New Revision: 73385
Log:
move to a naming scheme with all lowercase and underscores
Modified:
python/branches/py3k/Modules/_io/_iomodule.c
python/branches/py3k/Modules/_io/_iomodule.h
python/branches/py3k/Modules/_io/bufferedio.c
python/branches/py3k/Modules/_io/bytesio.c
python/branches/py3k/Modules/_io/fileio.c
python/branches/py3k/Modules/_io/iobase.c
python/branches/py3k/Modules/_io/stringio.c
python/branches/py3k/Modules/_io/textio.c
Modified: python/branches/py3k/Modules/_io/_iomodule.c
==============================================================================
--- python/branches/py3k/Modules/_io/_iomodule.c (original)
+++ python/branches/py3k/Modules/_io/_iomodule.c Fri Jun 12 04:07:12 2009
@@ -94,7 +94,7 @@
*/
static int
-BlockingIOError_init(PyBlockingIOErrorObject *self, PyObject *args,
+blockingioerror_init(PyBlockingIOErrorObject *self, PyObject *args,
PyObject *kwds)
{
PyObject *myerrno = NULL, *strerror = NULL;
@@ -123,7 +123,7 @@
return 0;
}
-static PyMemberDef BlockingIOError_members[] = {
+static PyMemberDef blockingioerror_members[] = {
{"characters_written", T_PYSSIZET, offsetof(PyBlockingIOErrorObject, written), 0},
{NULL} /* Sentinel */
};
@@ -158,14 +158,14 @@
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
- BlockingIOError_members, /* tp_members */
+ blockingioerror_members, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
- (initproc)BlockingIOError_init, /* tp_init */
+ (initproc)blockingioerror_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};
Modified: python/branches/py3k/Modules/_io/_iomodule.h
==============================================================================
--- python/branches/py3k/Modules/_io/_iomodule.h (original)
+++ python/branches/py3k/Modules/_io/_iomodule.h Fri Jun 12 04:07:12 2009
@@ -23,10 +23,10 @@
* with args=NULL, and return a new reference.
* BUT when args=Py_True is passed, they return a borrowed reference.
*/
-extern PyObject* _PyIOBase_checkReadable(PyObject *self, PyObject *args);
-extern PyObject* _PyIOBase_checkWritable(PyObject *self, PyObject *args);
-extern PyObject* _PyIOBase_checkSeekable(PyObject *self, PyObject *args);
-extern PyObject* _PyIOBase_checkClosed(PyObject *self, PyObject *args);
+extern PyObject* _PyIOBase_check_readable(PyObject *self, PyObject *args);
+extern PyObject* _PyIOBase_check_writable(PyObject *self, PyObject *args);
+extern PyObject* _PyIOBase_check_seekable(PyObject *self, PyObject *args);
+extern PyObject* _PyIOBase_check_closed(PyObject *self, PyObject *args);
/* Helper for finalization.
This function will revive an object ready to be deallocated and try to
Modified: python/branches/py3k/Modules/_io/bufferedio.c
==============================================================================
--- python/branches/py3k/Modules/_io/bufferedio.c (original)
+++ python/branches/py3k/Modules/_io/bufferedio.c Fri Jun 12 04:07:12 2009
@@ -16,7 +16,7 @@
/*
* BufferedIOBase class, inherits from IOBase.
*/
-PyDoc_STRVAR(BufferedIOBase_doc,
+PyDoc_STRVAR(bufferediobase_doc,
"Base class for buffered IO objects.\n"
"\n"
"The main difference with RawIOBase is that the read() method\n"
@@ -33,7 +33,7 @@
);
static PyObject *
-BufferedIOBase_readinto(PyObject *self, PyObject *args)
+bufferediobase_readinto(PyObject *self, PyObject *args)
{
Py_buffer buf;
Py_ssize_t len;
@@ -67,25 +67,25 @@
}
static PyObject *
-BufferedIOBase_unsupported(const char *message)
+bufferediobase_unsupported(const char *message)
{
PyErr_SetString(IO_STATE->unsupported_operation, message);
return NULL;
}
-PyDoc_STRVAR(BufferedIOBase_detach_doc,
+PyDoc_STRVAR(bufferediobase_detach_doc,
"Disconnect this buffer from its underlying raw stream and return it.\n"
"\n"
"After the raw stream has been detached, the buffer is in an unusable\n"
"state.\n");
static PyObject *
-BufferedIOBase_detach(PyObject *self)
+bufferediobase_detach(PyObject *self)
{
- return BufferedIOBase_unsupported("detach");
+ return bufferediobase_unsupported("detach");
}
-PyDoc_STRVAR(BufferedIOBase_read_doc,
+PyDoc_STRVAR(bufferediobase_read_doc,
"Read and return up to n bytes.\n"
"\n"
"If the argument is omitted, None, or negative, reads and\n"
@@ -104,12 +104,12 @@
"mode and no data is available at the moment.\n");
static PyObject *
-BufferedIOBase_read(PyObject *self, PyObject *args)
+bufferediobase_read(PyObject *self, PyObject *args)
{
- return BufferedIOBase_unsupported("read");
+ return bufferediobase_unsupported("read");
}
-PyDoc_STRVAR(BufferedIOBase_read1_doc,
+PyDoc_STRVAR(bufferediobase_read1_doc,
"Read and return up to n bytes, with at most one read() call\n"
"to the underlying raw stream. A short result does not imply\n"
"that EOF is imminent.\n"
@@ -117,12 +117,12 @@
"Returns an empty bytes object on EOF.\n");
static PyObject *
-BufferedIOBase_read1(PyObject *self, PyObject *args)
+bufferediobase_read1(PyObject *self, PyObject *args)
{
- return BufferedIOBase_unsupported("read1");
+ return bufferediobase_unsupported("read1");
}
-PyDoc_STRVAR(BufferedIOBase_write_doc,
+PyDoc_STRVAR(bufferediobase_write_doc,
"Write the given buffer to the IO stream.\n"
"\n"
"Returns the number of bytes written, which is never less than\n"
@@ -132,18 +132,18 @@
"underlying raw stream cannot accept more data at the moment.\n");
static PyObject *
-BufferedIOBase_write(PyObject *self, PyObject *args)
+bufferediobase_write(PyObject *self, PyObject *args)
{
- return BufferedIOBase_unsupported("write");
+ return bufferediobase_unsupported("write");
}
-static PyMethodDef BufferedIOBase_methods[] = {
- {"detach", (PyCFunction)BufferedIOBase_detach, METH_NOARGS, BufferedIOBase_detach_doc},
- {"read", BufferedIOBase_read, METH_VARARGS, BufferedIOBase_read_doc},
- {"read1", BufferedIOBase_read1, METH_VARARGS, BufferedIOBase_read1_doc},
- {"readinto", BufferedIOBase_readinto, METH_VARARGS, NULL},
- {"write", BufferedIOBase_write, METH_VARARGS, BufferedIOBase_write_doc},
+static PyMethodDef bufferediobase_methods[] = {
+ {"detach", (PyCFunction)bufferediobase_detach, METH_NOARGS, bufferediobase_detach_doc},
+ {"read", bufferediobase_read, METH_VARARGS, bufferediobase_read_doc},
+ {"read1", bufferediobase_read1, METH_VARARGS, bufferediobase_read1_doc},
+ {"readinto", bufferediobase_readinto, METH_VARARGS, NULL},
+ {"write", bufferediobase_write, METH_VARARGS, bufferediobase_write_doc},
{NULL, NULL}
};
@@ -168,14 +168,14 @@
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
- BufferedIOBase_doc, /* tp_doc */
+ bufferediobase_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
- BufferedIOBase_methods, /* tp_methods */
+ bufferediobase_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
&PyIOBase_Type, /* tp_base */
@@ -231,7 +231,7 @@
PyObject *dict;
PyObject *weakreflist;
-} BufferedObject;
+} buffered;
/*
Implementation notes:
@@ -245,19 +245,18 @@
* The absolute position of the raw stream is cached, if possible, in the
`abs_pos` member. It must be updated every time an operation is done
on the raw stream. If not sure, it can be reinitialized by calling
- _Buffered_raw_tell(), which queries the raw stream (_Buffered_raw_seek()
+ _buffered_raw_tell(), which queries the raw stream (_buffered_raw_seek()
also does it). To read it, use RAW_TELL().
- * Three helpers, _BufferedReader_raw_read, _BufferedWriter_raw_write and
- _BufferedWriter_flush_unlocked do a lot of useful housekeeping.
+ * Three helpers, _bufferedreader_raw_read, _bufferedwriter_raw_write and
+ _bufferedwriter_flush_unlocked do a lot of useful housekeeping.
NOTE: we should try to maintain block alignment of reads and writes to the
raw stream (according to the buffer size), but for now it is only done
in read() and friends.
- XXX: method naming is a bit messy.
*/
-/* These macros protect the BufferedObject against concurrent operations. */
+/* These macros protect the buffered object against concurrent operations. */
#ifdef WITH_THREAD
#define ENTER_BUFFERED(self) \
@@ -299,7 +298,7 @@
#define IS_CLOSED(self) \
(self->fast_closed_checks \
? _PyFileIO_closed(self->raw) \
- : BufferedIOMixin_closed(self))
+ : buffered_closed(self))
#define CHECK_CLOSED(self, error_msg) \
if (IS_CLOSED(self)) { \
@@ -330,7 +329,7 @@
&& self->raw_pos >= 0) ? self->raw_pos - self->pos : 0)
#define RAW_TELL(self) \
- (self->abs_pos != -1 ? self->abs_pos : _Buffered_raw_tell(self))
+ (self->abs_pos != -1 ? self->abs_pos : _buffered_raw_tell(self))
#define MINUS_LAST_BLOCK(self, size) \
(self->buffer_mask ? \
@@ -339,7 +338,7 @@
static void
-BufferedObject_dealloc(BufferedObject *self)
+buffered_dealloc(buffered *self)
{
if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
return;
@@ -363,7 +362,7 @@
}
static int
-Buffered_traverse(BufferedObject *self, visitproc visit, void *arg)
+buffered_traverse(buffered *self, visitproc visit, void *arg)
{
Py_VISIT(self->raw);
Py_VISIT(self->dict);
@@ -371,7 +370,7 @@
}
static int
-Buffered_clear(BufferedObject *self)
+buffered_clear(buffered *self)
{
if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
return -1;
@@ -390,14 +389,14 @@
/* Flush and close */
static PyObject *
-BufferedIOMixin_flush(BufferedObject *self, PyObject *args)
+buffered_simple_flush(buffered *self, PyObject *args)
{
CHECK_INITIALIZED(self)
return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_flush, NULL);
}
static int
-BufferedIOMixin_closed(BufferedObject *self)
+buffered_closed(buffered *self)
{
int closed;
PyObject *res;
@@ -411,14 +410,14 @@
}
static PyObject *
-BufferedIOMixin_closed_get(BufferedObject *self, void *context)
+buffered_closed_get(buffered *self, void *context)
{
CHECK_INITIALIZED(self)
return PyObject_GetAttr(self->raw, _PyIO_str_closed);
}
static PyObject *
-BufferedIOMixin_close(BufferedObject *self, PyObject *args)
+buffered_close(buffered *self, PyObject *args)
{
PyObject *res = NULL;
int r;
@@ -426,7 +425,7 @@
CHECK_INITIALIZED(self)
ENTER_BUFFERED(self)
- r = BufferedIOMixin_closed(self);
+ r = buffered_closed(self);
if (r < 0)
goto end;
if (r > 0) {
@@ -457,7 +456,7 @@
/* detach */
static PyObject *
-BufferedIOMixin_detach(BufferedObject *self, PyObject *args)
+buffered_detach(buffered *self, PyObject *args)
{
PyObject *raw, *res;
CHECK_INITIALIZED(self)
@@ -475,35 +474,35 @@
/* Inquiries */
static PyObject *
-BufferedIOMixin_seekable(BufferedObject *self, PyObject *args)
+buffered_seekable(buffered *self, PyObject *args)
{
CHECK_INITIALIZED(self)
return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_seekable, NULL);
}
static PyObject *
-BufferedIOMixin_readable(BufferedObject *self, PyObject *args)
+buffered_readable(buffered *self, PyObject *args)
{
CHECK_INITIALIZED(self)
return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_readable, NULL);
}
static PyObject *
-BufferedIOMixin_writable(BufferedObject *self, PyObject *args)
+buffered_writable(buffered *self, PyObject *args)
{
CHECK_INITIALIZED(self)
return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_writable, NULL);
}
static PyObject *
-BufferedIOMixin_name_get(BufferedObject *self, void *context)
+buffered_name_get(buffered *self, void *context)
{
CHECK_INITIALIZED(self)
return PyObject_GetAttrString(self->raw, "name");
}
static PyObject *
-BufferedIOMixin_mode_get(BufferedObject *self, void *context)
+buffered_mode_get(buffered *self, void *context)
{
CHECK_INITIALIZED(self)
return PyObject_GetAttrString(self->raw, "mode");
@@ -512,14 +511,14 @@
/* Lower-level APIs */
static PyObject *
-BufferedIOMixin_fileno(BufferedObject *self, PyObject *args)
+buffered_fileno(buffered *self, PyObject *args)
{
CHECK_INITIALIZED(self)
return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_fileno, NULL);
}
static PyObject *
-BufferedIOMixin_isatty(BufferedObject *self, PyObject *args)
+buffered_isatty(buffered *self, PyObject *args)
{
CHECK_INITIALIZED(self)
return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_isatty, NULL);
@@ -528,21 +527,21 @@
/* Forward decls */
static PyObject *
-_BufferedWriter_flush_unlocked(BufferedObject *, int);
+_bufferedwriter_flush_unlocked(buffered *, int);
static Py_ssize_t
-_BufferedReader_fill_buffer(BufferedObject *self);
+_bufferedreader_fill_buffer(buffered *self);
static void
-_BufferedReader_reset_buf(BufferedObject *self);
+_bufferedreader_reset_buf(buffered *self);
static void
-_BufferedWriter_reset_buf(BufferedObject *self);
+_bufferedwriter_reset_buf(buffered *self);
static PyObject *
-_BufferedReader_peek_unlocked(BufferedObject *self, Py_ssize_t);
+_bufferedreader_peek_unlocked(buffered *self, Py_ssize_t);
static PyObject *
-_BufferedReader_read_all(BufferedObject *self);
+_bufferedreader_read_all(buffered *self);
static PyObject *
-_BufferedReader_read_fast(BufferedObject *self, Py_ssize_t);
+_bufferedreader_read_fast(buffered *self, Py_ssize_t);
static PyObject *
-_BufferedReader_read_generic(BufferedObject *self, Py_ssize_t);
+_bufferedreader_read_generic(buffered *self, Py_ssize_t);
/*
@@ -552,7 +551,7 @@
/* Returns the address of the `written` member if a BlockingIOError was
raised, NULL otherwise. The error is always re-raised. */
static Py_ssize_t *
-_Buffered_check_blocking_error(void)
+_buffered_check_blocking_error(void)
{
PyObject *t, *v, *tb;
PyBlockingIOErrorObject *err;
@@ -569,7 +568,7 @@
}
static Py_off_t
-_Buffered_raw_tell(BufferedObject *self)
+_buffered_raw_tell(buffered *self)
{
Py_off_t n;
PyObject *res;
@@ -589,7 +588,7 @@
}
static Py_off_t
-_Buffered_raw_seek(BufferedObject *self, Py_off_t target, int whence)
+_buffered_raw_seek(buffered *self, Py_off_t target, int whence)
{
PyObject *res, *posobj, *whenceobj;
Py_off_t n;
@@ -621,7 +620,7 @@
}
static int
-_Buffered_init(BufferedObject *self)
+_buffered_init(buffered *self)
{
Py_ssize_t n;
if (self->buffer_size <= 0) {
@@ -651,7 +650,7 @@
self->buffer_mask = self->buffer_size - 1;
else
self->buffer_mask = 0;
- if (_Buffered_raw_tell(self) == -1)
+ if (_buffered_raw_tell(self) == -1)
PyErr_Clear();
return 0;
}
@@ -661,7 +660,7 @@
*/
static PyObject *
-Buffered_flush(BufferedObject *self, PyObject *args)
+buffered_flush(buffered *self, PyObject *args)
{
PyObject *res;
@@ -669,15 +668,15 @@
CHECK_CLOSED(self, "flush of closed file")
ENTER_BUFFERED(self)
- res = _BufferedWriter_flush_unlocked(self, 0);
+ res = _bufferedwriter_flush_unlocked(self, 0);
if (res != NULL && self->readable) {
/* Rewind the raw stream so that its position corresponds to
the current logical position. */
Py_off_t n;
- n = _Buffered_raw_seek(self, -RAW_OFFSET(self), 1);
+ n = _buffered_raw_seek(self, -RAW_OFFSET(self), 1);
if (n == -1)
Py_CLEAR(res);
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
}
LEAVE_BUFFERED(self)
@@ -685,7 +684,7 @@
}
static PyObject *
-Buffered_peek(BufferedObject *self, PyObject *args)
+buffered_peek(buffered *self, PyObject *args)
{
Py_ssize_t n = 0;
PyObject *res = NULL;
@@ -698,12 +697,12 @@
ENTER_BUFFERED(self)
if (self->writable) {
- res = _BufferedWriter_flush_unlocked(self, 1);
+ res = _bufferedwriter_flush_unlocked(self, 1);
if (res == NULL)
goto end;
Py_CLEAR(res);
}
- res = _BufferedReader_peek_unlocked(self, n);
+ res = _bufferedreader_peek_unlocked(self, n);
end:
LEAVE_BUFFERED(self)
@@ -711,7 +710,7 @@
}
static PyObject *
-Buffered_read(BufferedObject *self, PyObject *args)
+buffered_read(buffered *self, PyObject *args)
{
Py_ssize_t n = -1;
PyObject *res;
@@ -731,15 +730,15 @@
if (n == -1) {
/* The number of bytes is unspecified, read until the end of stream */
ENTER_BUFFERED(self)
- res = _BufferedReader_read_all(self);
+ res = _bufferedreader_read_all(self);
LEAVE_BUFFERED(self)
}
else {
- res = _BufferedReader_read_fast(self, n);
+ res = _bufferedreader_read_fast(self, n);
if (res == Py_None) {
Py_DECREF(res);
ENTER_BUFFERED(self)
- res = _BufferedReader_read_generic(self, n);
+ res = _bufferedreader_read_generic(self, n);
LEAVE_BUFFERED(self)
}
}
@@ -748,7 +747,7 @@
}
static PyObject *
-Buffered_read1(BufferedObject *self, PyObject *args)
+buffered_read1(buffered *self, PyObject *args)
{
Py_ssize_t n, have, r;
PyObject *res = NULL;
@@ -769,7 +768,7 @@
ENTER_BUFFERED(self)
if (self->writable) {
- res = _BufferedWriter_flush_unlocked(self, 1);
+ res = _bufferedwriter_flush_unlocked(self, 1);
if (res == NULL)
goto end;
Py_CLEAR(res);
@@ -795,8 +794,8 @@
}
/* Fill the buffer from the raw stream, and copy it to the result. */
- _BufferedReader_reset_buf(self);
- r = _BufferedReader_fill_buffer(self);
+ _bufferedreader_reset_buf(self);
+ r = _bufferedreader_fill_buffer(self);
if (r == -1)
goto end;
if (r == -2)
@@ -814,7 +813,7 @@
}
static PyObject *
-Buffered_readinto(BufferedObject *self, PyObject *args)
+buffered_readinto(buffered *self, PyObject *args)
{
PyObject *res = NULL;
@@ -823,20 +822,20 @@
/* TODO: use raw.readinto() instead! */
if (self->writable) {
ENTER_BUFFERED(self)
- res = _BufferedWriter_flush_unlocked(self, 0);
+ res = _bufferedwriter_flush_unlocked(self, 0);
LEAVE_BUFFERED(self)
if (res == NULL)
goto end;
Py_DECREF(res);
}
- res = BufferedIOBase_readinto((PyObject *)self, args);
+ res = bufferediobase_readinto((PyObject *)self, args);
end:
return res;
}
static PyObject *
-_Buffered_readline(BufferedObject *self, Py_ssize_t limit)
+_buffered_readline(buffered *self, Py_ssize_t limit)
{
PyObject *res = NULL;
PyObject *chunks = NULL;
@@ -870,7 +869,7 @@
/* Now we try to get some more from the raw stream */
if (self->writable) {
- res = _BufferedWriter_flush_unlocked(self, 1);
+ res = _bufferedwriter_flush_unlocked(self, 1);
if (res == NULL)
goto end;
Py_CLEAR(res);
@@ -893,8 +892,8 @@
}
for (;;) {
- _BufferedReader_reset_buf(self);
- n = _BufferedReader_fill_buffer(self);
+ _bufferedreader_reset_buf(self);
+ n = _bufferedreader_fill_buffer(self);
if (n == -1)
goto end;
if (n <= 0)
@@ -945,7 +944,7 @@
}
static PyObject *
-Buffered_readline(BufferedObject *self, PyObject *args)
+buffered_readline(buffered *self, PyObject *args)
{
Py_ssize_t limit = -1;
@@ -954,17 +953,17 @@
if (!PyArg_ParseTuple(args, "|n:readline", &limit)) {
return NULL;
}
- return _Buffered_readline(self, limit);
+ return _buffered_readline(self, limit);
}
static PyObject *
-Buffered_tell(BufferedObject *self, PyObject *args)
+buffered_tell(buffered *self, PyObject *args)
{
Py_off_t pos;
CHECK_INITIALIZED(self)
- pos = _Buffered_raw_tell(self);
+ pos = _buffered_raw_tell(self);
if (pos == -1)
return NULL;
pos -= RAW_OFFSET(self);
@@ -973,7 +972,7 @@
}
static PyObject *
-Buffered_seek(BufferedObject *self, PyObject *args)
+buffered_seek(buffered *self, PyObject *args)
{
Py_off_t target, n;
int whence = 0;
@@ -1022,23 +1021,23 @@
/* Fallback: invoke raw seek() method and clear buffer */
if (self->writable) {
- res = _BufferedWriter_flush_unlocked(self, 0);
+ res = _bufferedwriter_flush_unlocked(self, 0);
if (res == NULL)
goto end;
Py_CLEAR(res);
- _BufferedWriter_reset_buf(self);
+ _bufferedwriter_reset_buf(self);
}
/* TODO: align on block boundary and read buffer if needed? */
if (whence == 1)
target -= RAW_OFFSET(self);
- n = _Buffered_raw_seek(self, target, whence);
+ n = _buffered_raw_seek(self, target, whence);
if (n == -1)
goto end;
self->raw_pos = -1;
res = PyLong_FromOff_t(n);
if (res != NULL && self->readable)
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
end:
LEAVE_BUFFERED(self)
@@ -1046,7 +1045,7 @@
}
static PyObject *
-Buffered_truncate(BufferedObject *self, PyObject *args)
+buffered_truncate(buffered *self, PyObject *args)
{
PyObject *pos = Py_None;
PyObject *res = NULL;
@@ -1059,7 +1058,7 @@
ENTER_BUFFERED(self)
if (self->writable) {
- res = _BufferedWriter_flush_unlocked(self, 0);
+ res = _bufferedwriter_flush_unlocked(self, 0);
if (res == NULL)
goto end;
Py_CLEAR(res);
@@ -1068,16 +1067,16 @@
if (pos == Py_None) {
/* Rewind the raw stream so that its position corresponds to
the current logical position. */
- if (_Buffered_raw_seek(self, -RAW_OFFSET(self), 1) == -1)
+ if (_buffered_raw_seek(self, -RAW_OFFSET(self), 1) == -1)
goto end;
}
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
}
res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_truncate, pos, NULL);
if (res == NULL)
goto end;
/* Reset cached position */
- if (_Buffered_raw_tell(self) == -1)
+ if (_buffered_raw_tell(self) == -1)
PyErr_Clear();
end:
@@ -1086,7 +1085,7 @@
}
static PyObject *
-Buffered_iternext(BufferedObject *self)
+buffered_iternext(buffered *self)
{
PyObject *line;
PyTypeObject *tp;
@@ -1097,7 +1096,7 @@
if (tp == &PyBufferedReader_Type ||
tp == &PyBufferedRandom_Type) {
/* Skip method call overhead for speed */
- line = _Buffered_readline(self, -1);
+ line = _buffered_readline(self, -1);
}
else {
line = PyObject_CallMethodObjArgs((PyObject *)self,
@@ -1124,7 +1123,7 @@
}
static PyObject *
-Buffered_repr(BufferedObject *self)
+buffered_repr(buffered *self)
{
PyObject *nameobj, *res;
@@ -1148,16 +1147,16 @@
* class BufferedReader
*/
-PyDoc_STRVAR(BufferedReader_doc,
+PyDoc_STRVAR(bufferedreader_doc,
"Create a new buffered reader using the given readable raw IO object.");
-static void _BufferedReader_reset_buf(BufferedObject *self)
+static void _bufferedreader_reset_buf(buffered *self)
{
self->read_end = -1;
}
static int
-BufferedReader_init(BufferedObject *self, PyObject *args, PyObject *kwds)
+bufferedreader_init(buffered *self, PyObject *args, PyObject *kwds)
{
char *kwlist[] = {"raw", "buffer_size", NULL};
Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
@@ -1171,7 +1170,7 @@
return -1;
}
- if (_PyIOBase_checkReadable(raw, Py_True) == NULL)
+ if (_PyIOBase_check_readable(raw, Py_True) == NULL)
return -1;
Py_CLEAR(self->raw);
@@ -1181,9 +1180,9 @@
self->readable = 1;
self->writable = 0;
- if (_Buffered_init(self) < 0)
+ if (_buffered_init(self) < 0)
return -1;
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedReader_Type &&
Py_TYPE(raw) == &PyFileIO_Type);
@@ -1193,7 +1192,7 @@
}
static Py_ssize_t
-_BufferedReader_raw_read(BufferedObject *self, char *start, Py_ssize_t len)
+_bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len)
{
Py_buffer buf;
PyObject *memobj, *res;
@@ -1227,7 +1226,7 @@
}
static Py_ssize_t
-_BufferedReader_fill_buffer(BufferedObject *self)
+_bufferedreader_fill_buffer(buffered *self)
{
Py_ssize_t start, len, n;
if (VALID_READ_BUFFER(self))
@@ -1235,7 +1234,7 @@
else
start = 0;
len = self->buffer_size - start;
- n = _BufferedReader_raw_read(self, self->buffer + start, len);
+ n = _bufferedreader_raw_read(self, self->buffer + start, len);
if (n <= 0)
return n;
self->read_end = start + n;
@@ -1244,7 +1243,7 @@
}
static PyObject *
-_BufferedReader_read_all(BufferedObject *self)
+_bufferedreader_read_all(buffered *self)
{
Py_ssize_t current_size;
PyObject *res, *data = NULL;
@@ -1263,10 +1262,10 @@
return NULL;
}
}
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
/* We're going past the buffer's bounds, flush it */
if (self->writable) {
- res = _BufferedWriter_flush_unlocked(self, 1);
+ res = _bufferedwriter_flush_unlocked(self, 1);
if (res == NULL) {
Py_DECREF(chunks);
return NULL;
@@ -1316,7 +1315,7 @@
/* Read n bytes from the buffer if it can, otherwise return None.
This function is simple enough that it can run unlocked. */
static PyObject *
-_BufferedReader_read_fast(BufferedObject *self, Py_ssize_t n)
+_bufferedreader_read_fast(buffered *self, Py_ssize_t n)
{
Py_ssize_t current_size;
@@ -1335,7 +1334,7 @@
* or until an EOF occurs or until read() would block.
*/
static PyObject *
-_BufferedReader_read_generic(BufferedObject *self, Py_ssize_t n)
+_bufferedreader_read_generic(buffered *self, Py_ssize_t n)
{
PyObject *res = NULL;
Py_ssize_t current_size, remaining, written;
@@ -1343,7 +1342,7 @@
current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
if (n <= current_size)
- return _BufferedReader_read_fast(self, n);
+ return _bufferedreader_read_fast(self, n);
res = PyBytes_FromStringAndSize(NULL, n);
if (res == NULL)
@@ -1356,14 +1355,14 @@
remaining -= current_size;
written += current_size;
}
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
while (remaining > 0) {
/* We want to read a whole block at the end into buffer.
If we had readv() we could do this in one pass. */
Py_ssize_t r = MINUS_LAST_BLOCK(self, remaining);
if (r == 0)
break;
- r = _BufferedReader_raw_read(self, out + written, r);
+ r = _bufferedreader_raw_read(self, out + written, r);
if (r == -1)
goto error;
if (r == 0 || r == -2) {
@@ -1385,7 +1384,7 @@
self->raw_pos = 0;
self->read_end = 0;
while (self->read_end < self->buffer_size) {
- Py_ssize_t r = _BufferedReader_fill_buffer(self);
+ Py_ssize_t r = _bufferedreader_fill_buffer(self);
if (r == -1)
goto error;
if (r == 0 || r == -2) {
@@ -1423,7 +1422,7 @@
}
static PyObject *
-_BufferedReader_peek_unlocked(BufferedObject *self, Py_ssize_t n)
+_bufferedreader_peek_unlocked(buffered *self, Py_ssize_t n)
{
Py_ssize_t have, r;
@@ -1439,8 +1438,8 @@
}
/* Fill the buffer from the raw stream, and copy it to the result. */
- _BufferedReader_reset_buf(self);
- r = _BufferedReader_fill_buffer(self);
+ _bufferedreader_reset_buf(self);
+ r = _bufferedreader_fill_buffer(self);
if (r == -1)
return NULL;
if (r == -2)
@@ -1449,36 +1448,36 @@
return PyBytes_FromStringAndSize(self->buffer, r);
}
-static PyMethodDef BufferedReader_methods[] = {
+static PyMethodDef bufferedreader_methods[] = {
/* BufferedIOMixin methods */
- {"detach", (PyCFunction)BufferedIOMixin_detach, METH_NOARGS},
- {"flush", (PyCFunction)BufferedIOMixin_flush, METH_NOARGS},
- {"close", (PyCFunction)BufferedIOMixin_close, METH_NOARGS},
- {"seekable", (PyCFunction)BufferedIOMixin_seekable, METH_NOARGS},
- {"readable", (PyCFunction)BufferedIOMixin_readable, METH_NOARGS},
- {"writable", (PyCFunction)BufferedIOMixin_writable, METH_NOARGS},
- {"fileno", (PyCFunction)BufferedIOMixin_fileno, METH_NOARGS},
- {"isatty", (PyCFunction)BufferedIOMixin_isatty, METH_NOARGS},
-
- {"read", (PyCFunction)Buffered_read, METH_VARARGS},
- {"peek", (PyCFunction)Buffered_peek, METH_VARARGS},
- {"read1", (PyCFunction)Buffered_read1, METH_VARARGS},
- {"readline", (PyCFunction)Buffered_readline, METH_VARARGS},
- {"seek", (PyCFunction)Buffered_seek, METH_VARARGS},
- {"tell", (PyCFunction)Buffered_tell, METH_NOARGS},
- {"truncate", (PyCFunction)Buffered_truncate, METH_VARARGS},
+ {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
+ {"flush", (PyCFunction)buffered_simple_flush, METH_NOARGS},
+ {"close", (PyCFunction)buffered_close, METH_NOARGS},
+ {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
+ {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
+ {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
+ {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
+ {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
+
+ {"read", (PyCFunction)buffered_read, METH_VARARGS},
+ {"peek", (PyCFunction)buffered_peek, METH_VARARGS},
+ {"read1", (PyCFunction)buffered_read1, METH_VARARGS},
+ {"readline", (PyCFunction)buffered_readline, METH_VARARGS},
+ {"seek", (PyCFunction)buffered_seek, METH_VARARGS},
+ {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
+ {"truncate", (PyCFunction)buffered_truncate, METH_VARARGS},
{NULL, NULL}
};
-static PyMemberDef BufferedReader_members[] = {
- {"raw", T_OBJECT, offsetof(BufferedObject, raw), 0},
+static PyMemberDef bufferedreader_members[] = {
+ {"raw", T_OBJECT, offsetof(buffered, raw), 0},
{NULL}
};
-static PyGetSetDef BufferedReader_getset[] = {
- {"closed", (getter)BufferedIOMixin_closed_get, NULL, NULL},
- {"name", (getter)BufferedIOMixin_name_get, NULL, NULL},
- {"mode", (getter)BufferedIOMixin_mode_get, NULL, NULL},
+static PyGetSetDef bufferedreader_getset[] = {
+ {"closed", (getter)buffered_closed_get, NULL, NULL},
+ {"name", (getter)buffered_name_get, NULL, NULL},
+ {"mode", (getter)buffered_mode_get, NULL, NULL},
{NULL}
};
@@ -1486,14 +1485,14 @@
PyTypeObject PyBufferedReader_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.BufferedReader", /*tp_name*/
- sizeof(BufferedObject), /*tp_basicsize*/
+ sizeof(buffered), /*tp_basicsize*/
0, /*tp_itemsize*/
- (destructor)BufferedObject_dealloc, /*tp_dealloc*/
+ (destructor)buffered_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare */
- (reprfunc)Buffered_repr, /*tp_repr*/
+ (reprfunc)buffered_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
@@ -1505,22 +1504,22 @@
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- BufferedReader_doc, /* tp_doc */
- (traverseproc)Buffered_traverse, /* tp_traverse */
- (inquiry)Buffered_clear, /* tp_clear */
+ bufferedreader_doc, /* tp_doc */
+ (traverseproc)buffered_traverse, /* tp_traverse */
+ (inquiry)buffered_clear, /* tp_clear */
0, /* tp_richcompare */
- offsetof(BufferedObject, weakreflist), /*tp_weaklistoffset*/
+ offsetof(buffered, weakreflist), /*tp_weaklistoffset*/
0, /* tp_iter */
- (iternextfunc)Buffered_iternext, /* tp_iternext */
- BufferedReader_methods, /* tp_methods */
- BufferedReader_members, /* tp_members */
- BufferedReader_getset, /* tp_getset */
+ (iternextfunc)buffered_iternext, /* tp_iternext */
+ bufferedreader_methods, /* tp_methods */
+ bufferedreader_members, /* tp_members */
+ bufferedreader_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- offsetof(BufferedObject, dict), /* tp_dictoffset */
- (initproc)BufferedReader_init, /* tp_init */
+ offsetof(buffered, dict), /* tp_dictoffset */
+ (initproc)bufferedreader_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
@@ -1539,7 +1538,7 @@
/*
* class BufferedWriter
*/
-PyDoc_STRVAR(BufferedWriter_doc,
+PyDoc_STRVAR(bufferedwriter_doc,
"A buffer for a writeable sequential RawIO object.\n"
"\n"
"The constructor creates a BufferedWriter for the given writeable raw\n"
@@ -1548,14 +1547,14 @@
);
static void
-_BufferedWriter_reset_buf(BufferedObject *self)
+_bufferedwriter_reset_buf(buffered *self)
{
self->write_pos = 0;
self->write_end = -1;
}
static int
-BufferedWriter_init(BufferedObject *self, PyObject *args, PyObject *kwds)
+bufferedwriter_init(buffered *self, PyObject *args, PyObject *kwds)
{
/* TODO: properly deprecate max_buffer_size */
char *kwlist[] = {"raw", "buffer_size", "max_buffer_size", NULL};
@@ -1574,7 +1573,7 @@
if (max_buffer_size != -234 && !complain_about_max_buffer_size())
return -1;
- if (_PyIOBase_checkWritable(raw, Py_True) == NULL)
+ if (_PyIOBase_check_writable(raw, Py_True) == NULL)
return -1;
Py_CLEAR(self->raw);
@@ -1584,9 +1583,9 @@
self->writable = 1;
self->buffer_size = buffer_size;
- if (_Buffered_init(self) < 0)
+ if (_buffered_init(self) < 0)
return -1;
- _BufferedWriter_reset_buf(self);
+ _bufferedwriter_reset_buf(self);
self->pos = 0;
self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedWriter_Type &&
@@ -1597,7 +1596,7 @@
}
static Py_ssize_t
-_BufferedWriter_raw_write(BufferedObject *self, char *start, Py_ssize_t len)
+_bufferedwriter_raw_write(buffered *self, char *start, Py_ssize_t len)
{
Py_buffer buf;
PyObject *memobj, *res;
@@ -1628,7 +1627,7 @@
/* `restore_pos` is 1 if we need to restore the raw stream position at
the end, 0 otherwise. */
static PyObject *
-_BufferedWriter_flush_unlocked(BufferedObject *self, int restore_pos)
+_bufferedwriter_flush_unlocked(buffered *self, int restore_pos)
{
Py_ssize_t written = 0;
Py_off_t n, rewind;
@@ -1638,19 +1637,19 @@
/* First, rewind */
rewind = RAW_OFFSET(self) + (self->pos - self->write_pos);
if (rewind != 0) {
- n = _Buffered_raw_seek(self, -rewind, 1);
+ n = _buffered_raw_seek(self, -rewind, 1);
if (n < 0) {
goto error;
}
self->raw_pos -= rewind;
}
while (self->write_pos < self->write_end) {
- n = _BufferedWriter_raw_write(self,
+ n = _bufferedwriter_raw_write(self,
self->buffer + self->write_pos,
Py_SAFE_DOWNCAST(self->write_end - self->write_pos,
Py_off_t, Py_ssize_t));
if (n == -1) {
- Py_ssize_t *w = _Buffered_check_blocking_error();
+ Py_ssize_t *w = _buffered_check_blocking_error();
if (w == NULL)
goto error;
self->write_pos += *w;
@@ -1668,14 +1667,14 @@
if (restore_pos) {
Py_off_t forward = rewind - written;
if (forward != 0) {
- n = _Buffered_raw_seek(self, forward, 1);
+ n = _buffered_raw_seek(self, forward, 1);
if (n < 0) {
goto error;
}
self->raw_pos += forward;
}
}
- _BufferedWriter_reset_buf(self);
+ _bufferedwriter_reset_buf(self);
end:
Py_RETURN_NONE;
@@ -1685,7 +1684,7 @@
}
static PyObject *
-BufferedWriter_write(BufferedObject *self, PyObject *args)
+bufferedwriter_write(buffered *self, PyObject *args)
{
PyObject *res = NULL;
Py_buffer buf;
@@ -1723,13 +1722,13 @@
}
/* First write the current buffer */
- res = _BufferedWriter_flush_unlocked(self, 0);
+ res = _bufferedwriter_flush_unlocked(self, 0);
if (res == NULL) {
- Py_ssize_t *w = _Buffered_check_blocking_error();
+ Py_ssize_t *w = _buffered_check_blocking_error();
if (w == NULL)
goto error;
if (self->readable)
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
/* Make some place by shifting the buffer. */
assert(VALID_WRITE_BUFFER(self));
memmove(self->buffer, self->buffer + self->write_pos,
@@ -1762,10 +1761,10 @@
remaining = buf.len;
written = 0;
while (remaining > self->buffer_size) {
- n = _BufferedWriter_raw_write(
+ n = _bufferedwriter_raw_write(
self, (char *) buf.buf + written, buf.len - written);
if (n == -1) {
- Py_ssize_t *w = _Buffered_check_blocking_error();
+ Py_ssize_t *w = _buffered_check_blocking_error();
if (w == NULL)
goto error;
written += *w;
@@ -1788,7 +1787,7 @@
remaining -= n;
}
if (self->readable)
- _BufferedReader_reset_buf(self);
+ _bufferedreader_reset_buf(self);
if (remaining > 0) {
memcpy(self->buffer, (char *) buf.buf + written, remaining);
written += remaining;
@@ -1808,33 +1807,33 @@
return res;
}
-static PyMethodDef BufferedWriter_methods[] = {
+static PyMethodDef bufferedwriter_methods[] = {
/* BufferedIOMixin methods */
- {"close", (PyCFunction)BufferedIOMixin_close, METH_NOARGS},
- {"detach", (PyCFunction)BufferedIOMixin_detach, METH_NOARGS},
- {"seekable", (PyCFunction)BufferedIOMixin_seekable, METH_NOARGS},
- {"readable", (PyCFunction)BufferedIOMixin_readable, METH_NOARGS},
- {"writable", (PyCFunction)BufferedIOMixin_writable, METH_NOARGS},
- {"fileno", (PyCFunction)BufferedIOMixin_fileno, METH_NOARGS},
- {"isatty", (PyCFunction)BufferedIOMixin_isatty, METH_NOARGS},
-
- {"write", (PyCFunction)BufferedWriter_write, METH_VARARGS},
- {"truncate", (PyCFunction)Buffered_truncate, METH_VARARGS},
- {"flush", (PyCFunction)Buffered_flush, METH_NOARGS},
- {"seek", (PyCFunction)Buffered_seek, METH_VARARGS},
- {"tell", (PyCFunction)Buffered_tell, METH_NOARGS},
+ {"close", (PyCFunction)buffered_close, METH_NOARGS},
+ {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
+ {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
+ {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
+ {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
+ {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
+ {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
+
+ {"write", (PyCFunction)bufferedwriter_write, METH_VARARGS},
+ {"truncate", (PyCFunction)buffered_truncate, METH_VARARGS},
+ {"flush", (PyCFunction)buffered_flush, METH_NOARGS},
+ {"seek", (PyCFunction)buffered_seek, METH_VARARGS},
+ {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
{NULL, NULL}
};
-static PyMemberDef BufferedWriter_members[] = {
- {"raw", T_OBJECT, offsetof(BufferedObject, raw), 0},
+static PyMemberDef bufferedwriter_members[] = {
+ {"raw", T_OBJECT, offsetof(buffered, raw), 0},
{NULL}
};
-static PyGetSetDef BufferedWriter_getset[] = {
- {"closed", (getter)BufferedIOMixin_closed_get, NULL, NULL},
- {"name", (getter)BufferedIOMixin_name_get, NULL, NULL},
- {"mode", (getter)BufferedIOMixin_mode_get, NULL, NULL},
+static PyGetSetDef bufferedwriter_getset[] = {
+ {"closed", (getter)buffered_closed_get, NULL, NULL},
+ {"name", (getter)buffered_name_get, NULL, NULL},
+ {"mode", (getter)buffered_mode_get, NULL, NULL},
{NULL}
};
@@ -1842,14 +1841,14 @@
PyTypeObject PyBufferedWriter_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.BufferedWriter", /*tp_name*/
- sizeof(BufferedObject), /*tp_basicsize*/
+ sizeof(buffered), /*tp_basicsize*/
0, /*tp_itemsize*/
- (destructor)BufferedObject_dealloc, /*tp_dealloc*/
+ (destructor)buffered_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare */
- (reprfunc)Buffered_repr, /*tp_repr*/
+ (reprfunc)buffered_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
@@ -1861,22 +1860,22 @@
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- BufferedWriter_doc, /* tp_doc */
- (traverseproc)Buffered_traverse, /* tp_traverse */
- (inquiry)Buffered_clear, /* tp_clear */
+ bufferedwriter_doc, /* tp_doc */
+ (traverseproc)buffered_traverse, /* tp_traverse */
+ (inquiry)buffered_clear, /* tp_clear */
0, /* tp_richcompare */
- offsetof(BufferedObject, weakreflist), /*tp_weaklistoffset*/
+ offsetof(buffered, weakreflist), /*tp_weaklistoffset*/
0, /* tp_iter */
0, /* tp_iternext */
- BufferedWriter_methods, /* tp_methods */
- BufferedWriter_members, /* tp_members */
- BufferedWriter_getset, /* tp_getset */
+ bufferedwriter_methods, /* tp_methods */
+ bufferedwriter_members, /* tp_members */
+ bufferedwriter_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- offsetof(BufferedObject, dict), /* tp_dictoffset */
- (initproc)BufferedWriter_init, /* tp_init */
+ offsetof(buffered, dict), /* tp_dictoffset */
+ (initproc)bufferedwriter_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
@@ -1887,7 +1886,7 @@
* BufferedRWPair
*/
-PyDoc_STRVAR(BufferedRWPair_doc,
+PyDoc_STRVAR(bufferedrwpair_doc,
"A buffered reader and writer object together.\n"
"\n"
"A buffered reader object and buffered writer object put together to\n"
@@ -1905,15 +1904,14 @@
typedef struct {
PyObject_HEAD
- BufferedObject *reader;
- BufferedObject *writer;
+ buffered *reader;
+ buffered *writer;
PyObject *dict;
PyObject *weakreflist;
-} BufferedRWPairObject;
+} rwpair;
static int
-BufferedRWPair_init(BufferedRWPairObject *self, PyObject *args,
- PyObject *kwds)
+bufferedrwpair_init(rwpair *self, PyObject *args, PyObject *kwds)
{
PyObject *reader, *writer;
Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
@@ -1927,17 +1925,17 @@
if (max_buffer_size != -234 && !complain_about_max_buffer_size())
return -1;
- if (_PyIOBase_checkReadable(reader, Py_True) == NULL)
+ if (_PyIOBase_check_readable(reader, Py_True) == NULL)
return -1;
- if (_PyIOBase_checkWritable(writer, Py_True) == NULL)
+ if (_PyIOBase_check_writable(writer, Py_True) == NULL)
return -1;
- self->reader = (BufferedObject *) PyObject_CallFunction(
+ self->reader = (buffered *) PyObject_CallFunction(
(PyObject *) &PyBufferedReader_Type, "On", reader, buffer_size);
if (self->reader == NULL)
return -1;
- self->writer = (BufferedObject *) PyObject_CallFunction(
+ self->writer = (buffered *) PyObject_CallFunction(
(PyObject *) &PyBufferedWriter_Type, "On", writer, buffer_size);
if (self->writer == NULL) {
Py_CLEAR(self->reader);
@@ -1948,14 +1946,14 @@
}
static int
-BufferedRWPair_traverse(BufferedRWPairObject *self, visitproc visit, void *arg)
+bufferedrwpair_traverse(rwpair *self, visitproc visit, void *arg)
{
Py_VISIT(self->dict);
return 0;
}
static int
-BufferedRWPair_clear(BufferedRWPairObject *self)
+bufferedrwpair_clear(rwpair *self)
{
Py_CLEAR(self->reader);
Py_CLEAR(self->writer);
@@ -1964,7 +1962,7 @@
}
static void
-BufferedRWPair_dealloc(BufferedRWPairObject *self)
+bufferedrwpair_dealloc(rwpair *self)
{
_PyObject_GC_UNTRACK(self);
Py_CLEAR(self->reader);
@@ -1974,7 +1972,7 @@
}
static PyObject *
-_forward_call(BufferedObject *self, const char *name, PyObject *args)
+_forward_call(buffered *self, const char *name, PyObject *args)
{
PyObject *func = PyObject_GetAttrString((PyObject *)self, name);
PyObject *ret;
@@ -1990,55 +1988,55 @@
}
static PyObject *
-BufferedRWPair_read(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_read(rwpair *self, PyObject *args)
{
return _forward_call(self->reader, "read", args);
}
static PyObject *
-BufferedRWPair_peek(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_peek(rwpair *self, PyObject *args)
{
return _forward_call(self->reader, "peek", args);
}
static PyObject *
-BufferedRWPair_read1(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_read1(rwpair *self, PyObject *args)
{
return _forward_call(self->reader, "read1", args);
}
static PyObject *
-BufferedRWPair_readinto(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_readinto(rwpair *self, PyObject *args)
{
return _forward_call(self->reader, "readinto", args);
}
static PyObject *
-BufferedRWPair_write(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_write(rwpair *self, PyObject *args)
{
return _forward_call(self->writer, "write", args);
}
static PyObject *
-BufferedRWPair_flush(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_flush(rwpair *self, PyObject *args)
{
return _forward_call(self->writer, "flush", args);
}
static PyObject *
-BufferedRWPair_readable(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_readable(rwpair *self, PyObject *args)
{
return _forward_call(self->reader, "readable", args);
}
static PyObject *
-BufferedRWPair_writable(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_writable(rwpair *self, PyObject *args)
{
return _forward_call(self->writer, "writable", args);
}
static PyObject *
-BufferedRWPair_close(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_close(rwpair *self, PyObject *args)
{
PyObject *ret = _forward_call(self->writer, "close", args);
if (ret == NULL)
@@ -2049,7 +2047,7 @@
}
static PyObject *
-BufferedRWPair_isatty(BufferedRWPairObject *self, PyObject *args)
+bufferedrwpair_isatty(rwpair *self, PyObject *args)
{
PyObject *ret = _forward_call(self->writer, "isatty", args);
@@ -2063,40 +2061,40 @@
}
static PyObject *
-BufferedRWPair_closed_get(BufferedRWPairObject *self, void *context)
+bufferedrwpair_closed_get(rwpair *self, void *context)
{
return PyObject_GetAttr((PyObject *) self->writer, _PyIO_str_closed);
}
-static PyMethodDef BufferedRWPair_methods[] = {
- {"read", (PyCFunction)BufferedRWPair_read, METH_VARARGS},
- {"peek", (PyCFunction)BufferedRWPair_peek, METH_VARARGS},
- {"read1", (PyCFunction)BufferedRWPair_read1, METH_VARARGS},
- {"readinto", (PyCFunction)BufferedRWPair_readinto, METH_VARARGS},
+static PyMethodDef bufferedrwpair_methods[] = {
+ {"read", (PyCFunction)bufferedrwpair_read, METH_VARARGS},
+ {"peek", (PyCFunction)bufferedrwpair_peek, METH_VARARGS},
+ {"read1", (PyCFunction)bufferedrwpair_read1, METH_VARARGS},
+ {"readinto", (PyCFunction)bufferedrwpair_readinto, METH_VARARGS},
- {"write", (PyCFunction)BufferedRWPair_write, METH_VARARGS},
- {"flush", (PyCFunction)BufferedRWPair_flush, METH_NOARGS},
+ {"write", (PyCFunction)bufferedrwpair_write, METH_VARARGS},
+ {"flush", (PyCFunction)bufferedrwpair_flush, METH_NOARGS},
- {"readable", (PyCFunction)BufferedRWPair_readable, METH_NOARGS},
- {"writable", (PyCFunction)BufferedRWPair_writable, METH_NOARGS},
+ {"readable", (PyCFunction)bufferedrwpair_readable, METH_NOARGS},
+ {"writable", (PyCFunction)bufferedrwpair_writable, METH_NOARGS},
- {"close", (PyCFunction)BufferedRWPair_close, METH_NOARGS},
- {"isatty", (PyCFunction)BufferedRWPair_isatty, METH_NOARGS},
+ {"close", (PyCFunction)bufferedrwpair_close, METH_NOARGS},
+ {"isatty", (PyCFunction)bufferedrwpair_isatty, METH_NOARGS},
{NULL, NULL}
};
-static PyGetSetDef BufferedRWPair_getset[] = {
- {"closed", (getter)BufferedRWPair_closed_get, NULL, NULL},
+static PyGetSetDef bufferedrwpair_getset[] = {
+ {"closed", (getter)bufferedrwpair_closed_get, NULL, NULL},
{NULL}
};
PyTypeObject PyBufferedRWPair_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.BufferedRWPair", /*tp_name*/
- sizeof(BufferedRWPairObject), /*tp_basicsize*/
+ sizeof(rwpair), /*tp_basicsize*/
0, /*tp_itemsize*/
- (destructor)BufferedRWPair_dealloc, /*tp_dealloc*/
+ (destructor)bufferedrwpair_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
@@ -2113,22 +2111,22 @@
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC, /* tp_flags */
- BufferedRWPair_doc, /* tp_doc */
- (traverseproc)BufferedRWPair_traverse, /* tp_traverse */
- (inquiry)BufferedRWPair_clear, /* tp_clear */
+ bufferedrwpair_doc, /* tp_doc */
+ (traverseproc)bufferedrwpair_traverse, /* tp_traverse */
+ (inquiry)bufferedrwpair_clear, /* tp_clear */
0, /* tp_richcompare */
- offsetof(BufferedRWPairObject, weakreflist), /*tp_weaklistoffset*/
+ offsetof(rwpair, weakreflist), /*tp_weaklistoffset*/
0, /* tp_iter */
0, /* tp_iternext */
- BufferedRWPair_methods, /* tp_methods */
+ bufferedrwpair_methods, /* tp_methods */
0, /* tp_members */
- BufferedRWPair_getset, /* tp_getset */
+ bufferedrwpair_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- offsetof(BufferedRWPairObject, dict), /* tp_dictoffset */
- (initproc)BufferedRWPair_init, /* tp_init */
+ offsetof(rwpair, dict), /* tp_dictoffset */
+ (initproc)bufferedrwpair_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
@@ -2139,7 +2137,7 @@
* BufferedRandom
*/
-PyDoc_STRVAR(BufferedRandom_doc,
+PyDoc_STRVAR(bufferedrandom_doc,
"A buffered interface to random access streams.\n"
"\n"
"The constructor creates a reader and writer for a seekable stream,\n"
@@ -2148,7 +2146,7 @@
);
static int
-BufferedRandom_init(BufferedObject *self, PyObject *args, PyObject *kwds)
+bufferedrandom_init(buffered *self, PyObject *args, PyObject *kwds)
{
char *kwlist[] = {"raw", "buffer_size", "max_buffer_size", NULL};
Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
@@ -2166,11 +2164,11 @@
if (max_buffer_size != -234 && !complain_about_max_buffer_size())
return -1;
- if (_PyIOBase_checkSeekable(raw, Py_True) == NULL)
+ if (_PyIOBase_check_seekable(raw, Py_True) == NULL)
return -1;
- if (_PyIOBase_checkReadable(raw, Py_True) == NULL)
+ if (_PyIOBase_check_readable(raw, Py_True) == NULL)
return -1;
- if (_PyIOBase_checkWritable(raw, Py_True) == NULL)
+ if (_PyIOBase_check_writable(raw, Py_True) == NULL)
return -1;
Py_CLEAR(self->raw);
@@ -2180,10 +2178,10 @@
self->readable = 1;
self->writable = 1;
- if (_Buffered_init(self) < 0)
+ if (_buffered_init(self) < 0)
return -1;
- _BufferedReader_reset_buf(self);
- _BufferedWriter_reset_buf(self);
+ _bufferedreader_reset_buf(self);
+ _bufferedwriter_reset_buf(self);
self->pos = 0;
self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedRandom_Type &&
@@ -2193,39 +2191,39 @@
return 0;
}
-static PyMethodDef BufferedRandom_methods[] = {
+static PyMethodDef bufferedrandom_methods[] = {
/* BufferedIOMixin methods */
- {"close", (PyCFunction)BufferedIOMixin_close, METH_NOARGS},
- {"detach", (PyCFunction)BufferedIOMixin_detach, METH_NOARGS},
- {"seekable", (PyCFunction)BufferedIOMixin_seekable, METH_NOARGS},
- {"readable", (PyCFunction)BufferedIOMixin_readable, METH_NOARGS},
- {"writable", (PyCFunction)BufferedIOMixin_writable, METH_NOARGS},
- {"fileno", (PyCFunction)BufferedIOMixin_fileno, METH_NOARGS},
- {"isatty", (PyCFunction)BufferedIOMixin_isatty, METH_NOARGS},
-
- {"flush", (PyCFunction)Buffered_flush, METH_NOARGS},
-
- {"seek", (PyCFunction)Buffered_seek, METH_VARARGS},
- {"tell", (PyCFunction)Buffered_tell, METH_NOARGS},
- {"truncate", (PyCFunction)Buffered_truncate, METH_VARARGS},
- {"read", (PyCFunction)Buffered_read, METH_VARARGS},
- {"read1", (PyCFunction)Buffered_read1, METH_VARARGS},
- {"readinto", (PyCFunction)Buffered_readinto, METH_VARARGS},
- {"readline", (PyCFunction)Buffered_readline, METH_VARARGS},
- {"peek", (PyCFunction)Buffered_peek, METH_VARARGS},
- {"write", (PyCFunction)BufferedWriter_write, METH_VARARGS},
+ {"close", (PyCFunction)buffered_close, METH_NOARGS},
+ {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
+ {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
+ {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
+ {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
+ {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
+ {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
+
+ {"flush", (PyCFunction)buffered_flush, METH_NOARGS},
+
+ {"seek", (PyCFunction)buffered_seek, METH_VARARGS},
+ {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
+ {"truncate", (PyCFunction)buffered_truncate, METH_VARARGS},
+ {"read", (PyCFunction)buffered_read, METH_VARARGS},
+ {"read1", (PyCFunction)buffered_read1, METH_VARARGS},
+ {"readinto", (PyCFunction)buffered_readinto, METH_VARARGS},
+ {"readline", (PyCFunction)buffered_readline, METH_VARARGS},
+ {"peek", (PyCFunction)buffered_peek, METH_VARARGS},
+ {"write", (PyCFunction)bufferedwriter_write, METH_VARARGS},
{NULL, NULL}
};
-static PyMemberDef BufferedRandom_members[] = {
- {"raw", T_OBJECT, offsetof(BufferedObject, raw), 0},
+static PyMemberDef bufferedrandom_members[] = {
+ {"raw", T_OBJECT, offsetof(buffered, raw), 0},
{NULL}
};
-static PyGetSetDef BufferedRandom_getset[] = {
- {"closed", (getter)BufferedIOMixin_closed_get, NULL, NULL},
- {"name", (getter)BufferedIOMixin_name_get, NULL, NULL},
- {"mode", (getter)BufferedIOMixin_mode_get, NULL, NULL},
+static PyGetSetDef bufferedrandom_getset[] = {
+ {"closed", (getter)buffered_closed_get, NULL, NULL},
+ {"name", (getter)buffered_name_get, NULL, NULL},
+ {"mode", (getter)buffered_mode_get, NULL, NULL},
{NULL}
};
@@ -2233,14 +2231,14 @@
PyTypeObject PyBufferedRandom_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.BufferedRandom", /*tp_name*/
- sizeof(BufferedObject), /*tp_basicsize*/
+ sizeof(buffered), /*tp_basicsize*/
0, /*tp_itemsize*/
- (destructor)BufferedObject_dealloc, /*tp_dealloc*/
+ (destructor)buffered_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare */
- (reprfunc)Buffered_repr, /*tp_repr*/
+ (reprfunc)buffered_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
@@ -2252,22 +2250,22 @@
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- BufferedRandom_doc, /* tp_doc */
- (traverseproc)Buffered_traverse, /* tp_traverse */
- (inquiry)Buffered_clear, /* tp_clear */
+ bufferedrandom_doc, /* tp_doc */
+ (traverseproc)buffered_traverse, /* tp_traverse */
+ (inquiry)buffered_clear, /* tp_clear */
0, /* tp_richcompare */
- offsetof(BufferedObject, weakreflist), /*tp_weaklistoffset*/
+ offsetof(buffered, weakreflist), /*tp_weaklistoffset*/
0, /* tp_iter */
- (iternextfunc)Buffered_iternext, /* tp_iternext */
- BufferedRandom_methods, /* tp_methods */
- BufferedRandom_members, /* tp_members */
- BufferedRandom_getset, /* tp_getset */
+ (iternextfunc)buffered_iternext, /* tp_iternext */
+ bufferedrandom_methods, /* tp_methods */
+ bufferedrandom_members, /* tp_members */
+ bufferedrandom_getset, /* tp_getset */
0, /* tp_base */
0, /*tp_dict*/
0, /* tp_descr_get */
0, /* tp_descr_set */
- offsetof(BufferedObject, dict), /*tp_dictoffset*/
- (initproc)BufferedRandom_init, /* tp_init */
+ offsetof(buffered, dict), /*tp_dictoffset*/
+ (initproc)bufferedrandom_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
Modified: python/branches/py3k/Modules/_io/bytesio.c
==============================================================================
--- python/branches/py3k/Modules/_io/bytesio.c (original)
+++ python/branches/py3k/Modules/_io/bytesio.c Fri Jun 12 04:07:12 2009
@@ -10,7 +10,7 @@
size_t buf_size;
PyObject *dict;
PyObject *weakreflist;
-} BytesIOObject;
+} bytesio;
#define CHECK_CLOSED(self) \
if ((self)->buf == NULL) { \
@@ -23,7 +23,7 @@
object. Returns the length between the current position to the
next newline character. */
static Py_ssize_t
-get_line(BytesIOObject *self, char **output)
+get_line(bytesio *self, char **output)
{
char *n;
const char *str_end;
@@ -56,7 +56,7 @@
The caller should ensure that the 'size' argument is non-negative. Returns
0 on success, -1 otherwise. */
static int
-resize_buffer(BytesIOObject *self, size_t size)
+resize_buffer(bytesio *self, size_t size)
{
/* Here, unsigned types are used to avoid dealing with signed integer
overflow, which is undefined in C. */
@@ -108,7 +108,7 @@
/* Internal routine for writing a string of bytes to the buffer of a BytesIO
object. Returns the number of bytes wrote, or -1 on error. */
static Py_ssize_t
-write_bytes(BytesIOObject *self, const char *bytes, Py_ssize_t len)
+write_bytes(bytesio *self, const char *bytes, Py_ssize_t len)
{
assert(self->buf != NULL);
assert(self->pos >= 0);
@@ -146,7 +146,7 @@
}
static PyObject *
-bytesio_get_closed(BytesIOObject *self)
+bytesio_get_closed(bytesio *self)
{
if (self->buf == NULL) {
Py_RETURN_TRUE;
@@ -158,7 +158,7 @@
/* Generic getter for the writable, readable and seekable properties */
static PyObject *
-return_true(BytesIOObject *self)
+return_true(bytesio *self)
{
Py_RETURN_TRUE;
}
@@ -167,7 +167,7 @@
"flush() -> None. Does nothing.");
static PyObject *
-bytesio_flush(BytesIOObject *self)
+bytesio_flush(bytesio *self)
{
Py_RETURN_NONE;
}
@@ -178,7 +178,7 @@
"Retrieve the entire contents of the BytesIO object.");
static PyObject *
-bytesio_getvalue(BytesIOObject *self)
+bytesio_getvalue(bytesio *self)
{
CHECK_CLOSED(self);
return PyBytes_FromStringAndSize(self->buf, self->string_size);
@@ -191,7 +191,7 @@
"to a tty-like device.");
static PyObject *
-bytesio_isatty(BytesIOObject *self)
+bytesio_isatty(bytesio *self)
{
CHECK_CLOSED(self);
Py_RETURN_FALSE;
@@ -201,7 +201,7 @@
"tell() -> current file position, an integer\n");
static PyObject *
-bytesio_tell(BytesIOObject *self)
+bytesio_tell(bytesio *self)
{
CHECK_CLOSED(self);
return PyLong_FromSsize_t(self->pos);
@@ -214,7 +214,7 @@
"Return an empty string at EOF.");
static PyObject *
-bytesio_read(BytesIOObject *self, PyObject *args)
+bytesio_read(bytesio *self, PyObject *args)
{
Py_ssize_t size, n;
char *output;
@@ -263,7 +263,7 @@
"Return an empty string at EOF.");
static PyObject *
-bytesio_read1(BytesIOObject *self, PyObject *n)
+bytesio_read1(bytesio *self, PyObject *n)
{
PyObject *arg, *res;
@@ -283,7 +283,7 @@
"Return an empty string at EOF.\n");
static PyObject *
-bytesio_readline(BytesIOObject *self, PyObject *args)
+bytesio_readline(bytesio *self, PyObject *args)
{
Py_ssize_t size, n;
char *output;
@@ -328,7 +328,7 @@
"total number of bytes in the lines returned.\n");
static PyObject *
-bytesio_readlines(BytesIOObject *self, PyObject *args)
+bytesio_readlines(bytesio *self, PyObject *args)
{
Py_ssize_t maxsize, size, n;
PyObject *result, *line;
@@ -387,7 +387,7 @@
"is set not to block as has no data to read.");
static PyObject *
-bytesio_readinto(BytesIOObject *self, PyObject *buffer)
+bytesio_readinto(bytesio *self, PyObject *buffer)
{
void *raw_buffer;
Py_ssize_t len;
@@ -415,7 +415,7 @@
"Returns the new size. Imply an absolute seek to the position size.");
static PyObject *
-bytesio_truncate(BytesIOObject *self, PyObject *args)
+bytesio_truncate(bytesio *self, PyObject *args)
{
Py_ssize_t size;
PyObject *arg = Py_None;
@@ -457,7 +457,7 @@
}
static PyObject *
-bytesio_iternext(BytesIOObject *self)
+bytesio_iternext(bytesio *self)
{
char *next;
Py_ssize_t n;
@@ -482,7 +482,7 @@
"Returns the new absolute position.");
static PyObject *
-bytesio_seek(BytesIOObject *self, PyObject *args)
+bytesio_seek(bytesio *self, PyObject *args)
{
Py_ssize_t pos;
int mode = 0;
@@ -536,7 +536,7 @@
"Return the number of bytes written.");
static PyObject *
-bytesio_write(BytesIOObject *self, PyObject *obj)
+bytesio_write(bytesio *self, PyObject *obj)
{
Py_ssize_t n = 0;
Py_buffer buf;
@@ -564,7 +564,7 @@
"each string.");
static PyObject *
-bytesio_writelines(BytesIOObject *self, PyObject *v)
+bytesio_writelines(bytesio *self, PyObject *v)
{
PyObject *it, *item;
PyObject *ret;
@@ -597,7 +597,7 @@
"close() -> None. Disable all I/O operations.");
static PyObject *
-bytesio_close(BytesIOObject *self)
+bytesio_close(bytesio *self)
{
if (self->buf != NULL) {
PyMem_Free(self->buf);
@@ -607,7 +607,7 @@
}
static void
-bytesio_dealloc(BytesIOObject *self)
+bytesio_dealloc(bytesio *self)
{
if (self->buf != NULL) {
PyMem_Free(self->buf);
@@ -620,10 +620,10 @@
static PyObject *
bytesio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- BytesIOObject *self;
+ bytesio *self;
assert(type != NULL && type->tp_alloc != NULL);
- self = (BytesIOObject *)type->tp_alloc(type, 0);
+ self = (bytesio *)type->tp_alloc(type, 0);
if (self == NULL)
return NULL;
@@ -640,7 +640,7 @@
}
static int
-bytesio_init(BytesIOObject *self, PyObject *args, PyObject *kwds)
+bytesio_init(bytesio *self, PyObject *args, PyObject *kwds)
{
PyObject *initvalue = NULL;
@@ -664,7 +664,7 @@
}
static int
-bytesio_traverse(BytesIOObject *self, visitproc visit, void *arg)
+bytesio_traverse(bytesio *self, visitproc visit, void *arg)
{
Py_VISIT(self->dict);
Py_VISIT(self->weakreflist);
@@ -672,7 +672,7 @@
}
static int
-bytesio_clear(BytesIOObject *self)
+bytesio_clear(bytesio *self)
{
Py_CLEAR(self->dict);
if (self->weakreflist != NULL)
@@ -717,7 +717,7 @@
PyTypeObject PyBytesIO_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.BytesIO", /*tp_name*/
- sizeof(BytesIOObject), /*tp_basicsize*/
+ sizeof(bytesio), /*tp_basicsize*/
0, /*tp_itemsize*/
(destructor)bytesio_dealloc, /*tp_dealloc*/
0, /*tp_print*/
@@ -740,7 +740,7 @@
(traverseproc)bytesio_traverse, /*tp_traverse*/
(inquiry)bytesio_clear, /*tp_clear*/
0, /*tp_richcompare*/
- offsetof(BytesIOObject, weakreflist), /*tp_weaklistoffset*/
+ offsetof(bytesio, weakreflist), /*tp_weaklistoffset*/
PyObject_SelfIter, /*tp_iter*/
(iternextfunc)bytesio_iternext, /*tp_iternext*/
bytesio_methods, /*tp_methods*/
@@ -750,7 +750,7 @@
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
- offsetof(BytesIOObject, dict), /*tp_dictoffset*/
+ offsetof(bytesio, dict), /*tp_dictoffset*/
(initproc)bytesio_init, /*tp_init*/
0, /*tp_alloc*/
bytesio_new, /*tp_new*/
Modified: python/branches/py3k/Modules/_io/fileio.c
==============================================================================
--- python/branches/py3k/Modules/_io/fileio.c (original)
+++ python/branches/py3k/Modules/_io/fileio.c Fri Jun 12 04:07:12 2009
@@ -51,7 +51,7 @@
int closefd : 1;
PyObject *weakreflist;
PyObject *dict;
-} PyFileIOObject;
+} fileio;
PyTypeObject PyFileIO_Type;
@@ -60,7 +60,7 @@
int
_PyFileIO_closed(PyObject *self)
{
- return ((PyFileIOObject *)self)->fd < 0;
+ return ((fileio *)self)->fd < 0;
}
static PyObject *
@@ -70,7 +70,7 @@
/* Returns 0 on success, -1 with exception set on failure. */
static int
-internal_close(PyFileIOObject *self)
+internal_close(fileio *self)
{
int err = 0;
int save_errno = 0;
@@ -98,7 +98,7 @@
}
static PyObject *
-fileio_close(PyFileIOObject *self)
+fileio_close(fileio *self)
{
if (!self->closefd) {
self->fd = -1;
@@ -115,11 +115,11 @@
static PyObject *
fileio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyFileIOObject *self;
+ fileio *self;
assert(type != NULL && type->tp_alloc != NULL);
- self = (PyFileIOObject *) type->tp_alloc(type, 0);
+ self = (fileio *) type->tp_alloc(type, 0);
if (self != NULL) {
self->fd = -1;
self->readable = 0;
@@ -137,7 +137,7 @@
directories, so we need a check. */
static int
-dircheck(PyFileIOObject* self, const char *name)
+dircheck(fileio* self, const char *name)
{
#if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR)
struct stat buf;
@@ -181,7 +181,7 @@
static int
fileio_init(PyObject *oself, PyObject *args, PyObject *kwds)
{
- PyFileIOObject *self = (PyFileIOObject *) oself;
+ fileio *self = (fileio *) oself;
static char *kwlist[] = {"file", "mode", "closefd", NULL};
const char *name = NULL;
PyObject *nameobj, *stringobj = NULL;
@@ -380,21 +380,21 @@
}
static int
-fileio_traverse(PyFileIOObject *self, visitproc visit, void *arg)
+fileio_traverse(fileio *self, visitproc visit, void *arg)
{
Py_VISIT(self->dict);
return 0;
}
static int
-fileio_clear(PyFileIOObject *self)
+fileio_clear(fileio *self)
{
Py_CLEAR(self->dict);
return 0;
}
static void
-fileio_dealloc(PyFileIOObject *self)
+fileio_dealloc(fileio *self)
{
if (_PyIOBase_finalize((PyObject *) self) < 0)
return;
@@ -420,7 +420,7 @@
}
static PyObject *
-fileio_fileno(PyFileIOObject *self)
+fileio_fileno(fileio *self)
{
if (self->fd < 0)
return err_closed();
@@ -428,7 +428,7 @@
}
static PyObject *
-fileio_readable(PyFileIOObject *self)
+fileio_readable(fileio *self)
{
if (self->fd < 0)
return err_closed();
@@ -436,7 +436,7 @@
}
static PyObject *
-fileio_writable(PyFileIOObject *self)
+fileio_writable(fileio *self)
{
if (self->fd < 0)
return err_closed();
@@ -444,7 +444,7 @@
}
static PyObject *
-fileio_seekable(PyFileIOObject *self)
+fileio_seekable(fileio *self)
{
if (self->fd < 0)
return err_closed();
@@ -462,7 +462,7 @@
}
static PyObject *
-fileio_readinto(PyFileIOObject *self, PyObject *args)
+fileio_readinto(fileio *self, PyObject *args)
{
Py_buffer pbuf;
Py_ssize_t n;
@@ -494,7 +494,7 @@
}
static size_t
-new_buffersize(PyFileIOObject *self, size_t currentsize)
+new_buffersize(fileio *self, size_t currentsize)
{
#ifdef HAVE_FSTAT
off_t pos, end;
@@ -524,7 +524,7 @@
}
static PyObject *
-fileio_readall(PyFileIOObject *self)
+fileio_readall(fileio *self)
{
PyObject *result;
Py_ssize_t total = 0;
@@ -590,7 +590,7 @@
}
static PyObject *
-fileio_read(PyFileIOObject *self, PyObject *args)
+fileio_read(fileio *self, PyObject *args)
{
char *ptr;
Py_ssize_t n;
@@ -641,7 +641,7 @@
}
static PyObject *
-fileio_write(PyFileIOObject *self, PyObject *args)
+fileio_write(fileio *self, PyObject *args)
{
Py_buffer pbuf;
Py_ssize_t n;
@@ -734,7 +734,7 @@
}
static PyObject *
-fileio_seek(PyFileIOObject *self, PyObject *args)
+fileio_seek(fileio *self, PyObject *args)
{
PyObject *posobj;
int whence = 0;
@@ -749,7 +749,7 @@
}
static PyObject *
-fileio_tell(PyFileIOObject *self, PyObject *args)
+fileio_tell(fileio *self, PyObject *args)
{
if (self->fd < 0)
return err_closed();
@@ -759,7 +759,7 @@
#ifdef HAVE_FTRUNCATE
static PyObject *
-fileio_truncate(PyFileIOObject *self, PyObject *args)
+fileio_truncate(fileio *self, PyObject *args)
{
PyObject *posobj = NULL;
Py_off_t pos;
@@ -831,7 +831,7 @@
#endif
static char *
-mode_string(PyFileIOObject *self)
+mode_string(fileio *self)
{
if (self->readable) {
if (self->writable)
@@ -844,7 +844,7 @@
}
static PyObject *
-fileio_repr(PyFileIOObject *self)
+fileio_repr(fileio *self)
{
PyObject *nameobj, *res;
@@ -869,7 +869,7 @@
}
static PyObject *
-fileio_isatty(PyFileIOObject *self)
+fileio_isatty(fileio *self)
{
long res;
@@ -980,19 +980,19 @@
/* 'closed' and 'mode' are attributes for backwards compatibility reasons. */
static PyObject *
-get_closed(PyFileIOObject *self, void *closure)
+get_closed(fileio *self, void *closure)
{
return PyBool_FromLong((long)(self->fd < 0));
}
static PyObject *
-get_closefd(PyFileIOObject *self, void *closure)
+get_closefd(fileio *self, void *closure)
{
return PyBool_FromLong((long)(self->closefd));
}
static PyObject *
-get_mode(PyFileIOObject *self, void *closure)
+get_mode(fileio *self, void *closure)
{
return PyUnicode_FromString(mode_string(self));
}
@@ -1008,7 +1008,7 @@
PyTypeObject PyFileIO_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.FileIO",
- sizeof(PyFileIOObject),
+ sizeof(fileio),
0,
(destructor)fileio_dealloc, /* tp_dealloc */
0, /* tp_print */
@@ -1031,7 +1031,7 @@
(traverseproc)fileio_traverse, /* tp_traverse */
(inquiry)fileio_clear, /* tp_clear */
0, /* tp_richcompare */
- offsetof(PyFileIOObject, weakreflist), /* tp_weaklistoffset */
+ offsetof(fileio, weakreflist), /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
fileio_methods, /* tp_methods */
@@ -1041,7 +1041,7 @@
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- offsetof(PyFileIOObject, dict), /* tp_dictoffset */
+ offsetof(fileio, dict), /* tp_dictoffset */
fileio_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
fileio_new, /* tp_new */
Modified: python/branches/py3k/Modules/_io/iobase.c
==============================================================================
--- python/branches/py3k/Modules/_io/iobase.c (original)
+++ python/branches/py3k/Modules/_io/iobase.c Fri Jun 12 04:07:12 2009
@@ -22,9 +22,9 @@
PyObject *dict;
PyObject *weakreflist;
-} IOBaseObject;
+} iobase;
-PyDoc_STRVAR(IOBase_doc,
+PyDoc_STRVAR(iobase_doc,
"The abstract base class for all I/O classes, acting on streams of\n"
"bytes. There is no public constructor.\n"
"\n"
@@ -63,7 +63,7 @@
/* Internal methods */
static PyObject *
-IOBase_unsupported(const char *message)
+iobase_unsupported(const char *message)
{
PyErr_SetString(IO_STATE->unsupported_operation, message);
return NULL;
@@ -71,7 +71,7 @@
/* Positionning */
-PyDoc_STRVAR(IOBase_seek_doc,
+PyDoc_STRVAR(iobase_seek_doc,
"Change stream position.\n"
"\n"
"Change the stream position to byte offset offset. offset is\n"
@@ -85,41 +85,41 @@
"Return the new absolute position.");
static PyObject *
-IOBase_seek(PyObject *self, PyObject *args)
+iobase_seek(PyObject *self, PyObject *args)
{
- return IOBase_unsupported("seek");
+ return iobase_unsupported("seek");
}
-PyDoc_STRVAR(IOBase_tell_doc,
+PyDoc_STRVAR(iobase_tell_doc,
"Return current stream position.");
static PyObject *
-IOBase_tell(PyObject *self, PyObject *args)
+iobase_tell(PyObject *self, PyObject *args)
{
return PyObject_CallMethod(self, "seek", "ii", 0, 1);
}
-PyDoc_STRVAR(IOBase_truncate_doc,
+PyDoc_STRVAR(iobase_truncate_doc,
"Truncate file to size bytes.\n"
"\n"
"Size defaults to the current IO position as reported by tell(). Return\n"
"the new size.");
static PyObject *
-IOBase_truncate(PyObject *self, PyObject *args)
+iobase_truncate(PyObject *self, PyObject *args)
{
- return IOBase_unsupported("truncate");
+ return iobase_unsupported("truncate");
}
/* Flush and close methods */
-PyDoc_STRVAR(IOBase_flush_doc,
+PyDoc_STRVAR(iobase_flush_doc,
"Flush write buffers, if applicable.\n"
"\n"
"This is not implemented for read-only and non-blocking streams.\n");
static PyObject *
-IOBase_flush(PyObject *self, PyObject *args)
+iobase_flush(PyObject *self, PyObject *args)
{
/* XXX Should this return the number of bytes written??? */
if (IS_CLOSED(self)) {
@@ -129,13 +129,13 @@
Py_RETURN_NONE;
}
-PyDoc_STRVAR(IOBase_close_doc,
+PyDoc_STRVAR(iobase_close_doc,
"Flush and close the IO object.\n"
"\n"
"This method has no effect if the file is already closed.\n");
static int
-IOBase_closed(PyObject *self)
+iobase_closed(PyObject *self)
{
PyObject *res;
int closed;
@@ -150,15 +150,15 @@
}
static PyObject *
-IOBase_closed_get(PyObject *self, void *context)
+iobase_closed_get(PyObject *self, void *context)
{
return PyBool_FromLong(IS_CLOSED(self));
}
PyObject *
-_PyIOBase_checkClosed(PyObject *self, PyObject *args)
+_PyIOBase_check_closed(PyObject *self, PyObject *args)
{
- if (IOBase_closed(self)) {
+ if (iobase_closed(self)) {
PyErr_SetString(PyExc_ValueError, "I/O operation on closed file.");
return NULL;
}
@@ -173,7 +173,7 @@
whatever behaviour a non-trivial derived class will implement. */
static PyObject *
-IOBase_close(PyObject *self, PyObject *args)
+iobase_close(PyObject *self, PyObject *args)
{
PyObject *res;
@@ -260,14 +260,14 @@
}
static int
-IOBase_traverse(IOBaseObject *self, visitproc visit, void *arg)
+iobase_traverse(iobase *self, visitproc visit, void *arg)
{
Py_VISIT(self->dict);
return 0;
}
static int
-IOBase_clear(IOBaseObject *self)
+iobase_clear(iobase *self)
{
if (_PyIOBase_finalize((PyObject *) self) < 0)
return -1;
@@ -278,7 +278,7 @@
/* Destructor */
static void
-IOBase_dealloc(IOBaseObject *self)
+iobase_dealloc(iobase *self)
{
/* NOTE: since IOBaseObject has its own dict, Python-defined attributes
are still available here for close() to use.
@@ -301,20 +301,20 @@
/* Inquiry methods */
-PyDoc_STRVAR(IOBase_seekable_doc,
+PyDoc_STRVAR(iobase_seekable_doc,
"Return whether object supports random access.\n"
"\n"
"If False, seek(), tell() and truncate() will raise IOError.\n"
"This method may need to do a test seek().");
static PyObject *
-IOBase_seekable(PyObject *self, PyObject *args)
+iobase_seekable(PyObject *self, PyObject *args)
{
Py_RETURN_FALSE;
}
PyObject *
-_PyIOBase_checkSeekable(PyObject *self, PyObject *args)
+_PyIOBase_check_seekable(PyObject *self, PyObject *args)
{
PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_seekable, NULL);
if (res == NULL)
@@ -330,20 +330,20 @@
return res;
}
-PyDoc_STRVAR(IOBase_readable_doc,
+PyDoc_STRVAR(iobase_readable_doc,
"Return whether object was opened for reading.\n"
"\n"
"If False, read() will raise IOError.");
static PyObject *
-IOBase_readable(PyObject *self, PyObject *args)
+iobase_readable(PyObject *self, PyObject *args)
{
Py_RETURN_FALSE;
}
/* May be called with any object */
PyObject *
-_PyIOBase_checkReadable(PyObject *self, PyObject *args)
+_PyIOBase_check_readable(PyObject *self, PyObject *args)
{
PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_readable, NULL);
if (res == NULL)
@@ -359,20 +359,20 @@
return res;
}
-PyDoc_STRVAR(IOBase_writable_doc,
+PyDoc_STRVAR(iobase_writable_doc,
"Return whether object was opened for writing.\n"
"\n"
"If False, read() will raise IOError.");
static PyObject *
-IOBase_writable(PyObject *self, PyObject *args)
+iobase_writable(PyObject *self, PyObject *args)
{
Py_RETURN_FALSE;
}
/* May be called with any object */
PyObject *
-_PyIOBase_checkWritable(PyObject *self, PyObject *args)
+_PyIOBase_check_writable(PyObject *self, PyObject *args)
{
PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_writable, NULL);
if (res == NULL)
@@ -391,9 +391,9 @@
/* Context manager */
static PyObject *
-IOBase_enter(PyObject *self, PyObject *args)
+iobase_enter(PyObject *self, PyObject *args)
{
- if (_PyIOBase_checkClosed(self, Py_True) == NULL)
+ if (_PyIOBase_check_closed(self, Py_True) == NULL)
return NULL;
Py_INCREF(self);
@@ -401,7 +401,7 @@
}
static PyObject *
-IOBase_exit(PyObject *self, PyObject *args)
+iobase_exit(PyObject *self, PyObject *args)
{
return PyObject_CallMethodObjArgs(self, _PyIO_str_close, NULL);
}
@@ -410,33 +410,33 @@
/* XXX Should these be present even if unimplemented? */
-PyDoc_STRVAR(IOBase_fileno_doc,
+PyDoc_STRVAR(iobase_fileno_doc,
"Returns underlying file descriptor if one exists.\n"
"\n"
"An IOError is raised if the IO object does not use a file descriptor.\n");
static PyObject *
-IOBase_fileno(PyObject *self, PyObject *args)
+iobase_fileno(PyObject *self, PyObject *args)
{
- return IOBase_unsupported("fileno");
+ return iobase_unsupported("fileno");
}
-PyDoc_STRVAR(IOBase_isatty_doc,
+PyDoc_STRVAR(iobase_isatty_doc,
"Return whether this is an 'interactive' stream.\n"
"\n"
"Return False if it can't be determined.\n");
static PyObject *
-IOBase_isatty(PyObject *self, PyObject *args)
+iobase_isatty(PyObject *self, PyObject *args)
{
- if (_PyIOBase_checkClosed(self, Py_True) == NULL)
+ if (_PyIOBase_check_closed(self, Py_True) == NULL)
return NULL;
Py_RETURN_FALSE;
}
/* Readline(s) and writelines */
-PyDoc_STRVAR(IOBase_readline_doc,
+PyDoc_STRVAR(iobase_readline_doc,
"Read and return a line from the stream.\n"
"\n"
"If limit is specified, at most limit bytes will be read.\n"
@@ -446,7 +446,7 @@
"terminator(s) recognized.\n");
static PyObject *
-IOBase_readline(PyObject *self, PyObject *args)
+iobase_readline(PyObject *self, PyObject *args)
{
/* For backwards compatibility, a (slowish) readline(). */
@@ -541,9 +541,9 @@
}
static PyObject *
-IOBase_iter(PyObject *self)
+iobase_iter(PyObject *self)
{
- if (_PyIOBase_checkClosed(self, Py_True) == NULL)
+ if (_PyIOBase_check_closed(self, Py_True) == NULL)
return NULL;
Py_INCREF(self);
@@ -551,7 +551,7 @@
}
static PyObject *
-IOBase_iternext(PyObject *self)
+iobase_iternext(PyObject *self)
{
PyObject *line = PyObject_CallMethodObjArgs(self, _PyIO_str_readline, NULL);
@@ -566,7 +566,7 @@
return line;
}
-PyDoc_STRVAR(IOBase_readlines_doc,
+PyDoc_STRVAR(iobase_readlines_doc,
"Return a list of lines from the stream.\n"
"\n"
"hint can be specified to control the number of lines read: no more\n"
@@ -574,7 +574,7 @@
"lines so far exceeds hint.");
static PyObject *
-IOBase_readlines(PyObject *self, PyObject *args)
+iobase_readlines(PyObject *self, PyObject *args)
{
Py_ssize_t hint = -1, length = 0;
PyObject *hintobj = Py_None, *result;
@@ -631,7 +631,7 @@
}
static PyObject *
-IOBase_writelines(PyObject *self, PyObject *args)
+iobase_writelines(PyObject *self, PyObject *args)
{
PyObject *lines, *iter, *res;
@@ -639,7 +639,7 @@
return NULL;
}
- if (_PyIOBase_checkClosed(self, Py_True) == NULL)
+ if (_PyIOBase_check_closed(self, Py_True) == NULL)
return NULL;
iter = PyObject_GetIter(lines);
@@ -669,37 +669,37 @@
Py_RETURN_NONE;
}
-static PyMethodDef IOBase_methods[] = {
- {"seek", IOBase_seek, METH_VARARGS, IOBase_seek_doc},
- {"tell", IOBase_tell, METH_NOARGS, IOBase_tell_doc},
- {"truncate", IOBase_truncate, METH_VARARGS, IOBase_truncate_doc},
- {"flush", IOBase_flush, METH_NOARGS, IOBase_flush_doc},
- {"close", IOBase_close, METH_NOARGS, IOBase_close_doc},
-
- {"seekable", IOBase_seekable, METH_NOARGS, IOBase_seekable_doc},
- {"readable", IOBase_readable, METH_NOARGS, IOBase_readable_doc},
- {"writable", IOBase_writable, METH_NOARGS, IOBase_writable_doc},
-
- {"_checkClosed", _PyIOBase_checkClosed, METH_NOARGS},
- {"_checkSeekable", _PyIOBase_checkSeekable, METH_NOARGS},
- {"_checkReadable", _PyIOBase_checkReadable, METH_NOARGS},
- {"_checkWritable", _PyIOBase_checkWritable, METH_NOARGS},
-
- {"fileno", IOBase_fileno, METH_NOARGS, IOBase_fileno_doc},
- {"isatty", IOBase_isatty, METH_NOARGS, IOBase_isatty_doc},
-
- {"__enter__", IOBase_enter, METH_NOARGS},
- {"__exit__", IOBase_exit, METH_VARARGS},
-
- {"readline", IOBase_readline, METH_VARARGS, IOBase_readline_doc},
- {"readlines", IOBase_readlines, METH_VARARGS, IOBase_readlines_doc},
- {"writelines", IOBase_writelines, METH_VARARGS},
+static PyMethodDef iobase_methods[] = {
+ {"seek", iobase_seek, METH_VARARGS, iobase_seek_doc},
+ {"tell", iobase_tell, METH_NOARGS, iobase_tell_doc},
+ {"truncate", iobase_truncate, METH_VARARGS, iobase_truncate_doc},
+ {"flush", iobase_flush, METH_NOARGS, iobase_flush_doc},
+ {"close", iobase_close, METH_NOARGS, iobase_close_doc},
+
+ {"seekable", iobase_seekable, METH_NOARGS, iobase_seekable_doc},
+ {"readable", iobase_readable, METH_NOARGS, iobase_readable_doc},
+ {"writable", iobase_writable, METH_NOARGS, iobase_writable_doc},
+
+ {"_checkClosed", _PyIOBase_check_closed, METH_NOARGS},
+ {"_checkSeekable", _PyIOBase_check_seekable, METH_NOARGS},
+ {"_checkReadable", _PyIOBase_check_readable, METH_NOARGS},
+ {"_checkWritable", _PyIOBase_check_writable, METH_NOARGS},
+
+ {"fileno", iobase_fileno, METH_NOARGS, iobase_fileno_doc},
+ {"isatty", iobase_isatty, METH_NOARGS, iobase_isatty_doc},
+
+ {"__enter__", iobase_enter, METH_NOARGS},
+ {"__exit__", iobase_exit, METH_VARARGS},
+
+ {"readline", iobase_readline, METH_VARARGS, iobase_readline_doc},
+ {"readlines", iobase_readlines, METH_VARARGS, iobase_readlines_doc},
+ {"writelines", iobase_writelines, METH_VARARGS},
{NULL, NULL}
};
-static PyGetSetDef IOBase_getset[] = {
- {"closed", (getter)IOBase_closed_get, NULL, NULL},
+static PyGetSetDef iobase_getset[] = {
+ {"closed", (getter)iobase_closed_get, NULL, NULL},
{NULL}
};
@@ -707,9 +707,9 @@
PyTypeObject PyIOBase_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io._IOBase", /*tp_name*/
- sizeof(IOBaseObject), /*tp_basicsize*/
+ sizeof(iobase), /*tp_basicsize*/
0, /*tp_itemsize*/
- (destructor)IOBase_dealloc, /*tp_dealloc*/
+ (destructor)iobase_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
@@ -726,21 +726,21 @@
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- IOBase_doc, /* tp_doc */
- (traverseproc)IOBase_traverse, /* tp_traverse */
- (inquiry)IOBase_clear, /* tp_clear */
+ iobase_doc, /* tp_doc */
+ (traverseproc)iobase_traverse, /* tp_traverse */
+ (inquiry)iobase_clear, /* tp_clear */
0, /* tp_richcompare */
- offsetof(IOBaseObject, weakreflist), /* tp_weaklistoffset */
- IOBase_iter, /* tp_iter */
- IOBase_iternext, /* tp_iternext */
- IOBase_methods, /* tp_methods */
+ offsetof(iobase, weakreflist), /* tp_weaklistoffset */
+ iobase_iter, /* tp_iter */
+ iobase_iternext, /* tp_iternext */
+ iobase_methods, /* tp_methods */
0, /* tp_members */
- IOBase_getset, /* tp_getset */
+ iobase_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- offsetof(IOBaseObject, dict), /* tp_dictoffset */
+ offsetof(iobase, dict), /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
@@ -750,7 +750,7 @@
/*
* RawIOBase class, Inherits from IOBase.
*/
-PyDoc_STRVAR(RawIOBase_doc,
+PyDoc_STRVAR(rawiobase_doc,
"Base class for raw binary I/O.");
/*
@@ -766,7 +766,7 @@
*/
static PyObject *
-RawIOBase_read(PyObject *self, PyObject *args)
+rawiobase_read(PyObject *self, PyObject *args)
{
Py_ssize_t n = -1;
PyObject *b, *res;
@@ -803,11 +803,11 @@
}
-PyDoc_STRVAR(RawIOBase_readall_doc,
+PyDoc_STRVAR(rawiobase_readall_doc,
"Read until EOF, using multiple read() call.");
static PyObject *
-RawIOBase_readall(PyObject *self, PyObject *args)
+rawiobase_readall(PyObject *self, PyObject *args)
{
int r;
PyObject *chunks = PyList_New(0);
@@ -846,9 +846,9 @@
return result;
}
-static PyMethodDef RawIOBase_methods[] = {
- {"read", RawIOBase_read, METH_VARARGS},
- {"readall", RawIOBase_readall, METH_NOARGS, RawIOBase_readall_doc},
+static PyMethodDef rawiobase_methods[] = {
+ {"read", rawiobase_read, METH_VARARGS},
+ {"readall", rawiobase_readall, METH_NOARGS, rawiobase_readall_doc},
{NULL, NULL}
};
@@ -873,14 +873,14 @@
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
- RawIOBase_doc, /* tp_doc */
+ rawiobase_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
- RawIOBase_methods, /* tp_methods */
+ rawiobase_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
&PyIOBase_Type, /* tp_base */
Modified: python/branches/py3k/Modules/_io/stringio.c
==============================================================================
--- python/branches/py3k/Modules/_io/stringio.c (original)
+++ python/branches/py3k/Modules/_io/stringio.c Fri Jun 12 04:07:12 2009
@@ -24,7 +24,7 @@
PyObject *dict;
PyObject *weakreflist;
-} StringIOObject;
+} stringio;
#define CHECK_INITIALIZED(self) \
if (self->ok <= 0) { \
@@ -51,7 +51,7 @@
buffer of StringIO objects. The caller should ensure that the 'size'
argument is non-negative. Returns 0 on success, -1 otherwise. */
static int
-resize_buffer(StringIOObject *self, size_t size)
+resize_buffer(stringio *self, size_t size)
{
/* Here, unsigned types are used to avoid dealing with signed integer
overflow, which is undefined in C. */
@@ -106,7 +106,7 @@
/* Internal routine for writing a whole PyUnicode object to the buffer of a
StringIO object. Returns 0 on success, or -1 on error. */
static Py_ssize_t
-write_str(StringIOObject *self, PyObject *obj)
+write_str(stringio *self, PyObject *obj)
{
Py_UNICODE *str;
Py_ssize_t len;
@@ -186,7 +186,7 @@
"Retrieve the entire contents of the object.");
static PyObject *
-stringio_getvalue(StringIOObject *self)
+stringio_getvalue(stringio *self)
{
CHECK_INITIALIZED(self);
CHECK_CLOSED(self);
@@ -197,7 +197,7 @@
"Tell the current file position.");
static PyObject *
-stringio_tell(StringIOObject *self)
+stringio_tell(stringio *self)
{
CHECK_INITIALIZED(self);
CHECK_CLOSED(self);
@@ -211,7 +211,7 @@
"is reached. Return an empty string at EOF.\n");
static PyObject *
-stringio_read(StringIOObject *self, PyObject *args)
+stringio_read(stringio *self, PyObject *args)
{
Py_ssize_t size, n;
Py_UNICODE *output;
@@ -252,7 +252,7 @@
/* Internal helper, used by stringio_readline and stringio_iternext */
static PyObject *
-_stringio_readline(StringIOObject *self, Py_ssize_t limit)
+_stringio_readline(stringio *self, Py_ssize_t limit)
{
Py_UNICODE *start, *end, old_char;
Py_ssize_t len, consumed;
@@ -286,7 +286,7 @@
"Returns an empty string if EOF is hit immediately.\n");
static PyObject *
-stringio_readline(StringIOObject *self, PyObject *args)
+stringio_readline(stringio *self, PyObject *args)
{
PyObject *arg = Py_None;
Py_ssize_t limit = -1;
@@ -310,7 +310,7 @@
}
static PyObject *
-stringio_iternext(StringIOObject *self)
+stringio_iternext(stringio *self)
{
PyObject *line;
@@ -354,7 +354,7 @@
"Returns the new absolute position.\n");
static PyObject *
-stringio_truncate(StringIOObject *self, PyObject *args)
+stringio_truncate(stringio *self, PyObject *args)
{
Py_ssize_t size;
PyObject *arg = Py_None;
@@ -405,7 +405,7 @@
"Returns the new absolute position.\n");
static PyObject *
-stringio_seek(StringIOObject *self, PyObject *args)
+stringio_seek(stringio *self, PyObject *args)
{
Py_ssize_t pos;
int mode = 0;
@@ -453,7 +453,7 @@
"the length of the string.\n");
static PyObject *
-stringio_write(StringIOObject *self, PyObject *obj)
+stringio_write(stringio *self, PyObject *obj)
{
Py_ssize_t size;
@@ -479,7 +479,7 @@
"This method has no effect if the file is already closed.\n");
static PyObject *
-stringio_close(StringIOObject *self)
+stringio_close(stringio *self)
{
self->closed = 1;
/* Free up some memory */
@@ -492,21 +492,21 @@
}
static int
-stringio_traverse(StringIOObject *self, visitproc visit, void *arg)
+stringio_traverse(stringio *self, visitproc visit, void *arg)
{
Py_VISIT(self->dict);
return 0;
}
static int
-stringio_clear(StringIOObject *self)
+stringio_clear(stringio *self)
{
Py_CLEAR(self->dict);
return 0;
}
static void
-stringio_dealloc(StringIOObject *self)
+stringio_dealloc(stringio *self)
{
_PyObject_GC_UNTRACK(self);
Py_CLEAR(self->readnl);
@@ -522,10 +522,10 @@
static PyObject *
stringio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- StringIOObject *self;
+ stringio *self;
assert(type != NULL && type->tp_alloc != NULL);
- self = (StringIOObject *)type->tp_alloc(type, 0);
+ self = (stringio *)type->tp_alloc(type, 0);
if (self == NULL)
return NULL;
@@ -542,7 +542,7 @@
}
static int
-stringio_init(StringIOObject *self, PyObject *args, PyObject *kwds)
+stringio_init(stringio *self, PyObject *args, PyObject *kwds)
{
char *kwlist[] = {"initial_value", "newline", NULL};
PyObject *value = NULL;
@@ -625,28 +625,28 @@
/* Properties and pseudo-properties */
static PyObject *
-stringio_seekable(StringIOObject *self, PyObject *args)
+stringio_seekable(stringio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
Py_RETURN_TRUE;
}
static PyObject *
-stringio_readable(StringIOObject *self, PyObject *args)
+stringio_readable(stringio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
Py_RETURN_TRUE;
}
static PyObject *
-stringio_writable(StringIOObject *self, PyObject *args)
+stringio_writable(stringio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
Py_RETURN_TRUE;
}
static PyObject *
-stringio_buffer(StringIOObject *self, void *context)
+stringio_buffer(stringio *self, void *context)
{
PyErr_SetString(IO_STATE->unsupported_operation,
"buffer attribute is unsupported on type StringIO");
@@ -654,14 +654,14 @@
}
static PyObject *
-stringio_closed(StringIOObject *self, void *context)
+stringio_closed(stringio *self, void *context)
{
CHECK_INITIALIZED(self);
return PyBool_FromLong(self->closed);
}
static PyObject *
-stringio_line_buffering(StringIOObject *self, void *context)
+stringio_line_buffering(stringio *self, void *context)
{
CHECK_INITIALIZED(self);
CHECK_CLOSED(self);
@@ -669,7 +669,7 @@
}
static PyObject *
-stringio_newlines(StringIOObject *self, void *context)
+stringio_newlines(stringio *self, void *context)
{
CHECK_INITIALIZED(self);
CHECK_CLOSED(self);
@@ -711,7 +711,7 @@
PyTypeObject PyStringIO_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.StringIO", /*tp_name*/
- sizeof(StringIOObject), /*tp_basicsize*/
+ sizeof(stringio), /*tp_basicsize*/
0, /*tp_itemsize*/
(destructor)stringio_dealloc, /*tp_dealloc*/
0, /*tp_print*/
@@ -734,7 +734,7 @@
(traverseproc)stringio_traverse, /*tp_traverse*/
(inquiry)stringio_clear, /*tp_clear*/
0, /*tp_richcompare*/
- offsetof(StringIOObject, weakreflist), /*tp_weaklistoffset*/
+ offsetof(stringio, weakreflist), /*tp_weaklistoffset*/
0, /*tp_iter*/
(iternextfunc)stringio_iternext, /*tp_iternext*/
stringio_methods, /*tp_methods*/
@@ -744,7 +744,7 @@
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
- offsetof(StringIOObject, dict), /*tp_dictoffset*/
+ offsetof(stringio, dict), /*tp_dictoffset*/
(initproc)stringio_init, /*tp_init*/
0, /*tp_alloc*/
stringio_new, /*tp_new*/
Modified: python/branches/py3k/Modules/_io/textio.c
==============================================================================
--- python/branches/py3k/Modules/_io/textio.c (original)
+++ python/branches/py3k/Modules/_io/textio.c Fri Jun 12 04:07:12 2009
@@ -13,7 +13,7 @@
/* TextIOBase */
-PyDoc_STRVAR(TextIOBase_doc,
+PyDoc_STRVAR(textiobase_doc,
"Base class for text I/O.\n"
"\n"
"This class provides a character and line based interface to stream\n"
@@ -28,7 +28,7 @@
return NULL;
}
-PyDoc_STRVAR(TextIOBase_detach_doc,
+PyDoc_STRVAR(textiobase_detach_doc,
"Separate the underlying buffer from the TextIOBase and return it.\n"
"\n"
"After the underlying buffer has been detached, the TextIO is in an\n"
@@ -36,12 +36,12 @@
);
static PyObject *
-TextIOBase_detach(PyObject *self)
+textiobase_detach(PyObject *self)
{
return _unsupported("detach");
}
-PyDoc_STRVAR(TextIOBase_read_doc,
+PyDoc_STRVAR(textiobase_read_doc,
"Read at most n characters from stream.\n"
"\n"
"Read from underlying buffer until we have n characters or we hit EOF.\n"
@@ -49,48 +49,48 @@
);
static PyObject *
-TextIOBase_read(PyObject *self, PyObject *args)
+textiobase_read(PyObject *self, PyObject *args)
{
return _unsupported("read");
}
-PyDoc_STRVAR(TextIOBase_readline_doc,
+PyDoc_STRVAR(textiobase_readline_doc,
"Read until newline or EOF.\n"
"\n"
"Returns an empty string if EOF is hit immediately.\n"
);
static PyObject *
-TextIOBase_readline(PyObject *self, PyObject *args)
+textiobase_readline(PyObject *self, PyObject *args)
{
return _unsupported("readline");
}
-PyDoc_STRVAR(TextIOBase_write_doc,
+PyDoc_STRVAR(textiobase_write_doc,
"Write string to stream.\n"
"Returns the number of characters written (which is always equal to\n"
"the length of the string).\n"
);
static PyObject *
-TextIOBase_write(PyObject *self, PyObject *args)
+textiobase_write(PyObject *self, PyObject *args)
{
return _unsupported("write");
}
-PyDoc_STRVAR(TextIOBase_encoding_doc,
+PyDoc_STRVAR(textiobase_encoding_doc,
"Encoding of the text stream.\n"
"\n"
"Subclasses should override.\n"
);
static PyObject *
-TextIOBase_encoding_get(PyObject *self, void *context)
+textiobase_encoding_get(PyObject *self, void *context)
{
Py_RETURN_NONE;
}
-PyDoc_STRVAR(TextIOBase_newlines_doc,
+PyDoc_STRVAR(textiobase_newlines_doc,
"Line endings translated so far.\n"
"\n"
"Only line endings translated during reading are considered.\n"
@@ -99,36 +99,36 @@
);
static PyObject *
-TextIOBase_newlines_get(PyObject *self, void *context)
+textiobase_newlines_get(PyObject *self, void *context)
{
Py_RETURN_NONE;
}
-PyDoc_STRVAR(TextIOBase_errors_doc,
+PyDoc_STRVAR(textiobase_errors_doc,
"The error setting of the decoder or encoder.\n"
"\n"
"Subclasses should override.\n"
);
static PyObject *
-TextIOBase_errors_get(PyObject *self, void *context)
+textiobase_errors_get(PyObject *self, void *context)
{
Py_RETURN_NONE;
}
-static PyMethodDef TextIOBase_methods[] = {
- {"detach", (PyCFunction)TextIOBase_detach, METH_NOARGS, TextIOBase_detach_doc},
- {"read", TextIOBase_read, METH_VARARGS, TextIOBase_read_doc},
- {"readline", TextIOBase_readline, METH_VARARGS, TextIOBase_readline_doc},
- {"write", TextIOBase_write, METH_VARARGS, TextIOBase_write_doc},
+static PyMethodDef textiobase_methods[] = {
+ {"detach", (PyCFunction)textiobase_detach, METH_NOARGS, textiobase_detach_doc},
+ {"read", textiobase_read, METH_VARARGS, textiobase_read_doc},
+ {"readline", textiobase_readline, METH_VARARGS, textiobase_readline_doc},
+ {"write", textiobase_write, METH_VARARGS, textiobase_write_doc},
{NULL, NULL}
};
-static PyGetSetDef TextIOBase_getset[] = {
- {"encoding", (getter)TextIOBase_encoding_get, NULL, TextIOBase_encoding_doc},
- {"newlines", (getter)TextIOBase_newlines_get, NULL, TextIOBase_newlines_doc},
- {"errors", (getter)TextIOBase_errors_get, NULL, TextIOBase_errors_doc},
+static PyGetSetDef textiobase_getset[] = {
+ {"encoding", (getter)textiobase_encoding_get, NULL, textiobase_encoding_doc},
+ {"newlines", (getter)textiobase_newlines_get, NULL, textiobase_newlines_doc},
+ {"errors", (getter)textiobase_errors_get, NULL, textiobase_errors_doc},
{NULL}
};
@@ -153,16 +153,16 @@
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
- TextIOBase_doc, /* tp_doc */
+ textiobase_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
- TextIOBase_methods, /* tp_methods */
+ textiobase_methods, /* tp_methods */
0, /* tp_members */
- TextIOBase_getset, /* tp_getset */
+ textiobase_getset, /* tp_getset */
&PyIOBase_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
@@ -176,7 +176,7 @@
/* IncrementalNewlineDecoder */
-PyDoc_STRVAR(IncrementalNewlineDecoder_doc,
+PyDoc_STRVAR(incrementalnewlinedecoder_doc,
"Codec used when reading a file in universal newlines mode. It wraps\n"
"another incremental decoder, translating \\r\\n and \\r into \\n. It also\n"
"records the types of newlines encountered. When used with\n"
@@ -193,10 +193,10 @@
int pendingcr:1;
int translate:1;
unsigned int seennl:3;
-} PyNewLineDecoderObject;
+} nldecoder_object;
static int
-IncrementalNewlineDecoder_init(PyNewLineDecoderObject *self,
+incrementalnewlinedecoder_init(nldecoder_object *self,
PyObject *args, PyObject *kwds)
{
PyObject *decoder;
@@ -229,7 +229,7 @@
}
static void
-IncrementalNewlineDecoder_dealloc(PyNewLineDecoderObject *self)
+incrementalnewlinedecoder_dealloc(nldecoder_object *self)
{
Py_CLEAR(self->decoder);
Py_CLEAR(self->errors);
@@ -247,7 +247,7 @@
{
PyObject *output;
Py_ssize_t output_len;
- PyNewLineDecoderObject *self = (PyNewLineDecoderObject *) _self;
+ nldecoder_object *self = (nldecoder_object *) _self;
if (self->decoder == NULL) {
PyErr_SetString(PyExc_ValueError,
@@ -460,7 +460,7 @@
}
static PyObject *
-IncrementalNewlineDecoder_decode(PyNewLineDecoderObject *self,
+incrementalnewlinedecoder_decode(nldecoder_object *self,
PyObject *args, PyObject *kwds)
{
char *kwlist[] = {"input", "final", NULL};
@@ -474,7 +474,7 @@
}
static PyObject *
-IncrementalNewlineDecoder_getstate(PyNewLineDecoderObject *self, PyObject *args)
+incrementalnewlinedecoder_getstate(nldecoder_object *self, PyObject *args)
{
PyObject *buffer;
unsigned PY_LONG_LONG flag;
@@ -502,7 +502,7 @@
}
static PyObject *
-IncrementalNewlineDecoder_setstate(PyNewLineDecoderObject *self, PyObject *state)
+incrementalnewlinedecoder_setstate(nldecoder_object *self, PyObject *state)
{
PyObject *buffer;
unsigned PY_LONG_LONG flag;
@@ -521,7 +521,7 @@
}
static PyObject *
-IncrementalNewlineDecoder_reset(PyNewLineDecoderObject *self, PyObject *args)
+incrementalnewlinedecoder_reset(nldecoder_object *self, PyObject *args)
{
self->seennl = 0;
self->pendingcr = 0;
@@ -532,7 +532,7 @@
}
static PyObject *
-IncrementalNewlineDecoder_newlines_get(PyNewLineDecoderObject *self, void *context)
+incrementalnewlinedecoder_newlines_get(nldecoder_object *self, void *context)
{
switch (self->seennl) {
case SEEN_CR:
@@ -556,25 +556,25 @@
}
-static PyMethodDef IncrementalNewlineDecoder_methods[] = {
- {"decode", (PyCFunction)IncrementalNewlineDecoder_decode, METH_VARARGS|METH_KEYWORDS},
- {"getstate", (PyCFunction)IncrementalNewlineDecoder_getstate, METH_NOARGS},
- {"setstate", (PyCFunction)IncrementalNewlineDecoder_setstate, METH_O},
- {"reset", (PyCFunction)IncrementalNewlineDecoder_reset, METH_NOARGS},
+static PyMethodDef incrementalnewlinedecoder_methods[] = {
+ {"decode", (PyCFunction)incrementalnewlinedecoder_decode, METH_VARARGS|METH_KEYWORDS},
+ {"getstate", (PyCFunction)incrementalnewlinedecoder_getstate, METH_NOARGS},
+ {"setstate", (PyCFunction)incrementalnewlinedecoder_setstate, METH_O},
+ {"reset", (PyCFunction)incrementalnewlinedecoder_reset, METH_NOARGS},
{NULL}
};
-static PyGetSetDef IncrementalNewlineDecoder_getset[] = {
- {"newlines", (getter)IncrementalNewlineDecoder_newlines_get, NULL, NULL},
+static PyGetSetDef incrementalnewlinedecoder_getset[] = {
+ {"newlines", (getter)incrementalnewlinedecoder_newlines_get, NULL, NULL},
{NULL}
};
PyTypeObject PyIncrementalNewlineDecoder_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.IncrementalNewlineDecoder", /*tp_name*/
- sizeof(PyNewLineDecoderObject), /*tp_basicsize*/
+ sizeof(nldecoder_object), /*tp_basicsize*/
0, /*tp_itemsize*/
- (destructor)IncrementalNewlineDecoder_dealloc, /*tp_dealloc*/
+ (destructor)incrementalnewlinedecoder_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
@@ -590,22 +590,22 @@
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
- IncrementalNewlineDecoder_doc, /* tp_doc */
+ incrementalnewlinedecoder_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /*tp_weaklistoffset*/
0, /* tp_iter */
0, /* tp_iternext */
- IncrementalNewlineDecoder_methods, /* tp_methods */
+ incrementalnewlinedecoder_methods, /* tp_methods */
0, /* tp_members */
- IncrementalNewlineDecoder_getset, /* tp_getset */
+ incrementalnewlinedecoder_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
- (initproc)IncrementalNewlineDecoder_init, /* tp_init */
+ (initproc)incrementalnewlinedecoder_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
@@ -613,7 +613,7 @@
/* TextIOWrapper */
-PyDoc_STRVAR(TextIOWrapper_doc,
+PyDoc_STRVAR(textiowrapper_doc,
"Character and line based layer over a BufferedIOBase object, buffer.\n"
"\n"
"encoding gives the name of the encoding that the stream will be\n"
@@ -689,14 +689,14 @@
PyObject *weakreflist;
PyObject *dict;
-} PyTextIOWrapperObject;
+} textio;
/* A couple of specialized cases in order to bypass the slow incremental
encoding methods for the most popular encodings. */
static PyObject *
-ascii_encode(PyTextIOWrapperObject *self, PyObject *text)
+ascii_encode(textio *self, PyObject *text)
{
return PyUnicode_EncodeASCII(PyUnicode_AS_UNICODE(text),
PyUnicode_GET_SIZE(text),
@@ -704,7 +704,7 @@
}
static PyObject *
-utf16be_encode(PyTextIOWrapperObject *self, PyObject *text)
+utf16be_encode(textio *self, PyObject *text)
{
return PyUnicode_EncodeUTF16(PyUnicode_AS_UNICODE(text),
PyUnicode_GET_SIZE(text),
@@ -712,7 +712,7 @@
}
static PyObject *
-utf16le_encode(PyTextIOWrapperObject *self, PyObject *text)
+utf16le_encode(textio *self, PyObject *text)
{
return PyUnicode_EncodeUTF16(PyUnicode_AS_UNICODE(text),
PyUnicode_GET_SIZE(text),
@@ -720,7 +720,7 @@
}
static PyObject *
-utf16_encode(PyTextIOWrapperObject *self, PyObject *text)
+utf16_encode(textio *self, PyObject *text)
{
if (!self->encoding_start_of_stream) {
/* Skip the BOM and use native byte ordering */
@@ -736,7 +736,7 @@
}
static PyObject *
-utf32be_encode(PyTextIOWrapperObject *self, PyObject *text)
+utf32be_encode(textio *self, PyObject *text)
{
return PyUnicode_EncodeUTF32(PyUnicode_AS_UNICODE(text),
PyUnicode_GET_SIZE(text),
@@ -744,7 +744,7 @@
}
static PyObject *
-utf32le_encode(PyTextIOWrapperObject *self, PyObject *text)
+utf32le_encode(textio *self, PyObject *text)
{
return PyUnicode_EncodeUTF32(PyUnicode_AS_UNICODE(text),
PyUnicode_GET_SIZE(text),
@@ -752,7 +752,7 @@
}
static PyObject *
-utf32_encode(PyTextIOWrapperObject *self, PyObject *text)
+utf32_encode(textio *self, PyObject *text)
{
if (!self->encoding_start_of_stream) {
/* Skip the BOM and use native byte ordering */
@@ -768,7 +768,7 @@
}
static PyObject *
-utf8_encode(PyTextIOWrapperObject *self, PyObject *text)
+utf8_encode(textio *self, PyObject *text)
{
return PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(text),
PyUnicode_GET_SIZE(text),
@@ -776,7 +776,7 @@
}
static PyObject *
-latin1_encode(PyTextIOWrapperObject *self, PyObject *text)
+latin1_encode(textio *self, PyObject *text)
{
return PyUnicode_EncodeLatin1(PyUnicode_AS_UNICODE(text),
PyUnicode_GET_SIZE(text),
@@ -805,7 +805,7 @@
static int
-TextIOWrapper_init(PyTextIOWrapperObject *self, PyObject *args, PyObject *kwds)
+textiowrapper_init(textio *self, PyObject *args, PyObject *kwds)
{
char *kwlist[] = {"buffer", "encoding", "errors",
"newline", "line_buffering",
@@ -1068,7 +1068,7 @@
}
static int
-_TextIOWrapper_clear(PyTextIOWrapperObject *self)
+_textiowrapper_clear(textio *self)
{
if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
return -1;
@@ -1087,9 +1087,9 @@
}
static void
-TextIOWrapper_dealloc(PyTextIOWrapperObject *self)
+textiowrapper_dealloc(textio *self)
{
- if (_TextIOWrapper_clear(self) < 0)
+ if (_textiowrapper_clear(self) < 0)
return;
_PyObject_GC_UNTRACK(self);
if (self->weakreflist != NULL)
@@ -1099,7 +1099,7 @@
}
static int
-TextIOWrapper_traverse(PyTextIOWrapperObject *self, visitproc visit, void *arg)
+textiowrapper_traverse(textio *self, visitproc visit, void *arg)
{
Py_VISIT(self->buffer);
Py_VISIT(self->encoding);
@@ -1117,16 +1117,16 @@
}
static int
-TextIOWrapper_clear(PyTextIOWrapperObject *self)
+textiowrapper_clear(textio *self)
{
- if (_TextIOWrapper_clear(self) < 0)
+ if (_textiowrapper_clear(self) < 0)
return -1;
Py_CLEAR(self->dict);
return 0;
}
static PyObject *
-TextIOWrapper_closed_get(PyTextIOWrapperObject *self, void *context);
+textiowrapper_closed_get(textio *self, void *context);
/* This macro takes some shortcuts to make the common case faster. */
#define CHECK_CLOSED(self) \
@@ -1137,7 +1137,7 @@
if (self->raw != NULL) \
r = _PyFileIO_closed(self->raw); \
else { \
- _res = TextIOWrapper_closed_get(self, NULL); \
+ _res = textiowrapper_closed_get(self, NULL); \
if (_res == NULL) \
return NULL; \
r = PyObject_IsTrue(_res); \
@@ -1151,7 +1151,7 @@
return NULL; \
} \
} \
- else if (_PyIOBase_checkClosed((PyObject *)self, Py_True) == NULL) \
+ else if (_PyIOBase_check_closed((PyObject *)self, Py_True) == NULL) \
return NULL; \
} while (0)
@@ -1181,7 +1181,7 @@
static PyObject *
-TextIOWrapper_detach(PyTextIOWrapperObject *self)
+textiowrapper_detach(textio *self)
{
PyObject *buffer, *res;
CHECK_INITIALIZED(self);
@@ -1211,7 +1211,7 @@
/* Flush the internal write buffer. This doesn't explicitly flush the
underlying buffered object, though. */
static int
-_TextIOWrapper_writeflush(PyTextIOWrapperObject *self)
+_textiowrapper_writeflush(textio *self)
{
PyObject *b, *ret;
@@ -1232,7 +1232,7 @@
}
static PyObject *
-TextIOWrapper_write(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_write(textio *self, PyObject *args)
{
PyObject *ret;
PyObject *text; /* owned reference */
@@ -1305,7 +1305,7 @@
self->pending_bytes_count += PyBytes_GET_SIZE(b);
Py_DECREF(b);
if (self->pending_bytes_count > self->chunk_size || needflush) {
- if (_TextIOWrapper_writeflush(self) < 0)
+ if (_textiowrapper_writeflush(self) < 0)
return NULL;
}
@@ -1331,7 +1331,7 @@
/* Steal a reference to chars and store it in the decoded_char buffer;
*/
static void
-TextIOWrapper_set_decoded_chars(PyTextIOWrapperObject *self, PyObject *chars)
+textiowrapper_set_decoded_chars(textio *self, PyObject *chars)
{
Py_CLEAR(self->decoded_chars);
self->decoded_chars = chars;
@@ -1339,7 +1339,7 @@
}
static PyObject *
-TextIOWrapper_get_decoded_chars(PyTextIOWrapperObject *self, Py_ssize_t n)
+textiowrapper_get_decoded_chars(textio *self, Py_ssize_t n)
{
PyObject *chars;
Py_ssize_t avail;
@@ -1374,7 +1374,7 @@
/* Read and decode the next chunk of data from the BufferedReader.
*/
static int
-TextIOWrapper_read_chunk(PyTextIOWrapperObject *self)
+textiowrapper_read_chunk(textio *self)
{
PyObject *dec_buffer = NULL;
PyObject *dec_flags = NULL;
@@ -1439,7 +1439,7 @@
/* TODO sanity check: isinstance(decoded_chars, unicode) */
if (decoded_chars == NULL)
goto fail;
- TextIOWrapper_set_decoded_chars(self, decoded_chars);
+ textiowrapper_set_decoded_chars(self, decoded_chars);
if (PyUnicode_GET_SIZE(decoded_chars) > 0)
eof = 0;
@@ -1467,7 +1467,7 @@
}
static PyObject *
-TextIOWrapper_read(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_read(textio *self, PyObject *args)
{
Py_ssize_t n = -1;
PyObject *result = NULL, *chunks = NULL;
@@ -1484,7 +1484,7 @@
return NULL;
}
- if (_TextIOWrapper_writeflush(self) < 0)
+ if (_textiowrapper_writeflush(self) < 0)
return NULL;
if (n < 0) {
@@ -1499,7 +1499,7 @@
if (decoded == NULL)
goto fail;
- result = TextIOWrapper_get_decoded_chars(self, -1);
+ result = textiowrapper_get_decoded_chars(self, -1);
if (result == NULL) {
Py_DECREF(decoded);
@@ -1517,14 +1517,14 @@
int res = 1;
Py_ssize_t remaining = n;
- result = TextIOWrapper_get_decoded_chars(self, n);
+ result = textiowrapper_get_decoded_chars(self, n);
if (result == NULL)
goto fail;
remaining -= PyUnicode_GET_SIZE(result);
/* Keep reading chunks until we have n characters to return */
while (remaining > 0) {
- res = TextIOWrapper_read_chunk(self);
+ res = textiowrapper_read_chunk(self);
if (res < 0)
goto fail;
if (res == 0) /* EOF */
@@ -1537,7 +1537,7 @@
if (PyList_Append(chunks, result) < 0)
goto fail;
Py_DECREF(result);
- result = TextIOWrapper_get_decoded_chars(self, remaining);
+ result = textiowrapper_get_decoded_chars(self, remaining);
if (result == NULL)
goto fail;
remaining -= PyUnicode_GET_SIZE(result);
@@ -1662,7 +1662,7 @@
}
static PyObject *
-_TextIOWrapper_readline(PyTextIOWrapperObject *self, Py_ssize_t limit)
+_textiowrapper_readline(textio *self, Py_ssize_t limit)
{
PyObject *line = NULL, *chunks = NULL, *remaining = NULL;
Py_ssize_t start, endpos, chunked, offset_to_buffer;
@@ -1670,7 +1670,7 @@
CHECK_CLOSED(self);
- if (_TextIOWrapper_writeflush(self) < 0)
+ if (_textiowrapper_writeflush(self) < 0)
return NULL;
chunked = 0;
@@ -1684,7 +1684,7 @@
res = 1;
while (!self->decoded_chars ||
!PyUnicode_GET_SIZE(self->decoded_chars)) {
- res = TextIOWrapper_read_chunk(self);
+ res = textiowrapper_read_chunk(self);
if (res < 0)
goto error;
if (res == 0)
@@ -1692,7 +1692,7 @@
}
if (res == 0) {
/* end of file */
- TextIOWrapper_set_decoded_chars(self, NULL);
+ textiowrapper_set_decoded_chars(self, NULL);
Py_CLEAR(self->snapshot);
start = endpos = offset_to_buffer = 0;
break;
@@ -1763,7 +1763,7 @@
}
Py_CLEAR(line);
/* We have consumed the buffer */
- TextIOWrapper_set_decoded_chars(self, NULL);
+ textiowrapper_set_decoded_chars(self, NULL);
}
if (line != NULL) {
@@ -1816,7 +1816,7 @@
}
static PyObject *
-TextIOWrapper_readline(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_readline(textio *self, PyObject *args)
{
Py_ssize_t limit = -1;
@@ -1824,7 +1824,7 @@
if (!PyArg_ParseTuple(args, "|n:readline", &limit)) {
return NULL;
}
- return _TextIOWrapper_readline(self, limit);
+ return _textiowrapper_readline(self, limit);
}
/* Seek and Tell */
@@ -1835,7 +1835,7 @@
int bytes_to_feed;
int chars_to_skip;
char need_eof;
-} CookieStruct;
+} cookie_type;
/*
To speed up cookie packing/unpacking, we store the fields in a temporary
@@ -1876,7 +1876,7 @@
#endif
static int
-TextIOWrapper_parseCookie(CookieStruct *cookie, PyObject *cookieObj)
+textiowrapper_parse_cookie(cookie_type *cookie, PyObject *cookieObj)
{
unsigned char buffer[COOKIE_BUF_LEN];
PyLongObject *cookieLong = (PyLongObject *)PyNumber_Long(cookieObj);
@@ -1900,7 +1900,7 @@
}
static PyObject *
-TextIOWrapper_buildCookie(CookieStruct *cookie)
+textiowrapper_build_cookie(cookie_type *cookie)
{
unsigned char buffer[COOKIE_BUF_LEN];
@@ -1915,8 +1915,7 @@
#undef IS_LITTLE_ENDIAN
static int
-_TextIOWrapper_decoder_setstate(PyTextIOWrapperObject *self,
- CookieStruct *cookie)
+_textiowrapper_decoder_setstate(textio *self, cookie_type *cookie)
{
PyObject *res;
/* When seeking to the start of the stream, we call decoder.reset()
@@ -1937,11 +1936,10 @@
}
static int
-_TextIOWrapper_encoder_setstate(PyTextIOWrapperObject *self,
- CookieStruct *cookie)
+_textiowrapper_encoder_setstate(textio *self, cookie_type *cookie)
{
PyObject *res;
- /* Same as _TextIOWrapper_decoder_setstate() above. */
+ /* Same as _textiowrapper_decoder_setstate() above. */
if (cookie->start_pos == 0 && cookie->dec_flags == 0) {
res = PyObject_CallMethodObjArgs(self->encoder, _PyIO_str_reset, NULL);
self->encoding_start_of_stream = 1;
@@ -1958,10 +1956,10 @@
}
static PyObject *
-TextIOWrapper_seek(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_seek(textio *self, PyObject *args)
{
PyObject *cookieObj, *posobj;
- CookieStruct cookie;
+ cookie_type cookie;
int whence = 0;
PyObject *res;
int cmp;
@@ -2018,7 +2016,7 @@
goto fail;
Py_DECREF(res);
- TextIOWrapper_set_decoded_chars(self, NULL);
+ textiowrapper_set_decoded_chars(self, NULL);
Py_CLEAR(self->snapshot);
if (self->decoder) {
res = PyObject_CallMethod(self->decoder, "reset", NULL);
@@ -2055,7 +2053,7 @@
/* The strategy of seek() is to go back to the safe start point
* and replay the effect of read(chars_to_skip) from there.
*/
- if (TextIOWrapper_parseCookie(&cookie, cookieObj) < 0)
+ if (textiowrapper_parse_cookie(&cookie, cookieObj) < 0)
goto fail;
/* Seek back to the safe start point. */
@@ -2069,12 +2067,12 @@
goto fail;
Py_DECREF(res);
- TextIOWrapper_set_decoded_chars(self, NULL);
+ textiowrapper_set_decoded_chars(self, NULL);
Py_CLEAR(self->snapshot);
/* Restore the decoder to its state from the safe start point. */
if (self->decoder) {
- if (_TextIOWrapper_decoder_setstate(self, &cookie) < 0)
+ if (_textiowrapper_decoder_setstate(self, &cookie) < 0)
goto fail;
}
@@ -2101,7 +2099,7 @@
if (decoded == NULL)
goto fail;
- TextIOWrapper_set_decoded_chars(self, decoded);
+ textiowrapper_set_decoded_chars(self, decoded);
/* Skip chars_to_skip of the decoded characters. */
if (PyUnicode_GetSize(self->decoded_chars) < cookie.chars_to_skip) {
@@ -2118,7 +2116,7 @@
/* Finally, reset the encoder (merely useful for proper BOM handling) */
if (self->encoder) {
- if (_TextIOWrapper_encoder_setstate(self, &cookie) < 0)
+ if (_textiowrapper_encoder_setstate(self, &cookie) < 0)
goto fail;
}
return cookieObj;
@@ -2129,11 +2127,11 @@
}
static PyObject *
-TextIOWrapper_tell(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_tell(textio *self, PyObject *args)
{
PyObject *res;
PyObject *posobj = NULL;
- CookieStruct cookie = {0,0,0,0,0};
+ cookie_type cookie = {0,0,0,0,0};
PyObject *next_input;
Py_ssize_t chars_to_skip, chars_decoded;
PyObject *saved_state = NULL;
@@ -2153,7 +2151,7 @@
goto fail;
}
- if (_TextIOWrapper_writeflush(self) < 0)
+ if (_textiowrapper_writeflush(self) < 0)
return NULL;
res = PyObject_CallMethod((PyObject *)self, "flush", NULL);
if (res == NULL)
@@ -2189,7 +2187,7 @@
if (self->decoded_chars_used == 0) {
/* We haven't moved from the snapshot point. */
Py_DECREF(posobj);
- return TextIOWrapper_buildCookie(&cookie);
+ return textiowrapper_build_cookie(&cookie);
}
chars_to_skip = self->decoded_chars_used;
@@ -2203,7 +2201,7 @@
goto fail;
/* Note our initial start point. */
- if (_TextIOWrapper_decoder_setstate(self, &cookie) < 0)
+ if (_textiowrapper_decoder_setstate(self, &cookie) < 0)
goto fail;
/* Feed the decoder one byte at a time. As we go, note the
@@ -2280,7 +2278,7 @@
/* The returned cookie corresponds to the last safe start point. */
cookie.chars_to_skip = Py_SAFE_DOWNCAST(chars_to_skip, Py_ssize_t, int);
- return TextIOWrapper_buildCookie(&cookie);
+ return textiowrapper_build_cookie(&cookie);
fail:
Py_XDECREF(posobj);
@@ -2300,7 +2298,7 @@
}
static PyObject *
-TextIOWrapper_truncate(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_truncate(textio *self, PyObject *args)
{
PyObject *pos = Py_None;
PyObject *res;
@@ -2327,7 +2325,7 @@
}
static PyObject *
-TextIOWrapper_repr(PyTextIOWrapperObject *self)
+textiowrapper_repr(textio *self)
{
PyObject *nameobj, *res;
@@ -2354,53 +2352,53 @@
/* Inquiries */
static PyObject *
-TextIOWrapper_fileno(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_fileno(textio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
return PyObject_CallMethod(self->buffer, "fileno", NULL);
}
static PyObject *
-TextIOWrapper_seekable(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_seekable(textio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
return PyObject_CallMethod(self->buffer, "seekable", NULL);
}
static PyObject *
-TextIOWrapper_readable(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_readable(textio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
return PyObject_CallMethod(self->buffer, "readable", NULL);
}
static PyObject *
-TextIOWrapper_writable(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_writable(textio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
return PyObject_CallMethod(self->buffer, "writable", NULL);
}
static PyObject *
-TextIOWrapper_isatty(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_isatty(textio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
return PyObject_CallMethod(self->buffer, "isatty", NULL);
}
static PyObject *
-TextIOWrapper_flush(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_flush(textio *self, PyObject *args)
{
CHECK_INITIALIZED(self);
CHECK_CLOSED(self);
self->telling = self->seekable;
- if (_TextIOWrapper_writeflush(self) < 0)
+ if (_textiowrapper_writeflush(self) < 0)
return NULL;
return PyObject_CallMethod(self->buffer, "flush", NULL);
}
static PyObject *
-TextIOWrapper_close(PyTextIOWrapperObject *self, PyObject *args)
+textiowrapper_close(textio *self, PyObject *args)
{
PyObject *res;
CHECK_INITIALIZED(self);
@@ -2416,7 +2414,7 @@
}
static PyObject *
-TextIOWrapper_iternext(PyTextIOWrapperObject *self)
+textiowrapper_iternext(textio *self)
{
PyObject *line;
@@ -2425,7 +2423,7 @@
self->telling = 0;
if (Py_TYPE(self) == &PyTextIOWrapper_Type) {
/* Skip method call overhead for speed */
- line = _TextIOWrapper_readline(self, -1);
+ line = _textiowrapper_readline(self, -1);
}
else {
line = PyObject_CallMethodObjArgs((PyObject *)self,
@@ -2454,21 +2452,21 @@
}
static PyObject *
-TextIOWrapper_name_get(PyTextIOWrapperObject *self, void *context)
+textiowrapper_name_get(textio *self, void *context)
{
CHECK_INITIALIZED(self);
return PyObject_GetAttrString(self->buffer, "name");
}
static PyObject *
-TextIOWrapper_closed_get(PyTextIOWrapperObject *self, void *context)
+textiowrapper_closed_get(textio *self, void *context)
{
CHECK_INITIALIZED(self);
return PyObject_GetAttr(self->buffer, _PyIO_str_closed);
}
static PyObject *
-TextIOWrapper_newlines_get(PyTextIOWrapperObject *self, void *context)
+textiowrapper_newlines_get(textio *self, void *context)
{
PyObject *res;
CHECK_INITIALIZED(self);
@@ -2488,22 +2486,21 @@
}
static PyObject *
-TextIOWrapper_errors_get(PyTextIOWrapperObject *self, void *context)
+textiowrapper_errors_get(textio *self, void *context)
{
CHECK_INITIALIZED(self);
return PyUnicode_FromString(PyBytes_AS_STRING(self->errors));
}
static PyObject *
-TextIOWrapper_chunk_size_get(PyTextIOWrapperObject *self, void *context)
+textiowrapper_chunk_size_get(textio *self, void *context)
{
CHECK_INITIALIZED(self);
return PyLong_FromSsize_t(self->chunk_size);
}
static int
-TextIOWrapper_chunk_size_set(PyTextIOWrapperObject *self,
- PyObject *arg, void *context)
+textiowrapper_chunk_size_set(textio *self, PyObject *arg, void *context)
{
Py_ssize_t n;
CHECK_INITIALIZED_INT(self);
@@ -2519,56 +2516,56 @@
return 0;
}
-static PyMethodDef TextIOWrapper_methods[] = {
- {"detach", (PyCFunction)TextIOWrapper_detach, METH_NOARGS},
- {"write", (PyCFunction)TextIOWrapper_write, METH_VARARGS},
- {"read", (PyCFunction)TextIOWrapper_read, METH_VARARGS},
- {"readline", (PyCFunction)TextIOWrapper_readline, METH_VARARGS},
- {"flush", (PyCFunction)TextIOWrapper_flush, METH_NOARGS},
- {"close", (PyCFunction)TextIOWrapper_close, METH_NOARGS},
-
- {"fileno", (PyCFunction)TextIOWrapper_fileno, METH_NOARGS},
- {"seekable", (PyCFunction)TextIOWrapper_seekable, METH_NOARGS},
- {"readable", (PyCFunction)TextIOWrapper_readable, METH_NOARGS},
- {"writable", (PyCFunction)TextIOWrapper_writable, METH_NOARGS},
- {"isatty", (PyCFunction)TextIOWrapper_isatty, METH_NOARGS},
-
- {"seek", (PyCFunction)TextIOWrapper_seek, METH_VARARGS},
- {"tell", (PyCFunction)TextIOWrapper_tell, METH_NOARGS},
- {"truncate", (PyCFunction)TextIOWrapper_truncate, METH_VARARGS},
+static PyMethodDef textiowrapper_methods[] = {
+ {"detach", (PyCFunction)textiowrapper_detach, METH_NOARGS},
+ {"write", (PyCFunction)textiowrapper_write, METH_VARARGS},
+ {"read", (PyCFunction)textiowrapper_read, METH_VARARGS},
+ {"readline", (PyCFunction)textiowrapper_readline, METH_VARARGS},
+ {"flush", (PyCFunction)textiowrapper_flush, METH_NOARGS},
+ {"close", (PyCFunction)textiowrapper_close, METH_NOARGS},
+
+ {"fileno", (PyCFunction)textiowrapper_fileno, METH_NOARGS},
+ {"seekable", (PyCFunction)textiowrapper_seekable, METH_NOARGS},
+ {"readable", (PyCFunction)textiowrapper_readable, METH_NOARGS},
+ {"writable", (PyCFunction)textiowrapper_writable, METH_NOARGS},
+ {"isatty", (PyCFunction)textiowrapper_isatty, METH_NOARGS},
+
+ {"seek", (PyCFunction)textiowrapper_seek, METH_VARARGS},
+ {"tell", (PyCFunction)textiowrapper_tell, METH_NOARGS},
+ {"truncate", (PyCFunction)textiowrapper_truncate, METH_VARARGS},
{NULL, NULL}
};
-static PyMemberDef TextIOWrapper_members[] = {
- {"encoding", T_OBJECT, offsetof(PyTextIOWrapperObject, encoding), READONLY},
- {"buffer", T_OBJECT, offsetof(PyTextIOWrapperObject, buffer), READONLY},
- {"line_buffering", T_BOOL, offsetof(PyTextIOWrapperObject, line_buffering), READONLY},
+static PyMemberDef textiowrapper_members[] = {
+ {"encoding", T_OBJECT, offsetof(textio, encoding), READONLY},
+ {"buffer", T_OBJECT, offsetof(textio, buffer), READONLY},
+ {"line_buffering", T_BOOL, offsetof(textio, line_buffering), READONLY},
{NULL}
};
-static PyGetSetDef TextIOWrapper_getset[] = {
- {"name", (getter)TextIOWrapper_name_get, NULL, NULL},
- {"closed", (getter)TextIOWrapper_closed_get, NULL, NULL},
+static PyGetSetDef textiowrapper_getset[] = {
+ {"name", (getter)textiowrapper_name_get, NULL, NULL},
+ {"closed", (getter)textiowrapper_closed_get, NULL, NULL},
/* {"mode", (getter)TextIOWrapper_mode_get, NULL, NULL},
*/
- {"newlines", (getter)TextIOWrapper_newlines_get, NULL, NULL},
- {"errors", (getter)TextIOWrapper_errors_get, NULL, NULL},
- {"_CHUNK_SIZE", (getter)TextIOWrapper_chunk_size_get,
- (setter)TextIOWrapper_chunk_size_set, NULL},
+ {"newlines", (getter)textiowrapper_newlines_get, NULL, NULL},
+ {"errors", (getter)textiowrapper_errors_get, NULL, NULL},
+ {"_CHUNK_SIZE", (getter)textiowrapper_chunk_size_get,
+ (setter)textiowrapper_chunk_size_set, NULL},
{NULL}
};
PyTypeObject PyTextIOWrapper_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_io.TextIOWrapper", /*tp_name*/
- sizeof(PyTextIOWrapperObject), /*tp_basicsize*/
+ sizeof(textio), /*tp_basicsize*/
0, /*tp_itemsize*/
- (destructor)TextIOWrapper_dealloc, /*tp_dealloc*/
+ (destructor)textiowrapper_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tps_etattr*/
0, /*tp_compare */
- (reprfunc)TextIOWrapper_repr,/*tp_repr*/
+ (reprfunc)textiowrapper_repr,/*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
@@ -2580,22 +2577,22 @@
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- TextIOWrapper_doc, /* tp_doc */
- (traverseproc)TextIOWrapper_traverse, /* tp_traverse */
- (inquiry)TextIOWrapper_clear, /* tp_clear */
+ textiowrapper_doc, /* tp_doc */
+ (traverseproc)textiowrapper_traverse, /* tp_traverse */
+ (inquiry)textiowrapper_clear, /* tp_clear */
0, /* tp_richcompare */
- offsetof(PyTextIOWrapperObject, weakreflist), /*tp_weaklistoffset*/
+ offsetof(textio, weakreflist), /*tp_weaklistoffset*/
0, /* tp_iter */
- (iternextfunc)TextIOWrapper_iternext, /* tp_iternext */
- TextIOWrapper_methods, /* tp_methods */
- TextIOWrapper_members, /* tp_members */
- TextIOWrapper_getset, /* tp_getset */
+ (iternextfunc)textiowrapper_iternext, /* tp_iternext */
+ textiowrapper_methods, /* tp_methods */
+ textiowrapper_members, /* tp_members */
+ textiowrapper_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- offsetof(PyTextIOWrapperObject, dict), /*tp_dictoffset*/
- (initproc)TextIOWrapper_init, /* tp_init */
+ offsetof(textio, dict), /*tp_dictoffset*/
+ (initproc)textiowrapper_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
More information about the Python-checkins
mailing list