git/typthon
1
0
Fork 0
mirror of https://github.com/johndoe6345789/typthon.git synced 2026-04-24 13:45:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
c6802fc59c8a7a4645c024bf320b371c55fcc685
typthon/Modules/_io/fileio.c
copilot-swe-agent[bot] 42e2356c88 Fix incorrect replacements in Py_ to Ty_ renaming 
Fixed several macros and constants that should not have been renamed:
- _Py_CAST, _Py_NULL, _Py_RVALUE (internal utility macros)
- Py_UNUSED (unused parameter macro)
- Py_EQ, Py_NE, Py_LT, Py_LE, Py_GT, Py_GE (comparison constants)
- Py_RETURN_* macros (NONE, TRUE, FALSE, NOTIMPLEMENTED, RICHCOMPARE)
- Py_READONLY, Py_ULL, Py_CONTEXT_SWITCHED
- TyGC_Head in generated clinic files

Build is still in progress with some remaining issues to resolve.

Co-authored-by: johndoe6345789 <224850594+johndoe6345789@users.noreply.github.com>
2025-12-29 17:44:05 +00:00

1340 lines
35 KiB
C
Raw Blame History

/* Author: Daniel Stutzbach */
#include "Python.h"
#include "pycore_fileutils.h" // _Ty_BEGIN_SUPPRESS_IPH
#include "pycore_object.h" // _TyObject_GC_UNTRACK()
#include "pycore_pyerrors.h" // _TyErr_ChainExceptions1()
#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS()
#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 (8*1024)
#elif (BUFSIZ >= (2 << 25))
# error "unreasonable BUFSIZ > 64 MiB defined"
#else
# define SMALLCHUNK BUFSIZ
#endif
/* Size at which a buffer is considered "large" and behavior should change to
avoid excessive memory allocation */
#define LARGE_BUFFER_CUTOFF_SIZE 65536
/*[clinic input]
module _io
class _io.FileIO "fileio *" "clinic_state()->PyFileIO_Type"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=ac25ec278f4d6703]*/
typedef struct {
PyObject_HEAD
int fd;
unsigned int created : 1;
unsigned int readable : 1;
unsigned int writable : 1;
unsigned int appending : 1;
signed int seekable : 2; /* -1 means unknown */
unsigned int closefd : 1;
char finalizing;
/* Stat result which was grabbed at file open, useful for optimizing common
File I/O patterns to be more efficient. This is only guidance / an
estimate, as it is subject to Time-Of-Check to Time-Of-Use (TOCTOU)
issues / bugs. Both the underlying file descriptor and file may be
modified outside of the fileio object / Python (ex. gh-90102, GH-121941,
gh-109523). */
struct _Ty_stat_struct *stat_atopen;
TyObject *weakreflist;
TyObject *dict;
} fileio;
#define PyFileIO_Check(state, op) (PyObject_TypeCheck((op), state->PyFileIO_Type))
#define PyFileIO_CAST(op) ((fileio *)(op))
/* Forward declarations */
static TyObject* portable_lseek(fileio *self, TyObject *posobj, int whence, bool suppress_pipe_error);
int
_PyFileIO_closed(TyObject *self)
{
return (PyFileIO_CAST(self)->fd < 0);
}
/* 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 TyObject *
fileio_dealloc_warn(TyObject *op, TyObject *source)
{
fileio *self = PyFileIO_CAST(op);
if (self->fd >= 0 && self->closefd) {
TyObject *exc = TyErr_GetRaisedException();
if (TyErr_ResourceWarning(source, 1, "unclosed file %R", source)) {
/* Spurious errors can appear at shutdown */
if (TyErr_ExceptionMatches(TyExc_Warning)) {
TyErr_FormatUnraisable("Exception ignored "
"while finalizing file %R", self);
}
}
TyErr_SetRaisedException(exc);
}
Py_RETURN_NONE;
}
/* Returns 0 on success, -1 with exception set on failure. */
static int
internal_close(fileio *self)
{
int err = 0;
int save_errno = 0;
if (self->fd >= 0) {
int fd = self->fd;
self->fd = -1;
/* fd is accessible and someone else may have closed it */
Ty_BEGIN_ALLOW_THREADS
_Ty_BEGIN_SUPPRESS_IPH
err = close(fd);
if (err < 0)
save_errno = errno;
_Ty_END_SUPPRESS_IPH
Ty_END_ALLOW_THREADS
}
TyMem_Free(self->stat_atopen);
self->stat_atopen = NULL;
if (err < 0) {
errno = save_errno;
TyErr_SetFromErrno(TyExc_OSError);
return -1;
}
return 0;
}
/*[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 TyObject *
_io_FileIO_close_impl(fileio *self, TyTypeObject *cls)
/*[clinic end generated code: output=c30cbe9d1f23ca58 input=70da49e63db7c64d]*/
{
TyObject *res;
int rc;
_PyIO_State *state = get_io_state_by_cls(cls);
res = PyObject_CallMethodOneArg((TyObject*)state->PyRawIOBase_Type,
&_Ty_ID(close), (TyObject *)self);
if (!self->closefd) {
self->fd = -1;
return res;
}
TyObject *exc = NULL;
if (res == NULL) {
exc = TyErr_GetRaisedException();
}
if (self->finalizing) {
TyObject *r = fileio_dealloc_warn((TyObject*)self, (TyObject *) self);
if (r) {
Ty_DECREF(r);
}
else {
TyErr_Clear();
}
}
rc = internal_close(self);
if (res == NULL) {
_TyErr_ChainExceptions1(exc);
}
if (rc < 0) {
Ty_CLEAR(res);
}
return res;
}
static TyObject *
fileio_new(TyTypeObject *type, TyObject *args, TyObject *kwds)
{
assert(type != NULL && type->tp_alloc != NULL);
fileio *self = (fileio *) type->tp_alloc(type, 0);
if (self == NULL) {
return NULL;
}
self->fd = -1;
self->created = 0;
self->readable = 0;
self->writable = 0;
self->appending = 0;
self->seekable = -1;
self->stat_atopen = NULL;
self->closefd = 1;
self->weakreflist = NULL;
return (TyObject *) self;
}
#ifdef O_CLOEXEC
extern int _Ty_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, TyObject *nameobj, const char *mode,
int closefd, TyObject *opener)
/*[clinic end generated code: output=23413f68e6484bbd input=588aac967e0ba74b]*/
{
#ifdef MS_WINDOWS
wchar_t *widename = NULL;
#else
const char *name = NULL;
#endif
TyObject *stringobj = NULL;
const char *s;
int ret = 0;
int rwa = 0, plus = 0;
int flags = 0;
int fd = -1;
int fd_is_own = 0;
#ifdef O_CLOEXEC
int *atomic_flag_works = &_Ty_open_cloexec_works;
#elif !defined(MS_WINDOWS)
int *atomic_flag_works = NULL;
#endif
int fstat_result;
int async_err = 0;
#ifdef Ty_DEBUG
_PyIO_State *state = find_io_state_by_def(Ty_TYPE(self));
assert(PyFileIO_Check(state, self));
#endif
if (self->fd >= 0) {
if (self->closefd) {
/* Have to close the existing file first. */
if (internal_close(self) < 0) {
return -1;
}
}
else
self->fd = -1;
}
if (TyBool_Check(nameobj)) {
if (TyErr_WarnEx(TyExc_RuntimeWarning,
"bool is used as a file descriptor", 1))
{
return -1;
}
}
fd = TyLong_AsInt(nameobj);
if (fd < 0) {
if (!TyErr_Occurred()) {
TyErr_SetString(TyExc_ValueError,
"negative file descriptor");
return -1;
}
TyErr_Clear();
}
if (fd < 0) {
#ifdef MS_WINDOWS
if (!TyUnicode_FSDecoder(nameobj, &stringobj)) {
return -1;
}
widename = TyUnicode_AsWideCharString(stringobj, NULL);
if (widename == NULL)
return -1;
#else
if (!TyUnicode_FSConverter(nameobj, &stringobj)) {
return -1;
}
name = TyBytes_AS_STRING(stringobj);
#endif
}
s = mode;
while (*s) {
switch (*s++) {
case 'x':
if (rwa) {
bad_mode:
TyErr_SetString(TyExc_ValueError,
"Must have exactly one of create/read/write/append "
"mode and at most one plus");
goto error;
}
rwa = 1;
self->created = 1;
self->writable = 1;
flags |= O_EXCL | O_CREAT;
break;
case 'r':
if (rwa)
goto bad_mode;
rwa = 1;
self->readable = 1;
break;
case 'w':
if (rwa)
goto bad_mode;
rwa = 1;
self->writable = 1;
flags |= O_CREAT | O_TRUNC;
break;
case 'a':
if (rwa)
goto bad_mode;
rwa = 1;
self->writable = 1;
self->appending = 1;
flags |= O_APPEND | O_CREAT;
break;
case 'b':
break;
case '+':
if (plus)
goto bad_mode;
self->readable = self->writable = 1;
plus = 1;
break;
default:
TyErr_Format(TyExc_ValueError,
"invalid mode: %.200s", mode);
goto error;
}
}
if (!rwa)
goto bad_mode;
if (self->readable && self->writable)
flags |= O_RDWR;
else if (self->readable)
flags |= O_RDONLY;
else
flags |= O_WRONLY;
#ifdef O_BINARY
flags |= O_BINARY;
#endif
#ifdef MS_WINDOWS
flags |= O_NOINHERIT;
#elif defined(O_CLOEXEC)
flags |= O_CLOEXEC;
#endif
if (TySys_Audit("open", "Osi", nameobj, mode, flags) < 0) {
goto error;
}
if (fd >= 0) {
self->fd = fd;
self->closefd = closefd;
}
else {
self->closefd = 1;
if (!closefd) {
TyErr_SetString(TyExc_ValueError,
"Cannot use closefd=False with file name");
goto error;
}
errno = 0;
if (opener == Ty_None) {
do {
Ty_BEGIN_ALLOW_THREADS
#ifdef MS_WINDOWS
self->fd = _wopen(widename, flags, 0666);
#else
self->fd = open(name, flags, 0666);
#endif
Ty_END_ALLOW_THREADS
} while (self->fd < 0 && errno == EINTR &&
!(async_err = TyErr_CheckSignals()));
if (async_err)
goto error;
if (self->fd < 0) {
TyErr_SetFromErrnoWithFilenameObject(TyExc_OSError, nameobj);
goto error;
}
}
else {
TyObject *fdobj;
#ifndef MS_WINDOWS
/* the opener may clear the atomic flag */
atomic_flag_works = NULL;
#endif
fdobj = PyObject_CallFunction(opener, "Oi", nameobj, flags);
if (fdobj == NULL)
goto error;
if (!TyLong_Check(fdobj)) {
Ty_DECREF(fdobj);
TyErr_SetString(TyExc_TypeError,
"expected integer from opener");
goto error;
}
self->fd = TyLong_AsInt(fdobj);
Ty_DECREF(fdobj);
if (self->fd < 0) {
if (!TyErr_Occurred()) {
/* The opener returned a negative but didn't set an
exception. See issue #27066 */
TyErr_Format(TyExc_ValueError,
"opener returned %d", self->fd);
}
goto error;
}
}
fd_is_own = 1;
#ifndef MS_WINDOWS
if (_Ty_set_inheritable(self->fd, 0, atomic_flag_works) < 0)
goto error;
#endif
}
TyMem_Free(self->stat_atopen);
self->stat_atopen = TyMem_New(struct _Ty_stat_struct, 1);
if (self->stat_atopen == NULL) {
TyErr_NoMemory();
goto error;
}
Ty_BEGIN_ALLOW_THREADS
fstat_result = _Ty_fstat_noraise(self->fd, self->stat_atopen);
Ty_END_ALLOW_THREADS
if (fstat_result < 0) {
/* Tolerate fstat() errors other than EBADF. See Issue #25717, where
an anonymous file on a Virtual Box shared folder filesystem would
raise ENOENT. */
#ifdef MS_WINDOWS
if (GetLastError() == ERROR_INVALID_HANDLE) {
TyErr_SetFromWindowsErr(0);
#else
if (errno == EBADF) {
TyErr_SetFromErrno(TyExc_OSError);
#endif
goto error;
}
TyMem_Free(self->stat_atopen);
self->stat_atopen = NULL;
}
else {
#if defined(S_ISDIR) && defined(EISDIR)
/* On Unix, open will succeed for directories.
In Python, there should be no file objects referring to
directories, so we need a check. */
if (S_ISDIR(self->stat_atopen->st_mode)) {
errno = EISDIR;
TyErr_SetFromErrnoWithFilenameObject(TyExc_OSError, nameobj);
goto error;
}
#endif /* defined(S_ISDIR) */
}
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
/* don't translate newlines (\r\n <=> \n) */
_setmode(self->fd, O_BINARY);
#endif
if (PyObject_SetAttr((TyObject *)self, &_Ty_ID(name), nameobj) < 0)
goto error;
if (self->appending) {
/* For consistent behaviour, we explicitly seek to the
end of file (otherwise, it might be done only on the
first write()). */
TyObject *pos = portable_lseek(self, NULL, 2, true);
if (pos == NULL)
goto error;
Ty_DECREF(pos);
}
goto done;
error:
ret = -1;
if (!fd_is_own)
self->fd = -1;
if (self->fd >= 0) {
TyObject *exc = TyErr_GetRaisedException();
internal_close(self);
_TyErr_ChainExceptions1(exc);
}
TyMem_Free(self->stat_atopen);
self->stat_atopen = NULL;
done:
#ifdef MS_WINDOWS
TyMem_Free(widename);
#endif
Ty_CLEAR(stringobj);
return ret;
}
static int
fileio_traverse(TyObject *op, visitproc visit, void *arg)
{
fileio *self = PyFileIO_CAST(op);
Ty_VISIT(Ty_TYPE(self));
Ty_VISIT(self->dict);
return 0;
}
static int
fileio_clear(TyObject *op)
{
fileio *self = PyFileIO_CAST(op);
Ty_CLEAR(self->dict);
return 0;
}
static void
fileio_dealloc(TyObject *op)
{
fileio *self = PyFileIO_CAST(op);
self->finalizing = 1;
if (_PyIOBase_finalize(op) < 0) {
return;
}
_TyObject_GC_UNTRACK(self);
if (self->stat_atopen != NULL) {
TyMem_Free(self->stat_atopen);
self->stat_atopen = NULL;
}
FT_CLEAR_WEAKREFS(op, self->weakreflist);
(void)fileio_clear(op);
TyTypeObject *tp = Ty_TYPE(op);
tp->tp_free(op);
Ty_DECREF(tp);
}
static TyObject *
err_closed(void)
{
TyErr_SetString(TyExc_ValueError, "I/O operation on closed file");
return NULL;
}
static TyObject *
err_mode(_PyIO_State *state, const char *action)
{
return TyErr_Format(state->unsupported_operation,
"File not open for %s", action);
}
/*[clinic input]
_io.FileIO.fileno
Return the underlying file descriptor (an integer).
[clinic start generated code]*/
static TyObject *
_io_FileIO_fileno_impl(fileio *self)
/*[clinic end generated code: output=a9626ce5398ece90 input=0b9b2de67335ada3]*/
{
if (self->fd < 0)
return err_closed();
return TyLong_FromLong((long) self->fd);
}
/*[clinic input]
_io.FileIO.readable
True if file was opened in a read mode.
[clinic start generated code]*/
static TyObject *
_io_FileIO_readable_impl(fileio *self)
/*[clinic end generated code: output=640744a6150fe9ba input=a3fdfed6eea721c5]*/
{
if (self->fd < 0)
return err_closed();
return TyBool_FromLong((long) self->readable);
}
/*[clinic input]
_io.FileIO.writable
True if file was opened in a write mode.
[clinic start generated code]*/
static TyObject *
_io_FileIO_writable_impl(fileio *self)
/*[clinic end generated code: output=96cefc5446e89977 input=c204a808ca2e1748]*/
{
if (self->fd < 0)
return err_closed();
return TyBool_FromLong((long) self->writable);
}
/*[clinic input]
_io.FileIO.seekable
True if file supports random-access.
[clinic start generated code]*/
static TyObject *
_io_FileIO_seekable_impl(fileio *self)
/*[clinic end generated code: output=47909ca0a42e9287 input=c8e5554d2fd63c7f]*/
{
if (self->fd < 0)
return err_closed();
if (self->seekable < 0) {
/* portable_lseek() sets the seekable attribute */
TyObject *pos = portable_lseek(self, NULL, SEEK_CUR, false);
assert(self->seekable >= 0);
if (pos == NULL) {
TyErr_Clear();
}
else {
Ty_DECREF(pos);
}
}
return TyBool_FromLong((long) self->seekable);
}
/*[clinic input]
_io.FileIO.readinto
cls: defining_class
buffer: Ty_buffer(accept={rwbuffer})
/
Same as RawIOBase.readinto().
[clinic start generated code]*/
static TyObject *
_io_FileIO_readinto_impl(fileio *self, TyTypeObject *cls, Ty_buffer *buffer)
/*[clinic end generated code: output=97f0f3d69534db34 input=fd20323e18ce1ec8]*/
{
Ty_ssize_t n;
int err;
if (self->fd < 0)
return err_closed();
if (!self->readable) {
_PyIO_State *state = get_io_state_by_cls(cls);
return err_mode(state, "reading");
}
n = _Ty_read(self->fd, buffer->buf, buffer->len);
/* copy errno because PyBuffer_Release() can indirectly modify it */
err = errno;
if (n == -1) {
if (err == EAGAIN) {
TyErr_Clear();
Py_RETURN_NONE;
}
return NULL;
}
return TyLong_FromSsize_t(n);
}
static size_t
new_buffersize(fileio *self, size_t currentsize)
{
size_t addend;
/* Expand the buffer by an amount proportional to the current size,
giving us amortized linear-time behavior. For bigger sizes, use a
less-than-double growth factor to avoid excessive allocation. */
assert(currentsize <= PY_SSIZE_T_MAX);
if (currentsize > LARGE_BUFFER_CUTOFF_SIZE)
addend = currentsize >> 3;
else
addend = 256 + currentsize;
if (addend < SMALLCHUNK)
/* Avoid tiny read() calls. */
addend = SMALLCHUNK;
return addend + currentsize;
}
/*[clinic input]
_io.FileIO.readall
Read all data from the file, returned as bytes.
Reads until either there is an error or read() returns size 0 (indicates EOF).
If the file is already at EOF, returns an empty bytes object.
In non-blocking mode, returns as much data as could be read before EAGAIN. If no
data is available (EAGAIN is returned before bytes are read) returns None.
[clinic start generated code]*/
static TyObject *
_io_FileIO_readall_impl(fileio *self)
/*[clinic end generated code: output=faa0292b213b4022 input=1e19849857f5d0a1]*/
{
Ty_off_t pos, end;
TyObject *result;
Ty_ssize_t bytes_read = 0;
Ty_ssize_t n;
size_t bufsize;
if (self->fd < 0) {
return err_closed();
}
if (self->stat_atopen != NULL && self->stat_atopen->st_size < _PY_READ_MAX) {
end = (Ty_off_t)self->stat_atopen->st_size;
}
else {
end = -1;
}
if (end <= 0) {
/* Use a default size and resize as needed. */
bufsize = SMALLCHUNK;
}
else {
/* This is probably a real file. */
if (end > _PY_READ_MAX - 1) {
bufsize = _PY_READ_MAX;
}
else {
/* In order to detect end of file, need a read() of at
least 1 byte which returns size 0. Oversize the buffer
by 1 byte so the I/O can be completed with two read()
calls (one for all data, one for EOF) without needing
to resize the buffer. */
bufsize = (size_t)end + 1;
}
/* While a lot of code does open().read() to get the whole contents
of a file it is possible a caller seeks/reads a ways into the file
then calls readall() to get the rest, which would result in allocating
more than required. Guard against that for larger files where we expect
the I/O time to dominate anyways while keeping small files fast. */
if (bufsize > LARGE_BUFFER_CUTOFF_SIZE) {
Ty_BEGIN_ALLOW_THREADS
_Ty_BEGIN_SUPPRESS_IPH
#ifdef MS_WINDOWS
pos = _lseeki64(self->fd, 0L, SEEK_CUR);
#else
pos = lseek(self->fd, 0L, SEEK_CUR);
#endif
_Ty_END_SUPPRESS_IPH
Ty_END_ALLOW_THREADS
if (end >= pos && pos >= 0 && (end - pos) < (_PY_READ_MAX - 1)) {
bufsize = (size_t)(end - pos) + 1;
}
}
}
result = TyBytes_FromStringAndSize(NULL, bufsize);
if (result == NULL)
return NULL;
while (1) {
if (bytes_read >= (Ty_ssize_t)bufsize) {
bufsize = new_buffersize(self, bytes_read);
if (bufsize > PY_SSIZE_T_MAX || bufsize <= 0) {
TyErr_SetString(TyExc_OverflowError,
"unbounded read returned more bytes "
"than a Python bytes object can hold");
Ty_DECREF(result);
return NULL;
}
if (TyBytes_GET_SIZE(result) < (Ty_ssize_t)bufsize) {
if (_TyBytes_Resize(&result, bufsize) < 0)
return NULL;
}
}
n = _Ty_read(self->fd,
TyBytes_AS_STRING(result) + bytes_read,
bufsize - bytes_read);
if (n == 0)
break;
if (n == -1) {
if (errno == EAGAIN) {
TyErr_Clear();
if (bytes_read > 0)
break;
Ty_DECREF(result);
Py_RETURN_NONE;
}
Ty_DECREF(result);
return NULL;
}
bytes_read += n;
}
if (TyBytes_GET_SIZE(result) > bytes_read) {
if (_TyBytes_Resize(&result, bytes_read) < 0)
return NULL;
}
return result;
}
/*[clinic input]
_io.FileIO.read
cls: defining_class
size: Ty_ssize_t(accept={int, NoneType}) = -1
/
Read at most size bytes, returned as bytes.
If size is less than 0, read all bytes in the file making multiple read calls.
See ``FileIO.readall``.
Attempts to make only one system call, retrying only per PEP 475 (EINTR). This
means 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 TyObject *
_io_FileIO_read_impl(fileio *self, TyTypeObject *cls, Ty_ssize_t size)
/*[clinic end generated code: output=bbd749c7c224143e input=cf21fddef7d38ab6]*/
{
char *ptr;
Ty_ssize_t n;
TyObject *bytes;
if (self->fd < 0)
return err_closed();
if (!self->readable) {
_PyIO_State *state = get_io_state_by_cls(cls);
return err_mode(state, "reading");
}
if (size < 0)
return _io_FileIO_readall_impl(self);
if (size > _PY_READ_MAX) {
size = _PY_READ_MAX;
}
bytes = TyBytes_FromStringAndSize(NULL, size);
if (bytes == NULL)
return NULL;
ptr = TyBytes_AS_STRING(bytes);
n = _Ty_read(self->fd, ptr, size);
if (n == -1) {
/* copy errno because Ty_DECREF() can indirectly modify it */
int err = errno;
Ty_DECREF(bytes);
if (err == EAGAIN) {
TyErr_Clear();
Py_RETURN_NONE;
}
return NULL;
}
if (n != size) {
if (_TyBytes_Resize(&bytes, n) < 0) {
Ty_CLEAR(bytes);
return NULL;
}
}
return (TyObject *) bytes;
}
/*[clinic input]
_io.FileIO.write
cls: defining_class
b: Ty_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 TyObject *
_io_FileIO_write_impl(fileio *self, TyTypeObject *cls, Ty_buffer *b)
/*[clinic end generated code: output=927e25be80f3b77b input=2776314f043088f5]*/
{
Ty_ssize_t n;
int err;
if (self->fd < 0)
return err_closed();
if (!self->writable) {
_PyIO_State *state = get_io_state_by_cls(cls);
return err_mode(state, "writing");
}
n = _Ty_write(self->fd, b->buf, b->len);
/* copy errno because PyBuffer_Release() can indirectly modify it */
err = errno;
if (n < 0) {
if (err == EAGAIN) {
TyErr_Clear();
Py_RETURN_NONE;
}
return NULL;
}
return TyLong_FromSsize_t(n);
}
/* XXX Windows support below is likely incomplete */
/* Cribbed from posix_lseek() */
static TyObject *
portable_lseek(fileio *self, TyObject *posobj, int whence, bool suppress_pipe_error)
{
Ty_off_t pos, res;
int fd = self->fd;
#ifdef SEEK_SET
/* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
switch (whence) {
#if SEEK_SET != 0
case 0: whence = SEEK_SET; break;
#endif
#if SEEK_CUR != 1
case 1: whence = SEEK_CUR; break;
#endif
#if SEEK_END != 2
case 2: whence = SEEK_END; break;
#endif
}
#endif /* SEEK_SET */
if (posobj == NULL) {
pos = 0;
}
else {
#if defined(HAVE_LARGEFILE_SUPPORT)
pos = TyLong_AsLongLong(posobj);
#else
pos = TyLong_AsLong(posobj);
#endif
if (TyErr_Occurred())
return NULL;
}
Ty_BEGIN_ALLOW_THREADS
_Ty_BEGIN_SUPPRESS_IPH
#ifdef MS_WINDOWS
res = _lseeki64(fd, pos, whence);
#else
res = lseek(fd, pos, whence);
#endif
_Ty_END_SUPPRESS_IPH
Ty_END_ALLOW_THREADS
if (self->seekable < 0) {
self->seekable = (res >= 0);
}
if (res < 0) {
if (suppress_pipe_error && errno == ESPIPE) {
res = 0;
} else {
return TyErr_SetFromErrno(TyExc_OSError);
}
}
#if defined(HAVE_LARGEFILE_SUPPORT)
return TyLong_FromLongLong(res);
#else
return TyLong_FromLong(res);
#endif
}
/*[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 TyObject *
_io_FileIO_seek_impl(fileio *self, TyObject *pos, int whence)
/*[clinic end generated code: output=c976acdf054e6655 input=0439194b0774d454]*/
{
if (self->fd < 0)
return err_closed();
return portable_lseek(self, pos, whence, false);
}
/*[clinic input]
_io.FileIO.tell
Current file position.
Can raise OSError for non seekable files.
[clinic start generated code]*/
static TyObject *
_io_FileIO_tell_impl(fileio *self)
/*[clinic end generated code: output=ffe2147058809d0b input=807e24ead4cec2f9]*/
{
if (self->fd < 0)
return err_closed();
return portable_lseek(self, NULL, 1, false);
}
#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 TyObject *
_io_FileIO_truncate_impl(fileio *self, TyTypeObject *cls, TyObject *posobj)
/*[clinic end generated code: output=d936732a49e8d5a2 input=c367fb45d6bb2c18]*/
{
Ty_off_t pos;
int ret;
int fd;
fd = self->fd;
if (fd < 0)
return err_closed();
if (!self->writable) {
_PyIO_State *state = get_io_state_by_cls(cls);
return err_mode(state, "writing");
}
if (posobj == Ty_None) {
/* Get the current position. */
posobj = portable_lseek(self, NULL, 1, false);
if (posobj == NULL)
return NULL;
}
else {
Ty_INCREF(posobj);
}
#if defined(HAVE_LARGEFILE_SUPPORT)
pos = TyLong_AsLongLong(posobj);
#else
pos = TyLong_AsLong(posobj);
#endif
if (TyErr_Occurred()){
Ty_DECREF(posobj);
return NULL;
}
Ty_BEGIN_ALLOW_THREADS
_Ty_BEGIN_SUPPRESS_IPH
errno = 0;
#ifdef MS_WINDOWS
ret = _chsize_s(fd, pos);
#else
ret = ftruncate(fd, pos);
#endif
_Ty_END_SUPPRESS_IPH
Ty_END_ALLOW_THREADS
if (ret != 0) {
TyErr_SetFromErrno(TyExc_OSError);
Ty_DECREF(posobj);
return NULL;
}
/* Since the file was truncated, its size at open is no longer accurate
as an estimate. Clear out the stat result, and rely on dynamic resize
code if a readall is requested. */
if (self->stat_atopen != NULL) {
TyMem_Free(self->stat_atopen);
self->stat_atopen = NULL;
}
return posobj;
}
#endif /* HAVE_FTRUNCATE */
static const char *
mode_string(fileio *self)
{
if (self->created) {
if (self->readable)
return "xb+";
else
return "xb";
}
if (self->appending) {
if (self->readable)
return "ab+";
else
return "ab";
}
else if (self->readable) {
if (self->writable)
return "rb+";
else
return "rb";
}
else
return "wb";
}
static TyObject *
fileio_repr(TyObject *op)
{
fileio *self = PyFileIO_CAST(op);
const char *type_name = Ty_TYPE(self)->tp_name;
if (self->fd < 0) {
return TyUnicode_FromFormat("<%.100s [closed]>", type_name);
}
TyObject *nameobj;
if (PyObject_GetOptionalAttr((TyObject *) self, &_Ty_ID(name), &nameobj) < 0) {
return NULL;
}
TyObject *res;
if (nameobj == NULL) {
res = TyUnicode_FromFormat(
"<%.100s fd=%d mode='%s' closefd=%s>",
type_name, self->fd, mode_string(self), self->closefd ? "True" : "False");
}
else {
int status = Ty_ReprEnter((TyObject *)self);
res = NULL;
if (status == 0) {
res = TyUnicode_FromFormat(
"<%.100s name=%R mode='%s' closefd=%s>",
type_name, nameobj, mode_string(self), self->closefd ? "True" : "False");
Ty_ReprLeave((TyObject *)self);
}
else if (status > 0) {
TyErr_Format(TyExc_RuntimeError,
"reentrant call inside %.100s.__repr__", type_name);
}
Ty_DECREF(nameobj);
}
return res;
}
/*[clinic input]
_io.FileIO.isatty
True if the file is connected to a TTY device.
[clinic start generated code]*/
static TyObject *
_io_FileIO_isatty_impl(fileio *self)
/*[clinic end generated code: output=932c39924e9a8070 input=cd94ca1f5e95e843]*/
{
long res;
if (self->fd < 0)
return err_closed();
Ty_BEGIN_ALLOW_THREADS
_Ty_BEGIN_SUPPRESS_IPH
res = isatty(self->fd);
_Ty_END_SUPPRESS_IPH
Ty_END_ALLOW_THREADS
return TyBool_FromLong(res);
}
/* 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 TyObject *
_io_FileIO_isatty_open_only(TyObject *op, TyObject *Py_UNUSED(dummy))
{
fileio *self = PyFileIO_CAST(op);
if (self->stat_atopen != NULL && !S_ISCHR(self->stat_atopen->st_mode)) {
Py_RETURN_FALSE;
}
return _io_FileIO_isatty_impl(self);
}
#include "clinic/fileio.c.h"
static TyMethodDef fileio_methods[] = {
_IO_FILEIO_READ_METHODDEF
_IO_FILEIO_READALL_METHODDEF
_IO_FILEIO_READINTO_METHODDEF
_IO_FILEIO_WRITE_METHODDEF
_IO_FILEIO_SEEK_METHODDEF
_IO_FILEIO_TELL_METHODDEF
_IO_FILEIO_TRUNCATE_METHODDEF
_IO_FILEIO_CLOSE_METHODDEF
_IO_FILEIO_SEEKABLE_METHODDEF
_IO_FILEIO_READABLE_METHODDEF
_IO_FILEIO_WRITABLE_METHODDEF
_IO_FILEIO_FILENO_METHODDEF
_IO_FILEIO_ISATTY_METHODDEF
{"_isatty_open_only", _io_FileIO_isatty_open_only, METH_NOARGS},
{"_dealloc_warn", fileio_dealloc_warn, METH_O, NULL},
{"__getstate__", _PyIOBase_cannot_pickle, METH_NOARGS},
{NULL, NULL} /* sentinel */
};
/* 'closed' and 'mode' are attributes for backwards compatibility reasons. */
static TyObject *
fileio_get_closed(TyObject *op, void *closure)
{
fileio *self = PyFileIO_CAST(op);
return TyBool_FromLong((long)(self->fd < 0));
}
static TyObject *
fileio_get_closefd(TyObject *op, void *closure)
{
fileio *self = PyFileIO_CAST(op);
return TyBool_FromLong((long)(self->closefd));
}
static TyObject *
fileio_get_mode(TyObject *op, void *closure)
{
fileio *self = PyFileIO_CAST(op);
return TyUnicode_FromString(mode_string(self));
}
static TyObject *
fileio_get_blksize(TyObject *op, void *closure)
{
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
fileio *self = PyFileIO_CAST(op);
if (self->stat_atopen != NULL && self->stat_atopen->st_blksize > 1) {
return TyLong_FromLong(self->stat_atopen->st_blksize);
}
#endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
return TyLong_FromLong(DEFAULT_BUFFER_SIZE);
}
static TyGetSetDef fileio_getsetlist[] = {
{"closed", fileio_get_closed, NULL, "True if the file is closed"},
{"closefd", fileio_get_closefd, NULL,
"True if the file descriptor will be closed by close()."},
{"mode", fileio_get_mode, NULL, "String giving the file mode"},
{"_blksize", fileio_get_blksize, NULL, "Stat st_blksize if available"},
{NULL},
};
static TyMemberDef fileio_members[] = {
{"_finalizing", Ty_T_BOOL, offsetof(fileio, finalizing), 0},
{"__weaklistoffset__", Ty_T_PYSSIZET, offsetof(fileio, weakreflist), Py_READONLY},
{"__dictoffset__", Ty_T_PYSSIZET, offsetof(fileio, dict), Py_READONLY},
{NULL}
};
static TyType_Slot fileio_slots[] = {
{Ty_tp_dealloc, fileio_dealloc},
{Ty_tp_repr, fileio_repr},
{Ty_tp_doc, (void *)_io_FileIO___init____doc__},
{Ty_tp_traverse, fileio_traverse},
{Ty_tp_clear, fileio_clear},
{Ty_tp_methods, fileio_methods},
{Ty_tp_members, fileio_members},
{Ty_tp_getset, fileio_getsetlist},
{Ty_tp_init, _io_FileIO___init__},
{Ty_tp_new, fileio_new},
{0, NULL},
};
TyType_Spec fileio_spec = {
.name = "_io.FileIO",
.basicsize = sizeof(fileio),
.flags = (Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_HAVE_GC |
Ty_TPFLAGS_IMMUTABLETYPE),
.slots = fileio_slots,
};
Reference in New Issue View Git Blame Copy Permalink