LCOV - code coverage report
Current view: top level - Objects/clinic - dictobject.c.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 47 56 83.9 %
Date: 2023-03-20 08:15:36 Functions: 4 6 66.7 %
Branches: 15 32 46.9 %

           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(dict_fromkeys__doc__,
      12                 :            : "fromkeys($type, iterable, value=None, /)\n"
      13                 :            : "--\n"
      14                 :            : "\n"
      15                 :            : "Create a new dictionary with keys from iterable and values set to value.");
      16                 :            : 
      17                 :            : #define DICT_FROMKEYS_METHODDEF    \
      18                 :            :     {"fromkeys", _PyCFunction_CAST(dict_fromkeys), METH_FASTCALL|METH_CLASS, dict_fromkeys__doc__},
      19                 :            : 
      20                 :            : static PyObject *
      21                 :            : dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable, PyObject *value);
      22                 :            : 
      23                 :            : static PyObject *
      24                 :        152 : dict_fromkeys(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs)
      25                 :            : {
      26                 :        152 :     PyObject *return_value = NULL;
      27                 :            :     PyObject *iterable;
      28                 :        152 :     PyObject *value = Py_None;
      29                 :            : 
      30   [ +  -  -  +  :        152 :     if (!_PyArg_CheckPositional("fromkeys", nargs, 1, 2)) {
                   -  - ]
      31                 :          0 :         goto exit;
      32                 :            :     }
      33                 :        152 :     iterable = args[0];
      34         [ +  + ]:        152 :     if (nargs < 2) {
      35                 :        150 :         goto skip_optional;
      36                 :            :     }
      37                 :          2 :     value = args[1];
      38                 :        152 : skip_optional:
      39                 :        152 :     return_value = dict_fromkeys_impl(type, iterable, value);
      40                 :            : 
      41                 :        152 : exit:
      42                 :        152 :     return return_value;
      43                 :            : }
      44                 :            : 
      45                 :            : PyDoc_STRVAR(dict___contains____doc__,
      46                 :            : "__contains__($self, key, /)\n"
      47                 :            : "--\n"
      48                 :            : "\n"
      49                 :            : "True if the dictionary has the specified key, else False.");
      50                 :            : 
      51                 :            : #define DICT___CONTAINS___METHODDEF    \
      52                 :            :     {"__contains__", (PyCFunction)dict___contains__, METH_O|METH_COEXIST, dict___contains____doc__},
      53                 :            : 
      54                 :            : PyDoc_STRVAR(dict_get__doc__,
      55                 :            : "get($self, key, default=None, /)\n"
      56                 :            : "--\n"
      57                 :            : "\n"
      58                 :            : "Return the value for key if key is in the dictionary, else default.");
      59                 :            : 
      60                 :            : #define DICT_GET_METHODDEF    \
      61                 :            :     {"get", _PyCFunction_CAST(dict_get), METH_FASTCALL, dict_get__doc__},
      62                 :            : 
      63                 :            : static PyObject *
      64                 :            : dict_get_impl(PyDictObject *self, PyObject *key, PyObject *default_value);
      65                 :            : 
      66                 :            : static PyObject *
      67                 :     132694 : dict_get(PyDictObject *self, PyObject *const *args, Py_ssize_t nargs)
      68                 :            : {
      69                 :     132694 :     PyObject *return_value = NULL;
      70                 :            :     PyObject *key;
      71                 :     132694 :     PyObject *default_value = Py_None;
      72                 :            : 
      73   [ +  -  -  +  :     132694 :     if (!_PyArg_CheckPositional("get", nargs, 1, 2)) {
                   -  - ]
      74                 :          0 :         goto exit;
      75                 :            :     }
      76                 :     132694 :     key = args[0];
      77         [ +  + ]:     132694 :     if (nargs < 2) {
      78                 :     128523 :         goto skip_optional;
      79                 :            :     }
      80                 :       4171 :     default_value = args[1];
      81                 :     132694 : skip_optional:
      82                 :     132694 :     return_value = dict_get_impl(self, key, default_value);
      83                 :            : 
      84                 :     132694 : exit:
      85                 :     132694 :     return return_value;
      86                 :            : }
      87                 :            : 
      88                 :            : PyDoc_STRVAR(dict_setdefault__doc__,
      89                 :            : "setdefault($self, key, default=None, /)\n"
      90                 :            : "--\n"
      91                 :            : "\n"
      92                 :            : "Insert key with a value of default if key is not in the dictionary.\n"
      93                 :            : "\n"
      94                 :            : "Return the value for key if key is in the dictionary, else default.");
      95                 :            : 
      96                 :            : #define DICT_SETDEFAULT_METHODDEF    \
      97                 :            :     {"setdefault", _PyCFunction_CAST(dict_setdefault), METH_FASTCALL, dict_setdefault__doc__},
      98                 :            : 
      99                 :            : static PyObject *
     100                 :            : dict_setdefault_impl(PyDictObject *self, PyObject *key,
     101                 :            :                      PyObject *default_value);
     102                 :            : 
     103                 :            : static PyObject *
     104                 :       1723 : dict_setdefault(PyDictObject *self, PyObject *const *args, Py_ssize_t nargs)
     105                 :            : {
     106                 :       1723 :     PyObject *return_value = NULL;
     107                 :            :     PyObject *key;
     108                 :       1723 :     PyObject *default_value = Py_None;
     109                 :            : 
     110   [ +  -  -  +  :       1723 :     if (!_PyArg_CheckPositional("setdefault", nargs, 1, 2)) {
                   -  - ]
     111                 :          0 :         goto exit;
     112                 :            :     }
     113                 :       1723 :     key = args[0];
     114         [ -  + ]:       1723 :     if (nargs < 2) {
     115                 :          0 :         goto skip_optional;
     116                 :            :     }
     117                 :       1723 :     default_value = args[1];
     118                 :       1723 : skip_optional:
     119                 :       1723 :     return_value = dict_setdefault_impl(self, key, default_value);
     120                 :            : 
     121                 :       1723 : exit:
     122                 :       1723 :     return return_value;
     123                 :            : }
     124                 :            : 
     125                 :            : PyDoc_STRVAR(dict_pop__doc__,
     126                 :            : "pop($self, key, default=<unrepresentable>, /)\n"
     127                 :            : "--\n"
     128                 :            : "\n"
     129                 :            : "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n"
     130                 :            : "\n"
     131                 :            : "If the key is not found, return the default if given; otherwise,\n"
     132                 :            : "raise a KeyError.");
     133                 :            : 
     134                 :            : #define DICT_POP_METHODDEF    \
     135                 :            :     {"pop", _PyCFunction_CAST(dict_pop), METH_FASTCALL, dict_pop__doc__},
     136                 :            : 
     137                 :            : static PyObject *
     138                 :            : dict_pop_impl(PyDictObject *self, PyObject *key, PyObject *default_value);
     139                 :            : 
     140                 :            : static PyObject *
     141                 :       1427 : dict_pop(PyDictObject *self, PyObject *const *args, Py_ssize_t nargs)
     142                 :            : {
     143                 :       1427 :     PyObject *return_value = NULL;
     144                 :            :     PyObject *key;
     145                 :       1427 :     PyObject *default_value = NULL;
     146                 :            : 
     147   [ +  -  -  +  :       1427 :     if (!_PyArg_CheckPositional("pop", nargs, 1, 2)) {
                   -  - ]
     148                 :          0 :         goto exit;
     149                 :            :     }
     150                 :       1427 :     key = args[0];
     151         [ +  + ]:       1427 :     if (nargs < 2) {
     152                 :       1076 :         goto skip_optional;
     153                 :            :     }
     154                 :        351 :     default_value = args[1];
     155                 :       1427 : skip_optional:
     156                 :       1427 :     return_value = dict_pop_impl(self, key, default_value);
     157                 :            : 
     158                 :       1427 : exit:
     159                 :       1427 :     return return_value;
     160                 :            : }
     161                 :            : 
     162                 :            : PyDoc_STRVAR(dict_popitem__doc__,
     163                 :            : "popitem($self, /)\n"
     164                 :            : "--\n"
     165                 :            : "\n"
     166                 :            : "Remove and return a (key, value) pair as a 2-tuple.\n"
     167                 :            : "\n"
     168                 :            : "Pairs are returned in LIFO (last-in, first-out) order.\n"
     169                 :            : "Raises KeyError if the dict is empty.");
     170                 :            : 
     171                 :            : #define DICT_POPITEM_METHODDEF    \
     172                 :            :     {"popitem", (PyCFunction)dict_popitem, METH_NOARGS, dict_popitem__doc__},
     173                 :            : 
     174                 :            : static PyObject *
     175                 :            : dict_popitem_impl(PyDictObject *self);
     176                 :            : 
     177                 :            : static PyObject *
     178                 :          0 : dict_popitem(PyDictObject *self, PyObject *Py_UNUSED(ignored))
     179                 :            : {
     180                 :          0 :     return dict_popitem_impl(self);
     181                 :            : }
     182                 :            : 
     183                 :            : PyDoc_STRVAR(dict___reversed____doc__,
     184                 :            : "__reversed__($self, /)\n"
     185                 :            : "--\n"
     186                 :            : "\n"
     187                 :            : "Return a reverse iterator over the dict keys.");
     188                 :            : 
     189                 :            : #define DICT___REVERSED___METHODDEF    \
     190                 :            :     {"__reversed__", (PyCFunction)dict___reversed__, METH_NOARGS, dict___reversed____doc__},
     191                 :            : 
     192                 :            : static PyObject *
     193                 :            : dict___reversed___impl(PyDictObject *self);
     194                 :            : 
     195                 :            : static PyObject *
     196                 :          0 : dict___reversed__(PyDictObject *self, PyObject *Py_UNUSED(ignored))
     197                 :            : {
     198                 :          0 :     return dict___reversed___impl(self);
     199                 :            : }
     200                 :            : /*[clinic end generated code: output=c0064abbea6091c5 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14