/* Author: Daniel Stutzbach */ #include "Python.h" #include "pycore_fileutils.h" // _Py_BEGIN_SUPPRESS_IPH #include "pycore_object.h" // _PyObject_GC_UNTRACK() #include "pycore_pyerrors.h" // _PyErr_ChainExceptions1() #include <stdbool.h> // bool #ifdef HAVE_UNISTD_H # include <unistd.h> // lseek() #endif #ifdef HAVE_SYS_TYPES_H # include <sys/types.h> #endif #ifdef HAVE_IO_H # include <io.h> #endif #ifdef HAVE_FCNTL_H # include <fcntl.h> // open() #endif #include "_iomodule.h" /* * Known likely problems: * * - Files larger then 2**32-1 * - Files with unicode filenames * - Passing numbers greater than 2**32-1 when an integer is expected * - Making it work on Windows and other oddball platforms * * To Do: * * - autoconfify header file inclusion */ #ifdef MS_WINDOWS // can simulate truncate with Win32 API functions; see file_truncate #define HAVE_FTRUNCATE # ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN # endif # include <windows.h> #endif #if BUFSIZ < (8*1024) #define SMALLCHUNK … #elif (BUFSIZ >= (2 << 25)) # error "unreasonable BUFSIZ > 64 MiB defined" #else #define SMALLCHUNK … #endif /* Size at which a buffer is considered "large" and behavior should change to avoid excessive memory allocation */ #define LARGE_BUFFER_CUTOFF_SIZE … /*[clinic input] module _io class _io.FileIO "fileio *" "clinic_state()->PyFileIO_Type" [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=ac25ec278f4d6703]*/ fileio; #define PyFileIO_Check(state, op) … #define _PyFileIO_CAST(op) … /* Forward declarations */ static PyObject* portable_lseek(fileio *self, PyObject *posobj, int whence, bool suppress_pipe_error); int _PyFileIO_closed(PyObject *self) { … } /* Because this can call arbitrary code, it shouldn't be called when the refcount is 0 (that is, not directly from tp_dealloc unless the refcount has been temporarily re-incremented). */ static PyObject * fileio_dealloc_warn(PyObject *op, PyObject *source) { … } /* Returns 0 on success, -1 with exception set on failure. */ static int internal_close(fileio *self) { … } /*[clinic input] _io.FileIO.close cls: defining_class / Close the file. A closed file cannot be used for further I/O operations. close() may be called more than once without error. [clinic start generated code]*/ static PyObject * _io_FileIO_close_impl(fileio *self, PyTypeObject *cls) /*[clinic end generated code: output=c30cbe9d1f23ca58 input=70da49e63db7c64d]*/ { … } static PyObject * fileio_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { … } #ifdef O_CLOEXEC extern int _Py_open_cloexec_works; #endif /*[clinic input] _io.FileIO.__init__ file as nameobj: object mode: str = "r" closefd: bool = True opener: object = None Open a file. The mode can be 'r' (default), 'w', 'x' or 'a' for reading, writing, exclusive creation or appending. The file will be created if it doesn't exist when opened for writing or appending; it will be truncated when opened for writing. A FileExistsError will be raised if it already exists when opened for creating. Opening a file for creating implies writing so this mode behaves in a similar way to 'w'.Add a '+' to the mode to allow simultaneous reading and writing. A custom opener can be used by passing a callable as *opener*. The underlying file descriptor for the file object is then obtained by calling opener with (*name*, *flags*). *opener* must return an open file descriptor (passing os.open as *opener* results in functionality similar to passing None). [clinic start generated code]*/ static int _io_FileIO___init___impl(fileio *self, PyObject *nameobj, const char *mode, int closefd, PyObject *opener) /*[clinic end generated code: output=23413f68e6484bbd input=588aac967e0ba74b]*/ { … } static int fileio_traverse(PyObject *op, visitproc visit, void *arg) { … } static int fileio_clear(PyObject *op) { … } static void fileio_dealloc(PyObject *op) { … } static PyObject * err_closed(void) { … } static PyObject * err_mode(_PyIO_State *state, const char *action) { … } /*[clinic input] _io.FileIO.fileno Return the underlying file descriptor (an integer). [clinic start generated code]*/ static PyObject * _io_FileIO_fileno_impl(fileio *self) /*[clinic end generated code: output=a9626ce5398ece90 input=0b9b2de67335ada3]*/ { … } /*[clinic input] _io.FileIO.readable True if file was opened in a read mode. [clinic start generated code]*/ static PyObject * _io_FileIO_readable_impl(fileio *self) /*[clinic end generated code: output=640744a6150fe9ba input=a3fdfed6eea721c5]*/ { … } /*[clinic input] _io.FileIO.writable True if file was opened in a write mode. [clinic start generated code]*/ static PyObject * _io_FileIO_writable_impl(fileio *self) /*[clinic end generated code: output=96cefc5446e89977 input=c204a808ca2e1748]*/ { … } /*[clinic input] _io.FileIO.seekable True if file supports random-access. [clinic start generated code]*/ static PyObject * _io_FileIO_seekable_impl(fileio *self) /*[clinic end generated code: output=47909ca0a42e9287 input=c8e5554d2fd63c7f]*/ { … } /*[clinic input] _io.FileIO.readinto cls: defining_class buffer: Py_buffer(accept={rwbuffer}) / Same as RawIOBase.readinto(). [clinic start generated code]*/ static PyObject * _io_FileIO_readinto_impl(fileio *self, PyTypeObject *cls, Py_buffer *buffer) /*[clinic end generated code: output=97f0f3d69534db34 input=fd20323e18ce1ec8]*/ { … } static size_t new_buffersize(fileio *self, size_t currentsize) { … } /*[clinic input] _io.FileIO.readall Read all data from the file, returned as bytes. In non-blocking mode, returns as much as is immediately available, or None if no data is available. Return an empty bytes object at EOF. [clinic start generated code]*/ static PyObject * _io_FileIO_readall_impl(fileio *self) /*[clinic end generated code: output=faa0292b213b4022 input=dbdc137f55602834]*/ { … } /*[clinic input] _io.FileIO.read cls: defining_class size: Py_ssize_t(accept={int, NoneType}) = -1 / Read at most size bytes, returned as bytes. Only makes one system call, so less data may be returned than requested. In non-blocking mode, returns None if no data is available. Return an empty bytes object at EOF. [clinic start generated code]*/ static PyObject * _io_FileIO_read_impl(fileio *self, PyTypeObject *cls, Py_ssize_t size) /*[clinic end generated code: output=bbd749c7c224143e input=f613d2057e4a1918]*/ { … } /*[clinic input] _io.FileIO.write cls: defining_class b: Py_buffer / Write buffer b to file, return number of bytes written. Only makes one system call, so not all of the data may be written. The number of bytes actually written is returned. In non-blocking mode, returns None if the write would block. [clinic start generated code]*/ static PyObject * _io_FileIO_write_impl(fileio *self, PyTypeObject *cls, Py_buffer *b) /*[clinic end generated code: output=927e25be80f3b77b input=2776314f043088f5]*/ { … } /* XXX Windows support below is likely incomplete */ /* Cribbed from posix_lseek() */ static PyObject * portable_lseek(fileio *self, PyObject *posobj, int whence, bool suppress_pipe_error) { … } /*[clinic input] _io.FileIO.seek pos: object whence: int = 0 / Move to new file position and return the file position. Argument offset is a byte count. Optional argument whence defaults to SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values are SEEK_CUR or 1 (move relative to current position, positive or negative), and SEEK_END or 2 (move relative to end of file, usually negative, although many platforms allow seeking beyond the end of a file). Note that not all file objects are seekable. [clinic start generated code]*/ static PyObject * _io_FileIO_seek_impl(fileio *self, PyObject *pos, int whence) /*[clinic end generated code: output=c976acdf054e6655 input=0439194b0774d454]*/ { … } /*[clinic input] _io.FileIO.tell Current file position. Can raise OSError for non seekable files. [clinic start generated code]*/ static PyObject * _io_FileIO_tell_impl(fileio *self) /*[clinic end generated code: output=ffe2147058809d0b input=807e24ead4cec2f9]*/ { … } #ifdef HAVE_FTRUNCATE /*[clinic input] _io.FileIO.truncate cls: defining_class size as posobj: object = None / Truncate the file to at most size bytes and return the truncated size. Size defaults to the current file position, as returned by tell(). The current file position is changed to the value of size. [clinic start generated code]*/ static PyObject * _io_FileIO_truncate_impl(fileio *self, PyTypeObject *cls, PyObject *posobj) /*[clinic end generated code: output=d936732a49e8d5a2 input=c367fb45d6bb2c18]*/ { … } #endif /* HAVE_FTRUNCATE */ static const char * mode_string(fileio *self) { … } static PyObject * fileio_repr(PyObject *op) { … } /*[clinic input] _io.FileIO.isatty True if the file is connected to a TTY device. [clinic start generated code]*/ static PyObject * _io_FileIO_isatty_impl(fileio *self) /*[clinic end generated code: output=932c39924e9a8070 input=cd94ca1f5e95e843]*/ { … } /* Checks whether the file is a TTY using an open-only optimization. TTYs are always character devices. If the interpreter knows a file is not a character device when it would call ``isatty``, can skip that call. Inside ``open()`` there is a fresh stat result that contains that information. Use the stat result to skip a system call. Outside of that context TOCTOU issues (the fd could be arbitrarily modified by surrounding code). */ static PyObject * _io_FileIO_isatty_open_only(PyObject *op, PyObject *Py_UNUSED(ignored)) { … } #include "clinic/fileio.c.h" static PyMethodDef fileio_methods[] = …; /* 'closed' and 'mode' are attributes for backwards compatibility reasons. */ static PyObject * fileio_get_closed(PyObject *op, void *closure) { … } static PyObject * fileio_get_closefd(PyObject *op, void *closure) { … } static PyObject * fileio_get_mode(PyObject *op, void *closure) { … } static PyObject * fileio_get_blksize(PyObject *op, void *closure) { … } static PyGetSetDef fileio_getsetlist[] = …; static PyMemberDef fileio_members[] = …; static PyType_Slot fileio_slots[] = …; PyType_Spec fileio_spec = …;
Codebase Browser
cpython