mirror of
https://github.com/python/cpython.git
synced 2024-12-13 20:05:53 +08:00
72f455e96c
CID 1058763
942 lines
27 KiB
C
942 lines
27 KiB
C
/*
|
|
An implementation of the I/O abstract base classes hierarchy
|
|
as defined by PEP 3116 - "New I/O"
|
|
|
|
Classes defined here: IOBase, RawIOBase.
|
|
|
|
Written by Amaury Forgeot d'Arc and Antoine Pitrou
|
|
*/
|
|
|
|
|
|
#define PY_SSIZE_T_CLEAN
|
|
#include "Python.h"
|
|
#include "structmember.h"
|
|
#include "_iomodule.h"
|
|
|
|
/*
|
|
* IOBase class, an abstract class
|
|
*/
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
|
|
PyObject *dict;
|
|
PyObject *weakreflist;
|
|
} iobase;
|
|
|
|
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"
|
|
"This class provides dummy implementations for many methods that\n"
|
|
"derived classes can override selectively; the default implementations\n"
|
|
"represent a file that cannot be read, written or seeked.\n"
|
|
"\n"
|
|
"Even though IOBase does not declare read, readinto, or write because\n"
|
|
"their signatures will vary, implementations and clients should\n"
|
|
"consider those methods part of the interface. Also, implementations\n"
|
|
"may raise UnsupportedOperation when operations they do not support are\n"
|
|
"called.\n"
|
|
"\n"
|
|
"The basic type used for binary data read from or written to a file is\n"
|
|
"bytes. bytearrays are accepted too, and in some cases (such as\n"
|
|
"readinto) needed. Text I/O classes work with str data.\n"
|
|
"\n"
|
|
"Note that calling any method (even inquiries) on a closed stream is\n"
|
|
"undefined. Implementations may raise IOError in this case.\n"
|
|
"\n"
|
|
"IOBase (and its subclasses) support the iterator protocol, meaning\n"
|
|
"that an IOBase object can be iterated over yielding the lines in a\n"
|
|
"stream.\n"
|
|
"\n"
|
|
"IOBase also supports the :keyword:`with` statement. In this example,\n"
|
|
"fp is closed after the suite of the with statement is complete:\n"
|
|
"\n"
|
|
"with open('spam.txt', 'r') as fp:\n"
|
|
" fp.write('Spam and eggs!')\n");
|
|
|
|
/* Use this macro whenever you want to check the internal `closed` status
|
|
of the IOBase object rather than the virtual `closed` attribute as returned
|
|
by whatever subclass. */
|
|
|
|
_Py_IDENTIFIER(__IOBase_closed);
|
|
#define IS_CLOSED(self) \
|
|
_PyObject_HasAttrId(self, &PyId___IOBase_closed)
|
|
|
|
/* Internal methods */
|
|
static PyObject *
|
|
iobase_unsupported(const char *message)
|
|
{
|
|
PyErr_SetString(IO_STATE->unsupported_operation, message);
|
|
return NULL;
|
|
}
|
|
|
|
/* Positionning */
|
|
|
|
PyDoc_STRVAR(iobase_seek_doc,
|
|
"Change stream position.\n"
|
|
"\n"
|
|
"Change the stream position to the given byte offset. The offset is\n"
|
|
"interpreted relative to the position indicated by whence. Values\n"
|
|
"for whence are:\n"
|
|
"\n"
|
|
"* 0 -- start of stream (the default); offset should be zero or positive\n"
|
|
"* 1 -- current stream position; offset may be negative\n"
|
|
"* 2 -- end of stream; offset is usually negative\n"
|
|
"\n"
|
|
"Return the new absolute position.");
|
|
|
|
static PyObject *
|
|
iobase_seek(PyObject *self, PyObject *args)
|
|
{
|
|
return iobase_unsupported("seek");
|
|
}
|
|
|
|
PyDoc_STRVAR(iobase_tell_doc,
|
|
"Return current stream position.");
|
|
|
|
static PyObject *
|
|
iobase_tell(PyObject *self, PyObject *args)
|
|
{
|
|
_Py_IDENTIFIER(seek);
|
|
|
|
return _PyObject_CallMethodId(self, &PyId_seek, "ii", 0, 1);
|
|
}
|
|
|
|
PyDoc_STRVAR(iobase_truncate_doc,
|
|
"Truncate file to size bytes.\n"
|
|
"\n"
|
|
"File pointer is left unchanged. Size defaults to the current IO\n"
|
|
"position as reported by tell(). Returns the new size.");
|
|
|
|
static PyObject *
|
|
iobase_truncate(PyObject *self, PyObject *args)
|
|
{
|
|
return iobase_unsupported("truncate");
|
|
}
|
|
|
|
/* Flush and close methods */
|
|
|
|
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)
|
|
{
|
|
/* XXX Should this return the number of bytes written??? */
|
|
if (IS_CLOSED(self)) {
|
|
PyErr_SetString(PyExc_ValueError, "I/O operation on closed file.");
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
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)
|
|
{
|
|
PyObject *res;
|
|
int closed;
|
|
/* This gets the derived attribute, which is *not* __IOBase_closed
|
|
in most cases! */
|
|
res = PyObject_GetAttr(self, _PyIO_str_closed);
|
|
if (res == NULL)
|
|
return 0;
|
|
closed = PyObject_IsTrue(res);
|
|
Py_DECREF(res);
|
|
return closed;
|
|
}
|
|
|
|
static PyObject *
|
|
iobase_closed_get(PyObject *self, void *context)
|
|
{
|
|
return PyBool_FromLong(IS_CLOSED(self));
|
|
}
|
|
|
|
PyObject *
|
|
_PyIOBase_check_closed(PyObject *self, PyObject *args)
|
|
{
|
|
if (iobase_closed(self)) {
|
|
PyErr_SetString(PyExc_ValueError, "I/O operation on closed file.");
|
|
return NULL;
|
|
}
|
|
if (args == Py_True)
|
|
return Py_None;
|
|
else
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* XXX: IOBase thinks it has to maintain its own internal state in
|
|
`__IOBase_closed` and call flush() by itself, but it is redundant with
|
|
whatever behaviour a non-trivial derived class will implement. */
|
|
|
|
static PyObject *
|
|
iobase_close(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *res;
|
|
_Py_IDENTIFIER(__IOBase_closed);
|
|
|
|
if (IS_CLOSED(self))
|
|
Py_RETURN_NONE;
|
|
|
|
res = PyObject_CallMethodObjArgs(self, _PyIO_str_flush, NULL);
|
|
_PyObject_SetAttrId(self, &PyId___IOBase_closed, Py_True);
|
|
if (res == NULL) {
|
|
return NULL;
|
|
}
|
|
Py_XDECREF(res);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* Finalization and garbage collection support */
|
|
|
|
static void
|
|
iobase_finalize(PyObject *self)
|
|
{
|
|
PyObject *res;
|
|
PyObject *error_type, *error_value, *error_traceback;
|
|
int closed;
|
|
_Py_IDENTIFIER(_finalizing);
|
|
|
|
/* Save the current exception, if any. */
|
|
PyErr_Fetch(&error_type, &error_value, &error_traceback);
|
|
|
|
/* If `closed` doesn't exist or can't be evaluated as bool, then the
|
|
object is probably in an unusable state, so ignore. */
|
|
res = PyObject_GetAttr(self, _PyIO_str_closed);
|
|
if (res == NULL) {
|
|
PyErr_Clear();
|
|
closed = -1;
|
|
}
|
|
else {
|
|
closed = PyObject_IsTrue(res);
|
|
Py_DECREF(res);
|
|
if (closed == -1)
|
|
PyErr_Clear();
|
|
}
|
|
if (closed == 0) {
|
|
/* Signal close() that it was called as part of the object
|
|
finalization process. */
|
|
if (_PyObject_SetAttrId(self, &PyId__finalizing, Py_True))
|
|
PyErr_Clear();
|
|
res = PyObject_CallMethodObjArgs((PyObject *) self, _PyIO_str_close,
|
|
NULL);
|
|
/* Silencing I/O errors is bad, but printing spurious tracebacks is
|
|
equally as bad, and potentially more frequent (because of
|
|
shutdown issues). */
|
|
if (res == NULL)
|
|
PyErr_Clear();
|
|
else
|
|
Py_DECREF(res);
|
|
}
|
|
|
|
/* Restore the saved exception. */
|
|
PyErr_Restore(error_type, error_value, error_traceback);
|
|
}
|
|
|
|
int
|
|
_PyIOBase_finalize(PyObject *self)
|
|
{
|
|
int is_zombie;
|
|
|
|
/* If _PyIOBase_finalize() is called from a destructor, we need to
|
|
resurrect the object as calling close() can invoke arbitrary code. */
|
|
is_zombie = (Py_REFCNT(self) == 0);
|
|
if (is_zombie)
|
|
return PyObject_CallFinalizerFromDealloc(self);
|
|
else {
|
|
PyObject_CallFinalizer(self);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int
|
|
iobase_traverse(iobase *self, visitproc visit, void *arg)
|
|
{
|
|
Py_VISIT(self->dict);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
iobase_clear(iobase *self)
|
|
{
|
|
Py_CLEAR(self->dict);
|
|
return 0;
|
|
}
|
|
|
|
/* Destructor */
|
|
|
|
static void
|
|
iobase_dealloc(iobase *self)
|
|
{
|
|
/* NOTE: since IOBaseObject has its own dict, Python-defined attributes
|
|
are still available here for close() to use.
|
|
However, if the derived class declares a __slots__, those slots are
|
|
already gone.
|
|
*/
|
|
if (_PyIOBase_finalize((PyObject *) self) < 0) {
|
|
/* When called from a heap type's dealloc, the type will be
|
|
decref'ed on return (see e.g. subtype_dealloc in typeobject.c). */
|
|
if (PyType_HasFeature(Py_TYPE(self), Py_TPFLAGS_HEAPTYPE))
|
|
Py_INCREF(Py_TYPE(self));
|
|
return;
|
|
}
|
|
_PyObject_GC_UNTRACK(self);
|
|
if (self->weakreflist != NULL)
|
|
PyObject_ClearWeakRefs((PyObject *) self);
|
|
Py_CLEAR(self->dict);
|
|
Py_TYPE(self)->tp_free((PyObject *) self);
|
|
}
|
|
|
|
/* Inquiry methods */
|
|
|
|
PyDoc_STRVAR(iobase_seekable_doc,
|
|
"Return whether object supports random access.\n"
|
|
"\n"
|
|
"If False, seek(), tell() and truncate() will raise UnsupportedOperation.\n"
|
|
"This method may need to do a test seek().");
|
|
|
|
static PyObject *
|
|
iobase_seekable(PyObject *self, PyObject *args)
|
|
{
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PyObject *
|
|
_PyIOBase_check_seekable(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_seekable, NULL);
|
|
if (res == NULL)
|
|
return NULL;
|
|
if (res != Py_True) {
|
|
Py_CLEAR(res);
|
|
iobase_unsupported("File or stream is not seekable.");
|
|
return NULL;
|
|
}
|
|
if (args == Py_True) {
|
|
Py_DECREF(res);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
PyDoc_STRVAR(iobase_readable_doc,
|
|
"Return whether object was opened for reading.\n"
|
|
"\n"
|
|
"If False, read() will raise UnsupportedOperation.");
|
|
|
|
static PyObject *
|
|
iobase_readable(PyObject *self, PyObject *args)
|
|
{
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
/* May be called with any object */
|
|
PyObject *
|
|
_PyIOBase_check_readable(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_readable, NULL);
|
|
if (res == NULL)
|
|
return NULL;
|
|
if (res != Py_True) {
|
|
Py_CLEAR(res);
|
|
iobase_unsupported("File or stream is not readable.");
|
|
return NULL;
|
|
}
|
|
if (args == Py_True) {
|
|
Py_DECREF(res);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
PyDoc_STRVAR(iobase_writable_doc,
|
|
"Return whether object was opened for writing.\n"
|
|
"\n"
|
|
"If False, write() will raise UnsupportedOperation.");
|
|
|
|
static PyObject *
|
|
iobase_writable(PyObject *self, PyObject *args)
|
|
{
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
/* May be called with any object */
|
|
PyObject *
|
|
_PyIOBase_check_writable(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *res = PyObject_CallMethodObjArgs(self, _PyIO_str_writable, NULL);
|
|
if (res == NULL)
|
|
return NULL;
|
|
if (res != Py_True) {
|
|
Py_CLEAR(res);
|
|
iobase_unsupported("File or stream is not writable.");
|
|
return NULL;
|
|
}
|
|
if (args == Py_True) {
|
|
Py_DECREF(res);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/* Context manager */
|
|
|
|
static PyObject *
|
|
iobase_enter(PyObject *self, PyObject *args)
|
|
{
|
|
if (_PyIOBase_check_closed(self, Py_True) == NULL)
|
|
return NULL;
|
|
|
|
Py_INCREF(self);
|
|
return self;
|
|
}
|
|
|
|
static PyObject *
|
|
iobase_exit(PyObject *self, PyObject *args)
|
|
{
|
|
return PyObject_CallMethodObjArgs(self, _PyIO_str_close, NULL);
|
|
}
|
|
|
|
/* Lower-level APIs */
|
|
|
|
/* XXX Should these be present even if unimplemented? */
|
|
|
|
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)
|
|
{
|
|
return iobase_unsupported("fileno");
|
|
}
|
|
|
|
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)
|
|
{
|
|
if (_PyIOBase_check_closed(self, Py_True) == NULL)
|
|
return NULL;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
/* Readline(s) and writelines */
|
|
|
|
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"
|
|
"\n"
|
|
"The line terminator is always b'\\n' for binary files; for text\n"
|
|
"files, the newlines argument to open can be used to select the line\n"
|
|
"terminator(s) recognized.\n");
|
|
|
|
static PyObject *
|
|
iobase_readline(PyObject *self, PyObject *args)
|
|
{
|
|
/* For backwards compatibility, a (slowish) readline(). */
|
|
|
|
Py_ssize_t limit = -1;
|
|
int has_peek = 0;
|
|
PyObject *buffer, *result;
|
|
Py_ssize_t old_size = -1;
|
|
_Py_IDENTIFIER(read);
|
|
_Py_IDENTIFIER(peek);
|
|
|
|
if (!PyArg_ParseTuple(args, "|O&:readline", &_PyIO_ConvertSsize_t, &limit)) {
|
|
return NULL;
|
|
}
|
|
|
|
if (_PyObject_HasAttrId(self, &PyId_peek))
|
|
has_peek = 1;
|
|
|
|
buffer = PyByteArray_FromStringAndSize(NULL, 0);
|
|
if (buffer == NULL)
|
|
return NULL;
|
|
|
|
while (limit < 0 || Py_SIZE(buffer) < limit) {
|
|
Py_ssize_t nreadahead = 1;
|
|
PyObject *b;
|
|
|
|
if (has_peek) {
|
|
PyObject *readahead = _PyObject_CallMethodId(self, &PyId_peek, "i", 1);
|
|
if (readahead == NULL) {
|
|
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
|
|
when EINTR occurs so we needn't do it ourselves. */
|
|
if (_PyIO_trap_eintr()) {
|
|
continue;
|
|
}
|
|
goto fail;
|
|
}
|
|
if (!PyBytes_Check(readahead)) {
|
|
PyErr_Format(PyExc_IOError,
|
|
"peek() should have returned a bytes object, "
|
|
"not '%.200s'", Py_TYPE(readahead)->tp_name);
|
|
Py_DECREF(readahead);
|
|
goto fail;
|
|
}
|
|
if (PyBytes_GET_SIZE(readahead) > 0) {
|
|
Py_ssize_t n = 0;
|
|
const char *buf = PyBytes_AS_STRING(readahead);
|
|
if (limit >= 0) {
|
|
do {
|
|
if (n >= PyBytes_GET_SIZE(readahead) || n >= limit)
|
|
break;
|
|
if (buf[n++] == '\n')
|
|
break;
|
|
} while (1);
|
|
}
|
|
else {
|
|
do {
|
|
if (n >= PyBytes_GET_SIZE(readahead))
|
|
break;
|
|
if (buf[n++] == '\n')
|
|
break;
|
|
} while (1);
|
|
}
|
|
nreadahead = n;
|
|
}
|
|
Py_DECREF(readahead);
|
|
}
|
|
|
|
b = _PyObject_CallMethodId(self, &PyId_read, "n", nreadahead);
|
|
if (b == NULL) {
|
|
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
|
|
when EINTR occurs so we needn't do it ourselves. */
|
|
if (_PyIO_trap_eintr()) {
|
|
continue;
|
|
}
|
|
goto fail;
|
|
}
|
|
if (!PyBytes_Check(b)) {
|
|
PyErr_Format(PyExc_IOError,
|
|
"read() should have returned a bytes object, "
|
|
"not '%.200s'", Py_TYPE(b)->tp_name);
|
|
Py_DECREF(b);
|
|
goto fail;
|
|
}
|
|
if (PyBytes_GET_SIZE(b) == 0) {
|
|
Py_DECREF(b);
|
|
break;
|
|
}
|
|
|
|
old_size = PyByteArray_GET_SIZE(buffer);
|
|
PyByteArray_Resize(buffer, old_size + PyBytes_GET_SIZE(b));
|
|
memcpy(PyByteArray_AS_STRING(buffer) + old_size,
|
|
PyBytes_AS_STRING(b), PyBytes_GET_SIZE(b));
|
|
|
|
Py_DECREF(b);
|
|
|
|
if (PyByteArray_AS_STRING(buffer)[PyByteArray_GET_SIZE(buffer) - 1] == '\n')
|
|
break;
|
|
}
|
|
|
|
result = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(buffer),
|
|
PyByteArray_GET_SIZE(buffer));
|
|
Py_DECREF(buffer);
|
|
return result;
|
|
fail:
|
|
Py_DECREF(buffer);
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *
|
|
iobase_iter(PyObject *self)
|
|
{
|
|
if (_PyIOBase_check_closed(self, Py_True) == NULL)
|
|
return NULL;
|
|
|
|
Py_INCREF(self);
|
|
return self;
|
|
}
|
|
|
|
static PyObject *
|
|
iobase_iternext(PyObject *self)
|
|
{
|
|
PyObject *line = PyObject_CallMethodObjArgs(self, _PyIO_str_readline, NULL);
|
|
|
|
if (line == NULL)
|
|
return NULL;
|
|
|
|
if (PyObject_Size(line) == 0) {
|
|
Py_DECREF(line);
|
|
return NULL;
|
|
}
|
|
|
|
return line;
|
|
}
|
|
|
|
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"
|
|
"lines will be read if the total size (in bytes/characters) of all\n"
|
|
"lines so far exceeds hint.");
|
|
|
|
static PyObject *
|
|
iobase_readlines(PyObject *self, PyObject *args)
|
|
{
|
|
Py_ssize_t hint = -1, length = 0;
|
|
PyObject *result;
|
|
|
|
if (!PyArg_ParseTuple(args, "|O&:readlines", &_PyIO_ConvertSsize_t, &hint)) {
|
|
return NULL;
|
|
}
|
|
|
|
result = PyList_New(0);
|
|
if (result == NULL)
|
|
return NULL;
|
|
|
|
if (hint <= 0) {
|
|
/* XXX special-casing this made sense in the Python version in order
|
|
to remove the bytecode interpretation overhead, but it could
|
|
probably be removed here. */
|
|
_Py_IDENTIFIER(extend);
|
|
PyObject *ret = _PyObject_CallMethodId(result, &PyId_extend, "O", self);
|
|
|
|
if (ret == NULL) {
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
}
|
|
Py_DECREF(ret);
|
|
return result;
|
|
}
|
|
|
|
while (1) {
|
|
PyObject *line = PyIter_Next(self);
|
|
if (line == NULL) {
|
|
if (PyErr_Occurred()) {
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
}
|
|
else
|
|
break; /* StopIteration raised */
|
|
}
|
|
|
|
if (PyList_Append(result, line) < 0) {
|
|
Py_DECREF(line);
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
}
|
|
length += PyObject_Size(line);
|
|
Py_DECREF(line);
|
|
|
|
if (length > hint)
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static PyObject *
|
|
iobase_writelines(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *lines, *iter, *res;
|
|
|
|
if (!PyArg_ParseTuple(args, "O:writelines", &lines)) {
|
|
return NULL;
|
|
}
|
|
|
|
if (_PyIOBase_check_closed(self, Py_True) == NULL)
|
|
return NULL;
|
|
|
|
iter = PyObject_GetIter(lines);
|
|
if (iter == NULL)
|
|
return NULL;
|
|
|
|
while (1) {
|
|
PyObject *line = PyIter_Next(iter);
|
|
if (line == NULL) {
|
|
if (PyErr_Occurred()) {
|
|
Py_DECREF(iter);
|
|
return NULL;
|
|
}
|
|
else
|
|
break; /* Stop Iteration */
|
|
}
|
|
|
|
res = NULL;
|
|
do {
|
|
res = PyObject_CallMethodObjArgs(self, _PyIO_str_write, line, NULL);
|
|
} while (res == NULL && _PyIO_trap_eintr());
|
|
Py_DECREF(line);
|
|
if (res == NULL) {
|
|
Py_DECREF(iter);
|
|
return NULL;
|
|
}
|
|
Py_DECREF(res);
|
|
}
|
|
Py_DECREF(iter);
|
|
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_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[] = {
|
|
{"__dict__", PyObject_GenericGetDict, NULL, NULL},
|
|
{"closed", (getter)iobase_closed_get, NULL, NULL},
|
|
{NULL}
|
|
};
|
|
|
|
|
|
PyTypeObject PyIOBase_Type = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"_io._IOBase", /*tp_name*/
|
|
sizeof(iobase), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
(destructor)iobase_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare */
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash */
|
|
0, /*tp_call*/
|
|
0, /*tp_str*/
|
|
0, /*tp_getattro*/
|
|
0, /*tp_setattro*/
|
|
0, /*tp_as_buffer*/
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
|
|
| Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
|
|
iobase_doc, /* tp_doc */
|
|
(traverseproc)iobase_traverse, /* tp_traverse */
|
|
(inquiry)iobase_clear, /* tp_clear */
|
|
0, /* tp_richcompare */
|
|
offsetof(iobase, weakreflist), /* tp_weaklistoffset */
|
|
iobase_iter, /* tp_iter */
|
|
iobase_iternext, /* tp_iternext */
|
|
iobase_methods, /* tp_methods */
|
|
0, /* tp_members */
|
|
iobase_getset, /* tp_getset */
|
|
0, /* tp_base */
|
|
0, /* tp_dict */
|
|
0, /* tp_descr_get */
|
|
0, /* tp_descr_set */
|
|
offsetof(iobase, dict), /* tp_dictoffset */
|
|
0, /* tp_init */
|
|
0, /* tp_alloc */
|
|
PyType_GenericNew, /* tp_new */
|
|
0, /* tp_free */
|
|
0, /* tp_is_gc */
|
|
0, /* tp_bases */
|
|
0, /* tp_mro */
|
|
0, /* tp_cache */
|
|
0, /* tp_subclasses */
|
|
0, /* tp_weaklist */
|
|
0, /* tp_del */
|
|
0, /* tp_version_tag */
|
|
(destructor)iobase_finalize, /* tp_finalize */
|
|
};
|
|
|
|
|
|
/*
|
|
* RawIOBase class, Inherits from IOBase.
|
|
*/
|
|
PyDoc_STRVAR(rawiobase_doc,
|
|
"Base class for raw binary I/O.");
|
|
|
|
/*
|
|
* The read() method is implemented by calling readinto(); derived classes
|
|
* that want to support read() only need to implement readinto() as a
|
|
* primitive operation. In general, readinto() can be more efficient than
|
|
* read().
|
|
*
|
|
* (It would be tempting to also provide an implementation of readinto() in
|
|
* terms of read(), in case the latter is a more suitable primitive operation,
|
|
* but that would lead to nasty recursion in case a subclass doesn't implement
|
|
* either.)
|
|
*/
|
|
|
|
static PyObject *
|
|
rawiobase_read(PyObject *self, PyObject *args)
|
|
{
|
|
Py_ssize_t n = -1;
|
|
PyObject *b, *res;
|
|
|
|
if (!PyArg_ParseTuple(args, "|n:read", &n)) {
|
|
return NULL;
|
|
}
|
|
|
|
if (n < 0) {
|
|
_Py_IDENTIFIER(readall);
|
|
|
|
return _PyObject_CallMethodId(self, &PyId_readall, NULL);
|
|
}
|
|
|
|
/* TODO: allocate a bytes object directly instead and manually construct
|
|
a writable memoryview pointing to it. */
|
|
b = PyByteArray_FromStringAndSize(NULL, n);
|
|
if (b == NULL)
|
|
return NULL;
|
|
|
|
res = PyObject_CallMethodObjArgs(self, _PyIO_str_readinto, b, NULL);
|
|
if (res == NULL || res == Py_None) {
|
|
Py_DECREF(b);
|
|
return res;
|
|
}
|
|
|
|
n = PyNumber_AsSsize_t(res, PyExc_ValueError);
|
|
Py_DECREF(res);
|
|
if (n == -1 && PyErr_Occurred()) {
|
|
Py_DECREF(b);
|
|
return NULL;
|
|
}
|
|
|
|
res = PyBytes_FromStringAndSize(PyByteArray_AsString(b), n);
|
|
Py_DECREF(b);
|
|
return res;
|
|
}
|
|
|
|
|
|
PyDoc_STRVAR(rawiobase_readall_doc,
|
|
"Read until EOF, using multiple read() call.");
|
|
|
|
static PyObject *
|
|
rawiobase_readall(PyObject *self, PyObject *args)
|
|
{
|
|
int r;
|
|
PyObject *chunks = PyList_New(0);
|
|
PyObject *result;
|
|
|
|
if (chunks == NULL)
|
|
return NULL;
|
|
|
|
while (1) {
|
|
_Py_IDENTIFIER(read);
|
|
PyObject *data = _PyObject_CallMethodId(self, &PyId_read,
|
|
"i", DEFAULT_BUFFER_SIZE);
|
|
if (!data) {
|
|
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
|
|
when EINTR occurs so we needn't do it ourselves. */
|
|
if (_PyIO_trap_eintr()) {
|
|
continue;
|
|
}
|
|
Py_DECREF(chunks);
|
|
return NULL;
|
|
}
|
|
if (data == Py_None) {
|
|
if (PyList_GET_SIZE(chunks) == 0) {
|
|
Py_DECREF(chunks);
|
|
return data;
|
|
}
|
|
Py_DECREF(data);
|
|
break;
|
|
}
|
|
if (!PyBytes_Check(data)) {
|
|
Py_DECREF(chunks);
|
|
Py_DECREF(data);
|
|
PyErr_SetString(PyExc_TypeError, "read() should return bytes");
|
|
return NULL;
|
|
}
|
|
if (PyBytes_GET_SIZE(data) == 0) {
|
|
/* EOF */
|
|
Py_DECREF(data);
|
|
break;
|
|
}
|
|
r = PyList_Append(chunks, data);
|
|
Py_DECREF(data);
|
|
if (r < 0) {
|
|
Py_DECREF(chunks);
|
|
return NULL;
|
|
}
|
|
}
|
|
result = _PyBytes_Join(_PyIO_empty_bytes, chunks);
|
|
Py_DECREF(chunks);
|
|
return result;
|
|
}
|
|
|
|
static PyMethodDef rawiobase_methods[] = {
|
|
{"read", rawiobase_read, METH_VARARGS},
|
|
{"readall", rawiobase_readall, METH_NOARGS, rawiobase_readall_doc},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
PyTypeObject PyRawIOBase_Type = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"_io._RawIOBase", /*tp_name*/
|
|
0, /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
0, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare */
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash */
|
|
0, /*tp_call*/
|
|
0, /*tp_str*/
|
|
0, /*tp_getattro*/
|
|
0, /*tp_setattro*/
|
|
0, /*tp_as_buffer*/
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
|
|
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 */
|
|
0, /* tp_members */
|
|
0, /* tp_getset */
|
|
&PyIOBase_Type, /* tp_base */
|
|
0, /* tp_dict */
|
|
0, /* tp_descr_get */
|
|
0, /* tp_descr_set */
|
|
0, /* tp_dictoffset */
|
|
0, /* tp_init */
|
|
0, /* tp_alloc */
|
|
0, /* tp_new */
|
|
0, /* tp_free */
|
|
0, /* tp_is_gc */
|
|
0, /* tp_bases */
|
|
0, /* tp_mro */
|
|
0, /* tp_cache */
|
|
0, /* tp_subclasses */
|
|
0, /* tp_weaklist */
|
|
0, /* tp_del */
|
|
0, /* tp_version_tag */
|
|
0, /* tp_finalize */
|
|
};
|