LCOV - code coverage report
Current view: | top level - Modules/_io/clinic - fileio.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 75 | 120 | 62.5 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 12 | 14 | 85.7 %
|  |  | Branches: | 26 | 72 | 36.1 %

               Branch data     Line data    Source code
           1                 :            : /*[clinic input]
           2                 :            : preserve
           3                 :            : [clinic start generated code]*/
           4                 :            :
           5                 :            : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
           6                 :            : #  include "pycore_gc.h"            // PyGC_Head
           7                 :            : #  include "pycore_runtime.h"       // _Py_ID()
           8                 :            : #endif
           9                 :            :
          10                 :            :
          11                 :            : PyDoc_STRVAR(_io_FileIO_close__doc__,
          12                 :            : "close($self, /)\n"
          13                 :            : "--\n"
          14                 :            : "\n"
          15                 :            : "Close the file.\n"
          16                 :            : "\n"
          17                 :            : "A closed file cannot be used for further I/O operations.  close() may be\n"
          18                 :            : "called more than once without error.");
          19                 :            :
          20                 :            : #define _IO_FILEIO_CLOSE_METHODDEF    \
          21                 :            :     {"close", (PyCFunction)_io_FileIO_close, METH_NOARGS, _io_FileIO_close__doc__},
          22                 :            :
          23                 :            : static PyObject *
          24                 :            : _io_FileIO_close_impl(fileio *self);
          25                 :            :
          26                 :            : static PyObject *
          27                 :       1500 : _io_FileIO_close(fileio *self, PyObject *Py_UNUSED(ignored))
          28                 :            : {
          29                 :       1500 :     return _io_FileIO_close_impl(self);
          30                 :            : }
          31                 :            :
          32                 :            : PyDoc_STRVAR(_io_FileIO___init____doc__,
          33                 :            : "FileIO(file, mode=\'r\', closefd=True, opener=None)\n"
          34                 :            : "--\n"
          35                 :            : "\n"
          36                 :            : "Open a file.\n"
          37                 :            : "\n"
          38                 :            : "The mode can be \'r\' (default), \'w\', \'x\' or \'a\' for reading,\n"
          39                 :            : "writing, exclusive creation or appending.  The file will be created if it\n"
          40                 :            : "doesn\'t exist when opened for writing or appending; it will be truncated\n"
          41                 :            : "when opened for writing.  A FileExistsError will be raised if it already\n"
          42                 :            : "exists when opened for creating. Opening a file for creating implies\n"
          43                 :            : "writing so this mode behaves in a similar way to \'w\'.Add a \'+\' to the mode\n"
          44                 :            : "to allow simultaneous reading and writing. A custom opener can be used by\n"
          45                 :            : "passing a callable as *opener*. The underlying file descriptor for the file\n"
          46                 :            : "object is then obtained by calling opener with (*name*, *flags*).\n"
          47                 :            : "*opener* must return an open file descriptor (passing os.open as *opener*\n"
          48                 :            : "results in functionality similar to passing None).");
          49                 :            :
          50                 :            : static int
          51                 :            : _io_FileIO___init___impl(fileio *self, PyObject *nameobj, const char *mode,
          52                 :            :                          int closefd, PyObject *opener);
          53                 :            :
          54                 :            : static int
          55                 :       1660 : _io_FileIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
          56                 :            : {
          57                 :       1660 :     int return_value = -1;
          58                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
          59                 :            :
          60                 :            :     #define NUM_KEYWORDS 4
          61                 :            :     static struct {
          62                 :            :         PyGC_Head _this_is_not_used;
          63                 :            :         PyObject_VAR_HEAD
          64                 :            :         PyObject *ob_item[NUM_KEYWORDS];
          65                 :            :     } _kwtuple = {
          66                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
          67                 :            :         .ob_item = { &_Py_ID(file), &_Py_ID(mode), &_Py_ID(closefd), &_Py_ID(opener), },
          68                 :            :     };
          69                 :            :     #undef NUM_KEYWORDS
          70                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
          71                 :            :
          72                 :            :     #else  // !Py_BUILD_CORE
          73                 :            :     #  define KWTUPLE NULL
          74                 :            :     #endif  // !Py_BUILD_CORE
          75                 :            :
          76                 :            :     static const char * const _keywords[] = {"file", "mode", "closefd", "opener", NULL};
          77                 :            :     static _PyArg_Parser _parser = {
          78                 :            :         .keywords = _keywords,
          79                 :            :         .fname = "FileIO",
          80                 :            :         .kwtuple = KWTUPLE,
          81                 :            :     };
          82                 :            :     #undef KWTUPLE
          83                 :            :     PyObject *argsbuf[4];
          84                 :            :     PyObject * const *fastargs;
          85                 :       1660 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
          86         [ -  + ]:       1660 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
          87                 :            :     PyObject *nameobj;
          88                 :       1660 :     const char *mode = "r";
          89                 :       1660 :     int closefd = 1;
          90                 :       1660 :     PyObject *opener = Py_None;
          91                 :            :
          92   [ +  -  +  -  :       1660 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 4, 0, argsbuf);
                 +  -  +  - ]
          93         [ -  + ]:       1660 :     if (!fastargs) {
          94                 :          0 :         goto exit;
          95                 :            :     }
          96                 :       1660 :     nameobj = fastargs[0];
          97         [ -  + ]:       1660 :     if (!noptargs) {
          98                 :          0 :         goto skip_optional_pos;
          99                 :            :     }
         100         [ +  - ]:       1660 :     if (fastargs[1]) {
         101         [ -  + ]:       1660 :         if (!PyUnicode_Check(fastargs[1])) {
         102                 :          0 :             _PyArg_BadArgument("FileIO", "argument 'mode'", "str", fastargs[1]);
         103                 :          0 :             goto exit;
         104                 :            :         }
         105                 :            :         Py_ssize_t mode_length;
         106                 :       1660 :         mode = PyUnicode_AsUTF8AndSize(fastargs[1], &mode_length);
         107         [ -  + ]:       1660 :         if (mode == NULL) {
         108                 :          0 :             goto exit;
         109                 :            :         }
         110         [ -  + ]:       1660 :         if (strlen(mode) != (size_t)mode_length) {
         111                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null character");
         112                 :          0 :             goto exit;
         113                 :            :         }
         114         [ +  + ]:       1660 :         if (!--noptargs) {
         115                 :        159 :             goto skip_optional_pos;
         116                 :            :         }
         117                 :            :     }
         118         [ +  - ]:       1501 :     if (fastargs[2]) {
         119                 :       1501 :         closefd = PyObject_IsTrue(fastargs[2]);
         120         [ -  + ]:       1501 :         if (closefd < 0) {
         121                 :          0 :             goto exit;
         122                 :            :         }
         123         [ -  + ]:       1501 :         if (!--noptargs) {
         124                 :          0 :             goto skip_optional_pos;
         125                 :            :         }
         126                 :            :     }
         127                 :       1501 :     opener = fastargs[3];
         128                 :       1660 : skip_optional_pos:
         129                 :       1660 :     return_value = _io_FileIO___init___impl((fileio *)self, nameobj, mode, closefd, opener);
         130                 :            :
         131                 :       1660 : exit:
         132                 :       1660 :     return return_value;
         133                 :            : }
         134                 :            :
         135                 :            : PyDoc_STRVAR(_io_FileIO_fileno__doc__,
         136                 :            : "fileno($self, /)\n"
         137                 :            : "--\n"
         138                 :            : "\n"
         139                 :            : "Return the underlying file descriptor (an integer).");
         140                 :            :
         141                 :            : #define _IO_FILEIO_FILENO_METHODDEF    \
         142                 :            :     {"fileno", (PyCFunction)_io_FileIO_fileno, METH_NOARGS, _io_FileIO_fileno__doc__},
         143                 :            :
         144                 :            : static PyObject *
         145                 :            : _io_FileIO_fileno_impl(fileio *self);
         146                 :            :
         147                 :            : static PyObject *
         148                 :         13 : _io_FileIO_fileno(fileio *self, PyObject *Py_UNUSED(ignored))
         149                 :            : {
         150                 :         13 :     return _io_FileIO_fileno_impl(self);
         151                 :            : }
         152                 :            :
         153                 :            : PyDoc_STRVAR(_io_FileIO_readable__doc__,
         154                 :            : "readable($self, /)\n"
         155                 :            : "--\n"
         156                 :            : "\n"
         157                 :            : "True if file was opened in a read mode.");
         158                 :            :
         159                 :            : #define _IO_FILEIO_READABLE_METHODDEF    \
         160                 :            :     {"readable", (PyCFunction)_io_FileIO_readable, METH_NOARGS, _io_FileIO_readable__doc__},
         161                 :            :
         162                 :            : static PyObject *
         163                 :            : _io_FileIO_readable_impl(fileio *self);
         164                 :            :
         165                 :            : static PyObject *
         166                 :       1946 : _io_FileIO_readable(fileio *self, PyObject *Py_UNUSED(ignored))
         167                 :            : {
         168                 :       1946 :     return _io_FileIO_readable_impl(self);
         169                 :            : }
         170                 :            :
         171                 :            : PyDoc_STRVAR(_io_FileIO_writable__doc__,
         172                 :            : "writable($self, /)\n"
         173                 :            : "--\n"
         174                 :            : "\n"
         175                 :            : "True if file was opened in a write mode.");
         176                 :            :
         177                 :            : #define _IO_FILEIO_WRITABLE_METHODDEF    \
         178                 :            :     {"writable", (PyCFunction)_io_FileIO_writable, METH_NOARGS, _io_FileIO_writable__doc__},
         179                 :            :
         180                 :            : static PyObject *
         181                 :            : _io_FileIO_writable_impl(fileio *self);
         182                 :            :
         183                 :            : static PyObject *
         184                 :        148 : _io_FileIO_writable(fileio *self, PyObject *Py_UNUSED(ignored))
         185                 :            : {
         186                 :        148 :     return _io_FileIO_writable_impl(self);
         187                 :            : }
         188                 :            :
         189                 :            : PyDoc_STRVAR(_io_FileIO_seekable__doc__,
         190                 :            : "seekable($self, /)\n"
         191                 :            : "--\n"
         192                 :            : "\n"
         193                 :            : "True if file supports random-access.");
         194                 :            :
         195                 :            : #define _IO_FILEIO_SEEKABLE_METHODDEF    \
         196                 :            :     {"seekable", (PyCFunction)_io_FileIO_seekable, METH_NOARGS, _io_FileIO_seekable__doc__},
         197                 :            :
         198                 :            : static PyObject *
         199                 :            : _io_FileIO_seekable_impl(fileio *self);
         200                 :            :
         201                 :            : static PyObject *
         202                 :        842 : _io_FileIO_seekable(fileio *self, PyObject *Py_UNUSED(ignored))
         203                 :            : {
         204                 :        842 :     return _io_FileIO_seekable_impl(self);
         205                 :            : }
         206                 :            :
         207                 :            : PyDoc_STRVAR(_io_FileIO_readinto__doc__,
         208                 :            : "readinto($self, buffer, /)\n"
         209                 :            : "--\n"
         210                 :            : "\n"
         211                 :            : "Same as RawIOBase.readinto().");
         212                 :            :
         213                 :            : #define _IO_FILEIO_READINTO_METHODDEF    \
         214                 :            :     {"readinto", (PyCFunction)_io_FileIO_readinto, METH_O, _io_FileIO_readinto__doc__},
         215                 :            :
         216                 :            : static PyObject *
         217                 :            : _io_FileIO_readinto_impl(fileio *self, Py_buffer *buffer);
         218                 :            :
         219                 :            : static PyObject *
         220                 :       4092 : _io_FileIO_readinto(fileio *self, PyObject *arg)
         221                 :            : {
         222                 :       4092 :     PyObject *return_value = NULL;
         223                 :       4092 :     Py_buffer buffer = {NULL, NULL};
         224                 :            :
         225         [ -  + ]:       4092 :     if (PyObject_GetBuffer(arg, &buffer, PyBUF_WRITABLE) < 0) {
         226                 :          0 :         PyErr_Clear();
         227                 :          0 :         _PyArg_BadArgument("readinto", "argument", "read-write bytes-like object", arg);
         228                 :          0 :         goto exit;
         229                 :            :     }
         230         [ -  + ]:       4092 :     if (!PyBuffer_IsContiguous(&buffer, 'C')) {
         231                 :          0 :         _PyArg_BadArgument("readinto", "argument", "contiguous buffer", arg);
         232                 :          0 :         goto exit;
         233                 :            :     }
         234                 :       4092 :     return_value = _io_FileIO_readinto_impl(self, &buffer);
         235                 :            :
         236                 :       4092 : exit:
         237                 :            :     /* Cleanup for buffer */
         238         [ +  - ]:       4092 :     if (buffer.obj) {
         239                 :       4092 :        PyBuffer_Release(&buffer);
         240                 :            :     }
         241                 :            :
         242                 :       4092 :     return return_value;
         243                 :            : }
         244                 :            :
         245                 :            : PyDoc_STRVAR(_io_FileIO_readall__doc__,
         246                 :            : "readall($self, /)\n"
         247                 :            : "--\n"
         248                 :            : "\n"
         249                 :            : "Read all data from the file, returned as bytes.\n"
         250                 :            : "\n"
         251                 :            : "In non-blocking mode, returns as much as is immediately available,\n"
         252                 :            : "or None if no data is available.  Return an empty bytes object at EOF.");
         253                 :            :
         254                 :            : #define _IO_FILEIO_READALL_METHODDEF    \
         255                 :            :     {"readall", (PyCFunction)_io_FileIO_readall, METH_NOARGS, _io_FileIO_readall__doc__},
         256                 :            :
         257                 :            : static PyObject *
         258                 :            : _io_FileIO_readall_impl(fileio *self);
         259                 :            :
         260                 :            : static PyObject *
         261                 :        612 : _io_FileIO_readall(fileio *self, PyObject *Py_UNUSED(ignored))
         262                 :            : {
         263                 :        612 :     return _io_FileIO_readall_impl(self);
         264                 :            : }
         265                 :            :
         266                 :            : PyDoc_STRVAR(_io_FileIO_read__doc__,
         267                 :            : "read($self, size=-1, /)\n"
         268                 :            : "--\n"
         269                 :            : "\n"
         270                 :            : "Read at most size bytes, returned as bytes.\n"
         271                 :            : "\n"
         272                 :            : "Only makes one system call, so less data may be returned than requested.\n"
         273                 :            : "In non-blocking mode, returns None if no data is available.\n"
         274                 :            : "Return an empty bytes object at EOF.");
         275                 :            :
         276                 :            : #define _IO_FILEIO_READ_METHODDEF    \
         277                 :            :     {"read", _PyCFunction_CAST(_io_FileIO_read), METH_FASTCALL, _io_FileIO_read__doc__},
         278                 :            :
         279                 :            : static PyObject *
         280                 :            : _io_FileIO_read_impl(fileio *self, Py_ssize_t size);
         281                 :            :
         282                 :            : static PyObject *
         283                 :          0 : _io_FileIO_read(fileio *self, PyObject *const *args, Py_ssize_t nargs)
         284                 :            : {
         285                 :          0 :     PyObject *return_value = NULL;
         286                 :          0 :     Py_ssize_t size = -1;
         287                 :            :
         288   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
                       #  # ]
         289                 :          0 :         goto exit;
         290                 :            :     }
         291         [ #  # ]:          0 :     if (nargs < 1) {
         292                 :          0 :         goto skip_optional;
         293                 :            :     }
         294         [ #  # ]:          0 :     if (!_Py_convert_optional_to_ssize_t(args[0], &size)) {
         295                 :          0 :         goto exit;
         296                 :            :     }
         297                 :          0 : skip_optional:
         298                 :          0 :     return_value = _io_FileIO_read_impl(self, size);
         299                 :            :
         300                 :          0 : exit:
         301                 :          0 :     return return_value;
         302                 :            : }
         303                 :            :
         304                 :            : PyDoc_STRVAR(_io_FileIO_write__doc__,
         305                 :            : "write($self, b, /)\n"
         306                 :            : "--\n"
         307                 :            : "\n"
         308                 :            : "Write buffer b to file, return number of bytes written.\n"
         309                 :            : "\n"
         310                 :            : "Only makes one system call, so not all of the data may be written.\n"
         311                 :            : "The number of bytes actually written is returned.  In non-blocking mode,\n"
         312                 :            : "returns None if the write would block.");
         313                 :            :
         314                 :            : #define _IO_FILEIO_WRITE_METHODDEF    \
         315                 :            :     {"write", (PyCFunction)_io_FileIO_write, METH_O, _io_FileIO_write__doc__},
         316                 :            :
         317                 :            : static PyObject *
         318                 :            : _io_FileIO_write_impl(fileio *self, Py_buffer *b);
         319                 :            :
         320                 :            : static PyObject *
         321                 :        919 : _io_FileIO_write(fileio *self, PyObject *arg)
         322                 :            : {
         323                 :        919 :     PyObject *return_value = NULL;
         324                 :        919 :     Py_buffer b = {NULL, NULL};
         325                 :            :
         326         [ -  + ]:        919 :     if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) {
         327                 :          0 :         goto exit;
         328                 :            :     }
         329         [ -  + ]:        919 :     if (!PyBuffer_IsContiguous(&b, 'C')) {
         330                 :          0 :         _PyArg_BadArgument("write", "argument", "contiguous buffer", arg);
         331                 :          0 :         goto exit;
         332                 :            :     }
         333                 :        919 :     return_value = _io_FileIO_write_impl(self, &b);
         334                 :            :
         335                 :        919 : exit:
         336                 :            :     /* Cleanup for b */
         337         [ +  - ]:        919 :     if (b.obj) {
         338                 :        919 :        PyBuffer_Release(&b);
         339                 :            :     }
         340                 :            :
         341                 :        919 :     return return_value;
         342                 :            : }
         343                 :            :
         344                 :            : PyDoc_STRVAR(_io_FileIO_seek__doc__,
         345                 :            : "seek($self, pos, whence=0, /)\n"
         346                 :            : "--\n"
         347                 :            : "\n"
         348                 :            : "Move to new file position and return the file position.\n"
         349                 :            : "\n"
         350                 :            : "Argument offset is a byte count.  Optional argument whence defaults to\n"
         351                 :            : "SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values\n"
         352                 :            : "are SEEK_CUR or 1 (move relative to current position, positive or negative),\n"
         353                 :            : "and SEEK_END or 2 (move relative to end of file, usually negative, although\n"
         354                 :            : "many platforms allow seeking beyond the end of a file).\n"
         355                 :            : "\n"
         356                 :            : "Note that not all file objects are seekable.");
         357                 :            :
         358                 :            : #define _IO_FILEIO_SEEK_METHODDEF    \
         359                 :            :     {"seek", _PyCFunction_CAST(_io_FileIO_seek), METH_FASTCALL, _io_FileIO_seek__doc__},
         360                 :            :
         361                 :            : static PyObject *
         362                 :            : _io_FileIO_seek_impl(fileio *self, PyObject *pos, int whence);
         363                 :            :
         364                 :            : static PyObject *
         365                 :         88 : _io_FileIO_seek(fileio *self, PyObject *const *args, Py_ssize_t nargs)
         366                 :            : {
         367                 :         88 :     PyObject *return_value = NULL;
         368                 :            :     PyObject *pos;
         369                 :         88 :     int whence = 0;
         370                 :            :
         371   [ +  -  -  +  :         88 :     if (!_PyArg_CheckPositional("seek", nargs, 1, 2)) {
                       -  - ]
         372                 :          0 :         goto exit;
         373                 :            :     }
         374                 :         88 :     pos = args[0];
         375         [ -  + ]:         88 :     if (nargs < 2) {
         376                 :          0 :         goto skip_optional;
         377                 :            :     }
         378                 :         88 :     whence = _PyLong_AsInt(args[1]);
         379   [ -  +  -  - ]:         88 :     if (whence == -1 && PyErr_Occurred()) {
         380                 :          0 :         goto exit;
         381                 :            :     }
         382                 :         88 : skip_optional:
         383                 :         88 :     return_value = _io_FileIO_seek_impl(self, pos, whence);
         384                 :            :
         385                 :         88 : exit:
         386                 :         88 :     return return_value;
         387                 :            : }
         388                 :            :
         389                 :            : PyDoc_STRVAR(_io_FileIO_tell__doc__,
         390                 :            : "tell($self, /)\n"
         391                 :            : "--\n"
         392                 :            : "\n"
         393                 :            : "Current file position.\n"
         394                 :            : "\n"
         395                 :            : "Can raise OSError for non seekable files.");
         396                 :            :
         397                 :            : #define _IO_FILEIO_TELL_METHODDEF    \
         398                 :            :     {"tell", (PyCFunction)_io_FileIO_tell, METH_NOARGS, _io_FileIO_tell__doc__},
         399                 :            :
         400                 :            : static PyObject *
         401                 :            : _io_FileIO_tell_impl(fileio *self);
         402                 :            :
         403                 :            : static PyObject *
         404                 :       1431 : _io_FileIO_tell(fileio *self, PyObject *Py_UNUSED(ignored))
         405                 :            : {
         406                 :       1431 :     return _io_FileIO_tell_impl(self);
         407                 :            : }
         408                 :            :
         409                 :            : #if defined(HAVE_FTRUNCATE)
         410                 :            :
         411                 :            : PyDoc_STRVAR(_io_FileIO_truncate__doc__,
         412                 :            : "truncate($self, size=None, /)\n"
         413                 :            : "--\n"
         414                 :            : "\n"
         415                 :            : "Truncate the file to at most size bytes and return the truncated size.\n"
         416                 :            : "\n"
         417                 :            : "Size defaults to the current file position, as returned by tell().\n"
         418                 :            : "The current file position is changed to the value of size.");
         419                 :            :
         420                 :            : #define _IO_FILEIO_TRUNCATE_METHODDEF    \
         421                 :            :     {"truncate", _PyCFunction_CAST(_io_FileIO_truncate), METH_FASTCALL, _io_FileIO_truncate__doc__},
         422                 :            :
         423                 :            : static PyObject *
         424                 :            : _io_FileIO_truncate_impl(fileio *self, PyObject *posobj);
         425                 :            :
         426                 :            : static PyObject *
         427                 :          0 : _io_FileIO_truncate(fileio *self, PyObject *const *args, Py_ssize_t nargs)
         428                 :            : {
         429                 :          0 :     PyObject *return_value = NULL;
         430                 :          0 :     PyObject *posobj = Py_None;
         431                 :            :
         432   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("truncate", nargs, 0, 1)) {
                       #  # ]
         433                 :          0 :         goto exit;
         434                 :            :     }
         435         [ #  # ]:          0 :     if (nargs < 1) {
         436                 :          0 :         goto skip_optional;
         437                 :            :     }
         438                 :          0 :     posobj = args[0];
         439                 :          0 : skip_optional:
         440                 :          0 :     return_value = _io_FileIO_truncate_impl(self, posobj);
         441                 :            :
         442                 :          0 : exit:
         443                 :          0 :     return return_value;
         444                 :            : }
         445                 :            :
         446                 :            : #endif /* defined(HAVE_FTRUNCATE) */
         447                 :            :
         448                 :            : PyDoc_STRVAR(_io_FileIO_isatty__doc__,
         449                 :            : "isatty($self, /)\n"
         450                 :            : "--\n"
         451                 :            : "\n"
         452                 :            : "True if the file is connected to a TTY device.");
         453                 :            :
         454                 :            : #define _IO_FILEIO_ISATTY_METHODDEF    \
         455                 :            :     {"isatty", (PyCFunction)_io_FileIO_isatty, METH_NOARGS, _io_FileIO_isatty__doc__},
         456                 :            :
         457                 :            : static PyObject *
         458                 :            : _io_FileIO_isatty_impl(fileio *self);
         459                 :            :
         460                 :            : static PyObject *
         461                 :       1416 : _io_FileIO_isatty(fileio *self, PyObject *Py_UNUSED(ignored))
         462                 :            : {
         463                 :       1416 :     return _io_FileIO_isatty_impl(self);
         464                 :            : }
         465                 :            :
         466                 :            : #ifndef _IO_FILEIO_TRUNCATE_METHODDEF
         467                 :            :     #define _IO_FILEIO_TRUNCATE_METHODDEF
         468                 :            : #endif /* !defined(_IO_FILEIO_TRUNCATE_METHODDEF) */
         469                 :            : /*[clinic end generated code: output=27f883807a6c29ae input=a9049054013a1b77]*/

Generated by: LCOV version 1.14