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

               Branch data     Line data    Source code
           1                 :            : #ifndef Py_CPYTHON_BYTESOBJECT_H
           2                 :            : #  error "this header file must not be included directly"
           3                 :            : #endif
           4                 :            :
           5                 :            : typedef struct {
           6                 :            :     PyObject_VAR_HEAD
           7                 :            :     Py_DEPRECATED(3.11) Py_hash_t ob_shash;
           8                 :            :     char ob_sval[1];
           9                 :            :
          10                 :            :     /* Invariants:
          11                 :            :      *     ob_sval contains space for 'ob_size+1' elements.
          12                 :            :      *     ob_sval[ob_size] == 0.
          13                 :            :      *     ob_shash is the hash of the byte string or -1 if not computed yet.
          14                 :            :      */
          15                 :            : } PyBytesObject;
          16                 :            :
          17                 :            : PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t);
          18                 :            : PyAPI_FUNC(PyObject*) _PyBytes_FormatEx(
          19                 :            :     const char *format,
          20                 :            :     Py_ssize_t format_len,
          21                 :            :     PyObject *args,
          22                 :            :     int use_bytearray);
          23                 :            : PyAPI_FUNC(PyObject*) _PyBytes_FromHex(
          24                 :            :     PyObject *string,
          25                 :            :     int use_bytearray);
          26                 :            :
          27                 :            : /* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */
          28                 :            : PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t,
          29                 :            :                                              const char *, const char **);
          30                 :            :
          31                 :            : /* Macros and static inline functions, trading safety for speed */
          32                 :            : #define _PyBytes_CAST(op) \
          33                 :            :     (assert(PyBytes_Check(op)), _Py_CAST(PyBytesObject*, op))
          34                 :            :
          35                 :    1849987 : static inline char* PyBytes_AS_STRING(PyObject *op)
          36                 :            : {
          37         [ #  # ]:    1849987 :     return _PyBytes_CAST(op)->ob_sval;
          38                 :            : }
          39                 :            : #define PyBytes_AS_STRING(op) PyBytes_AS_STRING(_PyObject_CAST(op))
          40                 :            :
          41                 :    1819818 : static inline Py_ssize_t PyBytes_GET_SIZE(PyObject *op) {
          42         [ #  # ]:    1819818 :     PyBytesObject *self = _PyBytes_CAST(op);
          43                 :    1819818 :     return Py_SIZE(self);
          44                 :            : }
          45                 :            : #define PyBytes_GET_SIZE(self) PyBytes_GET_SIZE(_PyObject_CAST(self))
          46                 :            :
          47                 :            : /* _PyBytes_Join(sep, x) is like sep.join(x).  sep must be PyBytesObject*,
          48                 :            :    x must be an iterable object. */
          49                 :            : PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x);
          50                 :            :
          51                 :            :
          52                 :            : /* The _PyBytesWriter structure is big: it contains an embedded "stack buffer".
          53                 :            :    A _PyBytesWriter variable must be declared at the end of variables in a
          54                 :            :    function to optimize the memory allocation on the stack. */
          55                 :            : typedef struct {
          56                 :            :     /* bytes, bytearray or NULL (when the small buffer is used) */
          57                 :            :     PyObject *buffer;
          58                 :            :
          59                 :            :     /* Number of allocated size. */
          60                 :            :     Py_ssize_t allocated;
          61                 :            :
          62                 :            :     /* Minimum number of allocated bytes,
          63                 :            :        incremented by _PyBytesWriter_Prepare() */
          64                 :            :     Py_ssize_t min_size;
          65                 :            :
          66                 :            :     /* If non-zero, use a bytearray instead of a bytes object for buffer. */
          67                 :            :     int use_bytearray;
          68                 :            :
          69                 :            :     /* If non-zero, overallocate the buffer (default: 0).
          70                 :            :        This flag must be zero if use_bytearray is non-zero. */
          71                 :            :     int overallocate;
          72                 :            :
          73                 :            :     /* Stack buffer */
          74                 :            :     int use_small_buffer;
          75                 :            :     char small_buffer[512];
          76                 :            : } _PyBytesWriter;
          77                 :            :
          78                 :            : /* Initialize a bytes writer
          79                 :            :
          80                 :            :    By default, the overallocation is disabled. Set the overallocate attribute
          81                 :            :    to control the allocation of the buffer. */
          82                 :            : PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer);
          83                 :            :
          84                 :            : /* Get the buffer content and reset the writer.
          85                 :            :    Return a bytes object, or a bytearray object if use_bytearray is non-zero.
          86                 :            :    Raise an exception and return NULL on error. */
          87                 :            : PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer,
          88                 :            :     void *str);
          89                 :            :
          90                 :            : /* Deallocate memory of a writer (clear its internal buffer). */
          91                 :            : PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer);
          92                 :            :
          93                 :            : /* Allocate the buffer to write size bytes.
          94                 :            :    Return the pointer to the beginning of buffer data.
          95                 :            :    Raise an exception and return NULL on error. */
          96                 :            : PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer,
          97                 :            :     Py_ssize_t size);
          98                 :            :
          99                 :            : /* Ensure that the buffer is large enough to write *size* bytes.
         100                 :            :    Add size to the writer minimum size (min_size attribute).
         101                 :            :
         102                 :            :    str is the current pointer inside the buffer.
         103                 :            :    Return the updated current pointer inside the buffer.
         104                 :            :    Raise an exception and return NULL on error. */
         105                 :            : PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer,
         106                 :            :     void *str,
         107                 :            :     Py_ssize_t size);
         108                 :            :
         109                 :            : /* Resize the buffer to make it larger.
         110                 :            :    The new buffer may be larger than size bytes because of overallocation.
         111                 :            :    Return the updated current pointer inside the buffer.
         112                 :            :    Raise an exception and return NULL on error.
         113                 :            :
         114                 :            :    Note: size must be greater than the number of allocated bytes in the writer.
         115                 :            :
         116                 :            :    This function doesn't use the writer minimum size (min_size attribute).
         117                 :            :
         118                 :            :    See also _PyBytesWriter_Prepare().
         119                 :            :    */
         120                 :            : PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer,
         121                 :            :     void *str,
         122                 :            :     Py_ssize_t size);
         123                 :            :
         124                 :            : /* Write bytes.
         125                 :            :    Raise an exception and return NULL on error. */
         126                 :            : PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer,
         127                 :            :     void *str,
         128                 :            :     const void *bytes,
         129                 :            :     Py_ssize_t size);

Generated by: LCOV version 1.14