Line data    Source code

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