LCOV - code coverage report
Current view: | top level - Python/clinic - bltinmodule.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 272 | 381 | 71.4 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 21 | 25 | 84.0 %
|  |  | Branches: | 122 | 278 | 43.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(builtin___import____doc__,
          12                 :            : "__import__($module, /, name, globals=None, locals=None, fromlist=(),\n"
          13                 :            : "           level=0)\n"
          14                 :            : "--\n"
          15                 :            : "\n"
          16                 :            : "Import a module.\n"
          17                 :            : "\n"
          18                 :            : "Because this function is meant for use by the Python\n"
          19                 :            : "interpreter and not for general use, it is better to use\n"
          20                 :            : "importlib.import_module() to programmatically import a module.\n"
          21                 :            : "\n"
          22                 :            : "The globals argument is only used to determine the context;\n"
          23                 :            : "they are not modified.  The locals argument is unused.  The fromlist\n"
          24                 :            : "should be a list of names to emulate ``from name import ...``, or an\n"
          25                 :            : "empty list to emulate ``import name``.\n"
          26                 :            : "When importing a module from a package, note that __import__(\'A.B\', ...)\n"
          27                 :            : "returns package A when fromlist is empty, but its submodule B when\n"
          28                 :            : "fromlist is not empty.  The level argument is used to determine whether to\n"
          29                 :            : "perform absolute or relative imports: 0 is absolute, while a positive number\n"
          30                 :            : "is the number of parent directories to search relative to the current module.");
          31                 :            :
          32                 :            : #define BUILTIN___IMPORT___METHODDEF    \
          33                 :            :     {"__import__", _PyCFunction_CAST(builtin___import__), METH_FASTCALL|METH_KEYWORDS, builtin___import____doc__},
          34                 :            :
          35                 :            : static PyObject *
          36                 :            : builtin___import___impl(PyObject *module, PyObject *name, PyObject *globals,
          37                 :            :                         PyObject *locals, PyObject *fromlist, int level);
          38                 :            :
          39                 :            : static PyObject *
          40                 :       1059 : builtin___import__(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
          41                 :            : {
          42                 :       1059 :     PyObject *return_value = NULL;
          43                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
          44                 :            :
          45                 :            :     #define NUM_KEYWORDS 5
          46                 :            :     static struct {
          47                 :            :         PyGC_Head _this_is_not_used;
          48                 :            :         PyObject_VAR_HEAD
          49                 :            :         PyObject *ob_item[NUM_KEYWORDS];
          50                 :            :     } _kwtuple = {
          51                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
          52                 :            :         .ob_item = { &_Py_ID(name), &_Py_ID(globals), &_Py_ID(locals), &_Py_ID(fromlist), &_Py_ID(level), },
          53                 :            :     };
          54                 :            :     #undef NUM_KEYWORDS
          55                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
          56                 :            :
          57                 :            :     #else  // !Py_BUILD_CORE
          58                 :            :     #  define KWTUPLE NULL
          59                 :            :     #endif  // !Py_BUILD_CORE
          60                 :            :
          61                 :            :     static const char * const _keywords[] = {"name", "globals", "locals", "fromlist", "level", NULL};
          62                 :            :     static _PyArg_Parser _parser = {
          63                 :            :         .keywords = _keywords,
          64                 :            :         .fname = "__import__",
          65                 :            :         .kwtuple = KWTUPLE,
          66                 :            :     };
          67                 :            :     #undef KWTUPLE
          68                 :            :     PyObject *argsbuf[5];
          69         [ +  + ]:       1059 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
          70                 :            :     PyObject *name;
          71                 :       1059 :     PyObject *globals = NULL;
          72                 :       1059 :     PyObject *locals = NULL;
          73                 :       1059 :     PyObject *fromlist = NULL;
          74                 :       1059 :     int level = 0;
          75                 :            :
          76   [ +  +  +  -  :       1059 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 5, 0, argsbuf);
                 +  -  -  + ]
          77         [ -  + ]:       1059 :     if (!args) {
          78                 :          0 :         goto exit;
          79                 :            :     }
          80                 :       1059 :     name = args[0];
          81         [ +  + ]:       1059 :     if (!noptargs) {
          82                 :         67 :         goto skip_optional_pos;
          83                 :            :     }
          84         [ +  + ]:        992 :     if (args[1]) {
          85                 :        942 :         globals = args[1];
          86         [ -  + ]:        942 :         if (!--noptargs) {
          87                 :          0 :             goto skip_optional_pos;
          88                 :            :         }
          89                 :            :     }
          90         [ +  + ]:        992 :     if (args[2]) {
          91                 :        942 :         locals = args[2];
          92         [ -  + ]:        942 :         if (!--noptargs) {
          93                 :          0 :             goto skip_optional_pos;
          94                 :            :         }
          95                 :            :     }
          96         [ +  - ]:        992 :     if (args[3]) {
          97                 :        992 :         fromlist = args[3];
          98         [ +  + ]:        992 :         if (!--noptargs) {
          99                 :          1 :             goto skip_optional_pos;
         100                 :            :         }
         101                 :            :     }
         102                 :        991 :     level = _PyLong_AsInt(args[4]);
         103   [ -  +  -  - ]:        991 :     if (level == -1 && PyErr_Occurred()) {
         104                 :          0 :         goto exit;
         105                 :            :     }
         106                 :        991 : skip_optional_pos:
         107                 :       1059 :     return_value = builtin___import___impl(module, name, globals, locals, fromlist, level);
         108                 :            :
         109                 :       1059 : exit:
         110                 :       1059 :     return return_value;
         111                 :            : }
         112                 :            :
         113                 :            : PyDoc_STRVAR(builtin_abs__doc__,
         114                 :            : "abs($module, x, /)\n"
         115                 :            : "--\n"
         116                 :            : "\n"
         117                 :            : "Return the absolute value of the argument.");
         118                 :            :
         119                 :            : #define BUILTIN_ABS_METHODDEF    \
         120                 :            :     {"abs", (PyCFunction)builtin_abs, METH_O, builtin_abs__doc__},
         121                 :            :
         122                 :            : PyDoc_STRVAR(builtin_all__doc__,
         123                 :            : "all($module, iterable, /)\n"
         124                 :            : "--\n"
         125                 :            : "\n"
         126                 :            : "Return True if bool(x) is True for all values x in the iterable.\n"
         127                 :            : "\n"
         128                 :            : "If the iterable is empty, return True.");
         129                 :            :
         130                 :            : #define BUILTIN_ALL_METHODDEF    \
         131                 :            :     {"all", (PyCFunction)builtin_all, METH_O, builtin_all__doc__},
         132                 :            :
         133                 :            : PyDoc_STRVAR(builtin_any__doc__,
         134                 :            : "any($module, iterable, /)\n"
         135                 :            : "--\n"
         136                 :            : "\n"
         137                 :            : "Return True if bool(x) is True for any x in the iterable.\n"
         138                 :            : "\n"
         139                 :            : "If the iterable is empty, return False.");
         140                 :            :
         141                 :            : #define BUILTIN_ANY_METHODDEF    \
         142                 :            :     {"any", (PyCFunction)builtin_any, METH_O, builtin_any__doc__},
         143                 :            :
         144                 :            : PyDoc_STRVAR(builtin_ascii__doc__,
         145                 :            : "ascii($module, obj, /)\n"
         146                 :            : "--\n"
         147                 :            : "\n"
         148                 :            : "Return an ASCII-only representation of an object.\n"
         149                 :            : "\n"
         150                 :            : "As repr(), return a string containing a printable representation of an\n"
         151                 :            : "object, but escape the non-ASCII characters in the string returned by\n"
         152                 :            : "repr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar\n"
         153                 :            : "to that returned by repr() in Python 2.");
         154                 :            :
         155                 :            : #define BUILTIN_ASCII_METHODDEF    \
         156                 :            :     {"ascii", (PyCFunction)builtin_ascii, METH_O, builtin_ascii__doc__},
         157                 :            :
         158                 :            : PyDoc_STRVAR(builtin_bin__doc__,
         159                 :            : "bin($module, number, /)\n"
         160                 :            : "--\n"
         161                 :            : "\n"
         162                 :            : "Return the binary representation of an integer.\n"
         163                 :            : "\n"
         164                 :            : "   >>> bin(2796202)\n"
         165                 :            : "   \'0b1010101010101010101010\'");
         166                 :            :
         167                 :            : #define BUILTIN_BIN_METHODDEF    \
         168                 :            :     {"bin", (PyCFunction)builtin_bin, METH_O, builtin_bin__doc__},
         169                 :            :
         170                 :            : PyDoc_STRVAR(builtin_callable__doc__,
         171                 :            : "callable($module, obj, /)\n"
         172                 :            : "--\n"
         173                 :            : "\n"
         174                 :            : "Return whether the object is callable (i.e., some kind of function).\n"
         175                 :            : "\n"
         176                 :            : "Note that classes are callable, as are instances of classes with a\n"
         177                 :            : "__call__() method.");
         178                 :            :
         179                 :            : #define BUILTIN_CALLABLE_METHODDEF    \
         180                 :            :     {"callable", (PyCFunction)builtin_callable, METH_O, builtin_callable__doc__},
         181                 :            :
         182                 :            : PyDoc_STRVAR(builtin_format__doc__,
         183                 :            : "format($module, value, format_spec=\'\', /)\n"
         184                 :            : "--\n"
         185                 :            : "\n"
         186                 :            : "Return type(value).__format__(value, format_spec)\n"
         187                 :            : "\n"
         188                 :            : "Many built-in types implement format_spec according to the\n"
         189                 :            : "Format Specification Mini-language. See help(\'FORMATTING\').\n"
         190                 :            : "\n"
         191                 :            : "If type(value) does not supply a method named __format__\n"
         192                 :            : "and format_spec is empty, then str(value) is returned.\n"
         193                 :            : "See also help(\'SPECIALMETHODS\').");
         194                 :            :
         195                 :            : #define BUILTIN_FORMAT_METHODDEF    \
         196                 :            :     {"format", _PyCFunction_CAST(builtin_format), METH_FASTCALL, builtin_format__doc__},
         197                 :            :
         198                 :            : static PyObject *
         199                 :            : builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec);
         200                 :            :
         201                 :            : static PyObject *
         202                 :          0 : builtin_format(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         203                 :            : {
         204                 :          0 :     PyObject *return_value = NULL;
         205                 :            :     PyObject *value;
         206                 :          0 :     PyObject *format_spec = NULL;
         207                 :            :
         208   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("format", nargs, 1, 2)) {
                       #  # ]
         209                 :          0 :         goto exit;
         210                 :            :     }
         211                 :          0 :     value = args[0];
         212         [ #  # ]:          0 :     if (nargs < 2) {
         213                 :          0 :         goto skip_optional;
         214                 :            :     }
         215         [ #  # ]:          0 :     if (!PyUnicode_Check(args[1])) {
         216                 :          0 :         _PyArg_BadArgument("format", "argument 2", "str", args[1]);
         217                 :          0 :         goto exit;
         218                 :            :     }
         219         [ #  # ]:          0 :     if (PyUnicode_READY(args[1]) == -1) {
         220                 :          0 :         goto exit;
         221                 :            :     }
         222                 :          0 :     format_spec = args[1];
         223                 :          0 : skip_optional:
         224                 :          0 :     return_value = builtin_format_impl(module, value, format_spec);
         225                 :            :
         226                 :          0 : exit:
         227                 :          0 :     return return_value;
         228                 :            : }
         229                 :            :
         230                 :            : PyDoc_STRVAR(builtin_chr__doc__,
         231                 :            : "chr($module, i, /)\n"
         232                 :            : "--\n"
         233                 :            : "\n"
         234                 :            : "Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
         235                 :            :
         236                 :            : #define BUILTIN_CHR_METHODDEF    \
         237                 :            :     {"chr", (PyCFunction)builtin_chr, METH_O, builtin_chr__doc__},
         238                 :            :
         239                 :            : static PyObject *
         240                 :            : builtin_chr_impl(PyObject *module, int i);
         241                 :            :
         242                 :            : static PyObject *
         243                 :         96 : builtin_chr(PyObject *module, PyObject *arg)
         244                 :            : {
         245                 :         96 :     PyObject *return_value = NULL;
         246                 :            :     int i;
         247                 :            :
         248                 :         96 :     i = _PyLong_AsInt(arg);
         249   [ -  +  -  - ]:         96 :     if (i == -1 && PyErr_Occurred()) {
         250                 :          0 :         goto exit;
         251                 :            :     }
         252                 :         96 :     return_value = builtin_chr_impl(module, i);
         253                 :            :
         254                 :         96 : exit:
         255                 :         96 :     return return_value;
         256                 :            : }
         257                 :            :
         258                 :            : PyDoc_STRVAR(builtin_compile__doc__,
         259                 :            : "compile($module, /, source, filename, mode, flags=0,\n"
         260                 :            : "        dont_inherit=False, optimize=-1, *, _feature_version=-1)\n"
         261                 :            : "--\n"
         262                 :            : "\n"
         263                 :            : "Compile source into a code object that can be executed by exec() or eval().\n"
         264                 :            : "\n"
         265                 :            : "The source code may represent a Python module, statement or expression.\n"
         266                 :            : "The filename will be used for run-time error messages.\n"
         267                 :            : "The mode must be \'exec\' to compile a module, \'single\' to compile a\n"
         268                 :            : "single (interactive) statement, or \'eval\' to compile an expression.\n"
         269                 :            : "The flags argument, if present, controls which future statements influence\n"
         270                 :            : "the compilation of the code.\n"
         271                 :            : "The dont_inherit argument, if true, stops the compilation inheriting\n"
         272                 :            : "the effects of any future statements in effect in the code calling\n"
         273                 :            : "compile; if absent or false these statements do influence the compilation,\n"
         274                 :            : "in addition to any features explicitly specified.");
         275                 :            :
         276                 :            : #define BUILTIN_COMPILE_METHODDEF    \
         277                 :            :     {"compile", _PyCFunction_CAST(builtin_compile), METH_FASTCALL|METH_KEYWORDS, builtin_compile__doc__},
         278                 :            :
         279                 :            : static PyObject *
         280                 :            : builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
         281                 :            :                      const char *mode, int flags, int dont_inherit,
         282                 :            :                      int optimize, int feature_version);
         283                 :            :
         284                 :            : static PyObject *
         285                 :        267 : builtin_compile(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         286                 :            : {
         287                 :        267 :     PyObject *return_value = NULL;
         288                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         289                 :            :
         290                 :            :     #define NUM_KEYWORDS 7
         291                 :            :     static struct {
         292                 :            :         PyGC_Head _this_is_not_used;
         293                 :            :         PyObject_VAR_HEAD
         294                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         295                 :            :     } _kwtuple = {
         296                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         297                 :            :         .ob_item = { &_Py_ID(source), &_Py_ID(filename), &_Py_ID(mode), &_Py_ID(flags), &_Py_ID(dont_inherit), &_Py_ID(optimize), &_Py_ID(_feature_version), },
         298                 :            :     };
         299                 :            :     #undef NUM_KEYWORDS
         300                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         301                 :            :
         302                 :            :     #else  // !Py_BUILD_CORE
         303                 :            :     #  define KWTUPLE NULL
         304                 :            :     #endif  // !Py_BUILD_CORE
         305                 :            :
         306                 :            :     static const char * const _keywords[] = {"source", "filename", "mode", "flags", "dont_inherit", "optimize", "_feature_version", NULL};
         307                 :            :     static _PyArg_Parser _parser = {
         308                 :            :         .keywords = _keywords,
         309                 :            :         .fname = "compile",
         310                 :            :         .kwtuple = KWTUPLE,
         311                 :            :     };
         312                 :            :     #undef KWTUPLE
         313                 :            :     PyObject *argsbuf[7];
         314         [ +  + ]:        267 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
         315                 :            :     PyObject *source;
         316                 :            :     PyObject *filename;
         317                 :            :     const char *mode;
         318                 :        267 :     int flags = 0;
         319                 :        267 :     int dont_inherit = 0;
         320                 :        267 :     int optimize = -1;
         321                 :        267 :     int feature_version = -1;
         322                 :            :
         323   [ +  +  +  -  :        267 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 6, 0, argsbuf);
                 +  -  -  + ]
         324         [ -  + ]:        267 :     if (!args) {
         325                 :          0 :         goto exit;
         326                 :            :     }
         327                 :        267 :     source = args[0];
         328         [ -  + ]:        267 :     if (!PyUnicode_FSDecoder(args[1], &filename)) {
         329                 :          0 :         goto exit;
         330                 :            :     }
         331         [ -  + ]:        267 :     if (!PyUnicode_Check(args[2])) {
         332                 :          0 :         _PyArg_BadArgument("compile", "argument 'mode'", "str", args[2]);
         333                 :          0 :         goto exit;
         334                 :            :     }
         335                 :            :     Py_ssize_t mode_length;
         336                 :        267 :     mode = PyUnicode_AsUTF8AndSize(args[2], &mode_length);
         337         [ -  + ]:        267 :     if (mode == NULL) {
         338                 :          0 :         goto exit;
         339                 :            :     }
         340         [ -  + ]:        267 :     if (strlen(mode) != (size_t)mode_length) {
         341                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
         342                 :          0 :         goto exit;
         343                 :            :     }
         344         [ -  + ]:        267 :     if (!noptargs) {
         345                 :          0 :         goto skip_optional_pos;
         346                 :            :     }
         347         [ +  + ]:        267 :     if (args[3]) {
         348                 :         88 :         flags = _PyLong_AsInt(args[3]);
         349   [ -  +  -  - ]:         88 :         if (flags == -1 && PyErr_Occurred()) {
         350                 :          0 :             goto exit;
         351                 :            :         }
         352         [ -  + ]:         88 :         if (!--noptargs) {
         353                 :          0 :             goto skip_optional_pos;
         354                 :            :         }
         355                 :            :     }
         356         [ +  + ]:        267 :     if (args[4]) {
         357                 :        235 :         dont_inherit = PyObject_IsTrue(args[4]);
         358         [ -  + ]:        235 :         if (dont_inherit < 0) {
         359                 :          0 :             goto exit;
         360                 :            :         }
         361         [ +  + ]:        235 :         if (!--noptargs) {
         362                 :         56 :             goto skip_optional_pos;
         363                 :            :         }
         364                 :            :     }
         365         [ +  + ]:        211 :     if (args[5]) {
         366                 :        179 :         optimize = _PyLong_AsInt(args[5]);
         367   [ +  +  -  + ]:        179 :         if (optimize == -1 && PyErr_Occurred()) {
         368                 :          0 :             goto exit;
         369                 :            :         }
         370         [ -  + ]:        179 :         if (!--noptargs) {
         371                 :        179 :             goto skip_optional_pos;
         372                 :            :         }
         373                 :            :     }
         374                 :         32 : skip_optional_pos:
         375         [ +  + ]:        267 :     if (!noptargs) {
         376                 :        235 :         goto skip_optional_kwonly;
         377                 :            :     }
         378                 :         32 :     feature_version = _PyLong_AsInt(args[6]);
         379   [ +  -  +  - ]:         32 :     if (feature_version == -1 && PyErr_Occurred()) {
         380                 :          0 :         goto exit;
         381                 :            :     }
         382                 :         32 : skip_optional_kwonly:
         383                 :        267 :     return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize, feature_version);
         384                 :            :
         385                 :        267 : exit:
         386                 :        267 :     return return_value;
         387                 :            : }
         388                 :            :
         389                 :            : PyDoc_STRVAR(builtin_dir__doc__,
         390                 :            : "dir($module, arg=<unrepresentable>, /)\n"
         391                 :            : "--\n"
         392                 :            : "\n"
         393                 :            : "Show attributes of an object.\n"
         394                 :            : "\n"
         395                 :            : "If called without an argument, return the names in the current scope.\n"
         396                 :            : "Else, return an alphabetized list of names comprising (some of) the attributes\n"
         397                 :            : "of the given object, and of attributes reachable from it.\n"
         398                 :            : "If the object supplies a method named __dir__, it will be used; otherwise\n"
         399                 :            : "the default dir() logic is used and returns:\n"
         400                 :            : "  for a module object: the module\'s attributes.\n"
         401                 :            : "  for a class object:  its attributes, and recursively the attributes\n"
         402                 :            : "    of its bases.\n"
         403                 :            : "  for any other object: its attributes, its class\'s attributes, and\n"
         404                 :            : "    recursively the attributes of its class\'s base classes.");
         405                 :            :
         406                 :            : #define BUILTIN_DIR_METHODDEF    \
         407                 :            :     {"dir", _PyCFunction_CAST(builtin_dir), METH_FASTCALL, builtin_dir__doc__},
         408                 :            :
         409                 :            : static PyObject *
         410                 :            : builtin_dir_impl(PyObject *module, PyObject *arg);
         411                 :            :
         412                 :            : static PyObject *
         413                 :         30 : builtin_dir(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         414                 :            : {
         415                 :         30 :     PyObject *return_value = NULL;
         416                 :         30 :     PyObject *arg = NULL;
         417                 :            :
         418   [ +  -  -  +  :         30 :     if (!_PyArg_CheckPositional("dir", nargs, 0, 1)) {
                       -  - ]
         419                 :          0 :         goto exit;
         420                 :            :     }
         421         [ -  + ]:         30 :     if (nargs < 1) {
         422                 :          0 :         goto skip_optional;
         423                 :            :     }
         424                 :         30 :     arg = args[0];
         425                 :         30 : skip_optional:
         426                 :         30 :     return_value = builtin_dir_impl(module, arg);
         427                 :            :
         428                 :         30 : exit:
         429                 :         30 :     return return_value;
         430                 :            : }
         431                 :            :
         432                 :            : PyDoc_STRVAR(builtin_divmod__doc__,
         433                 :            : "divmod($module, x, y, /)\n"
         434                 :            : "--\n"
         435                 :            : "\n"
         436                 :            : "Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.");
         437                 :            :
         438                 :            : #define BUILTIN_DIVMOD_METHODDEF    \
         439                 :            :     {"divmod", _PyCFunction_CAST(builtin_divmod), METH_FASTCALL, builtin_divmod__doc__},
         440                 :            :
         441                 :            : static PyObject *
         442                 :            : builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y);
         443                 :            :
         444                 :            : static PyObject *
         445                 :        148 : builtin_divmod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         446                 :            : {
         447                 :        148 :     PyObject *return_value = NULL;
         448                 :            :     PyObject *x;
         449                 :            :     PyObject *y;
         450                 :            :
         451   [ +  -  -  +  :        148 :     if (!_PyArg_CheckPositional("divmod", nargs, 2, 2)) {
                       -  - ]
         452                 :          0 :         goto exit;
         453                 :            :     }
         454                 :        148 :     x = args[0];
         455                 :        148 :     y = args[1];
         456                 :        148 :     return_value = builtin_divmod_impl(module, x, y);
         457                 :            :
         458                 :        148 : exit:
         459                 :        148 :     return return_value;
         460                 :            : }
         461                 :            :
         462                 :            : PyDoc_STRVAR(builtin_eval__doc__,
         463                 :            : "eval($module, source, globals=None, locals=None, /)\n"
         464                 :            : "--\n"
         465                 :            : "\n"
         466                 :            : "Evaluate the given source in the context of globals and locals.\n"
         467                 :            : "\n"
         468                 :            : "The source may be a string representing a Python expression\n"
         469                 :            : "or a code object as returned by compile().\n"
         470                 :            : "The globals must be a dictionary and locals can be any mapping,\n"
         471                 :            : "defaulting to the current globals and locals.\n"
         472                 :            : "If only globals is given, locals defaults to it.");
         473                 :            :
         474                 :            : #define BUILTIN_EVAL_METHODDEF    \
         475                 :            :     {"eval", _PyCFunction_CAST(builtin_eval), METH_FASTCALL, builtin_eval__doc__},
         476                 :            :
         477                 :            : static PyObject *
         478                 :            : builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
         479                 :            :                   PyObject *locals);
         480                 :            :
         481                 :            : static PyObject *
         482                 :         57 : builtin_eval(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         483                 :            : {
         484                 :         57 :     PyObject *return_value = NULL;
         485                 :            :     PyObject *source;
         486                 :         57 :     PyObject *globals = Py_None;
         487                 :         57 :     PyObject *locals = Py_None;
         488                 :            :
         489   [ +  -  -  +  :         57 :     if (!_PyArg_CheckPositional("eval", nargs, 1, 3)) {
                       -  - ]
         490                 :          0 :         goto exit;
         491                 :            :     }
         492                 :         57 :     source = args[0];
         493         [ -  + ]:         57 :     if (nargs < 2) {
         494                 :          0 :         goto skip_optional;
         495                 :            :     }
         496                 :         57 :     globals = args[1];
         497         [ +  - ]:         57 :     if (nargs < 3) {
         498                 :         57 :         goto skip_optional;
         499                 :            :     }
         500                 :          0 :     locals = args[2];
         501                 :         57 : skip_optional:
         502                 :         57 :     return_value = builtin_eval_impl(module, source, globals, locals);
         503                 :            :
         504                 :         57 : exit:
         505                 :         57 :     return return_value;
         506                 :            : }
         507                 :            :
         508                 :            : PyDoc_STRVAR(builtin_exec__doc__,
         509                 :            : "exec($module, source, globals=None, locals=None, /, *, closure=None)\n"
         510                 :            : "--\n"
         511                 :            : "\n"
         512                 :            : "Execute the given source in the context of globals and locals.\n"
         513                 :            : "\n"
         514                 :            : "The source may be a string representing one or more Python statements\n"
         515                 :            : "or a code object as returned by compile().\n"
         516                 :            : "The globals must be a dictionary and locals can be any mapping,\n"
         517                 :            : "defaulting to the current globals and locals.\n"
         518                 :            : "If only globals is given, locals defaults to it.\n"
         519                 :            : "The closure must be a tuple of cellvars, and can only be used\n"
         520                 :            : "when source is a code object requiring exactly that many cellvars.");
         521                 :            :
         522                 :            : #define BUILTIN_EXEC_METHODDEF    \
         523                 :            :     {"exec", _PyCFunction_CAST(builtin_exec), METH_FASTCALL|METH_KEYWORDS, builtin_exec__doc__},
         524                 :            :
         525                 :            : static PyObject *
         526                 :            : builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
         527                 :            :                   PyObject *locals, PyObject *closure);
         528                 :            :
         529                 :            : static PyObject *
         530                 :        698 : builtin_exec(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         531                 :            : {
         532                 :        698 :     PyObject *return_value = NULL;
         533                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         534                 :            :
         535                 :            :     #define NUM_KEYWORDS 1
         536                 :            :     static struct {
         537                 :            :         PyGC_Head _this_is_not_used;
         538                 :            :         PyObject_VAR_HEAD
         539                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         540                 :            :     } _kwtuple = {
         541                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         542                 :            :         .ob_item = { &_Py_ID(closure), },
         543                 :            :     };
         544                 :            :     #undef NUM_KEYWORDS
         545                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         546                 :            :
         547                 :            :     #else  // !Py_BUILD_CORE
         548                 :            :     #  define KWTUPLE NULL
         549                 :            :     #endif  // !Py_BUILD_CORE
         550                 :            :
         551                 :            :     static const char * const _keywords[] = {"", "", "", "closure", NULL};
         552                 :            :     static _PyArg_Parser _parser = {
         553                 :            :         .keywords = _keywords,
         554                 :            :         .fname = "exec",
         555                 :            :         .kwtuple = KWTUPLE,
         556                 :            :     };
         557                 :            :     #undef KWTUPLE
         558                 :            :     PyObject *argsbuf[4];
         559         [ -  + ]:        698 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
         560                 :            :     PyObject *source;
         561                 :        698 :     PyObject *globals = Py_None;
         562                 :        698 :     PyObject *locals = Py_None;
         563                 :        698 :     PyObject *closure = NULL;
         564                 :            :
         565   [ +  -  +  -  :        698 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
                 +  -  -  + ]
         566         [ -  + ]:        698 :     if (!args) {
         567                 :          0 :         goto exit;
         568                 :            :     }
         569                 :        698 :     source = args[0];
         570         [ -  + ]:        698 :     if (nargs < 2) {
         571                 :          0 :         goto skip_optional_posonly;
         572                 :            :     }
         573                 :        698 :     noptargs--;
         574                 :        698 :     globals = args[1];
         575         [ +  - ]:        698 :     if (nargs < 3) {
         576                 :        698 :         goto skip_optional_posonly;
         577                 :            :     }
         578                 :          0 :     noptargs--;
         579                 :          0 :     locals = args[2];
         580                 :        698 : skip_optional_posonly:
         581         [ +  - ]:        698 :     if (!noptargs) {
         582                 :        698 :         goto skip_optional_kwonly;
         583                 :            :     }
         584                 :          0 :     closure = args[3];
         585                 :        698 : skip_optional_kwonly:
         586                 :        698 :     return_value = builtin_exec_impl(module, source, globals, locals, closure);
         587                 :            :
         588                 :        698 : exit:
         589                 :        698 :     return return_value;
         590                 :            : }
         591                 :            :
         592                 :            : PyDoc_STRVAR(builtin_getattr__doc__,
         593                 :            : "getattr($module, object, name, default=<unrepresentable>, /)\n"
         594                 :            : "--\n"
         595                 :            : "\n"
         596                 :            : "Get a named attribute from an object.\n"
         597                 :            : "\n"
         598                 :            : "getattr(x, \'y\') is equivalent to x.y\n"
         599                 :            : "When a default argument is given, it is returned when the attribute doesn\'t\n"
         600                 :            : "exist; without it, an exception is raised in that case.");
         601                 :            :
         602                 :            : #define BUILTIN_GETATTR_METHODDEF    \
         603                 :            :     {"getattr", _PyCFunction_CAST(builtin_getattr), METH_FASTCALL, builtin_getattr__doc__},
         604                 :            :
         605                 :            : static PyObject *
         606                 :            : builtin_getattr_impl(PyObject *module, PyObject *object, PyObject *name,
         607                 :            :                      PyObject *default_value);
         608                 :            :
         609                 :            : static PyObject *
         610                 :     130711 : builtin_getattr(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         611                 :            : {
         612                 :     130711 :     PyObject *return_value = NULL;
         613                 :            :     PyObject *object;
         614                 :            :     PyObject *name;
         615                 :     130711 :     PyObject *default_value = NULL;
         616                 :            :
         617   [ +  -  -  +  :     130711 :     if (!_PyArg_CheckPositional("getattr", nargs, 2, 3)) {
                       -  - ]
         618                 :          0 :         goto exit;
         619                 :            :     }
         620                 :     130711 :     object = args[0];
         621                 :     130711 :     name = args[1];
         622         [ +  + ]:     130711 :     if (nargs < 3) {
         623                 :      23849 :         goto skip_optional;
         624                 :            :     }
         625                 :     106862 :     default_value = args[2];
         626                 :     130711 : skip_optional:
         627                 :     130711 :     return_value = builtin_getattr_impl(module, object, name, default_value);
         628                 :            :
         629                 :     130711 : exit:
         630                 :     130711 :     return return_value;
         631                 :            : }
         632                 :            :
         633                 :            : PyDoc_STRVAR(builtin_globals__doc__,
         634                 :            : "globals($module, /)\n"
         635                 :            : "--\n"
         636                 :            : "\n"
         637                 :            : "Return the dictionary containing the current scope\'s global variables.\n"
         638                 :            : "\n"
         639                 :            : "NOTE: Updates to this dictionary *will* affect name lookups in the current\n"
         640                 :            : "global scope and vice-versa.");
         641                 :            :
         642                 :            : #define BUILTIN_GLOBALS_METHODDEF    \
         643                 :            :     {"globals", (PyCFunction)builtin_globals, METH_NOARGS, builtin_globals__doc__},
         644                 :            :
         645                 :            : static PyObject *
         646                 :            : builtin_globals_impl(PyObject *module);
         647                 :            :
         648                 :            : static PyObject *
         649                 :        322 : builtin_globals(PyObject *module, PyObject *Py_UNUSED(ignored))
         650                 :            : {
         651                 :        322 :     return builtin_globals_impl(module);
         652                 :            : }
         653                 :            :
         654                 :            : PyDoc_STRVAR(builtin_hasattr__doc__,
         655                 :            : "hasattr($module, obj, name, /)\n"
         656                 :            : "--\n"
         657                 :            : "\n"
         658                 :            : "Return whether the object has an attribute with the given name.\n"
         659                 :            : "\n"
         660                 :            : "This is done by calling getattr(obj, name) and catching AttributeError.");
         661                 :            :
         662                 :            : #define BUILTIN_HASATTR_METHODDEF    \
         663                 :            :     {"hasattr", _PyCFunction_CAST(builtin_hasattr), METH_FASTCALL, builtin_hasattr__doc__},
         664                 :            :
         665                 :            : static PyObject *
         666                 :            : builtin_hasattr_impl(PyObject *module, PyObject *obj, PyObject *name);
         667                 :            :
         668                 :            : static PyObject *
         669                 :       6976 : builtin_hasattr(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         670                 :            : {
         671                 :       6976 :     PyObject *return_value = NULL;
         672                 :            :     PyObject *obj;
         673                 :            :     PyObject *name;
         674                 :            :
         675   [ +  -  -  +  :       6976 :     if (!_PyArg_CheckPositional("hasattr", nargs, 2, 2)) {
                       -  - ]
         676                 :          0 :         goto exit;
         677                 :            :     }
         678                 :       6976 :     obj = args[0];
         679                 :       6976 :     name = args[1];
         680                 :       6976 :     return_value = builtin_hasattr_impl(module, obj, name);
         681                 :            :
         682                 :       6976 : exit:
         683                 :       6976 :     return return_value;
         684                 :            : }
         685                 :            :
         686                 :            : PyDoc_STRVAR(builtin_id__doc__,
         687                 :            : "id($module, obj, /)\n"
         688                 :            : "--\n"
         689                 :            : "\n"
         690                 :            : "Return the identity of an object.\n"
         691                 :            : "\n"
         692                 :            : "This is guaranteed to be unique among simultaneously existing objects.\n"
         693                 :            : "(CPython uses the object\'s memory address.)");
         694                 :            :
         695                 :            : #define BUILTIN_ID_METHODDEF    \
         696                 :            :     {"id", (PyCFunction)builtin_id, METH_O, builtin_id__doc__},
         697                 :            :
         698                 :            : PyDoc_STRVAR(builtin_next__doc__,
         699                 :            : "next($module, iterator, default=<unrepresentable>, /)\n"
         700                 :            : "--\n"
         701                 :            : "\n"
         702                 :            : "Return the next item from the iterator.\n"
         703                 :            : "\n"
         704                 :            : "If default is given and the iterator is exhausted,\n"
         705                 :            : "it is returned instead of raising StopIteration.");
         706                 :            :
         707                 :            : #define BUILTIN_NEXT_METHODDEF    \
         708                 :            :     {"next", _PyCFunction_CAST(builtin_next), METH_FASTCALL, builtin_next__doc__},
         709                 :            :
         710                 :            : static PyObject *
         711                 :            : builtin_next_impl(PyObject *module, PyObject *iterator,
         712                 :            :                   PyObject *default_value);
         713                 :            :
         714                 :            : static PyObject *
         715                 :     196835 : builtin_next(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         716                 :            : {
         717                 :     196835 :     PyObject *return_value = NULL;
         718                 :            :     PyObject *iterator;
         719                 :     196835 :     PyObject *default_value = NULL;
         720                 :            :
         721   [ +  -  -  +  :     196835 :     if (!_PyArg_CheckPositional("next", nargs, 1, 2)) {
                       -  - ]
         722                 :          0 :         goto exit;
         723                 :            :     }
         724                 :     196835 :     iterator = args[0];
         725         [ +  - ]:     196835 :     if (nargs < 2) {
         726                 :     196835 :         goto skip_optional;
         727                 :            :     }
         728                 :          0 :     default_value = args[1];
         729                 :     196835 : skip_optional:
         730                 :     196835 :     return_value = builtin_next_impl(module, iterator, default_value);
         731                 :            :
         732                 :     196835 : exit:
         733                 :     196835 :     return return_value;
         734                 :            : }
         735                 :            :
         736                 :            : PyDoc_STRVAR(builtin_setattr__doc__,
         737                 :            : "setattr($module, obj, name, value, /)\n"
         738                 :            : "--\n"
         739                 :            : "\n"
         740                 :            : "Sets the named attribute on the given object to the specified value.\n"
         741                 :            : "\n"
         742                 :            : "setattr(x, \'y\', v) is equivalent to ``x.y = v``");
         743                 :            :
         744                 :            : #define BUILTIN_SETATTR_METHODDEF    \
         745                 :            :     {"setattr", _PyCFunction_CAST(builtin_setattr), METH_FASTCALL, builtin_setattr__doc__},
         746                 :            :
         747                 :            : static PyObject *
         748                 :            : builtin_setattr_impl(PyObject *module, PyObject *obj, PyObject *name,
         749                 :            :                      PyObject *value);
         750                 :            :
         751                 :            : static PyObject *
         752                 :       2427 : builtin_setattr(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         753                 :            : {
         754                 :       2427 :     PyObject *return_value = NULL;
         755                 :            :     PyObject *obj;
         756                 :            :     PyObject *name;
         757                 :            :     PyObject *value;
         758                 :            :
         759   [ +  -  -  +  :       2427 :     if (!_PyArg_CheckPositional("setattr", nargs, 3, 3)) {
                       -  - ]
         760                 :          0 :         goto exit;
         761                 :            :     }
         762                 :       2427 :     obj = args[0];
         763                 :       2427 :     name = args[1];
         764                 :       2427 :     value = args[2];
         765                 :       2427 :     return_value = builtin_setattr_impl(module, obj, name, value);
         766                 :            :
         767                 :       2427 : exit:
         768                 :       2427 :     return return_value;
         769                 :            : }
         770                 :            :
         771                 :            : PyDoc_STRVAR(builtin_delattr__doc__,
         772                 :            : "delattr($module, obj, name, /)\n"
         773                 :            : "--\n"
         774                 :            : "\n"
         775                 :            : "Deletes the named attribute from the given object.\n"
         776                 :            : "\n"
         777                 :            : "delattr(x, \'y\') is equivalent to ``del x.y``");
         778                 :            :
         779                 :            : #define BUILTIN_DELATTR_METHODDEF    \
         780                 :            :     {"delattr", _PyCFunction_CAST(builtin_delattr), METH_FASTCALL, builtin_delattr__doc__},
         781                 :            :
         782                 :            : static PyObject *
         783                 :            : builtin_delattr_impl(PyObject *module, PyObject *obj, PyObject *name);
         784                 :            :
         785                 :            : static PyObject *
         786                 :        187 : builtin_delattr(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         787                 :            : {
         788                 :        187 :     PyObject *return_value = NULL;
         789                 :            :     PyObject *obj;
         790                 :            :     PyObject *name;
         791                 :            :
         792   [ +  -  -  +  :        187 :     if (!_PyArg_CheckPositional("delattr", nargs, 2, 2)) {
                       -  - ]
         793                 :          0 :         goto exit;
         794                 :            :     }
         795                 :        187 :     obj = args[0];
         796                 :        187 :     name = args[1];
         797                 :        187 :     return_value = builtin_delattr_impl(module, obj, name);
         798                 :            :
         799                 :        187 : exit:
         800                 :        187 :     return return_value;
         801                 :            : }
         802                 :            :
         803                 :            : PyDoc_STRVAR(builtin_hash__doc__,
         804                 :            : "hash($module, obj, /)\n"
         805                 :            : "--\n"
         806                 :            : "\n"
         807                 :            : "Return the hash value for the given object.\n"
         808                 :            : "\n"
         809                 :            : "Two objects that compare equal must also have the same hash value, but the\n"
         810                 :            : "reverse is not necessarily true.");
         811                 :            :
         812                 :            : #define BUILTIN_HASH_METHODDEF    \
         813                 :            :     {"hash", (PyCFunction)builtin_hash, METH_O, builtin_hash__doc__},
         814                 :            :
         815                 :            : PyDoc_STRVAR(builtin_hex__doc__,
         816                 :            : "hex($module, number, /)\n"
         817                 :            : "--\n"
         818                 :            : "\n"
         819                 :            : "Return the hexadecimal representation of an integer.\n"
         820                 :            : "\n"
         821                 :            : "   >>> hex(12648430)\n"
         822                 :            : "   \'0xc0ffee\'");
         823                 :            :
         824                 :            : #define BUILTIN_HEX_METHODDEF    \
         825                 :            :     {"hex", (PyCFunction)builtin_hex, METH_O, builtin_hex__doc__},
         826                 :            :
         827                 :            : PyDoc_STRVAR(builtin_iter__doc__,
         828                 :            : "iter($module, object, sentinel=<unrepresentable>, /)\n"
         829                 :            : "--\n"
         830                 :            : "\n"
         831                 :            : "Get an iterator from an object.\n"
         832                 :            : "\n"
         833                 :            : "In the first form, the argument must supply its own iterator, or be a sequence.\n"
         834                 :            : "In the second form, the callable is called until it returns the sentinel.");
         835                 :            :
         836                 :            : #define BUILTIN_ITER_METHODDEF    \
         837                 :            :     {"iter", _PyCFunction_CAST(builtin_iter), METH_FASTCALL, builtin_iter__doc__},
         838                 :            :
         839                 :            : static PyObject *
         840                 :            : builtin_iter_impl(PyObject *module, PyObject *object, PyObject *sentinel);
         841                 :            :
         842                 :            : static PyObject *
         843                 :        428 : builtin_iter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         844                 :            : {
         845                 :        428 :     PyObject *return_value = NULL;
         846                 :            :     PyObject *object;
         847                 :        428 :     PyObject *sentinel = NULL;
         848                 :            :
         849   [ +  -  -  +  :        428 :     if (!_PyArg_CheckPositional("iter", nargs, 1, 2)) {
                       -  - ]
         850                 :          0 :         goto exit;
         851                 :            :     }
         852                 :        428 :     object = args[0];
         853         [ +  - ]:        428 :     if (nargs < 2) {
         854                 :        428 :         goto skip_optional;
         855                 :            :     }
         856                 :          0 :     sentinel = args[1];
         857                 :        428 : skip_optional:
         858                 :        428 :     return_value = builtin_iter_impl(module, object, sentinel);
         859                 :            :
         860                 :        428 : exit:
         861                 :        428 :     return return_value;
         862                 :            : }
         863                 :            :
         864                 :            : PyDoc_STRVAR(builtin_aiter__doc__,
         865                 :            : "aiter($module, async_iterable, /)\n"
         866                 :            : "--\n"
         867                 :            : "\n"
         868                 :            : "Return an AsyncIterator for an AsyncIterable object.");
         869                 :            :
         870                 :            : #define BUILTIN_AITER_METHODDEF    \
         871                 :            :     {"aiter", (PyCFunction)builtin_aiter, METH_O, builtin_aiter__doc__},
         872                 :            :
         873                 :            : PyDoc_STRVAR(builtin_anext__doc__,
         874                 :            : "anext($module, aiterator, default=<unrepresentable>, /)\n"
         875                 :            : "--\n"
         876                 :            : "\n"
         877                 :            : "async anext(aiterator[, default])\n"
         878                 :            : "\n"
         879                 :            : "Return the next item from the async iterator.  If default is given and the async\n"
         880                 :            : "iterator is exhausted, it is returned instead of raising StopAsyncIteration.");
         881                 :            :
         882                 :            : #define BUILTIN_ANEXT_METHODDEF    \
         883                 :            :     {"anext", _PyCFunction_CAST(builtin_anext), METH_FASTCALL, builtin_anext__doc__},
         884                 :            :
         885                 :            : static PyObject *
         886                 :            : builtin_anext_impl(PyObject *module, PyObject *aiterator,
         887                 :            :                    PyObject *default_value);
         888                 :            :
         889                 :            : static PyObject *
         890                 :          0 : builtin_anext(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         891                 :            : {
         892                 :          0 :     PyObject *return_value = NULL;
         893                 :            :     PyObject *aiterator;
         894                 :          0 :     PyObject *default_value = NULL;
         895                 :            :
         896   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("anext", nargs, 1, 2)) {
                       #  # ]
         897                 :          0 :         goto exit;
         898                 :            :     }
         899                 :          0 :     aiterator = args[0];
         900         [ #  # ]:          0 :     if (nargs < 2) {
         901                 :          0 :         goto skip_optional;
         902                 :            :     }
         903                 :          0 :     default_value = args[1];
         904                 :          0 : skip_optional:
         905                 :          0 :     return_value = builtin_anext_impl(module, aiterator, default_value);
         906                 :            :
         907                 :          0 : exit:
         908                 :          0 :     return return_value;
         909                 :            : }
         910                 :            :
         911                 :            : PyDoc_STRVAR(builtin_len__doc__,
         912                 :            : "len($module, obj, /)\n"
         913                 :            : "--\n"
         914                 :            : "\n"
         915                 :            : "Return the number of items in a container.");
         916                 :            :
         917                 :            : #define BUILTIN_LEN_METHODDEF    \
         918                 :            :     {"len", (PyCFunction)builtin_len, METH_O, builtin_len__doc__},
         919                 :            :
         920                 :            : PyDoc_STRVAR(builtin_locals__doc__,
         921                 :            : "locals($module, /)\n"
         922                 :            : "--\n"
         923                 :            : "\n"
         924                 :            : "Return a dictionary containing the current scope\'s local variables.\n"
         925                 :            : "\n"
         926                 :            : "NOTE: Whether or not updates to this dictionary will affect name lookups in\n"
         927                 :            : "the local scope and vice-versa is *implementation dependent* and not\n"
         928                 :            : "covered by any backwards compatibility guarantees.");
         929                 :            :
         930                 :            : #define BUILTIN_LOCALS_METHODDEF    \
         931                 :            :     {"locals", (PyCFunction)builtin_locals, METH_NOARGS, builtin_locals__doc__},
         932                 :            :
         933                 :            : static PyObject *
         934                 :            : builtin_locals_impl(PyObject *module);
         935                 :            :
         936                 :            : static PyObject *
         937                 :          2 : builtin_locals(PyObject *module, PyObject *Py_UNUSED(ignored))
         938                 :            : {
         939                 :          2 :     return builtin_locals_impl(module);
         940                 :            : }
         941                 :            :
         942                 :            : PyDoc_STRVAR(builtin_oct__doc__,
         943                 :            : "oct($module, number, /)\n"
         944                 :            : "--\n"
         945                 :            : "\n"
         946                 :            : "Return the octal representation of an integer.\n"
         947                 :            : "\n"
         948                 :            : "   >>> oct(342391)\n"
         949                 :            : "   \'0o1234567\'");
         950                 :            :
         951                 :            : #define BUILTIN_OCT_METHODDEF    \
         952                 :            :     {"oct", (PyCFunction)builtin_oct, METH_O, builtin_oct__doc__},
         953                 :            :
         954                 :            : PyDoc_STRVAR(builtin_ord__doc__,
         955                 :            : "ord($module, c, /)\n"
         956                 :            : "--\n"
         957                 :            : "\n"
         958                 :            : "Return the Unicode code point for a one-character string.");
         959                 :            :
         960                 :            : #define BUILTIN_ORD_METHODDEF    \
         961                 :            :     {"ord", (PyCFunction)builtin_ord, METH_O, builtin_ord__doc__},
         962                 :            :
         963                 :            : PyDoc_STRVAR(builtin_pow__doc__,
         964                 :            : "pow($module, /, base, exp, mod=None)\n"
         965                 :            : "--\n"
         966                 :            : "\n"
         967                 :            : "Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments\n"
         968                 :            : "\n"
         969                 :            : "Some types, such as ints, are able to use a more efficient algorithm when\n"
         970                 :            : "invoked using the three argument form.");
         971                 :            :
         972                 :            : #define BUILTIN_POW_METHODDEF    \
         973                 :            :     {"pow", _PyCFunction_CAST(builtin_pow), METH_FASTCALL|METH_KEYWORDS, builtin_pow__doc__},
         974                 :            :
         975                 :            : static PyObject *
         976                 :            : builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp,
         977                 :            :                  PyObject *mod);
         978                 :            :
         979                 :            : static PyObject *
         980                 :          0 : builtin_pow(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         981                 :            : {
         982                 :          0 :     PyObject *return_value = NULL;
         983                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         984                 :            :
         985                 :            :     #define NUM_KEYWORDS 3
         986                 :            :     static struct {
         987                 :            :         PyGC_Head _this_is_not_used;
         988                 :            :         PyObject_VAR_HEAD
         989                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         990                 :            :     } _kwtuple = {
         991                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         992                 :            :         .ob_item = { &_Py_ID(base), &_Py_ID(exp), &_Py_ID(mod), },
         993                 :            :     };
         994                 :            :     #undef NUM_KEYWORDS
         995                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         996                 :            :
         997                 :            :     #else  // !Py_BUILD_CORE
         998                 :            :     #  define KWTUPLE NULL
         999                 :            :     #endif  // !Py_BUILD_CORE
        1000                 :            :
        1001                 :            :     static const char * const _keywords[] = {"base", "exp", "mod", NULL};
        1002                 :            :     static _PyArg_Parser _parser = {
        1003                 :            :         .keywords = _keywords,
        1004                 :            :         .fname = "pow",
        1005                 :            :         .kwtuple = KWTUPLE,
        1006                 :            :     };
        1007                 :            :     #undef KWTUPLE
        1008                 :            :     PyObject *argsbuf[3];
        1009         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
        1010                 :            :     PyObject *base;
        1011                 :            :     PyObject *exp;
        1012                 :          0 :     PyObject *mod = Py_None;
        1013                 :            :
        1014   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
                 #  #  #  # ]
        1015         [ #  # ]:          0 :     if (!args) {
        1016                 :          0 :         goto exit;
        1017                 :            :     }
        1018                 :          0 :     base = args[0];
        1019                 :          0 :     exp = args[1];
        1020         [ #  # ]:          0 :     if (!noptargs) {
        1021                 :          0 :         goto skip_optional_pos;
        1022                 :            :     }
        1023                 :          0 :     mod = args[2];
        1024                 :          0 : skip_optional_pos:
        1025                 :          0 :     return_value = builtin_pow_impl(module, base, exp, mod);
        1026                 :            :
        1027                 :          0 : exit:
        1028                 :          0 :     return return_value;
        1029                 :            : }
        1030                 :            :
        1031                 :            : PyDoc_STRVAR(builtin_print__doc__,
        1032                 :            : "print($module, /, *args, sep=\' \', end=\'\\n\', file=None, flush=False)\n"
        1033                 :            : "--\n"
        1034                 :            : "\n"
        1035                 :            : "Prints the values to a stream, or to sys.stdout by default.\n"
        1036                 :            : "\n"
        1037                 :            : "  sep\n"
        1038                 :            : "    string inserted between values, default a space.\n"
        1039                 :            : "  end\n"
        1040                 :            : "    string appended after the last value, default a newline.\n"
        1041                 :            : "  file\n"
        1042                 :            : "    a file-like object (stream); defaults to the current sys.stdout.\n"
        1043                 :            : "  flush\n"
        1044                 :            : "    whether to forcibly flush the stream.");
        1045                 :            :
        1046                 :            : #define BUILTIN_PRINT_METHODDEF    \
        1047                 :            :     {"print", _PyCFunction_CAST(builtin_print), METH_FASTCALL|METH_KEYWORDS, builtin_print__doc__},
        1048                 :            :
        1049                 :            : static PyObject *
        1050                 :            : builtin_print_impl(PyObject *module, PyObject *args, PyObject *sep,
        1051                 :            :                    PyObject *end, PyObject *file, int flush);
        1052                 :            :
        1053                 :            : static PyObject *
        1054                 :         48 : builtin_print(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1055                 :            : {
        1056                 :         48 :     PyObject *return_value = NULL;
        1057                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1058                 :            :
        1059                 :            :     #define NUM_KEYWORDS 4
        1060                 :            :     static struct {
        1061                 :            :         PyGC_Head _this_is_not_used;
        1062                 :            :         PyObject_VAR_HEAD
        1063                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1064                 :            :     } _kwtuple = {
        1065                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1066                 :            :         .ob_item = { &_Py_ID(sep), &_Py_ID(end), &_Py_ID(file), &_Py_ID(flush), },
        1067                 :            :     };
        1068                 :            :     #undef NUM_KEYWORDS
        1069                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1070                 :            :
        1071                 :            :     #else  // !Py_BUILD_CORE
        1072                 :            :     #  define KWTUPLE NULL
        1073                 :            :     #endif  // !Py_BUILD_CORE
        1074                 :            :
        1075                 :            :     static const char * const _keywords[] = {"sep", "end", "file", "flush", NULL};
        1076                 :            :     static _PyArg_Parser _parser = {
        1077                 :            :         .keywords = _keywords,
        1078                 :            :         .fname = "print",
        1079                 :            :         .kwtuple = KWTUPLE,
        1080                 :            :     };
        1081                 :            :     #undef KWTUPLE
        1082                 :            :     PyObject *argsbuf[5];
        1083         [ +  + ]:         48 :     Py_ssize_t noptargs = 0 + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
        1084                 :         48 :     PyObject *__clinic_args = NULL;
        1085                 :         48 :     PyObject *sep = Py_None;
        1086                 :         48 :     PyObject *end = Py_None;
        1087                 :         48 :     PyObject *file = Py_None;
        1088                 :         48 :     int flush = 0;
        1089                 :            :
        1090                 :         48 :     args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, 0, argsbuf);
        1091         [ -  + ]:         48 :     if (!args) {
        1092                 :          0 :         goto exit;
        1093                 :            :     }
        1094                 :         48 :     __clinic_args = args[0];
        1095         [ +  + ]:         48 :     if (!noptargs) {
        1096                 :         10 :         goto skip_optional_kwonly;
        1097                 :            :     }
        1098         [ -  + ]:         38 :     if (args[1]) {
        1099                 :          0 :         sep = args[1];
        1100         [ #  # ]:          0 :         if (!--noptargs) {
        1101                 :          0 :             goto skip_optional_kwonly;
        1102                 :            :         }
        1103                 :            :     }
        1104         [ +  + ]:         38 :     if (args[2]) {
        1105                 :         36 :         end = args[2];
        1106         [ -  + ]:         36 :         if (!--noptargs) {
        1107                 :          0 :             goto skip_optional_kwonly;
        1108                 :            :         }
        1109                 :            :     }
        1110         [ +  + ]:         38 :     if (args[3]) {
        1111                 :         36 :         file = args[3];
        1112         [ +  - ]:         36 :         if (!--noptargs) {
        1113                 :         36 :             goto skip_optional_kwonly;
        1114                 :            :         }
        1115                 :            :     }
        1116                 :          2 :     flush = PyObject_IsTrue(args[4]);
        1117         [ -  + ]:          2 :     if (flush < 0) {
        1118                 :          0 :         goto exit;
        1119                 :            :     }
        1120                 :          2 : skip_optional_kwonly:
        1121                 :         48 :     return_value = builtin_print_impl(module, __clinic_args, sep, end, file, flush);
        1122                 :            :
        1123                 :         48 : exit:
        1124                 :         48 :     Py_XDECREF(__clinic_args);
        1125                 :         48 :     return return_value;
        1126                 :            : }
        1127                 :            :
        1128                 :            : PyDoc_STRVAR(builtin_input__doc__,
        1129                 :            : "input($module, prompt=\'\', /)\n"
        1130                 :            : "--\n"
        1131                 :            : "\n"
        1132                 :            : "Read a string from standard input.  The trailing newline is stripped.\n"
        1133                 :            : "\n"
        1134                 :            : "The prompt string, if given, is printed to standard output without a\n"
        1135                 :            : "trailing newline before reading input.\n"
        1136                 :            : "\n"
        1137                 :            : "If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.\n"
        1138                 :            : "On *nix systems, readline is used if available.");
        1139                 :            :
        1140                 :            : #define BUILTIN_INPUT_METHODDEF    \
        1141                 :            :     {"input", _PyCFunction_CAST(builtin_input), METH_FASTCALL, builtin_input__doc__},
        1142                 :            :
        1143                 :            : static PyObject *
        1144                 :            : builtin_input_impl(PyObject *module, PyObject *prompt);
        1145                 :            :
        1146                 :            : static PyObject *
        1147                 :          0 : builtin_input(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
        1148                 :            : {
        1149                 :          0 :     PyObject *return_value = NULL;
        1150                 :          0 :     PyObject *prompt = NULL;
        1151                 :            :
        1152   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("input", nargs, 0, 1)) {
                       #  # ]
        1153                 :          0 :         goto exit;
        1154                 :            :     }
        1155         [ #  # ]:          0 :     if (nargs < 1) {
        1156                 :          0 :         goto skip_optional;
        1157                 :            :     }
        1158                 :          0 :     prompt = args[0];
        1159                 :          0 : skip_optional:
        1160                 :          0 :     return_value = builtin_input_impl(module, prompt);
        1161                 :            :
        1162                 :          0 : exit:
        1163                 :          0 :     return return_value;
        1164                 :            : }
        1165                 :            :
        1166                 :            : PyDoc_STRVAR(builtin_repr__doc__,
        1167                 :            : "repr($module, obj, /)\n"
        1168                 :            : "--\n"
        1169                 :            : "\n"
        1170                 :            : "Return the canonical string representation of the object.\n"
        1171                 :            : "\n"
        1172                 :            : "For many object types, including most builtins, eval(repr(obj)) == obj.");
        1173                 :            :
        1174                 :            : #define BUILTIN_REPR_METHODDEF    \
        1175                 :            :     {"repr", (PyCFunction)builtin_repr, METH_O, builtin_repr__doc__},
        1176                 :            :
        1177                 :            : PyDoc_STRVAR(builtin_round__doc__,
        1178                 :            : "round($module, /, number, ndigits=None)\n"
        1179                 :            : "--\n"
        1180                 :            : "\n"
        1181                 :            : "Round a number to a given precision in decimal digits.\n"
        1182                 :            : "\n"
        1183                 :            : "The return value is an integer if ndigits is omitted or None.  Otherwise\n"
        1184                 :            : "the return value has the same type as the number.  ndigits may be negative.");
        1185                 :            :
        1186                 :            : #define BUILTIN_ROUND_METHODDEF    \
        1187                 :            :     {"round", _PyCFunction_CAST(builtin_round), METH_FASTCALL|METH_KEYWORDS, builtin_round__doc__},
        1188                 :            :
        1189                 :            : static PyObject *
        1190                 :            : builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits);
        1191                 :            :
        1192                 :            : static PyObject *
        1193                 :         18 : builtin_round(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1194                 :            : {
        1195                 :         18 :     PyObject *return_value = NULL;
        1196                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1197                 :            :
        1198                 :            :     #define NUM_KEYWORDS 2
        1199                 :            :     static struct {
        1200                 :            :         PyGC_Head _this_is_not_used;
        1201                 :            :         PyObject_VAR_HEAD
        1202                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1203                 :            :     } _kwtuple = {
        1204                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1205                 :            :         .ob_item = { &_Py_ID(number), &_Py_ID(ndigits), },
        1206                 :            :     };
        1207                 :            :     #undef NUM_KEYWORDS
        1208                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1209                 :            :
        1210                 :            :     #else  // !Py_BUILD_CORE
        1211                 :            :     #  define KWTUPLE NULL
        1212                 :            :     #endif  // !Py_BUILD_CORE
        1213                 :            :
        1214                 :            :     static const char * const _keywords[] = {"number", "ndigits", NULL};
        1215                 :            :     static _PyArg_Parser _parser = {
        1216                 :            :         .keywords = _keywords,
        1217                 :            :         .fname = "round",
        1218                 :            :         .kwtuple = KWTUPLE,
        1219                 :            :     };
        1220                 :            :     #undef KWTUPLE
        1221                 :            :     PyObject *argsbuf[2];
        1222         [ -  + ]:         18 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
        1223                 :            :     PyObject *number;
        1224                 :         18 :     PyObject *ndigits = Py_None;
        1225                 :            :
        1226   [ +  -  +  -  :         18 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
                 +  -  -  + ]
        1227         [ -  + ]:         18 :     if (!args) {
        1228                 :          0 :         goto exit;
        1229                 :            :     }
        1230                 :         18 :     number = args[0];
        1231         [ +  + ]:         18 :     if (!noptargs) {
        1232                 :         12 :         goto skip_optional_pos;
        1233                 :            :     }
        1234                 :          6 :     ndigits = args[1];
        1235                 :         18 : skip_optional_pos:
        1236                 :         18 :     return_value = builtin_round_impl(module, number, ndigits);
        1237                 :            :
        1238                 :         18 : exit:
        1239                 :         18 :     return return_value;
        1240                 :            : }
        1241                 :            :
        1242                 :            : PyDoc_STRVAR(builtin_vars__doc__,
        1243                 :            : "vars($module, object=<unrepresentable>, /)\n"
        1244                 :            : "--\n"
        1245                 :            : "\n"
        1246                 :            : "Show vars.\n"
        1247                 :            : "\n"
        1248                 :            : "Without arguments, equivalent to locals().\n"
        1249                 :            : "With an argument, equivalent to object.__dict__.");
        1250                 :            :
        1251                 :            : #define BUILTIN_VARS_METHODDEF    \
        1252                 :            :     {"vars", _PyCFunction_CAST(builtin_vars), METH_FASTCALL, builtin_vars__doc__},
        1253                 :            :
        1254                 :            : static PyObject *
        1255                 :            : builtin_vars_impl(PyObject *module, PyObject *object);
        1256                 :            :
        1257                 :            : static PyObject *
        1258                 :         25 : builtin_vars(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
        1259                 :            : {
        1260                 :         25 :     PyObject *return_value = NULL;
        1261                 :         25 :     PyObject *object = NULL;
        1262                 :            :
        1263   [ +  -  -  +  :         25 :     if (!_PyArg_CheckPositional("vars", nargs, 0, 1)) {
                       -  - ]
        1264                 :          0 :         goto exit;
        1265                 :            :     }
        1266         [ -  + ]:         25 :     if (nargs < 1) {
        1267                 :          0 :         goto skip_optional;
        1268                 :            :     }
        1269                 :         25 :     object = args[0];
        1270                 :         25 : skip_optional:
        1271                 :         25 :     return_value = builtin_vars_impl(module, object);
        1272                 :            :
        1273                 :         25 : exit:
        1274                 :         25 :     return return_value;
        1275                 :            : }
        1276                 :            :
        1277                 :            : PyDoc_STRVAR(builtin_sum__doc__,
        1278                 :            : "sum($module, iterable, /, start=0)\n"
        1279                 :            : "--\n"
        1280                 :            : "\n"
        1281                 :            : "Return the sum of a \'start\' value (default: 0) plus an iterable of numbers\n"
        1282                 :            : "\n"
        1283                 :            : "When the iterable is empty, return the start value.\n"
        1284                 :            : "This function is intended specifically for use with numeric values and may\n"
        1285                 :            : "reject non-numeric types.");
        1286                 :            :
        1287                 :            : #define BUILTIN_SUM_METHODDEF    \
        1288                 :            :     {"sum", _PyCFunction_CAST(builtin_sum), METH_FASTCALL|METH_KEYWORDS, builtin_sum__doc__},
        1289                 :            :
        1290                 :            : static PyObject *
        1291                 :            : builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start);
        1292                 :            :
        1293                 :            : static PyObject *
        1294                 :        835 : builtin_sum(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1295                 :            : {
        1296                 :        835 :     PyObject *return_value = NULL;
        1297                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1298                 :            :
        1299                 :            :     #define NUM_KEYWORDS 1
        1300                 :            :     static struct {
        1301                 :            :         PyGC_Head _this_is_not_used;
        1302                 :            :         PyObject_VAR_HEAD
        1303                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1304                 :            :     } _kwtuple = {
        1305                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1306                 :            :         .ob_item = { &_Py_ID(start), },
        1307                 :            :     };
        1308                 :            :     #undef NUM_KEYWORDS
        1309                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1310                 :            :
        1311                 :            :     #else  // !Py_BUILD_CORE
        1312                 :            :     #  define KWTUPLE NULL
        1313                 :            :     #endif  // !Py_BUILD_CORE
        1314                 :            :
        1315                 :            :     static const char * const _keywords[] = {"", "start", NULL};
        1316                 :            :     static _PyArg_Parser _parser = {
        1317                 :            :         .keywords = _keywords,
        1318                 :            :         .fname = "sum",
        1319                 :            :         .kwtuple = KWTUPLE,
        1320                 :            :     };
        1321                 :            :     #undef KWTUPLE
        1322                 :            :     PyObject *argsbuf[2];
        1323         [ -  + ]:        835 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
        1324                 :            :     PyObject *iterable;
        1325                 :        835 :     PyObject *start = NULL;
        1326                 :            :
        1327   [ +  -  +  -  :        835 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
                 +  -  -  + ]
        1328         [ -  + ]:        835 :     if (!args) {
        1329                 :          0 :         goto exit;
        1330                 :            :     }
        1331                 :        835 :     iterable = args[0];
        1332         [ +  - ]:        835 :     if (!noptargs) {
        1333                 :        835 :         goto skip_optional_pos;
        1334                 :            :     }
        1335                 :          0 :     start = args[1];
        1336                 :        835 : skip_optional_pos:
        1337                 :        835 :     return_value = builtin_sum_impl(module, iterable, start);
        1338                 :            :
        1339                 :        835 : exit:
        1340                 :        835 :     return return_value;
        1341                 :            : }
        1342                 :            :
        1343                 :            : PyDoc_STRVAR(builtin_isinstance__doc__,
        1344                 :            : "isinstance($module, obj, class_or_tuple, /)\n"
        1345                 :            : "--\n"
        1346                 :            : "\n"
        1347                 :            : "Return whether an object is an instance of a class or of a subclass thereof.\n"
        1348                 :            : "\n"
        1349                 :            : "A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\n"
        1350                 :            : "check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\n"
        1351                 :            : "or ...`` etc.");
        1352                 :            :
        1353                 :            : #define BUILTIN_ISINSTANCE_METHODDEF    \
        1354                 :            :     {"isinstance", _PyCFunction_CAST(builtin_isinstance), METH_FASTCALL, builtin_isinstance__doc__},
        1355                 :            :
        1356                 :            : static PyObject *
        1357                 :            : builtin_isinstance_impl(PyObject *module, PyObject *obj,
        1358                 :            :                         PyObject *class_or_tuple);
        1359                 :            :
        1360                 :            : static PyObject *
        1361                 :        595 : builtin_isinstance(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
        1362                 :            : {
        1363                 :        595 :     PyObject *return_value = NULL;
        1364                 :            :     PyObject *obj;
        1365                 :            :     PyObject *class_or_tuple;
        1366                 :            :
        1367   [ +  -  -  +  :        595 :     if (!_PyArg_CheckPositional("isinstance", nargs, 2, 2)) {
                       -  - ]
        1368                 :          0 :         goto exit;
        1369                 :            :     }
        1370                 :        595 :     obj = args[0];
        1371                 :        595 :     class_or_tuple = args[1];
        1372                 :        595 :     return_value = builtin_isinstance_impl(module, obj, class_or_tuple);
        1373                 :            :
        1374                 :        595 : exit:
        1375                 :        595 :     return return_value;
        1376                 :            : }
        1377                 :            :
        1378                 :            : PyDoc_STRVAR(builtin_issubclass__doc__,
        1379                 :            : "issubclass($module, cls, class_or_tuple, /)\n"
        1380                 :            : "--\n"
        1381                 :            : "\n"
        1382                 :            : "Return whether \'cls\' is derived from another class or is the same class.\n"
        1383                 :            : "\n"
        1384                 :            : "A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\n"
        1385                 :            : "check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\n"
        1386                 :            : "or ...``.");
        1387                 :            :
        1388                 :            : #define BUILTIN_ISSUBCLASS_METHODDEF    \
        1389                 :            :     {"issubclass", _PyCFunction_CAST(builtin_issubclass), METH_FASTCALL, builtin_issubclass__doc__},
        1390                 :            :
        1391                 :            : static PyObject *
        1392                 :            : builtin_issubclass_impl(PyObject *module, PyObject *cls,
        1393                 :            :                         PyObject *class_or_tuple);
        1394                 :            :
        1395                 :            : static PyObject *
        1396                 :       2274 : builtin_issubclass(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
        1397                 :            : {
        1398                 :       2274 :     PyObject *return_value = NULL;
        1399                 :            :     PyObject *cls;
        1400                 :            :     PyObject *class_or_tuple;
        1401                 :            :
        1402   [ +  -  -  +  :       2274 :     if (!_PyArg_CheckPositional("issubclass", nargs, 2, 2)) {
                       -  - ]
        1403                 :          0 :         goto exit;
        1404                 :            :     }
        1405                 :       2274 :     cls = args[0];
        1406                 :       2274 :     class_or_tuple = args[1];
        1407                 :       2274 :     return_value = builtin_issubclass_impl(module, cls, class_or_tuple);
        1408                 :            :
        1409                 :       2274 : exit:
        1410                 :       2274 :     return return_value;
        1411                 :            : }
        1412                 :            : /*[clinic end generated code: output=84a04e7446debf58 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14