move to a naming scheme with all lowercase and underscores
diff --git a/Modules/_io/bufferedio.c b/Modules/_io/bufferedio.c
index 034fe51..98f8413 100644
--- a/Modules/_io/bufferedio.c
+++ b/Modules/_io/bufferedio.c
@@ -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},
+ {"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},
+ {"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},
+ {"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},
+ {"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},
+ {"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},
+ {"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},
+ {"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 */
};