LCOV - code coverage report
Current view: top level - Modules/clinic - arraymodule.c.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 0 164 0.0 %
Date: 2023-03-20 08:15:36 Functions: 0 19 0.0 %
Branches: 0 114 0.0 %

           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(array_array___copy____doc__,
      12                 :            : "__copy__($self, /)\n"
      13                 :            : "--\n"
      14                 :            : "\n"
      15                 :            : "Return a copy of the array.");
      16                 :            : 
      17                 :            : #define ARRAY_ARRAY___COPY___METHODDEF    \
      18                 :            :     {"__copy__", (PyCFunction)array_array___copy__, METH_NOARGS, array_array___copy____doc__},
      19                 :            : 
      20                 :            : static PyObject *
      21                 :            : array_array___copy___impl(arrayobject *self);
      22                 :            : 
      23                 :            : static PyObject *
      24                 :          0 : array_array___copy__(arrayobject *self, PyObject *Py_UNUSED(ignored))
      25                 :            : {
      26                 :          0 :     return array_array___copy___impl(self);
      27                 :            : }
      28                 :            : 
      29                 :            : PyDoc_STRVAR(array_array___deepcopy____doc__,
      30                 :            : "__deepcopy__($self, unused, /)\n"
      31                 :            : "--\n"
      32                 :            : "\n"
      33                 :            : "Return a copy of the array.");
      34                 :            : 
      35                 :            : #define ARRAY_ARRAY___DEEPCOPY___METHODDEF    \
      36                 :            :     {"__deepcopy__", (PyCFunction)array_array___deepcopy__, METH_O, array_array___deepcopy____doc__},
      37                 :            : 
      38                 :            : PyDoc_STRVAR(array_array_count__doc__,
      39                 :            : "count($self, v, /)\n"
      40                 :            : "--\n"
      41                 :            : "\n"
      42                 :            : "Return number of occurrences of v in the array.");
      43                 :            : 
      44                 :            : #define ARRAY_ARRAY_COUNT_METHODDEF    \
      45                 :            :     {"count", (PyCFunction)array_array_count, METH_O, array_array_count__doc__},
      46                 :            : 
      47                 :            : PyDoc_STRVAR(array_array_index__doc__,
      48                 :            : "index($self, v, start=0, stop=sys.maxsize, /)\n"
      49                 :            : "--\n"
      50                 :            : "\n"
      51                 :            : "Return index of first occurrence of v in the array.\n"
      52                 :            : "\n"
      53                 :            : "Raise ValueError if the value is not present.");
      54                 :            : 
      55                 :            : #define ARRAY_ARRAY_INDEX_METHODDEF    \
      56                 :            :     {"index", _PyCFunction_CAST(array_array_index), METH_FASTCALL, array_array_index__doc__},
      57                 :            : 
      58                 :            : static PyObject *
      59                 :            : array_array_index_impl(arrayobject *self, PyObject *v, Py_ssize_t start,
      60                 :            :                        Py_ssize_t stop);
      61                 :            : 
      62                 :            : static PyObject *
      63                 :          0 : array_array_index(arrayobject *self, PyObject *const *args, Py_ssize_t nargs)
      64                 :            : {
      65                 :          0 :     PyObject *return_value = NULL;
      66                 :            :     PyObject *v;
      67                 :          0 :     Py_ssize_t start = 0;
      68                 :          0 :     Py_ssize_t stop = PY_SSIZE_T_MAX;
      69                 :            : 
      70   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("index", nargs, 1, 3)) {
                   #  # ]
      71                 :          0 :         goto exit;
      72                 :            :     }
      73                 :          0 :     v = args[0];
      74         [ #  # ]:          0 :     if (nargs < 2) {
      75                 :          0 :         goto skip_optional;
      76                 :            :     }
      77         [ #  # ]:          0 :     if (!_PyEval_SliceIndexNotNone(args[1], &start)) {
      78                 :          0 :         goto exit;
      79                 :            :     }
      80         [ #  # ]:          0 :     if (nargs < 3) {
      81                 :          0 :         goto skip_optional;
      82                 :            :     }
      83         [ #  # ]:          0 :     if (!_PyEval_SliceIndexNotNone(args[2], &stop)) {
      84                 :          0 :         goto exit;
      85                 :            :     }
      86                 :          0 : skip_optional:
      87                 :          0 :     return_value = array_array_index_impl(self, v, start, stop);
      88                 :            : 
      89                 :          0 : exit:
      90                 :          0 :     return return_value;
      91                 :            : }
      92                 :            : 
      93                 :            : PyDoc_STRVAR(array_array_remove__doc__,
      94                 :            : "remove($self, v, /)\n"
      95                 :            : "--\n"
      96                 :            : "\n"
      97                 :            : "Remove the first occurrence of v in the array.");
      98                 :            : 
      99                 :            : #define ARRAY_ARRAY_REMOVE_METHODDEF    \
     100                 :            :     {"remove", (PyCFunction)array_array_remove, METH_O, array_array_remove__doc__},
     101                 :            : 
     102                 :            : PyDoc_STRVAR(array_array_pop__doc__,
     103                 :            : "pop($self, i=-1, /)\n"
     104                 :            : "--\n"
     105                 :            : "\n"
     106                 :            : "Return the i-th element and delete it from the array.\n"
     107                 :            : "\n"
     108                 :            : "i defaults to -1.");
     109                 :            : 
     110                 :            : #define ARRAY_ARRAY_POP_METHODDEF    \
     111                 :            :     {"pop", _PyCFunction_CAST(array_array_pop), METH_FASTCALL, array_array_pop__doc__},
     112                 :            : 
     113                 :            : static PyObject *
     114                 :            : array_array_pop_impl(arrayobject *self, Py_ssize_t i);
     115                 :            : 
     116                 :            : static PyObject *
     117                 :          0 : array_array_pop(arrayobject *self, PyObject *const *args, Py_ssize_t nargs)
     118                 :            : {
     119                 :          0 :     PyObject *return_value = NULL;
     120                 :          0 :     Py_ssize_t i = -1;
     121                 :            : 
     122   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("pop", nargs, 0, 1)) {
                   #  # ]
     123                 :          0 :         goto exit;
     124                 :            :     }
     125         [ #  # ]:          0 :     if (nargs < 1) {
     126                 :          0 :         goto skip_optional;
     127                 :            :     }
     128                 :            :     {
     129                 :          0 :         Py_ssize_t ival = -1;
     130                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
     131         [ #  # ]:          0 :         if (iobj != NULL) {
     132                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     133                 :          0 :             Py_DECREF(iobj);
     134                 :            :         }
     135   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     136                 :          0 :             goto exit;
     137                 :            :         }
     138                 :          0 :         i = ival;
     139                 :            :     }
     140                 :          0 : skip_optional:
     141                 :          0 :     return_value = array_array_pop_impl(self, i);
     142                 :            : 
     143                 :          0 : exit:
     144                 :          0 :     return return_value;
     145                 :            : }
     146                 :            : 
     147                 :            : PyDoc_STRVAR(array_array_extend__doc__,
     148                 :            : "extend($self, bb, /)\n"
     149                 :            : "--\n"
     150                 :            : "\n"
     151                 :            : "Append items to the end of the array.");
     152                 :            : 
     153                 :            : #define ARRAY_ARRAY_EXTEND_METHODDEF    \
     154                 :            :     {"extend", _PyCFunction_CAST(array_array_extend), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, array_array_extend__doc__},
     155                 :            : 
     156                 :            : static PyObject *
     157                 :            : array_array_extend_impl(arrayobject *self, PyTypeObject *cls, PyObject *bb);
     158                 :            : 
     159                 :            : static PyObject *
     160                 :          0 : array_array_extend(arrayobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     161                 :            : {
     162                 :          0 :     PyObject *return_value = NULL;
     163                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     164                 :            :     #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
     165                 :            :     #else
     166                 :            :     #  define KWTUPLE NULL
     167                 :            :     #endif
     168                 :            : 
     169                 :            :     static const char * const _keywords[] = {"", NULL};
     170                 :            :     static _PyArg_Parser _parser = {
     171                 :            :         .keywords = _keywords,
     172                 :            :         .fname = "extend",
     173                 :            :         .kwtuple = KWTUPLE,
     174                 :            :     };
     175                 :            :     #undef KWTUPLE
     176                 :            :     PyObject *argsbuf[1];
     177                 :            :     PyObject *bb;
     178                 :            : 
     179   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     180         [ #  # ]:          0 :     if (!args) {
     181                 :          0 :         goto exit;
     182                 :            :     }
     183                 :          0 :     bb = args[0];
     184                 :          0 :     return_value = array_array_extend_impl(self, cls, bb);
     185                 :            : 
     186                 :          0 : exit:
     187                 :          0 :     return return_value;
     188                 :            : }
     189                 :            : 
     190                 :            : PyDoc_STRVAR(array_array_insert__doc__,
     191                 :            : "insert($self, i, v, /)\n"
     192                 :            : "--\n"
     193                 :            : "\n"
     194                 :            : "Insert a new item v into the array before position i.");
     195                 :            : 
     196                 :            : #define ARRAY_ARRAY_INSERT_METHODDEF    \
     197                 :            :     {"insert", _PyCFunction_CAST(array_array_insert), METH_FASTCALL, array_array_insert__doc__},
     198                 :            : 
     199                 :            : static PyObject *
     200                 :            : array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v);
     201                 :            : 
     202                 :            : static PyObject *
     203                 :          0 : array_array_insert(arrayobject *self, PyObject *const *args, Py_ssize_t nargs)
     204                 :            : {
     205                 :          0 :     PyObject *return_value = NULL;
     206                 :            :     Py_ssize_t i;
     207                 :            :     PyObject *v;
     208                 :            : 
     209   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
                   #  # ]
     210                 :          0 :         goto exit;
     211                 :            :     }
     212                 :            :     {
     213                 :          0 :         Py_ssize_t ival = -1;
     214                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
     215         [ #  # ]:          0 :         if (iobj != NULL) {
     216                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     217                 :          0 :             Py_DECREF(iobj);
     218                 :            :         }
     219   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     220                 :          0 :             goto exit;
     221                 :            :         }
     222                 :          0 :         i = ival;
     223                 :            :     }
     224                 :          0 :     v = args[1];
     225                 :          0 :     return_value = array_array_insert_impl(self, i, v);
     226                 :            : 
     227                 :          0 : exit:
     228                 :          0 :     return return_value;
     229                 :            : }
     230                 :            : 
     231                 :            : PyDoc_STRVAR(array_array_buffer_info__doc__,
     232                 :            : "buffer_info($self, /)\n"
     233                 :            : "--\n"
     234                 :            : "\n"
     235                 :            : "Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array\'s contents.\n"
     236                 :            : "\n"
     237                 :            : "The length should be multiplied by the itemsize attribute to calculate\n"
     238                 :            : "the buffer length in bytes.");
     239                 :            : 
     240                 :            : #define ARRAY_ARRAY_BUFFER_INFO_METHODDEF    \
     241                 :            :     {"buffer_info", (PyCFunction)array_array_buffer_info, METH_NOARGS, array_array_buffer_info__doc__},
     242                 :            : 
     243                 :            : static PyObject *
     244                 :            : array_array_buffer_info_impl(arrayobject *self);
     245                 :            : 
     246                 :            : static PyObject *
     247                 :          0 : array_array_buffer_info(arrayobject *self, PyObject *Py_UNUSED(ignored))
     248                 :            : {
     249                 :          0 :     return array_array_buffer_info_impl(self);
     250                 :            : }
     251                 :            : 
     252                 :            : PyDoc_STRVAR(array_array_append__doc__,
     253                 :            : "append($self, v, /)\n"
     254                 :            : "--\n"
     255                 :            : "\n"
     256                 :            : "Append new value v to the end of the array.");
     257                 :            : 
     258                 :            : #define ARRAY_ARRAY_APPEND_METHODDEF    \
     259                 :            :     {"append", (PyCFunction)array_array_append, METH_O, array_array_append__doc__},
     260                 :            : 
     261                 :            : PyDoc_STRVAR(array_array_byteswap__doc__,
     262                 :            : "byteswap($self, /)\n"
     263                 :            : "--\n"
     264                 :            : "\n"
     265                 :            : "Byteswap all items of the array.\n"
     266                 :            : "\n"
     267                 :            : "If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is\n"
     268                 :            : "raised.");
     269                 :            : 
     270                 :            : #define ARRAY_ARRAY_BYTESWAP_METHODDEF    \
     271                 :            :     {"byteswap", (PyCFunction)array_array_byteswap, METH_NOARGS, array_array_byteswap__doc__},
     272                 :            : 
     273                 :            : static PyObject *
     274                 :            : array_array_byteswap_impl(arrayobject *self);
     275                 :            : 
     276                 :            : static PyObject *
     277                 :          0 : array_array_byteswap(arrayobject *self, PyObject *Py_UNUSED(ignored))
     278                 :            : {
     279                 :          0 :     return array_array_byteswap_impl(self);
     280                 :            : }
     281                 :            : 
     282                 :            : PyDoc_STRVAR(array_array_reverse__doc__,
     283                 :            : "reverse($self, /)\n"
     284                 :            : "--\n"
     285                 :            : "\n"
     286                 :            : "Reverse the order of the items in the array.");
     287                 :            : 
     288                 :            : #define ARRAY_ARRAY_REVERSE_METHODDEF    \
     289                 :            :     {"reverse", (PyCFunction)array_array_reverse, METH_NOARGS, array_array_reverse__doc__},
     290                 :            : 
     291                 :            : static PyObject *
     292                 :            : array_array_reverse_impl(arrayobject *self);
     293                 :            : 
     294                 :            : static PyObject *
     295                 :          0 : array_array_reverse(arrayobject *self, PyObject *Py_UNUSED(ignored))
     296                 :            : {
     297                 :          0 :     return array_array_reverse_impl(self);
     298                 :            : }
     299                 :            : 
     300                 :            : PyDoc_STRVAR(array_array_fromfile__doc__,
     301                 :            : "fromfile($self, f, n, /)\n"
     302                 :            : "--\n"
     303                 :            : "\n"
     304                 :            : "Read n objects from the file object f and append them to the end of the array.");
     305                 :            : 
     306                 :            : #define ARRAY_ARRAY_FROMFILE_METHODDEF    \
     307                 :            :     {"fromfile", _PyCFunction_CAST(array_array_fromfile), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, array_array_fromfile__doc__},
     308                 :            : 
     309                 :            : static PyObject *
     310                 :            : array_array_fromfile_impl(arrayobject *self, PyTypeObject *cls, PyObject *f,
     311                 :            :                           Py_ssize_t n);
     312                 :            : 
     313                 :            : static PyObject *
     314                 :          0 : array_array_fromfile(arrayobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     315                 :            : {
     316                 :          0 :     PyObject *return_value = NULL;
     317                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     318                 :            :     #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
     319                 :            :     #else
     320                 :            :     #  define KWTUPLE NULL
     321                 :            :     #endif
     322                 :            : 
     323                 :            :     static const char * const _keywords[] = {"", "", NULL};
     324                 :            :     static _PyArg_Parser _parser = {
     325                 :            :         .keywords = _keywords,
     326                 :            :         .fname = "fromfile",
     327                 :            :         .kwtuple = KWTUPLE,
     328                 :            :     };
     329                 :            :     #undef KWTUPLE
     330                 :            :     PyObject *argsbuf[2];
     331                 :            :     PyObject *f;
     332                 :            :     Py_ssize_t n;
     333                 :            : 
     334   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
             #  #  #  # ]
     335         [ #  # ]:          0 :     if (!args) {
     336                 :          0 :         goto exit;
     337                 :            :     }
     338                 :          0 :     f = args[0];
     339                 :            :     {
     340                 :          0 :         Py_ssize_t ival = -1;
     341                 :          0 :         PyObject *iobj = _PyNumber_Index(args[1]);
     342         [ #  # ]:          0 :         if (iobj != NULL) {
     343                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     344                 :          0 :             Py_DECREF(iobj);
     345                 :            :         }
     346   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     347                 :          0 :             goto exit;
     348                 :            :         }
     349                 :          0 :         n = ival;
     350                 :            :     }
     351                 :          0 :     return_value = array_array_fromfile_impl(self, cls, f, n);
     352                 :            : 
     353                 :          0 : exit:
     354                 :          0 :     return return_value;
     355                 :            : }
     356                 :            : 
     357                 :            : PyDoc_STRVAR(array_array_tofile__doc__,
     358                 :            : "tofile($self, f, /)\n"
     359                 :            : "--\n"
     360                 :            : "\n"
     361                 :            : "Write all items (as machine values) to the file object f.");
     362                 :            : 
     363                 :            : #define ARRAY_ARRAY_TOFILE_METHODDEF    \
     364                 :            :     {"tofile", _PyCFunction_CAST(array_array_tofile), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, array_array_tofile__doc__},
     365                 :            : 
     366                 :            : static PyObject *
     367                 :            : array_array_tofile_impl(arrayobject *self, PyTypeObject *cls, PyObject *f);
     368                 :            : 
     369                 :            : static PyObject *
     370                 :          0 : array_array_tofile(arrayobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     371                 :            : {
     372                 :          0 :     PyObject *return_value = NULL;
     373                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     374                 :            :     #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
     375                 :            :     #else
     376                 :            :     #  define KWTUPLE NULL
     377                 :            :     #endif
     378                 :            : 
     379                 :            :     static const char * const _keywords[] = {"", NULL};
     380                 :            :     static _PyArg_Parser _parser = {
     381                 :            :         .keywords = _keywords,
     382                 :            :         .fname = "tofile",
     383                 :            :         .kwtuple = KWTUPLE,
     384                 :            :     };
     385                 :            :     #undef KWTUPLE
     386                 :            :     PyObject *argsbuf[1];
     387                 :            :     PyObject *f;
     388                 :            : 
     389   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     390         [ #  # ]:          0 :     if (!args) {
     391                 :          0 :         goto exit;
     392                 :            :     }
     393                 :          0 :     f = args[0];
     394                 :          0 :     return_value = array_array_tofile_impl(self, cls, f);
     395                 :            : 
     396                 :          0 : exit:
     397                 :          0 :     return return_value;
     398                 :            : }
     399                 :            : 
     400                 :            : PyDoc_STRVAR(array_array_fromlist__doc__,
     401                 :            : "fromlist($self, list, /)\n"
     402                 :            : "--\n"
     403                 :            : "\n"
     404                 :            : "Append items to array from list.");
     405                 :            : 
     406                 :            : #define ARRAY_ARRAY_FROMLIST_METHODDEF    \
     407                 :            :     {"fromlist", (PyCFunction)array_array_fromlist, METH_O, array_array_fromlist__doc__},
     408                 :            : 
     409                 :            : PyDoc_STRVAR(array_array_tolist__doc__,
     410                 :            : "tolist($self, /)\n"
     411                 :            : "--\n"
     412                 :            : "\n"
     413                 :            : "Convert array to an ordinary list with the same items.");
     414                 :            : 
     415                 :            : #define ARRAY_ARRAY_TOLIST_METHODDEF    \
     416                 :            :     {"tolist", (PyCFunction)array_array_tolist, METH_NOARGS, array_array_tolist__doc__},
     417                 :            : 
     418                 :            : static PyObject *
     419                 :            : array_array_tolist_impl(arrayobject *self);
     420                 :            : 
     421                 :            : static PyObject *
     422                 :          0 : array_array_tolist(arrayobject *self, PyObject *Py_UNUSED(ignored))
     423                 :            : {
     424                 :          0 :     return array_array_tolist_impl(self);
     425                 :            : }
     426                 :            : 
     427                 :            : PyDoc_STRVAR(array_array_frombytes__doc__,
     428                 :            : "frombytes($self, buffer, /)\n"
     429                 :            : "--\n"
     430                 :            : "\n"
     431                 :            : "Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method.");
     432                 :            : 
     433                 :            : #define ARRAY_ARRAY_FROMBYTES_METHODDEF    \
     434                 :            :     {"frombytes", (PyCFunction)array_array_frombytes, METH_O, array_array_frombytes__doc__},
     435                 :            : 
     436                 :            : static PyObject *
     437                 :            : array_array_frombytes_impl(arrayobject *self, Py_buffer *buffer);
     438                 :            : 
     439                 :            : static PyObject *
     440                 :          0 : array_array_frombytes(arrayobject *self, PyObject *arg)
     441                 :            : {
     442                 :          0 :     PyObject *return_value = NULL;
     443                 :          0 :     Py_buffer buffer = {NULL, NULL};
     444                 :            : 
     445         [ #  # ]:          0 :     if (PyObject_GetBuffer(arg, &buffer, PyBUF_SIMPLE) != 0) {
     446                 :          0 :         goto exit;
     447                 :            :     }
     448         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&buffer, 'C')) {
     449                 :          0 :         _PyArg_BadArgument("frombytes", "argument", "contiguous buffer", arg);
     450                 :          0 :         goto exit;
     451                 :            :     }
     452                 :          0 :     return_value = array_array_frombytes_impl(self, &buffer);
     453                 :            : 
     454                 :          0 : exit:
     455                 :            :     /* Cleanup for buffer */
     456         [ #  # ]:          0 :     if (buffer.obj) {
     457                 :          0 :        PyBuffer_Release(&buffer);
     458                 :            :     }
     459                 :            : 
     460                 :          0 :     return return_value;
     461                 :            : }
     462                 :            : 
     463                 :            : PyDoc_STRVAR(array_array_tobytes__doc__,
     464                 :            : "tobytes($self, /)\n"
     465                 :            : "--\n"
     466                 :            : "\n"
     467                 :            : "Convert the array to an array of machine values and return the bytes representation.");
     468                 :            : 
     469                 :            : #define ARRAY_ARRAY_TOBYTES_METHODDEF    \
     470                 :            :     {"tobytes", (PyCFunction)array_array_tobytes, METH_NOARGS, array_array_tobytes__doc__},
     471                 :            : 
     472                 :            : static PyObject *
     473                 :            : array_array_tobytes_impl(arrayobject *self);
     474                 :            : 
     475                 :            : static PyObject *
     476                 :          0 : array_array_tobytes(arrayobject *self, PyObject *Py_UNUSED(ignored))
     477                 :            : {
     478                 :          0 :     return array_array_tobytes_impl(self);
     479                 :            : }
     480                 :            : 
     481                 :            : PyDoc_STRVAR(array_array_fromunicode__doc__,
     482                 :            : "fromunicode($self, ustr, /)\n"
     483                 :            : "--\n"
     484                 :            : "\n"
     485                 :            : "Extends this array with data from the unicode string ustr.\n"
     486                 :            : "\n"
     487                 :            : "The array must be a unicode type array; otherwise a ValueError is raised.\n"
     488                 :            : "Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of\n"
     489                 :            : "some other type.");
     490                 :            : 
     491                 :            : #define ARRAY_ARRAY_FROMUNICODE_METHODDEF    \
     492                 :            :     {"fromunicode", (PyCFunction)array_array_fromunicode, METH_O, array_array_fromunicode__doc__},
     493                 :            : 
     494                 :            : static PyObject *
     495                 :            : array_array_fromunicode_impl(arrayobject *self, PyObject *ustr);
     496                 :            : 
     497                 :            : static PyObject *
     498                 :          0 : array_array_fromunicode(arrayobject *self, PyObject *arg)
     499                 :            : {
     500                 :          0 :     PyObject *return_value = NULL;
     501                 :            :     PyObject *ustr;
     502                 :            : 
     503         [ #  # ]:          0 :     if (!PyUnicode_Check(arg)) {
     504                 :          0 :         _PyArg_BadArgument("fromunicode", "argument", "str", arg);
     505                 :          0 :         goto exit;
     506                 :            :     }
     507         [ #  # ]:          0 :     if (PyUnicode_READY(arg) == -1) {
     508                 :          0 :         goto exit;
     509                 :            :     }
     510                 :          0 :     ustr = arg;
     511                 :          0 :     return_value = array_array_fromunicode_impl(self, ustr);
     512                 :            : 
     513                 :          0 : exit:
     514                 :          0 :     return return_value;
     515                 :            : }
     516                 :            : 
     517                 :            : PyDoc_STRVAR(array_array_tounicode__doc__,
     518                 :            : "tounicode($self, /)\n"
     519                 :            : "--\n"
     520                 :            : "\n"
     521                 :            : "Extends this array with data from the unicode string ustr.\n"
     522                 :            : "\n"
     523                 :            : "Convert the array to a unicode string.  The array must be a unicode type array;\n"
     524                 :            : "otherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a\n"
     525                 :            : "unicode string from an array of some other type.");
     526                 :            : 
     527                 :            : #define ARRAY_ARRAY_TOUNICODE_METHODDEF    \
     528                 :            :     {"tounicode", (PyCFunction)array_array_tounicode, METH_NOARGS, array_array_tounicode__doc__},
     529                 :            : 
     530                 :            : static PyObject *
     531                 :            : array_array_tounicode_impl(arrayobject *self);
     532                 :            : 
     533                 :            : static PyObject *
     534                 :          0 : array_array_tounicode(arrayobject *self, PyObject *Py_UNUSED(ignored))
     535                 :            : {
     536                 :          0 :     return array_array_tounicode_impl(self);
     537                 :            : }
     538                 :            : 
     539                 :            : PyDoc_STRVAR(array_array___sizeof____doc__,
     540                 :            : "__sizeof__($self, /)\n"
     541                 :            : "--\n"
     542                 :            : "\n"
     543                 :            : "Size of the array in memory, in bytes.");
     544                 :            : 
     545                 :            : #define ARRAY_ARRAY___SIZEOF___METHODDEF    \
     546                 :            :     {"__sizeof__", (PyCFunction)array_array___sizeof__, METH_NOARGS, array_array___sizeof____doc__},
     547                 :            : 
     548                 :            : static PyObject *
     549                 :            : array_array___sizeof___impl(arrayobject *self);
     550                 :            : 
     551                 :            : static PyObject *
     552                 :          0 : array_array___sizeof__(arrayobject *self, PyObject *Py_UNUSED(ignored))
     553                 :            : {
     554                 :          0 :     return array_array___sizeof___impl(self);
     555                 :            : }
     556                 :            : 
     557                 :            : PyDoc_STRVAR(array__array_reconstructor__doc__,
     558                 :            : "_array_reconstructor($module, arraytype, typecode, mformat_code, items,\n"
     559                 :            : "                     /)\n"
     560                 :            : "--\n"
     561                 :            : "\n"
     562                 :            : "Internal. Used for pickling support.");
     563                 :            : 
     564                 :            : #define ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF    \
     565                 :            :     {"_array_reconstructor", _PyCFunction_CAST(array__array_reconstructor), METH_FASTCALL, array__array_reconstructor__doc__},
     566                 :            : 
     567                 :            : static PyObject *
     568                 :            : array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
     569                 :            :                                 int typecode,
     570                 :            :                                 enum machine_format_code mformat_code,
     571                 :            :                                 PyObject *items);
     572                 :            : 
     573                 :            : static PyObject *
     574                 :          0 : array__array_reconstructor(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
     575                 :            : {
     576                 :          0 :     PyObject *return_value = NULL;
     577                 :            :     PyTypeObject *arraytype;
     578                 :            :     int typecode;
     579                 :            :     enum machine_format_code mformat_code;
     580                 :            :     PyObject *items;
     581                 :            : 
     582   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("_array_reconstructor", nargs, 4, 4)) {
                   #  # ]
     583                 :          0 :         goto exit;
     584                 :            :     }
     585                 :          0 :     arraytype = (PyTypeObject *)args[0];
     586         [ #  # ]:          0 :     if (!PyUnicode_Check(args[1])) {
     587                 :          0 :         _PyArg_BadArgument("_array_reconstructor", "argument 2", "a unicode character", args[1]);
     588                 :          0 :         goto exit;
     589                 :            :     }
     590         [ #  # ]:          0 :     if (PyUnicode_READY(args[1])) {
     591                 :          0 :         goto exit;
     592                 :            :     }
     593         [ #  # ]:          0 :     if (PyUnicode_GET_LENGTH(args[1]) != 1) {
     594                 :          0 :         _PyArg_BadArgument("_array_reconstructor", "argument 2", "a unicode character", args[1]);
     595                 :          0 :         goto exit;
     596                 :            :     }
     597                 :          0 :     typecode = PyUnicode_READ_CHAR(args[1], 0);
     598                 :          0 :     mformat_code = _PyLong_AsInt(args[2]);
     599   [ #  #  #  # ]:          0 :     if (mformat_code == -1 && PyErr_Occurred()) {
     600                 :          0 :         goto exit;
     601                 :            :     }
     602                 :          0 :     items = args[3];
     603                 :          0 :     return_value = array__array_reconstructor_impl(module, arraytype, typecode, mformat_code, items);
     604                 :            : 
     605                 :          0 : exit:
     606                 :          0 :     return return_value;
     607                 :            : }
     608                 :            : 
     609                 :            : PyDoc_STRVAR(array_array___reduce_ex____doc__,
     610                 :            : "__reduce_ex__($self, value, /)\n"
     611                 :            : "--\n"
     612                 :            : "\n"
     613                 :            : "Return state information for pickling.");
     614                 :            : 
     615                 :            : #define ARRAY_ARRAY___REDUCE_EX___METHODDEF    \
     616                 :            :     {"__reduce_ex__", _PyCFunction_CAST(array_array___reduce_ex__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, array_array___reduce_ex____doc__},
     617                 :            : 
     618                 :            : static PyObject *
     619                 :            : array_array___reduce_ex___impl(arrayobject *self, PyTypeObject *cls,
     620                 :            :                                PyObject *value);
     621                 :            : 
     622                 :            : static PyObject *
     623                 :          0 : array_array___reduce_ex__(arrayobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     624                 :            : {
     625                 :          0 :     PyObject *return_value = NULL;
     626                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     627                 :            :     #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
     628                 :            :     #else
     629                 :            :     #  define KWTUPLE NULL
     630                 :            :     #endif
     631                 :            : 
     632                 :            :     static const char * const _keywords[] = {"", NULL};
     633                 :            :     static _PyArg_Parser _parser = {
     634                 :            :         .keywords = _keywords,
     635                 :            :         .fname = "__reduce_ex__",
     636                 :            :         .kwtuple = KWTUPLE,
     637                 :            :     };
     638                 :            :     #undef KWTUPLE
     639                 :            :     PyObject *argsbuf[1];
     640                 :            :     PyObject *value;
     641                 :            : 
     642   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     643         [ #  # ]:          0 :     if (!args) {
     644                 :          0 :         goto exit;
     645                 :            :     }
     646                 :          0 :     value = args[0];
     647                 :          0 :     return_value = array_array___reduce_ex___impl(self, cls, value);
     648                 :            : 
     649                 :          0 : exit:
     650                 :          0 :     return return_value;
     651                 :            : }
     652                 :            : 
     653                 :            : PyDoc_STRVAR(array_arrayiterator___reduce____doc__,
     654                 :            : "__reduce__($self, /)\n"
     655                 :            : "--\n"
     656                 :            : "\n"
     657                 :            : "Return state information for pickling.");
     658                 :            : 
     659                 :            : #define ARRAY_ARRAYITERATOR___REDUCE___METHODDEF    \
     660                 :            :     {"__reduce__", _PyCFunction_CAST(array_arrayiterator___reduce__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, array_arrayiterator___reduce____doc__},
     661                 :            : 
     662                 :            : static PyObject *
     663                 :            : array_arrayiterator___reduce___impl(arrayiterobject *self, PyTypeObject *cls);
     664                 :            : 
     665                 :            : static PyObject *
     666                 :          0 : array_arrayiterator___reduce__(arrayiterobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     667                 :            : {
     668         [ #  # ]:          0 :     if (nargs) {
     669                 :          0 :         PyErr_SetString(PyExc_TypeError, "__reduce__() takes no arguments");
     670                 :          0 :         return NULL;
     671                 :            :     }
     672                 :          0 :     return array_arrayiterator___reduce___impl(self, cls);
     673                 :            : }
     674                 :            : 
     675                 :            : PyDoc_STRVAR(array_arrayiterator___setstate____doc__,
     676                 :            : "__setstate__($self, state, /)\n"
     677                 :            : "--\n"
     678                 :            : "\n"
     679                 :            : "Set state information for unpickling.");
     680                 :            : 
     681                 :            : #define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF    \
     682                 :            :     {"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__},
     683                 :            : /*[clinic end generated code: output=69bc1451f7bda234 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14