add ydb deps

author: nkozlovskiy <nmk@ydb.tech> 2023-09-29 12:24:06 +0300
committer: nkozlovskiy <nmk@ydb.tech> 2023-09-29 12:41:34 +0300
commit: e0e3e1717e3d33762ce61950504f9637a6e669ed (patch)
tree: bca3ff6939b10ed60c3d5c12439963a1146b9711 /contrib/tools/python/src/Modules/_io/fileio.c
parent: 38f2c5852db84c7b4d83adfcb009eb61541d1ccd (diff)
download: ydb-e0e3e1717e3d33762ce61950504f9637a6e669ed.tar.gz
1 files changed, 1175 insertions, 0 deletions
diff --git a/contrib/tools/python/src/Modules/_io/fileio.c b/contrib/tools/python/src/Modules/_io/fileio.c
new file mode 100644
index 0000000000..ed5b918e76
--- /dev/null
+++ b/contrib/tools/python/src/Modules/_io/fileio.c
@@ -0,0 +1,1175 @@
+/* Author: Daniel Stutzbach */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include <stddef.h> /* For offsetof */
+#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
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#if BUFSIZ < (8*1024)
+#define SMALLCHUNK (8*1024)
+#elif (BUFSIZ >= (2 << 25))
+#error "unreasonable BUFSIZ > 64MB defined"
+#else
+#define SMALLCHUNK BUFSIZ
+#endif
+
+typedef struct {
+    PyObject_HEAD
+    int fd;
+    unsigned int readable : 1;
+    unsigned int writable : 1;
+    unsigned int appending : 1;
+    signed int seekable : 2; /* -1 means unknown */
+    unsigned int closefd : 1;
+    PyObject *weakreflist;
+    PyObject *dict;
+} fileio;
+
+PyTypeObject PyFileIO_Type;
+
+#define PyFileIO_Check(op) (PyObject_TypeCheck((op), &PyFileIO_Type))
+
+int
+_PyFileIO_closed(PyObject *self)
+{
+    return ((fileio *)self)->fd < 0;
+}
+
+static PyObject *
+portable_lseek(int fd, PyObject *posobj, int whence);
+
+static PyObject *portable_lseek(int fd, PyObject *posobj, int whence);
+
+/* 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 */
+        if (_PyVerify_fd(fd)) {
+            Py_BEGIN_ALLOW_THREADS
+            err = close(fd);
+            if (err < 0)
+                save_errno = errno;
+            Py_END_ALLOW_THREADS
+        } else {
+            save_errno = errno;
+            err = -1;
+        }
+    }
+    if (err < 0) {
+        errno = save_errno;
+        PyErr_SetFromErrno(PyExc_IOError);
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+fileio_close(fileio *self)
+{
+    PyObject *res;
+    res = PyObject_CallMethod((PyObject*)&PyRawIOBase_Type,
+                              "close", "O", self);
+    if (!self->closefd) {
+        self->fd = -1;
+        return res;
+    }
+    if (internal_close(self) < 0)
+        Py_CLEAR(res);
+    return res;
+}
+
+static PyObject *
+fileio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    fileio *self;
+
+    assert(type != NULL && type->tp_alloc != NULL);
+
+    self = (fileio *) type->tp_alloc(type, 0);
+    if (self != NULL) {
+        self->fd = -1;
+        self->readable = 0;
+        self->writable = 0;
+        self->appending = 0;
+        self->seekable = -1;
+        self->closefd = 1;
+        self->weakreflist = NULL;
+    }
+
+    return (PyObject *) self;
+}
+
+/* On Unix, open will succeed for directories.
+   In Python, there should be no file objects referring to
+   directories, so we need a check.  */
+
+static int
+dircheck(fileio* self, PyObject *nameobj)
+{
+#if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR)
+    struct stat buf;
+    int res;
+    if (self->fd < 0)
+        return 0;
+
+    Py_BEGIN_ALLOW_THREADS
+    res = fstat(self->fd, &buf);
+    Py_END_ALLOW_THREADS
+
+    if (res == 0 && S_ISDIR(buf.st_mode)) {
+        errno = EISDIR;
+        PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, nameobj);
+        return -1;
+    }
+#endif
+    return 0;
+}
+
+static int
+check_fd(int fd)
+{
+#if defined(HAVE_FSTAT)
+    struct stat buf;
+    int res;
+    PyObject *exc;
+    char *msg;
+
+    if (!_PyVerify_fd(fd)) {
+        goto badfd;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    res = fstat(fd, &buf);
+    Py_END_ALLOW_THREADS
+
+    if (res < 0 && errno == EBADF) {
+        goto badfd;
+    }
+
+    return 0;
+
+badfd:
+    msg = strerror(EBADF);
+    exc = PyObject_CallFunction(PyExc_OSError, "(is)",
+                                EBADF, msg);
+    PyErr_SetObject(PyExc_OSError, exc);
+    Py_XDECREF(exc);
+    return -1;
+#else
+    return 0;
+#endif
+}
+
+
+static int
+fileio_init(PyObject *oself, PyObject *args, PyObject *kwds)
+{
+    fileio *self = (fileio *) oself;
+    static char *kwlist[] = {"file", "mode", "closefd", NULL};
+    const char *name = NULL;
+    PyObject *nameobj, *stringobj = NULL;
+    char *mode = "r";
+    char *s;
+#ifdef MS_WINDOWS
+    Py_UNICODE *widename = NULL;
+#endif
+    int ret = 0;
+    int rwa = 0, plus = 0;
+    int flags = 0;
+    int fd = -1;
+    int closefd = 1;
+    int fd_is_own = 0;
+
+    assert(PyFileIO_Check(oself));
+    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 (!PyArg_ParseTupleAndKeywords(args, kwds, "O|si:fileio",
+                                     kwlist, &nameobj, &mode, &closefd))
+        return -1;
+
+    if (PyFloat_Check(nameobj)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float");
+        return -1;
+    }
+
+    fd = _PyLong_AsInt(nameobj);
+    if (fd < 0) {
+        if (!PyErr_Occurred()) {
+            PyErr_SetString(PyExc_ValueError,
+                            "negative file descriptor");
+            return -1;
+        }
+        PyErr_Clear();
+    }
+
+#ifdef MS_WINDOWS
+    if (PyUnicode_Check(nameobj)) {
+        widename = PyUnicode_AS_UNICODE(nameobj);
+        if (wcslen(widename) != (size_t)PyUnicode_GET_SIZE(nameobj)) {
+            PyErr_SetString(PyExc_TypeError, "embedded NUL character");
+            return -1;
+        }
+    }
+    if (widename == NULL)
+#endif
+    if (fd < 0)
+    {
+        if (PyBytes_Check(nameobj) || PyByteArray_Check(nameobj)) {
+            Py_ssize_t namelen;
+            if (PyObject_AsCharBuffer(nameobj, &name, &namelen) < 0)
+                return -1;
+            if (strlen(name) != (size_t)namelen) {
+                PyErr_SetString(PyExc_TypeError, "embedded NUL character");
+                return -1;
+            }
+        }
+        else {
+            PyObject *u = PyUnicode_FromObject(nameobj);
+
+            if (u == NULL)
+                return -1;
+
+            stringobj = PyUnicode_AsEncodedString(
+                u, Py_FileSystemDefaultEncoding, NULL);
+            Py_DECREF(u);
+            if (stringobj == NULL)
+                return -1;
+            if (!PyBytes_Check(stringobj)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "encoder failed to return bytes");
+                goto error;
+            }
+            name = PyBytes_AS_STRING(stringobj);
+            if (strlen(name) != (size_t)PyBytes_GET_SIZE(stringobj)) {
+                PyErr_SetString(PyExc_TypeError, "embedded NUL character");
+                goto error;
+            }
+        }
+    }
+
+    s = mode;
+    while (*s) {
+        switch (*s++) {
+        case 'r':
+            if (rwa) {
+            bad_mode:
+                PyErr_SetString(PyExc_ValueError,
+                                "Must have exactly one of read/write/append "
+                                "mode and at most one plus");
+                goto error;
+            }
+            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:
+            PyErr_Format(PyExc_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
+
+    if (fd >= 0) {
+        if (check_fd(fd))
+            goto error;
+        self->fd = fd;
+        self->closefd = closefd;
+    }
+    else {
+        self->closefd = 1;
+        if (!closefd) {
+            PyErr_SetString(PyExc_ValueError,
+                "Cannot use closefd=False with file name");
+            goto error;
+        }
+
+        Py_BEGIN_ALLOW_THREADS
+        errno = 0;
+#ifdef MS_WINDOWS
+        if (widename != NULL)
+            self->fd = _wopen(widename, flags, 0666);
+        else
+#endif
+            self->fd = open(name, flags, 0666);
+        Py_END_ALLOW_THREADS
+        fd_is_own = 1;
+        if (self->fd < 0) {
+#ifdef MS_WINDOWS
+            if (widename != NULL)
+                PyErr_SetFromErrnoWithUnicodeFilename(PyExc_IOError, widename);
+            else
+#endif
+                PyErr_SetFromErrnoWithFilename(PyExc_IOError, name);
+            goto error;
+        }
+    }
+    if (dircheck(self, nameobj) < 0)
+        goto error;
+
+    if (PyObject_SetAttrString((PyObject *)self, "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()). */
+        PyObject *pos = portable_lseek(self->fd, NULL, 2);
+        if (pos == NULL)
+            goto error;
+        Py_DECREF(pos);
+    }
+
+    goto done;
+
+ error:
+    if (!fd_is_own)
+        self->fd = -1;
+
+    ret = -1;
+
+ done:
+    Py_CLEAR(stringobj);
+    return ret;
+}
+
+static int
+fileio_traverse(fileio *self, visitproc visit, void *arg)
+{
+    Py_VISIT(self->dict);
+    return 0;
+}
+
+static int
+fileio_clear(fileio *self)
+{
+    Py_CLEAR(self->dict);
+    return 0;
+}
+
+static void
+fileio_dealloc(fileio *self)
+{
+    if (_PyIOBase_finalize((PyObject *) self) < 0)
+        return;
+    _PyObject_GC_UNTRACK(self);
+    if (self->weakreflist != NULL)
+        PyObject_ClearWeakRefs((PyObject *) self);
+    Py_CLEAR(self->dict);
+    Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyObject *
+err_closed(void)
+{
+    PyErr_SetString(PyExc_ValueError, "I/O operation on closed file");
+    return NULL;
+}
+
+static PyObject *
+err_mode(char *action)
+{
+    PyErr_Format(PyExc_ValueError, "File not open for %s", action);
+    return NULL;
+}
+
+static PyObject *
+fileio_fileno(fileio *self)
+{
+    if (self->fd < 0)
+        return err_closed();
+    return PyInt_FromLong((long) self->fd);
+}
+
+static PyObject *
+fileio_readable(fileio *self)
+{
+    if (self->fd < 0)
+        return err_closed();
+    return PyBool_FromLong((long) self->readable);
+}
+
+static PyObject *
+fileio_writable(fileio *self)
+{
+    if (self->fd < 0)
+        return err_closed();
+    return PyBool_FromLong((long) self->writable);
+}
+
+static PyObject *
+fileio_seekable(fileio *self)
+{
+    if (self->fd < 0)
+        return err_closed();
+    if (self->seekable < 0) {
+        PyObject *pos = portable_lseek(self->fd, NULL, SEEK_CUR);
+        if (pos == NULL) {
+            PyErr_Clear();
+            self->seekable = 0;
+        } else {
+            Py_DECREF(pos);
+            self->seekable = 1;
+        }
+    }
+    return PyBool_FromLong((long) self->seekable);
+}
+
+static PyObject *
+fileio_readinto(fileio *self, PyObject *args)
+{
+    Py_buffer pbuf;
+    Py_ssize_t n, len;
+
+    if (self->fd < 0)
+        return err_closed();
+    if (!self->readable)
+        return err_mode("reading");
+
+    if (!PyArg_ParseTuple(args, "w*", &pbuf))
+        return NULL;
+
+    if (_PyVerify_fd(self->fd)) {
+        len = pbuf.len;
+        Py_BEGIN_ALLOW_THREADS
+        errno = 0;
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
+        if (len > INT_MAX)
+            len = INT_MAX;
+        n = read(self->fd, pbuf.buf, (int)len);
+#else
+        n = read(self->fd, pbuf.buf, len);
+#endif
+        Py_END_ALLOW_THREADS
+    } else
+        n = -1;
+    PyBuffer_Release(&pbuf);
+    if (n < 0) {
+        if (errno == EAGAIN)
+            Py_RETURN_NONE;
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+
+    return PyLong_FromSsize_t(n);
+}
+
+static size_t
+new_buffersize(fileio *self, size_t currentsize)
+{
+#ifdef HAVE_FSTAT
+    off_t pos, end;
+    struct stat st;
+    int res;
+
+    Py_BEGIN_ALLOW_THREADS
+    res = fstat(self->fd, &st);
+    Py_END_ALLOW_THREADS
+
+    if (res == 0) {
+        end = st.st_size;
+
+        Py_BEGIN_ALLOW_THREADS
+        pos = lseek(self->fd, 0L, SEEK_CUR);
+        Py_END_ALLOW_THREADS
+
+        /* Files claiming a size smaller than SMALLCHUNK may
+           actually be streaming pseudo-files. In this case, we
+           apply the more aggressive algorithm below.
+        */
+        if (end >= SMALLCHUNK && end >= pos && pos >= 0) {
+            /* Add 1 so if the file were to grow we'd notice. */
+            return currentsize + end - pos + 1;
+        }
+    }
+#endif
+    /* Expand the buffer by an amount proportional to the current size,
+       giving us amortized linear-time behavior. Use a less-than-double
+       growth factor to avoid excessive allocation. */
+    return currentsize + (currentsize >> 3) + 6;
+}
+
+static PyObject *
+fileio_readall(fileio *self)
+{
+    PyObject *result;
+    Py_ssize_t total = 0;
+    Py_ssize_t n;
+
+    if (self->fd < 0)
+        return err_closed();
+    if (!_PyVerify_fd(self->fd))
+        return PyErr_SetFromErrno(PyExc_IOError);
+
+    result = PyBytes_FromStringAndSize(NULL, SMALLCHUNK);
+    if (result == NULL)
+        return NULL;
+
+    while (1) {
+        size_t newsize = new_buffersize(self, total);
+        if (newsize > PY_SSIZE_T_MAX || newsize <= 0) {
+            PyErr_SetString(PyExc_OverflowError,
+                "unbounded read returned more bytes "
+                "than a Python string can hold ");
+            Py_DECREF(result);
+            return NULL;
+        }
+
+        if (PyBytes_GET_SIZE(result) < (Py_ssize_t)newsize) {
+            if (_PyBytes_Resize(&result, newsize) < 0)
+                return NULL; /* result has been freed */
+        }
+        Py_BEGIN_ALLOW_THREADS
+        errno = 0;
+        n = newsize - total;
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
+        if (n > INT_MAX)
+            n = INT_MAX;
+        n = read(self->fd,
+                 PyBytes_AS_STRING(result) + total,
+                 (int)n);
+#else
+        n = read(self->fd,
+                 PyBytes_AS_STRING(result) + total,
+                 n);
+#endif
+        Py_END_ALLOW_THREADS
+        if (n == 0)
+            break;
+        if (n < 0) {
+            if (errno == EINTR) {
+                if (PyErr_CheckSignals()) {
+                    Py_DECREF(result);
+                    return NULL;
+                }
+                continue;
+            }
+            if (errno == EAGAIN) {
+                if (total > 0)
+                    break;
+                Py_DECREF(result);
+                Py_RETURN_NONE;
+            }
+            Py_DECREF(result);
+            PyErr_SetFromErrno(PyExc_IOError);
+            return NULL;
+        }
+        total += n;
+    }
+
+    if (PyBytes_GET_SIZE(result) > total) {
+        if (_PyBytes_Resize(&result, total) < 0) {
+            /* This should never happen, but just in case */
+            return NULL;
+        }
+    }
+    return result;
+}
+
+static PyObject *
+fileio_read(fileio *self, PyObject *args)
+{
+    char *ptr;
+    Py_ssize_t n;
+    Py_ssize_t size = -1;
+    PyObject *bytes;
+
+    if (self->fd < 0)
+        return err_closed();
+    if (!self->readable)
+        return err_mode("reading");
+
+    if (!PyArg_ParseTuple(args, "|O&", &_PyIO_ConvertSsize_t, &size))
+        return NULL;
+
+    if (size < 0) {
+        return fileio_readall(self);
+    }
+
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
+    if (size > INT_MAX)
+        size = INT_MAX;
+#endif
+    bytes = PyBytes_FromStringAndSize(NULL, size);
+    if (bytes == NULL)
+        return NULL;
+    ptr = PyBytes_AS_STRING(bytes);
+
+    if (_PyVerify_fd(self->fd)) {
+        Py_BEGIN_ALLOW_THREADS
+        errno = 0;
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
+        n = read(self->fd, ptr, (int)size);
+#else
+        n = read(self->fd, ptr, size);
+#endif
+        Py_END_ALLOW_THREADS
+    } else
+        n = -1;
+
+    if (n < 0) {
+        Py_DECREF(bytes);
+        if (errno == EAGAIN)
+            Py_RETURN_NONE;
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+
+    if (n != size) {
+        if (_PyBytes_Resize(&bytes, n) < 0)
+            return NULL;
+    }
+
+    return (PyObject *) bytes;
+}
+
+static PyObject *
+fileio_write(fileio *self, PyObject *args)
+{
+    Py_buffer pbuf;
+    Py_ssize_t n, len;
+
+    if (self->fd < 0)
+        return err_closed();
+    if (!self->writable)
+        return err_mode("writing");
+
+    if (!PyArg_ParseTuple(args, "s*:write", &pbuf)) {
+        return NULL;
+    }
+    if (PyUnicode_Check(PyTuple_GET_ITEM(args, 0)) &&
+        PyErr_WarnPy3k("write() argument must be string or buffer, "
+                       "not 'unicode'", 1) < 0)
+    {
+        PyBuffer_Release(&pbuf);
+        return NULL;
+    }
+
+    if (_PyVerify_fd(self->fd)) {
+        Py_BEGIN_ALLOW_THREADS
+        errno = 0;
+        len = pbuf.len;
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
+        if (len > INT_MAX)
+            len = INT_MAX;
+        n = write(self->fd, pbuf.buf, (int)len);
+#else
+        n = write(self->fd, pbuf.buf, len);
+#endif
+        Py_END_ALLOW_THREADS
+    } else
+        n = -1;
+
+    PyBuffer_Release(&pbuf);
+
+    if (n < 0) {
+        if (errno == EAGAIN)
+            Py_RETURN_NONE;
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+
+    return PyLong_FromSsize_t(n);
+}
+
+/* XXX Windows support below is likely incomplete */
+
+/* Cribbed from posix_lseek() */
+static PyObject *
+portable_lseek(int fd, PyObject *posobj, int whence)
+{
+    Py_off_t pos, res;
+
+#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(PyFloat_Check(posobj)) {
+            PyErr_SetString(PyExc_TypeError, "an integer is required");
+            return NULL;
+        }
+#if defined(HAVE_LARGEFILE_SUPPORT)
+        pos = PyLong_AsLongLong(posobj);
+#else
+        pos = PyLong_AsLong(posobj);
+#endif
+        if (PyErr_Occurred())
+            return NULL;
+    }
+
+    if (_PyVerify_fd(fd)) {
+        Py_BEGIN_ALLOW_THREADS
+#if defined(MS_WIN64) || defined(MS_WINDOWS)
+        res = _lseeki64(fd, pos, whence);
+#else
+        res = lseek(fd, pos, whence);
+#endif
+        Py_END_ALLOW_THREADS
+    } else
+        res = -1;
+    if (res < 0)
+        return PyErr_SetFromErrno(PyExc_IOError);
+
+#if defined(HAVE_LARGEFILE_SUPPORT)
+    return PyLong_FromLongLong(res);
+#else
+    return PyLong_FromLong(res);
+#endif
+}
+
+static PyObject *
+fileio_seek(fileio *self, PyObject *args)
+{
+    PyObject *posobj;
+    int whence = 0;
+
+    if (self->fd < 0)
+        return err_closed();
+
+    if (!PyArg_ParseTuple(args, "O|i", &posobj, &whence))
+        return NULL;
+
+    return portable_lseek(self->fd, posobj, whence);
+}
+
+static PyObject *
+fileio_tell(fileio *self, PyObject *args)
+{
+    if (self->fd < 0)
+        return err_closed();
+
+    return portable_lseek(self->fd, NULL, 1);
+}
+
+#ifdef HAVE_FTRUNCATE
+static PyObject *
+fileio_truncate(fileio *self, PyObject *args)
+{
+    PyObject *posobj = NULL; /* the new size wanted by the user */
+#ifndef MS_WINDOWS
+    Py_off_t pos;
+#endif
+    int ret;
+    int fd;
+
+    fd = self->fd;
+    if (fd < 0)
+        return err_closed();
+    if (!self->writable)
+        return err_mode("writing");
+
+    if (!PyArg_ParseTuple(args, "|O", &posobj))
+        return NULL;
+
+    if (posobj == Py_None || posobj == NULL) {
+        /* Get the current position. */
+        posobj = portable_lseek(fd, NULL, 1);
+        if (posobj == NULL)
+            return NULL;
+    }
+    else {
+        Py_INCREF(posobj);
+    }
+
+#ifdef MS_WINDOWS
+    /* MS _chsize doesn't work if newsize doesn't fit in 32 bits,
+       so don't even try using it. */
+    {
+        PyObject *oldposobj, *tempposobj;
+        HANDLE hFile;
+
+        /* we save the file pointer position */
+        oldposobj = portable_lseek(fd, NULL, 1);
+        if (oldposobj == NULL) {
+            Py_DECREF(posobj);
+            return NULL;
+        }
+
+        /* we then move to the truncation position */
+        tempposobj = portable_lseek(fd, posobj, 0);
+        if (tempposobj == NULL) {
+            Py_DECREF(oldposobj);
+            Py_DECREF(posobj);
+            return NULL;
+        }
+        Py_DECREF(tempposobj);
+
+        /* Truncate.  Note that this may grow the file! */
+        Py_BEGIN_ALLOW_THREADS
+        errno = 0;
+        hFile = (HANDLE)_get_osfhandle(fd);
+        ret = hFile == (HANDLE)-1; /* testing for INVALID_HANDLE value */
+        if (ret == 0) {
+            ret = SetEndOfFile(hFile) == 0;
+            if (ret)
+                errno = EACCES;
+        }
+        Py_END_ALLOW_THREADS
+
+        /* we restore the file pointer position in any case */
+        tempposobj = portable_lseek(fd, oldposobj, 0);
+        Py_DECREF(oldposobj);
+        if (tempposobj == NULL) {
+            Py_DECREF(posobj);
+            return NULL;
+        }
+        Py_DECREF(tempposobj);
+    }
+#else
+
+#if defined(HAVE_LARGEFILE_SUPPORT)
+    pos = PyLong_AsLongLong(posobj);
+#else
+    pos = PyLong_AsLong(posobj);
+#endif
+    if (PyErr_Occurred()){
+        Py_DECREF(posobj);
+        return NULL;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    errno = 0;
+    ret = ftruncate(fd, pos);
+    Py_END_ALLOW_THREADS
+
+#endif /* !MS_WINDOWS */
+
+    if (ret != 0) {
+        Py_DECREF(posobj);
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+
+    return posobj;
+}
+#endif /* HAVE_FTRUNCATE */
+
+static char *
+mode_string(fileio *self)
+{
+    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 PyObject *
+fileio_repr(fileio *self)
+{
+    PyObject *nameobj, *res;
+
+    if (self->fd < 0)
+        return PyString_FromFormat("<_io.FileIO [closed]>");
+
+    nameobj = PyObject_GetAttrString((PyObject *) self, "name");
+    if (nameobj == NULL) {
+        if (PyErr_ExceptionMatches(PyExc_AttributeError))
+            PyErr_Clear();
+        else
+            return NULL;
+        res = PyString_FromFormat("<_io.FileIO fd=%d mode='%s'>",
+                                   self->fd, mode_string(self));
+    }
+    else {
+        PyObject *repr = PyObject_Repr(nameobj);
+        Py_DECREF(nameobj);
+        if (repr == NULL)
+            return NULL;
+        res = PyString_FromFormat("<_io.FileIO name=%s mode='%s'>",
+                                   PyString_AS_STRING(repr),
+                                   mode_string(self));
+        Py_DECREF(repr);
+    }
+    return res;
+}
+
+static PyObject *
+fileio_isatty(fileio *self)
+{
+    long res;
+
+    if (self->fd < 0)
+        return err_closed();
+    Py_BEGIN_ALLOW_THREADS
+    res = isatty(self->fd);
+    Py_END_ALLOW_THREADS
+    return PyBool_FromLong(res);
+}
+
+
+PyDoc_STRVAR(fileio_doc,
+"file(name: str[, mode: str]) -> file IO object\n"
+"\n"
+"Open a file.  The mode can be 'r' (default), 'w' or 'a' for reading,\n"
+"writing or appending.  The file will be created if it doesn't exist\n"
+"when opened for writing or appending; it will be truncated when\n"
+"opened for writing.  Add a '+' to the mode to allow simultaneous\n"
+"reading and writing.");
+
+PyDoc_STRVAR(read_doc,
+"read(size: int) -> bytes.  read at most size bytes, returned as bytes.\n"
+"\n"
+"Only makes one system call, so less data may be returned than requested\n"
+"In non-blocking mode, returns None if no data is available.\n"
+"On end-of-file, returns ''.");
+
+PyDoc_STRVAR(readall_doc,
+"readall() -> bytes.  read all data from the file, returned as bytes.\n"
+"\n"
+"In non-blocking mode, returns as much as is immediately available,\n"
+"or None if no data is available.  On end-of-file, returns ''.");
+
+PyDoc_STRVAR(write_doc,
+"write(b) -> int.  Write array of bytes b, return number written.\n"
+"\n"
+"Only makes one system call, so not all of the data may be written.\n"
+"The number of bytes actually written is returned.  In non-blocking mode,\n"
+"returns None if the write would block."
+);
+
+PyDoc_STRVAR(fileno_doc,
+"fileno() -> int.  Return the underlying file descriptor (an integer).");
+
+PyDoc_STRVAR(seek_doc,
+"seek(offset: int[, whence: int]) -> int.  Move to new file position\n"
+"and return the file position.\n"
+"\n"
+"Argument offset is a byte count.  Optional argument whence defaults to\n"
+"SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values\n"
+"are SEEK_CUR or 1 (move relative to current position, positive or negative),\n"
+"and SEEK_END or 2 (move relative to end of file, usually negative, although\n"
+"many platforms allow seeking beyond the end of a file).\n"
+"\n"
+"Note that not all file objects are seekable.");
+
+#ifdef HAVE_FTRUNCATE
+PyDoc_STRVAR(truncate_doc,
+"truncate([size: int]) -> int.  Truncate the file to at most size bytes and\n"
+"return the truncated size.\n"
+"\n"
+"Size defaults to the current file position, as returned by tell().\n"
+"The current file position is changed to the value of size.");
+#endif
+
+PyDoc_STRVAR(tell_doc,
+"tell() -> int.  Current file position.\n"
+"\n"
+"Can raise OSError for non seekable files."
+);
+
+PyDoc_STRVAR(readinto_doc,
+"readinto() -> Same as RawIOBase.readinto().");
+
+PyDoc_STRVAR(close_doc,
+"close() -> None.  Close the file.\n"
+"\n"
+"A closed file cannot be used for further I/O operations.  close() may be\n"
+"called more than once without error.");
+
+PyDoc_STRVAR(isatty_doc,
+"isatty() -> bool.  True if the file is connected to a TTY device.");
+
+PyDoc_STRVAR(seekable_doc,
+"seekable() -> bool.  True if file supports random-access.");
+
+PyDoc_STRVAR(readable_doc,
+"readable() -> bool.  True if file was opened in a read mode.");
+
+PyDoc_STRVAR(writable_doc,
+"writable() -> bool.  True if file was opened in a write mode.");
+
+static PyMethodDef fileio_methods[] = {
+    {"read",     (PyCFunction)fileio_read,         METH_VARARGS, read_doc},
+    {"readall",  (PyCFunction)fileio_readall,  METH_NOARGS,  readall_doc},
+    {"readinto", (PyCFunction)fileio_readinto, METH_VARARGS, readinto_doc},
+    {"write",    (PyCFunction)fileio_write,        METH_VARARGS, write_doc},
+    {"seek",     (PyCFunction)fileio_seek,         METH_VARARGS, seek_doc},
+    {"tell",     (PyCFunction)fileio_tell,         METH_VARARGS, tell_doc},
+#ifdef HAVE_FTRUNCATE
+    {"truncate", (PyCFunction)fileio_truncate, METH_VARARGS, truncate_doc},
+#endif
+    {"close",    (PyCFunction)fileio_close,        METH_NOARGS,  close_doc},
+    {"seekable", (PyCFunction)fileio_seekable, METH_NOARGS,      seekable_doc},
+    {"readable", (PyCFunction)fileio_readable, METH_NOARGS,      readable_doc},
+    {"writable", (PyCFunction)fileio_writable, METH_NOARGS,      writable_doc},
+    {"fileno",   (PyCFunction)fileio_fileno,   METH_NOARGS,      fileno_doc},
+    {"isatty",   (PyCFunction)fileio_isatty,   METH_NOARGS,      isatty_doc},
+    {NULL,           NULL}             /* sentinel */
+};
+
+/* 'closed' and 'mode' are attributes for backwards compatibility reasons. */
+
+static PyObject *
+get_closed(fileio *self, void *closure)
+{
+    return PyBool_FromLong((long)(self->fd < 0));
+}
+
+static PyObject *
+get_closefd(fileio *self, void *closure)
+{
+    return PyBool_FromLong((long)(self->closefd));
+}
+
+static PyObject *
+get_mode(fileio *self, void *closure)
+{
+    return PyUnicode_FromString(mode_string(self));
+}
+
+static PyGetSetDef fileio_getsetlist[] = {
+    {"closed", (getter)get_closed, NULL, "True if the file is closed"},
+    {"closefd", (getter)get_closefd, NULL,
+        "True if the file descriptor will be closed by close()."},
+    {"mode", (getter)get_mode, NULL, "String giving the file mode"},
+    {NULL},
+};
+
+PyTypeObject PyFileIO_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_io.FileIO",
+    sizeof(fileio),
+    0,
+    (destructor)fileio_dealloc,                 /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_reserved */
+    (reprfunc)fileio_repr,                      /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    PyObject_GenericGetAttr,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
+                    | Py_TPFLAGS_HAVE_GC,       /* tp_flags */
+    fileio_doc,                                 /* tp_doc */
+    (traverseproc)fileio_traverse,              /* tp_traverse */
+    (inquiry)fileio_clear,                      /* tp_clear */
+    0,                                          /* tp_richcompare */
+    offsetof(fileio, weakreflist),      /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    fileio_methods,                             /* tp_methods */
+    0,                                          /* tp_members */
+    fileio_getsetlist,                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    offsetof(fileio, dict),         /* tp_dictoffset */
+    fileio_init,                                /* tp_init */
+    PyType_GenericAlloc,                        /* tp_alloc */
+    fileio_new,                                 /* tp_new */
+    PyObject_GC_Del,                            /* tp_free */
+};
author	nkozlovskiy <nmk@ydb.tech>	2023-09-29 12:24:06 +0300
committer	nkozlovskiy <nmk@ydb.tech>	2023-09-29 12:41:34 +0300
commit	e0e3e1717e3d33762ce61950504f9637a6e669ed (patch)
tree	bca3ff6939b10ed60c3d5c12439963a1146b9711 /contrib/tools/python/src/Modules/_io/fileio.c
parent	38f2c5852db84c7b4d83adfcb009eb61541d1ccd (diff)
download	ydb-e0e3e1717e3d33762ce61950504f9637a6e669ed.tar.gz