LCOV - code coverage report
Current view: | top level - Modules/clinic - _struct.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 35 | 130 | 26.9 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 4 | 8 | 50.0 %
|  |  | Branches: | 13 | 98 | 13.3 %

               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(Struct__doc__,
          12                 :            : "Struct(format)\n"
          13                 :            : "--\n"
          14                 :            : "\n"
          15                 :            : "Create a compiled struct object.\n"
          16                 :            : "\n"
          17                 :            : "Return a new Struct object which writes and reads binary data according to\n"
          18                 :            : "the format string.\n"
          19                 :            : "\n"
          20                 :            : "See help(struct) for more on format strings.");
          21                 :            :
          22                 :            : static PyObject *
          23                 :            : Struct_impl(PyTypeObject *type, PyObject *format);
          24                 :            :
          25                 :            : static PyObject *
          26                 :         15 : Struct(PyTypeObject *type, PyObject *args, PyObject *kwargs)
          27                 :            : {
          28                 :         15 :     PyObject *return_value = NULL;
          29                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
          30                 :            :
          31                 :            :     #define NUM_KEYWORDS 1
          32                 :            :     static struct {
          33                 :            :         PyGC_Head _this_is_not_used;
          34                 :            :         PyObject_VAR_HEAD
          35                 :            :         PyObject *ob_item[NUM_KEYWORDS];
          36                 :            :     } _kwtuple = {
          37                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
          38                 :            :         .ob_item = { &_Py_ID(format), },
          39                 :            :     };
          40                 :            :     #undef NUM_KEYWORDS
          41                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
          42                 :            :
          43                 :            :     #else  // !Py_BUILD_CORE
          44                 :            :     #  define KWTUPLE NULL
          45                 :            :     #endif  // !Py_BUILD_CORE
          46                 :            :
          47                 :            :     static const char * const _keywords[] = {"format", NULL};
          48                 :            :     static _PyArg_Parser _parser = {
          49                 :            :         .keywords = _keywords,
          50                 :            :         .fname = "Struct",
          51                 :            :         .kwtuple = KWTUPLE,
          52                 :            :     };
          53                 :            :     #undef KWTUPLE
          54                 :            :     PyObject *argsbuf[1];
          55                 :            :     PyObject * const *fastargs;
          56                 :         15 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
          57                 :            :     PyObject *format;
          58                 :            :
          59   [ +  -  +  -  :         15 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf);
                 +  -  +  - ]
          60         [ -  + ]:         15 :     if (!fastargs) {
          61                 :          0 :         goto exit;
          62                 :            :     }
          63                 :         15 :     format = fastargs[0];
          64                 :         15 :     return_value = Struct_impl(type, format);
          65                 :            :
          66                 :         15 : exit:
          67                 :         15 :     return return_value;
          68                 :            : }
          69                 :            :
          70                 :            : PyDoc_STRVAR(Struct_unpack__doc__,
          71                 :            : "unpack($self, buffer, /)\n"
          72                 :            : "--\n"
          73                 :            : "\n"
          74                 :            : "Return a tuple containing unpacked values.\n"
          75                 :            : "\n"
          76                 :            : "Unpack according to the format string Struct.format. The buffer\'s size\n"
          77                 :            : "in bytes must be Struct.size.\n"
          78                 :            : "\n"
          79                 :            : "See help(struct) for more on format strings.");
          80                 :            :
          81                 :            : #define STRUCT_UNPACK_METHODDEF    \
          82                 :            :     {"unpack", (PyCFunction)Struct_unpack, METH_O, Struct_unpack__doc__},
          83                 :            :
          84                 :            : static PyObject *
          85                 :            : Struct_unpack_impl(PyStructObject *self, Py_buffer *buffer);
          86                 :            :
          87                 :            : static PyObject *
          88                 :          0 : Struct_unpack(PyStructObject *self, PyObject *arg)
          89                 :            : {
          90                 :          0 :     PyObject *return_value = NULL;
          91                 :          0 :     Py_buffer buffer = {NULL, NULL};
          92                 :            :
          93         [ #  # ]:          0 :     if (PyObject_GetBuffer(arg, &buffer, PyBUF_SIMPLE) != 0) {
          94                 :          0 :         goto exit;
          95                 :            :     }
          96         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&buffer, 'C')) {
          97                 :          0 :         _PyArg_BadArgument("unpack", "argument", "contiguous buffer", arg);
          98                 :          0 :         goto exit;
          99                 :            :     }
         100                 :          0 :     return_value = Struct_unpack_impl(self, &buffer);
         101                 :            :
         102                 :          0 : exit:
         103                 :            :     /* Cleanup for buffer */
         104         [ #  # ]:          0 :     if (buffer.obj) {
         105                 :          0 :        PyBuffer_Release(&buffer);
         106                 :            :     }
         107                 :            :
         108                 :          0 :     return return_value;
         109                 :            : }
         110                 :            :
         111                 :            : PyDoc_STRVAR(Struct_unpack_from__doc__,
         112                 :            : "unpack_from($self, /, buffer, offset=0)\n"
         113                 :            : "--\n"
         114                 :            : "\n"
         115                 :            : "Return a tuple containing unpacked values.\n"
         116                 :            : "\n"
         117                 :            : "Values are unpacked according to the format string Struct.format.\n"
         118                 :            : "\n"
         119                 :            : "The buffer\'s size in bytes, starting at position offset, must be\n"
         120                 :            : "at least Struct.size.\n"
         121                 :            : "\n"
         122                 :            : "See help(struct) for more on format strings.");
         123                 :            :
         124                 :            : #define STRUCT_UNPACK_FROM_METHODDEF    \
         125                 :            :     {"unpack_from", _PyCFunction_CAST(Struct_unpack_from), METH_FASTCALL|METH_KEYWORDS, Struct_unpack_from__doc__},
         126                 :            :
         127                 :            : static PyObject *
         128                 :            : Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
         129                 :            :                         Py_ssize_t offset);
         130                 :            :
         131                 :            : static PyObject *
         132                 :          0 : Struct_unpack_from(PyStructObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         133                 :            : {
         134                 :          0 :     PyObject *return_value = NULL;
         135                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         136                 :            :
         137                 :            :     #define NUM_KEYWORDS 2
         138                 :            :     static struct {
         139                 :            :         PyGC_Head _this_is_not_used;
         140                 :            :         PyObject_VAR_HEAD
         141                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         142                 :            :     } _kwtuple = {
         143                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         144                 :            :         .ob_item = { &_Py_ID(buffer), &_Py_ID(offset), },
         145                 :            :     };
         146                 :            :     #undef NUM_KEYWORDS
         147                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         148                 :            :
         149                 :            :     #else  // !Py_BUILD_CORE
         150                 :            :     #  define KWTUPLE NULL
         151                 :            :     #endif  // !Py_BUILD_CORE
         152                 :            :
         153                 :            :     static const char * const _keywords[] = {"buffer", "offset", NULL};
         154                 :            :     static _PyArg_Parser _parser = {
         155                 :            :         .keywords = _keywords,
         156                 :            :         .fname = "unpack_from",
         157                 :            :         .kwtuple = KWTUPLE,
         158                 :            :     };
         159                 :            :     #undef KWTUPLE
         160                 :            :     PyObject *argsbuf[2];
         161         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
         162                 :          0 :     Py_buffer buffer = {NULL, NULL};
         163                 :          0 :     Py_ssize_t offset = 0;
         164                 :            :
         165   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
                 #  #  #  # ]
         166         [ #  # ]:          0 :     if (!args) {
         167                 :          0 :         goto exit;
         168                 :            :     }
         169         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[0], &buffer, PyBUF_SIMPLE) != 0) {
         170                 :          0 :         goto exit;
         171                 :            :     }
         172         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&buffer, 'C')) {
         173                 :          0 :         _PyArg_BadArgument("unpack_from", "argument 'buffer'", "contiguous buffer", args[0]);
         174                 :          0 :         goto exit;
         175                 :            :     }
         176         [ #  # ]:          0 :     if (!noptargs) {
         177                 :          0 :         goto skip_optional_pos;
         178                 :            :     }
         179                 :            :     {
         180                 :          0 :         Py_ssize_t ival = -1;
         181                 :          0 :         PyObject *iobj = _PyNumber_Index(args[1]);
         182         [ #  # ]:          0 :         if (iobj != NULL) {
         183                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         184                 :          0 :             Py_DECREF(iobj);
         185                 :            :         }
         186   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         187                 :          0 :             goto exit;
         188                 :            :         }
         189                 :          0 :         offset = ival;
         190                 :            :     }
         191                 :          0 : skip_optional_pos:
         192                 :          0 :     return_value = Struct_unpack_from_impl(self, &buffer, offset);
         193                 :            :
         194                 :          0 : exit:
         195                 :            :     /* Cleanup for buffer */
         196         [ #  # ]:          0 :     if (buffer.obj) {
         197                 :          0 :        PyBuffer_Release(&buffer);
         198                 :            :     }
         199                 :            :
         200                 :          0 :     return return_value;
         201                 :            : }
         202                 :            :
         203                 :            : PyDoc_STRVAR(Struct_iter_unpack__doc__,
         204                 :            : "iter_unpack($self, buffer, /)\n"
         205                 :            : "--\n"
         206                 :            : "\n"
         207                 :            : "Return an iterator yielding tuples.\n"
         208                 :            : "\n"
         209                 :            : "Tuples are unpacked from the given bytes source, like a repeated\n"
         210                 :            : "invocation of unpack_from().\n"
         211                 :            : "\n"
         212                 :            : "Requires that the bytes length be a multiple of the struct size.");
         213                 :            :
         214                 :            : #define STRUCT_ITER_UNPACK_METHODDEF    \
         215                 :            :     {"iter_unpack", (PyCFunction)Struct_iter_unpack, METH_O, Struct_iter_unpack__doc__},
         216                 :            :
         217                 :            : PyDoc_STRVAR(_clearcache__doc__,
         218                 :            : "_clearcache($module, /)\n"
         219                 :            : "--\n"
         220                 :            : "\n"
         221                 :            : "Clear the internal cache.");
         222                 :            :
         223                 :            : #define _CLEARCACHE_METHODDEF    \
         224                 :            :     {"_clearcache", (PyCFunction)_clearcache, METH_NOARGS, _clearcache__doc__},
         225                 :            :
         226                 :            : static PyObject *
         227                 :            : _clearcache_impl(PyObject *module);
         228                 :            :
         229                 :            : static PyObject *
         230                 :          1 : _clearcache(PyObject *module, PyObject *Py_UNUSED(ignored))
         231                 :            : {
         232                 :          1 :     return _clearcache_impl(module);
         233                 :            : }
         234                 :            :
         235                 :            : PyDoc_STRVAR(calcsize__doc__,
         236                 :            : "calcsize($module, format, /)\n"
         237                 :            : "--\n"
         238                 :            : "\n"
         239                 :            : "Return size in bytes of the struct described by the format string.");
         240                 :            :
         241                 :            : #define CALCSIZE_METHODDEF    \
         242                 :            :     {"calcsize", (PyCFunction)calcsize, METH_O, calcsize__doc__},
         243                 :            :
         244                 :            : static Py_ssize_t
         245                 :            : calcsize_impl(PyObject *module, PyStructObject *s_object);
         246                 :            :
         247                 :            : static PyObject *
         248                 :         18 : calcsize(PyObject *module, PyObject *arg)
         249                 :            : {
         250                 :         18 :     PyObject *return_value = NULL;
         251                 :         18 :     PyStructObject *s_object = NULL;
         252                 :            :     Py_ssize_t _return_value;
         253                 :            :
         254         [ -  + ]:         18 :     if (!cache_struct_converter(module, arg, &s_object)) {
         255                 :          0 :         goto exit;
         256                 :            :     }
         257                 :         18 :     _return_value = calcsize_impl(module, s_object);
         258   [ -  +  -  - ]:         18 :     if ((_return_value == -1) && PyErr_Occurred()) {
         259                 :          0 :         goto exit;
         260                 :            :     }
         261                 :         18 :     return_value = PyLong_FromSsize_t(_return_value);
         262                 :            :
         263                 :         18 : exit:
         264                 :            :     /* Cleanup for s_object */
         265                 :         18 :     Py_XDECREF(s_object);
         266                 :            :
         267                 :         18 :     return return_value;
         268                 :            : }
         269                 :            :
         270                 :            : PyDoc_STRVAR(unpack__doc__,
         271                 :            : "unpack($module, format, buffer, /)\n"
         272                 :            : "--\n"
         273                 :            : "\n"
         274                 :            : "Return a tuple containing values unpacked according to the format string.\n"
         275                 :            : "\n"
         276                 :            : "The buffer\'s size in bytes must be calcsize(format).\n"
         277                 :            : "\n"
         278                 :            : "See help(struct) for more on format strings.");
         279                 :            :
         280                 :            : #define UNPACK_METHODDEF    \
         281                 :            :     {"unpack", _PyCFunction_CAST(unpack), METH_FASTCALL, unpack__doc__},
         282                 :            :
         283                 :            : static PyObject *
         284                 :            : unpack_impl(PyObject *module, PyStructObject *s_object, Py_buffer *buffer);
         285                 :            :
         286                 :            : static PyObject *
         287                 :        198 : unpack(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         288                 :            : {
         289                 :        198 :     PyObject *return_value = NULL;
         290                 :        198 :     PyStructObject *s_object = NULL;
         291                 :        198 :     Py_buffer buffer = {NULL, NULL};
         292                 :            :
         293   [ +  -  -  +  :        198 :     if (!_PyArg_CheckPositional("unpack", nargs, 2, 2)) {
                       -  - ]
         294                 :          0 :         goto exit;
         295                 :            :     }
         296         [ -  + ]:        198 :     if (!cache_struct_converter(module, args[0], &s_object)) {
         297                 :          0 :         goto exit;
         298                 :            :     }
         299         [ -  + ]:        198 :     if (PyObject_GetBuffer(args[1], &buffer, PyBUF_SIMPLE) != 0) {
         300                 :          0 :         goto exit;
         301                 :            :     }
         302         [ -  + ]:        198 :     if (!PyBuffer_IsContiguous(&buffer, 'C')) {
         303                 :          0 :         _PyArg_BadArgument("unpack", "argument 2", "contiguous buffer", args[1]);
         304                 :          0 :         goto exit;
         305                 :            :     }
         306                 :        198 :     return_value = unpack_impl(module, s_object, &buffer);
         307                 :            :
         308                 :        198 : exit:
         309                 :            :     /* Cleanup for s_object */
         310                 :        198 :     Py_XDECREF(s_object);
         311                 :            :     /* Cleanup for buffer */
         312         [ +  - ]:        198 :     if (buffer.obj) {
         313                 :        198 :        PyBuffer_Release(&buffer);
         314                 :            :     }
         315                 :            :
         316                 :        198 :     return return_value;
         317                 :            : }
         318                 :            :
         319                 :            : PyDoc_STRVAR(unpack_from__doc__,
         320                 :            : "unpack_from($module, format, /, buffer, offset=0)\n"
         321                 :            : "--\n"
         322                 :            : "\n"
         323                 :            : "Return a tuple containing values unpacked according to the format string.\n"
         324                 :            : "\n"
         325                 :            : "The buffer\'s size, minus offset, must be at least calcsize(format).\n"
         326                 :            : "\n"
         327                 :            : "See help(struct) for more on format strings.");
         328                 :            :
         329                 :            : #define UNPACK_FROM_METHODDEF    \
         330                 :            :     {"unpack_from", _PyCFunction_CAST(unpack_from), METH_FASTCALL|METH_KEYWORDS, unpack_from__doc__},
         331                 :            :
         332                 :            : static PyObject *
         333                 :            : unpack_from_impl(PyObject *module, PyStructObject *s_object,
         334                 :            :                  Py_buffer *buffer, Py_ssize_t offset);
         335                 :            :
         336                 :            : static PyObject *
         337                 :          0 : unpack_from(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         338                 :            : {
         339                 :          0 :     PyObject *return_value = NULL;
         340                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         341                 :            :
         342                 :            :     #define NUM_KEYWORDS 2
         343                 :            :     static struct {
         344                 :            :         PyGC_Head _this_is_not_used;
         345                 :            :         PyObject_VAR_HEAD
         346                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         347                 :            :     } _kwtuple = {
         348                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         349                 :            :         .ob_item = { &_Py_ID(buffer), &_Py_ID(offset), },
         350                 :            :     };
         351                 :            :     #undef NUM_KEYWORDS
         352                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         353                 :            :
         354                 :            :     #else  // !Py_BUILD_CORE
         355                 :            :     #  define KWTUPLE NULL
         356                 :            :     #endif  // !Py_BUILD_CORE
         357                 :            :
         358                 :            :     static const char * const _keywords[] = {"", "buffer", "offset", NULL};
         359                 :            :     static _PyArg_Parser _parser = {
         360                 :            :         .keywords = _keywords,
         361                 :            :         .fname = "unpack_from",
         362                 :            :         .kwtuple = KWTUPLE,
         363                 :            :     };
         364                 :            :     #undef KWTUPLE
         365                 :            :     PyObject *argsbuf[3];
         366         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
         367                 :          0 :     PyStructObject *s_object = NULL;
         368                 :          0 :     Py_buffer buffer = {NULL, NULL};
         369                 :          0 :     Py_ssize_t offset = 0;
         370                 :            :
         371   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
                 #  #  #  # ]
         372         [ #  # ]:          0 :     if (!args) {
         373                 :          0 :         goto exit;
         374                 :            :     }
         375         [ #  # ]:          0 :     if (!cache_struct_converter(module, args[0], &s_object)) {
         376                 :          0 :         goto exit;
         377                 :            :     }
         378         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[1], &buffer, PyBUF_SIMPLE) != 0) {
         379                 :          0 :         goto exit;
         380                 :            :     }
         381         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&buffer, 'C')) {
         382                 :          0 :         _PyArg_BadArgument("unpack_from", "argument 'buffer'", "contiguous buffer", args[1]);
         383                 :          0 :         goto exit;
         384                 :            :     }
         385         [ #  # ]:          0 :     if (!noptargs) {
         386                 :          0 :         goto skip_optional_pos;
         387                 :            :     }
         388                 :            :     {
         389                 :          0 :         Py_ssize_t ival = -1;
         390                 :          0 :         PyObject *iobj = _PyNumber_Index(args[2]);
         391         [ #  # ]:          0 :         if (iobj != NULL) {
         392                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         393                 :          0 :             Py_DECREF(iobj);
         394                 :            :         }
         395   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         396                 :          0 :             goto exit;
         397                 :            :         }
         398                 :          0 :         offset = ival;
         399                 :            :     }
         400                 :          0 : skip_optional_pos:
         401                 :          0 :     return_value = unpack_from_impl(module, s_object, &buffer, offset);
         402                 :            :
         403                 :          0 : exit:
         404                 :            :     /* Cleanup for s_object */
         405                 :          0 :     Py_XDECREF(s_object);
         406                 :            :     /* Cleanup for buffer */
         407         [ #  # ]:          0 :     if (buffer.obj) {
         408                 :          0 :        PyBuffer_Release(&buffer);
         409                 :            :     }
         410                 :            :
         411                 :          0 :     return return_value;
         412                 :            : }
         413                 :            :
         414                 :            : PyDoc_STRVAR(iter_unpack__doc__,
         415                 :            : "iter_unpack($module, format, buffer, /)\n"
         416                 :            : "--\n"
         417                 :            : "\n"
         418                 :            : "Return an iterator yielding tuples unpacked from the given bytes.\n"
         419                 :            : "\n"
         420                 :            : "The bytes are unpacked according to the format string, like\n"
         421                 :            : "a repeated invocation of unpack_from().\n"
         422                 :            : "\n"
         423                 :            : "Requires that the bytes length be a multiple of the format struct size.");
         424                 :            :
         425                 :            : #define ITER_UNPACK_METHODDEF    \
         426                 :            :     {"iter_unpack", _PyCFunction_CAST(iter_unpack), METH_FASTCALL, iter_unpack__doc__},
         427                 :            :
         428                 :            : static PyObject *
         429                 :            : iter_unpack_impl(PyObject *module, PyStructObject *s_object,
         430                 :            :                  PyObject *buffer);
         431                 :            :
         432                 :            : static PyObject *
         433                 :          0 : iter_unpack(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         434                 :            : {
         435                 :          0 :     PyObject *return_value = NULL;
         436                 :          0 :     PyStructObject *s_object = NULL;
         437                 :            :     PyObject *buffer;
         438                 :            :
         439   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("iter_unpack", nargs, 2, 2)) {
                       #  # ]
         440                 :          0 :         goto exit;
         441                 :            :     }
         442         [ #  # ]:          0 :     if (!cache_struct_converter(module, args[0], &s_object)) {
         443                 :          0 :         goto exit;
         444                 :            :     }
         445                 :          0 :     buffer = args[1];
         446                 :          0 :     return_value = iter_unpack_impl(module, s_object, buffer);
         447                 :            :
         448                 :          0 : exit:
         449                 :            :     /* Cleanup for s_object */
         450                 :          0 :     Py_XDECREF(s_object);
         451                 :            :
         452                 :          0 :     return return_value;
         453                 :            : }
         454                 :            : /*[clinic end generated code: output=f3d6e06f80368998 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14