LCOV - code coverage report
Current view: top level - Modules/_io - _iomodule.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 6 6 100.0 %
Date: 2023-03-20 08:15:36 Functions: 2 2 100.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Declarations shared between the different parts of the io module
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "exports.h"
       6                 :            : 
       7                 :            : #include "pycore_moduleobject.h"  // _PyModule_GetState()
       8                 :            : #include "structmember.h"
       9                 :            : 
      10                 :            : /* ABCs */
      11                 :            : extern PyTypeObject PyIOBase_Type;
      12                 :            : extern PyTypeObject PyRawIOBase_Type;
      13                 :            : extern PyTypeObject PyBufferedIOBase_Type;
      14                 :            : extern PyTypeObject PyTextIOBase_Type;
      15                 :            : 
      16                 :            : /* Concrete classes */
      17                 :            : extern PyTypeObject PyIncrementalNewlineDecoder_Type;
      18                 :            : 
      19                 :            : /* Type specs */
      20                 :            : extern PyType_Spec bufferedrandom_spec;
      21                 :            : extern PyType_Spec bufferedreader_spec;
      22                 :            : extern PyType_Spec bufferedrwpair_spec;
      23                 :            : extern PyType_Spec bufferedwriter_spec;
      24                 :            : extern PyType_Spec bytesio_spec;
      25                 :            : extern PyType_Spec fileio_spec;
      26                 :            : extern PyType_Spec stringio_spec;
      27                 :            : extern PyType_Spec textiowrapper_spec;
      28                 :            : 
      29                 :            : #ifdef HAVE_WINDOWS_CONSOLE_IO
      30                 :            : extern PyTypeObject PyWindowsConsoleIO_Type;
      31                 :            : #endif /* HAVE_WINDOWS_CONSOLE_IO */
      32                 :            : 
      33                 :            : /* These functions are used as METH_NOARGS methods, are normally called
      34                 :            :  * with args=NULL, and return a new reference.
      35                 :            :  * BUT when args=Py_True is passed, they return a borrowed reference.
      36                 :            :  */
      37                 :            : extern PyObject* _PyIOBase_check_readable(PyObject *self, PyObject *args);
      38                 :            : extern PyObject* _PyIOBase_check_writable(PyObject *self, PyObject *args);
      39                 :            : extern PyObject* _PyIOBase_check_seekable(PyObject *self, PyObject *args);
      40                 :            : extern PyObject* _PyIOBase_check_closed(PyObject *self, PyObject *args);
      41                 :            : 
      42                 :            : /* Helper for finalization.
      43                 :            :    This function will revive an object ready to be deallocated and try to
      44                 :            :    close() it. It returns 0 if the object can be destroyed, or -1 if it
      45                 :            :    is alive again. */
      46                 :            : extern int _PyIOBase_finalize(PyObject *self);
      47                 :            : 
      48                 :            : /* Returns true if the given FileIO object is closed.
      49                 :            :    Doesn't check the argument type, so be careful! */
      50                 :            : extern int _PyFileIO_closed(PyObject *self);
      51                 :            : 
      52                 :            : /* Shortcut to the core of the IncrementalNewlineDecoder.decode method */
      53                 :            : extern PyObject *_PyIncrementalNewlineDecoder_decode(
      54                 :            :     PyObject *self, PyObject *input, int final);
      55                 :            : 
      56                 :            : /* Finds the first line ending between `start` and `end`.
      57                 :            :    If found, returns the index after the line ending and doesn't touch
      58                 :            :    `*consumed`.
      59                 :            :    If not found, returns -1 and sets `*consumed` to the number of characters
      60                 :            :    which can be safely put aside until another search.
      61                 :            : 
      62                 :            :    NOTE: for performance reasons, `end` must point to a NUL character ('\0').
      63                 :            :    Otherwise, the function will scan further and return garbage.
      64                 :            : 
      65                 :            :    There are three modes, in order of priority:
      66                 :            :    * translated: Only find \n (assume newlines already translated)
      67                 :            :    * universal: Use universal newlines algorithm
      68                 :            :    * Otherwise, the line ending is specified by readnl, a str object */
      69                 :            : extern Py_ssize_t _PyIO_find_line_ending(
      70                 :            :     int translated, int universal, PyObject *readnl,
      71                 :            :     int kind, const char *start, const char *end, Py_ssize_t *consumed);
      72                 :            : 
      73                 :            : /* Return 1 if an OSError with errno == EINTR is set (and then
      74                 :            :    clears the error indicator), 0 otherwise.
      75                 :            :    Should only be called when PyErr_Occurred() is true.
      76                 :            : */
      77                 :            : extern int _PyIO_trap_eintr(void);
      78                 :            : 
      79                 :            : #define DEFAULT_BUFFER_SIZE (8 * 1024)  /* bytes */
      80                 :            : 
      81                 :            : /*
      82                 :            :  * Offset type for positioning.
      83                 :            :  */
      84                 :            : 
      85                 :            : /* Printing a variable of type off_t (with e.g., PyUnicode_FromFormat)
      86                 :            :    correctly and without producing compiler warnings is surprisingly painful.
      87                 :            :    We identify an integer type whose size matches off_t and then: (1) cast the
      88                 :            :    off_t to that integer type and (2) use the appropriate conversion
      89                 :            :    specification.  The cast is necessary: gcc complains about formatting a
      90                 :            :    long with "%lld" even when both long and long long have the same
      91                 :            :    precision. */
      92                 :            : 
      93                 :            : #ifdef MS_WINDOWS
      94                 :            : 
      95                 :            : /* Windows uses long long for offsets */
      96                 :            : typedef long long Py_off_t;
      97                 :            : # define PyLong_AsOff_t     PyLong_AsLongLong
      98                 :            : # define PyLong_FromOff_t   PyLong_FromLongLong
      99                 :            : # define PY_OFF_T_MAX       LLONG_MAX
     100                 :            : # define PY_OFF_T_MIN       LLONG_MIN
     101                 :            : # define PY_OFF_T_COMPAT    long long    /* type compatible with off_t */
     102                 :            : # define PY_PRIdOFF         "lld"        /* format to use for that type */
     103                 :            : 
     104                 :            : #else
     105                 :            : 
     106                 :            : /* Other platforms use off_t */
     107                 :            : typedef off_t Py_off_t;
     108                 :            : #if (SIZEOF_OFF_T == SIZEOF_SIZE_T)
     109                 :            : # define PyLong_AsOff_t     PyLong_AsSsize_t
     110                 :            : # define PyLong_FromOff_t   PyLong_FromSsize_t
     111                 :            : # define PY_OFF_T_MAX       PY_SSIZE_T_MAX
     112                 :            : # define PY_OFF_T_MIN       PY_SSIZE_T_MIN
     113                 :            : # define PY_OFF_T_COMPAT    Py_ssize_t
     114                 :            : # define PY_PRIdOFF         "zd"
     115                 :            : #elif (SIZEOF_OFF_T == SIZEOF_LONG_LONG)
     116                 :            : # define PyLong_AsOff_t     PyLong_AsLongLong
     117                 :            : # define PyLong_FromOff_t   PyLong_FromLongLong
     118                 :            : # define PY_OFF_T_MAX       LLONG_MAX
     119                 :            : # define PY_OFF_T_MIN       LLONG_MIN
     120                 :            : # define PY_OFF_T_COMPAT    long long
     121                 :            : # define PY_PRIdOFF         "lld"
     122                 :            : #elif (SIZEOF_OFF_T == SIZEOF_LONG)
     123                 :            : # define PyLong_AsOff_t     PyLong_AsLong
     124                 :            : # define PyLong_FromOff_t   PyLong_FromLong
     125                 :            : # define PY_OFF_T_MAX       LONG_MAX
     126                 :            : # define PY_OFF_T_MIN       LONG_MIN
     127                 :            : # define PY_OFF_T_COMPAT    long
     128                 :            : # define PY_PRIdOFF         "ld"
     129                 :            : #else
     130                 :            : # error off_t does not match either size_t, long, or long long!
     131                 :            : #endif
     132                 :            : 
     133                 :            : #endif
     134                 :            : 
     135                 :            : extern Py_off_t PyNumber_AsOff_t(PyObject *item, PyObject *err);
     136                 :            : 
     137                 :            : /* Implementation details */
     138                 :            : 
     139                 :            : /* IO module structure */
     140                 :            : 
     141                 :            : extern PyModuleDef _PyIO_Module;
     142                 :            : 
     143                 :            : typedef struct {
     144                 :            :     int initialized;
     145                 :            :     PyObject *locale_module;
     146                 :            : 
     147                 :            :     PyObject *unsupported_operation;
     148                 :            : 
     149                 :            :     /* Types */
     150                 :            :     PyTypeObject *PyBufferedRWPair_Type;
     151                 :            :     PyTypeObject *PyBufferedRandom_Type;
     152                 :            :     PyTypeObject *PyBufferedReader_Type;
     153                 :            :     PyTypeObject *PyBufferedWriter_Type;
     154                 :            :     PyTypeObject *PyBytesIO_Type;
     155                 :            :     PyTypeObject *PyFileIO_Type;
     156                 :            :     PyTypeObject *PyStringIO_Type;
     157                 :            :     PyTypeObject *PyTextIOWrapper_Type;
     158                 :            : } _PyIO_State;
     159                 :            : 
     160                 :            : #define IO_MOD_STATE(mod) ((_PyIO_State *)PyModule_GetState(mod))
     161                 :            : #define IO_STATE() _PyIO_get_module_state()
     162                 :            : 
     163                 :            : static inline _PyIO_State *
     164                 :       3934 : get_io_state(PyObject *module)
     165                 :            : {
     166                 :       3934 :     void *state = _PyModule_GetState(module);
     167                 :            :     assert(state != NULL);
     168                 :       3934 :     return (_PyIO_State *)state;
     169                 :            : }
     170                 :            : 
     171                 :            : static inline _PyIO_State *
     172                 :       2105 : find_io_state_by_def(PyTypeObject *type)
     173                 :            : {
     174                 :       2105 :     PyObject *mod = PyType_GetModuleByDef(type, &_PyIO_Module);
     175                 :            :     assert(mod != NULL);
     176                 :       2105 :     return get_io_state(mod);
     177                 :            : }
     178                 :            : 
     179                 :            : extern _PyIO_State *_PyIO_get_module_state(void);
     180                 :            : 
     181                 :            : #ifdef HAVE_WINDOWS_CONSOLE_IO
     182                 :            : extern char _PyIO_get_console_type(PyObject *);
     183                 :            : #endif
     184                 :            : 
     185                 :            : extern Py_EXPORTED_SYMBOL PyTypeObject _PyBytesIOBuffer_Type;

Generated by: LCOV version 1.14