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