LCOV - code coverage report
Current view: | top level - Objects/clinic - listobject.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 60 | 102 | 58.8 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 6 | 10 | 60.0 %
|  |  | Branches: | 27 | 76 | 35.5 %

               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(list_insert__doc__,
          12                 :            : "insert($self, index, object, /)\n"
          13                 :            : "--\n"
          14                 :            : "\n"
          15                 :            : "Insert object before index.");
          16                 :            :
          17                 :            : #define LIST_INSERT_METHODDEF    \
          18                 :            :     {"insert", _PyCFunction_CAST(list_insert), METH_FASTCALL, list_insert__doc__},
          19                 :            :
          20                 :            : static PyObject *
          21                 :            : list_insert_impl(PyListObject *self, Py_ssize_t index, PyObject *object);
          22                 :            :
          23                 :            : static PyObject *
          24                 :        127 : list_insert(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
          25                 :            : {
          26                 :        127 :     PyObject *return_value = NULL;
          27                 :            :     Py_ssize_t index;
          28                 :            :     PyObject *object;
          29                 :            :
          30   [ +  -  -  +  :        127 :     if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
                       -  - ]
          31                 :          0 :         goto exit;
          32                 :            :     }
          33                 :            :     {
          34                 :        127 :         Py_ssize_t ival = -1;
          35                 :        127 :         PyObject *iobj = _PyNumber_Index(args[0]);
          36         [ +  - ]:        127 :         if (iobj != NULL) {
          37                 :        127 :             ival = PyLong_AsSsize_t(iobj);
          38                 :        127 :             Py_DECREF(iobj);
          39                 :            :         }
          40   [ -  +  -  - ]:        127 :         if (ival == -1 && PyErr_Occurred()) {
          41                 :          0 :             goto exit;
          42                 :            :         }
          43                 :        127 :         index = ival;
          44                 :            :     }
          45                 :        127 :     object = args[1];
          46                 :        127 :     return_value = list_insert_impl(self, index, object);
          47                 :            :
          48                 :        127 : exit:
          49                 :        127 :     return return_value;
          50                 :            : }
          51                 :            :
          52                 :            : PyDoc_STRVAR(list_clear__doc__,
          53                 :            : "clear($self, /)\n"
          54                 :            : "--\n"
          55                 :            : "\n"
          56                 :            : "Remove all items from list.");
          57                 :            :
          58                 :            : #define LIST_CLEAR_METHODDEF    \
          59                 :            :     {"clear", (PyCFunction)list_clear, METH_NOARGS, list_clear__doc__},
          60                 :            :
          61                 :            : static PyObject *
          62                 :            : list_clear_impl(PyListObject *self);
          63                 :            :
          64                 :            : static PyObject *
          65                 :          0 : list_clear(PyListObject *self, PyObject *Py_UNUSED(ignored))
          66                 :            : {
          67                 :          0 :     return list_clear_impl(self);
          68                 :            : }
          69                 :            :
          70                 :            : PyDoc_STRVAR(list_copy__doc__,
          71                 :            : "copy($self, /)\n"
          72                 :            : "--\n"
          73                 :            : "\n"
          74                 :            : "Return a shallow copy of the list.");
          75                 :            :
          76                 :            : #define LIST_COPY_METHODDEF    \
          77                 :            :     {"copy", (PyCFunction)list_copy, METH_NOARGS, list_copy__doc__},
          78                 :            :
          79                 :            : static PyObject *
          80                 :            : list_copy_impl(PyListObject *self);
          81                 :            :
          82                 :            : static PyObject *
          83                 :          0 : list_copy(PyListObject *self, PyObject *Py_UNUSED(ignored))
          84                 :            : {
          85                 :          0 :     return list_copy_impl(self);
          86                 :            : }
          87                 :            :
          88                 :            : PyDoc_STRVAR(list_append__doc__,
          89                 :            : "append($self, object, /)\n"
          90                 :            : "--\n"
          91                 :            : "\n"
          92                 :            : "Append object to the end of the list.");
          93                 :            :
          94                 :            : #define LIST_APPEND_METHODDEF    \
          95                 :            :     {"append", (PyCFunction)list_append, METH_O, list_append__doc__},
          96                 :            :
          97                 :            : PyDoc_STRVAR(list_extend__doc__,
          98                 :            : "extend($self, iterable, /)\n"
          99                 :            : "--\n"
         100                 :            : "\n"
         101                 :            : "Extend list by appending elements from the iterable.");
         102                 :            :
         103                 :            : #define LIST_EXTEND_METHODDEF    \
         104                 :            :     {"extend", (PyCFunction)list_extend, METH_O, list_extend__doc__},
         105                 :            :
         106                 :            : PyDoc_STRVAR(list_pop__doc__,
         107                 :            : "pop($self, index=-1, /)\n"
         108                 :            : "--\n"
         109                 :            : "\n"
         110                 :            : "Remove and return item at index (default last).\n"
         111                 :            : "\n"
         112                 :            : "Raises IndexError if list is empty or index is out of range.");
         113                 :            :
         114                 :            : #define LIST_POP_METHODDEF    \
         115                 :            :     {"pop", _PyCFunction_CAST(list_pop), METH_FASTCALL, list_pop__doc__},
         116                 :            :
         117                 :            : static PyObject *
         118                 :            : list_pop_impl(PyListObject *self, Py_ssize_t index);
         119                 :            :
         120                 :            : static PyObject *
         121                 :       1537 : list_pop(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
         122                 :            : {
         123                 :       1537 :     PyObject *return_value = NULL;
         124                 :       1537 :     Py_ssize_t index = -1;
         125                 :            :
         126   [ +  -  -  +  :       1537 :     if (!_PyArg_CheckPositional("pop", nargs, 0, 1)) {
                       -  - ]
         127                 :          0 :         goto exit;
         128                 :            :     }
         129         [ +  - ]:       1537 :     if (nargs < 1) {
         130                 :       1537 :         goto skip_optional;
         131                 :            :     }
         132                 :            :     {
         133                 :          0 :         Py_ssize_t ival = -1;
         134                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
         135         [ #  # ]:          0 :         if (iobj != NULL) {
         136                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         137                 :          0 :             Py_DECREF(iobj);
         138                 :            :         }
         139   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         140                 :          0 :             goto exit;
         141                 :            :         }
         142                 :          0 :         index = ival;
         143                 :            :     }
         144                 :       1537 : skip_optional:
         145                 :       1537 :     return_value = list_pop_impl(self, index);
         146                 :            :
         147                 :       1537 : exit:
         148                 :       1537 :     return return_value;
         149                 :            : }
         150                 :            :
         151                 :            : PyDoc_STRVAR(list_sort__doc__,
         152                 :            : "sort($self, /, *, key=None, reverse=False)\n"
         153                 :            : "--\n"
         154                 :            : "\n"
         155                 :            : "Sort the list in ascending order and return None.\n"
         156                 :            : "\n"
         157                 :            : "The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n"
         158                 :            : "order of two equal elements is maintained).\n"
         159                 :            : "\n"
         160                 :            : "If a key function is given, apply it once to each list item and sort them,\n"
         161                 :            : "ascending or descending, according to their function values.\n"
         162                 :            : "\n"
         163                 :            : "The reverse flag can be set to sort in descending order.");
         164                 :            :
         165                 :            : #define LIST_SORT_METHODDEF    \
         166                 :            :     {"sort", _PyCFunction_CAST(list_sort), METH_FASTCALL|METH_KEYWORDS, list_sort__doc__},
         167                 :            :
         168                 :            : static PyObject *
         169                 :            : list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse);
         170                 :            :
         171                 :            : static PyObject *
         172                 :        124 : list_sort(PyListObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         173                 :            : {
         174                 :        124 :     PyObject *return_value = NULL;
         175                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         176                 :            :
         177                 :            :     #define NUM_KEYWORDS 2
         178                 :            :     static struct {
         179                 :            :         PyGC_Head _this_is_not_used;
         180                 :            :         PyObject_VAR_HEAD
         181                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         182                 :            :     } _kwtuple = {
         183                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         184                 :            :         .ob_item = { &_Py_ID(key), &_Py_ID(reverse), },
         185                 :            :     };
         186                 :            :     #undef NUM_KEYWORDS
         187                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         188                 :            :
         189                 :            :     #else  // !Py_BUILD_CORE
         190                 :            :     #  define KWTUPLE NULL
         191                 :            :     #endif  // !Py_BUILD_CORE
         192                 :            :
         193                 :            :     static const char * const _keywords[] = {"key", "reverse", NULL};
         194                 :            :     static _PyArg_Parser _parser = {
         195                 :            :         .keywords = _keywords,
         196                 :            :         .fname = "sort",
         197                 :            :         .kwtuple = KWTUPLE,
         198                 :            :     };
         199                 :            :     #undef KWTUPLE
         200                 :            :     PyObject *argsbuf[2];
         201         [ +  + ]:        124 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
         202                 :        124 :     PyObject *keyfunc = Py_None;
         203                 :        124 :     int reverse = 0;
         204                 :            :
         205   [ +  +  +  -  :        124 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
                 +  -  -  + ]
         206         [ -  + ]:        124 :     if (!args) {
         207                 :          0 :         goto exit;
         208                 :            :     }
         209         [ +  + ]:        124 :     if (!noptargs) {
         210                 :         94 :         goto skip_optional_kwonly;
         211                 :            :     }
         212         [ +  + ]:         30 :     if (args[0]) {
         213                 :         27 :         keyfunc = args[0];
         214         [ +  - ]:         27 :         if (!--noptargs) {
         215                 :         27 :             goto skip_optional_kwonly;
         216                 :            :         }
         217                 :            :     }
         218                 :          3 :     reverse = PyObject_IsTrue(args[1]);
         219         [ -  + ]:          3 :     if (reverse < 0) {
         220                 :          0 :         goto exit;
         221                 :            :     }
         222                 :          3 : skip_optional_kwonly:
         223                 :        124 :     return_value = list_sort_impl(self, keyfunc, reverse);
         224                 :            :
         225                 :        124 : exit:
         226                 :        124 :     return return_value;
         227                 :            : }
         228                 :            :
         229                 :            : PyDoc_STRVAR(list_reverse__doc__,
         230                 :            : "reverse($self, /)\n"
         231                 :            : "--\n"
         232                 :            : "\n"
         233                 :            : "Reverse *IN PLACE*.");
         234                 :            :
         235                 :            : #define LIST_REVERSE_METHODDEF    \
         236                 :            :     {"reverse", (PyCFunction)list_reverse, METH_NOARGS, list_reverse__doc__},
         237                 :            :
         238                 :            : static PyObject *
         239                 :            : list_reverse_impl(PyListObject *self);
         240                 :            :
         241                 :            : static PyObject *
         242                 :         24 : list_reverse(PyListObject *self, PyObject *Py_UNUSED(ignored))
         243                 :            : {
         244                 :         24 :     return list_reverse_impl(self);
         245                 :            : }
         246                 :            :
         247                 :            : PyDoc_STRVAR(list_index__doc__,
         248                 :            : "index($self, value, start=0, stop=sys.maxsize, /)\n"
         249                 :            : "--\n"
         250                 :            : "\n"
         251                 :            : "Return first index of value.\n"
         252                 :            : "\n"
         253                 :            : "Raises ValueError if the value is not present.");
         254                 :            :
         255                 :            : #define LIST_INDEX_METHODDEF    \
         256                 :            :     {"index", _PyCFunction_CAST(list_index), METH_FASTCALL, list_index__doc__},
         257                 :            :
         258                 :            : static PyObject *
         259                 :            : list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
         260                 :            :                 Py_ssize_t stop);
         261                 :            :
         262                 :            : static PyObject *
         263                 :          0 : list_index(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
         264                 :            : {
         265                 :          0 :     PyObject *return_value = NULL;
         266                 :            :     PyObject *value;
         267                 :          0 :     Py_ssize_t start = 0;
         268                 :          0 :     Py_ssize_t stop = PY_SSIZE_T_MAX;
         269                 :            :
         270   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("index", nargs, 1, 3)) {
                       #  # ]
         271                 :          0 :         goto exit;
         272                 :            :     }
         273                 :          0 :     value = args[0];
         274         [ #  # ]:          0 :     if (nargs < 2) {
         275                 :          0 :         goto skip_optional;
         276                 :            :     }
         277         [ #  # ]:          0 :     if (!_PyEval_SliceIndexNotNone(args[1], &start)) {
         278                 :          0 :         goto exit;
         279                 :            :     }
         280         [ #  # ]:          0 :     if (nargs < 3) {
         281                 :          0 :         goto skip_optional;
         282                 :            :     }
         283         [ #  # ]:          0 :     if (!_PyEval_SliceIndexNotNone(args[2], &stop)) {
         284                 :          0 :         goto exit;
         285                 :            :     }
         286                 :          0 : skip_optional:
         287                 :          0 :     return_value = list_index_impl(self, value, start, stop);
         288                 :            :
         289                 :          0 : exit:
         290                 :          0 :     return return_value;
         291                 :            : }
         292                 :            :
         293                 :            : PyDoc_STRVAR(list_count__doc__,
         294                 :            : "count($self, value, /)\n"
         295                 :            : "--\n"
         296                 :            : "\n"
         297                 :            : "Return number of occurrences of value.");
         298                 :            :
         299                 :            : #define LIST_COUNT_METHODDEF    \
         300                 :            :     {"count", (PyCFunction)list_count, METH_O, list_count__doc__},
         301                 :            :
         302                 :            : PyDoc_STRVAR(list_remove__doc__,
         303                 :            : "remove($self, value, /)\n"
         304                 :            : "--\n"
         305                 :            : "\n"
         306                 :            : "Remove first occurrence of value.\n"
         307                 :            : "\n"
         308                 :            : "Raises ValueError if the value is not present.");
         309                 :            :
         310                 :            : #define LIST_REMOVE_METHODDEF    \
         311                 :            :     {"remove", (PyCFunction)list_remove, METH_O, list_remove__doc__},
         312                 :            :
         313                 :            : PyDoc_STRVAR(list___init____doc__,
         314                 :            : "list(iterable=(), /)\n"
         315                 :            : "--\n"
         316                 :            : "\n"
         317                 :            : "Built-in mutable sequence.\n"
         318                 :            : "\n"
         319                 :            : "If no argument is given, the constructor creates a new empty list.\n"
         320                 :            : "The argument must be an iterable if specified.");
         321                 :            :
         322                 :            : static int
         323                 :            : list___init___impl(PyListObject *self, PyObject *iterable);
         324                 :            :
         325                 :            : static int
         326                 :         18 : list___init__(PyObject *self, PyObject *args, PyObject *kwargs)
         327                 :            : {
         328                 :         18 :     int return_value = -1;
         329                 :         18 :     PyTypeObject *base_tp = &PyList_Type;
         330                 :         18 :     PyObject *iterable = NULL;
         331                 :            :
         332         [ +  - ]:         18 :     if ((Py_IS_TYPE(self, base_tp) ||
         333   [ +  -  -  + ]:         18 :          Py_TYPE(self)->tp_new == base_tp->tp_new) &&
         334         [ #  # ]:          0 :         !_PyArg_NoKeywords("list", kwargs)) {
         335                 :          0 :         goto exit;
         336                 :            :     }
         337   [ +  -  -  +  :         18 :     if (!_PyArg_CheckPositional("list", PyTuple_GET_SIZE(args), 0, 1)) {
                       -  - ]
         338                 :          0 :         goto exit;
         339                 :            :     }
         340         [ +  - ]:         18 :     if (PyTuple_GET_SIZE(args) < 1) {
         341                 :         18 :         goto skip_optional;
         342                 :            :     }
         343                 :          0 :     iterable = PyTuple_GET_ITEM(args, 0);
         344                 :         18 : skip_optional:
         345                 :         18 :     return_value = list___init___impl((PyListObject *)self, iterable);
         346                 :            :
         347                 :         18 : exit:
         348                 :         18 :     return return_value;
         349                 :            : }
         350                 :            :
         351                 :            : PyDoc_STRVAR(list___sizeof____doc__,
         352                 :            : "__sizeof__($self, /)\n"
         353                 :            : "--\n"
         354                 :            : "\n"
         355                 :            : "Return the size of the list in memory, in bytes.");
         356                 :            :
         357                 :            : #define LIST___SIZEOF___METHODDEF    \
         358                 :            :     {"__sizeof__", (PyCFunction)list___sizeof__, METH_NOARGS, list___sizeof____doc__},
         359                 :            :
         360                 :            : static PyObject *
         361                 :            : list___sizeof___impl(PyListObject *self);
         362                 :            :
         363                 :            : static PyObject *
         364                 :          0 : list___sizeof__(PyListObject *self, PyObject *Py_UNUSED(ignored))
         365                 :            : {
         366                 :          0 :     return list___sizeof___impl(self);
         367                 :            : }
         368                 :            :
         369                 :            : PyDoc_STRVAR(list___reversed____doc__,
         370                 :            : "__reversed__($self, /)\n"
         371                 :            : "--\n"
         372                 :            : "\n"
         373                 :            : "Return a reverse iterator over the list.");
         374                 :            :
         375                 :            : #define LIST___REVERSED___METHODDEF    \
         376                 :            :     {"__reversed__", (PyCFunction)list___reversed__, METH_NOARGS, list___reversed____doc__},
         377                 :            :
         378                 :            : static PyObject *
         379                 :            : list___reversed___impl(PyListObject *self);
         380                 :            :
         381                 :            : static PyObject *
         382                 :        268 : list___reversed__(PyListObject *self, PyObject *Py_UNUSED(ignored))
         383                 :            : {
         384                 :        268 :     return list___reversed___impl(self);
         385                 :            : }
         386                 :            : /*[clinic end generated code: output=2ca109d8acc775bc input=a9049054013a1b77]*/

Generated by: LCOV version 1.14