LCOV - code coverage report
Current view: top level - Python - bltinmodule.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 629 1195 52.6 %
Date: 2023-03-20 08:15:36 Functions: 47 65 72.3 %
Branches: 331 834 39.7 %

           Branch data     Line data    Source code
       1                 :            : /* Built-in functions */
       2                 :            : 
       3                 :            : #include "Python.h"
       4                 :            : #include <ctype.h>
       5                 :            : #include "pycore_ast.h"           // _PyAST_Validate()
       6                 :            : #include "pycore_call.h"          // _PyObject_CallNoArgs()
       7                 :            : #include "pycore_compile.h"       // _PyAST_Compile()
       8                 :            : #include "pycore_object.h"        // _Py_AddToAllObjects()
       9                 :            : #include "pycore_pyerrors.h"      // _PyErr_NoMemory()
      10                 :            : #include "pycore_pystate.h"       // _PyThreadState_GET()
      11                 :            : #include "pycore_tuple.h"         // _PyTuple_FromArray()
      12                 :            : #include "pycore_ceval.h"         // _PyEval_Vector()
      13                 :            : 
      14                 :            : #include "clinic/bltinmodule.c.h"
      15                 :            : 
      16                 :            : static PyObject*
      17                 :       3141 : update_bases(PyObject *bases, PyObject *const *args, Py_ssize_t nargs)
      18                 :            : {
      19                 :            :     Py_ssize_t i, j;
      20                 :       3141 :     PyObject *base, *meth, *new_base, *result, *new_bases = NULL;
      21                 :            :     assert(PyTuple_Check(bases));
      22                 :            : 
      23         [ +  + ]:       5779 :     for (i = 0; i < nargs; i++) {
      24                 :       2638 :         base  = args[i];
      25         [ +  + ]:       2638 :         if (PyType_Check(base)) {
      26         [ -  + ]:       2623 :             if (new_bases) {
      27                 :            :                 /* If we already have made a replacement, then we append every normal base,
      28                 :            :                    otherwise just skip it. */
      29         [ #  # ]:          0 :                 if (PyList_Append(new_bases, base) < 0) {
      30                 :          0 :                     goto error;
      31                 :            :                 }
      32                 :            :             }
      33                 :       2623 :             continue;
      34                 :            :         }
      35         [ -  + ]:         15 :         if (_PyObject_LookupAttr(base, &_Py_ID(__mro_entries__), &meth) < 0) {
      36                 :          0 :             goto error;
      37                 :            :         }
      38         [ -  + ]:         15 :         if (!meth) {
      39         [ #  # ]:          0 :             if (new_bases) {
      40         [ #  # ]:          0 :                 if (PyList_Append(new_bases, base) < 0) {
      41                 :          0 :                     goto error;
      42                 :            :                 }
      43                 :            :             }
      44                 :          0 :             continue;
      45                 :            :         }
      46                 :         15 :         new_base = PyObject_CallOneArg(meth, bases);
      47                 :         15 :         Py_DECREF(meth);
      48         [ -  + ]:         15 :         if (!new_base) {
      49                 :          0 :             goto error;
      50                 :            :         }
      51         [ -  + ]:         15 :         if (!PyTuple_Check(new_base)) {
      52                 :          0 :             PyErr_SetString(PyExc_TypeError,
      53                 :            :                             "__mro_entries__ must return a tuple");
      54                 :          0 :             Py_DECREF(new_base);
      55                 :          0 :             goto error;
      56                 :            :         }
      57         [ +  - ]:         15 :         if (!new_bases) {
      58                 :            :             /* If this is a first successful replacement, create new_bases list and
      59                 :            :                copy previously encountered bases. */
      60         [ -  + ]:         15 :             if (!(new_bases = PyList_New(i))) {
      61                 :          0 :                 Py_DECREF(new_base);
      62                 :          0 :                 goto error;
      63                 :            :             }
      64         [ -  + ]:         15 :             for (j = 0; j < i; j++) {
      65                 :          0 :                 base = args[j];
      66                 :          0 :                 PyList_SET_ITEM(new_bases, j, Py_NewRef(base));
      67                 :            :             }
      68                 :            :         }
      69                 :         15 :         j = PyList_GET_SIZE(new_bases);
      70         [ -  + ]:         15 :         if (PyList_SetSlice(new_bases, j, j, new_base) < 0) {
      71                 :          0 :             Py_DECREF(new_base);
      72                 :          0 :             goto error;
      73                 :            :         }
      74                 :         15 :         Py_DECREF(new_base);
      75                 :            :     }
      76         [ +  + ]:       3141 :     if (!new_bases) {
      77                 :       3126 :         return bases;
      78                 :            :     }
      79                 :         15 :     result = PyList_AsTuple(new_bases);
      80                 :         15 :     Py_DECREF(new_bases);
      81                 :         15 :     return result;
      82                 :            : 
      83                 :          0 : error:
      84                 :          0 :     Py_XDECREF(new_bases);
      85                 :          0 :     return NULL;
      86                 :            : }
      87                 :            : 
      88                 :            : /* AC: cannot convert yet, waiting for *args support */
      89                 :            : static PyObject *
      90                 :       3141 : builtin___build_class__(PyObject *self, PyObject *const *args, Py_ssize_t nargs,
      91                 :            :                         PyObject *kwnames)
      92                 :            : {
      93                 :            :     PyObject *func, *name, *winner, *prep;
      94                 :       3141 :     PyObject *cls = NULL, *cell = NULL, *ns = NULL, *meta = NULL, *orig_bases = NULL;
      95                 :       3141 :     PyObject *mkw = NULL, *bases = NULL;
      96                 :       3141 :     int isclass = 0;   /* initialize to prevent gcc warning */
      97                 :            : 
      98         [ -  + ]:       3141 :     if (nargs < 2) {
      99                 :          0 :         PyErr_SetString(PyExc_TypeError,
     100                 :            :                         "__build_class__: not enough arguments");
     101                 :          0 :         return NULL;
     102                 :            :     }
     103                 :       3141 :     func = args[0];   /* Better be callable */
     104         [ -  + ]:       3141 :     if (!PyFunction_Check(func)) {
     105                 :          0 :         PyErr_SetString(PyExc_TypeError,
     106                 :            :                         "__build_class__: func must be a function");
     107                 :          0 :         return NULL;
     108                 :            :     }
     109                 :       3141 :     name = args[1];
     110         [ -  + ]:       3141 :     if (!PyUnicode_Check(name)) {
     111                 :          0 :         PyErr_SetString(PyExc_TypeError,
     112                 :            :                         "__build_class__: name is not a string");
     113                 :          0 :         return NULL;
     114                 :            :     }
     115                 :       3141 :     orig_bases = _PyTuple_FromArray(args + 2, nargs - 2);
     116         [ -  + ]:       3141 :     if (orig_bases == NULL)
     117                 :          0 :         return NULL;
     118                 :            : 
     119                 :       3141 :     bases = update_bases(orig_bases, args + 2, nargs - 2);
     120         [ -  + ]:       3141 :     if (bases == NULL) {
     121                 :          0 :         Py_DECREF(orig_bases);
     122                 :          0 :         return NULL;
     123                 :            :     }
     124                 :            : 
     125         [ +  + ]:       3141 :     if (kwnames == NULL) {
     126                 :       2807 :         meta = NULL;
     127                 :       2807 :         mkw = NULL;
     128                 :            :     }
     129                 :            :     else {
     130                 :        334 :         mkw = _PyStack_AsDict(args + nargs, kwnames);
     131         [ -  + ]:        334 :         if (mkw == NULL) {
     132                 :          0 :             goto error;
     133                 :            :         }
     134                 :            : 
     135                 :        334 :         meta = _PyDict_GetItemWithError(mkw, &_Py_ID(metaclass));
     136         [ +  + ]:        334 :         if (meta != NULL) {
     137                 :        269 :             Py_INCREF(meta);
     138         [ -  + ]:        269 :             if (PyDict_DelItem(mkw, &_Py_ID(metaclass)) < 0) {
     139                 :          0 :                 goto error;
     140                 :            :             }
     141                 :            :             /* metaclass is explicitly given, check if it's indeed a class */
     142                 :        269 :             isclass = PyType_Check(meta);
     143                 :            :         }
     144         [ -  + ]:         65 :         else if (PyErr_Occurred()) {
     145                 :          0 :             goto error;
     146                 :            :         }
     147                 :            :     }
     148         [ +  + ]:       3141 :     if (meta == NULL) {
     149                 :            :         /* if there are no bases, use type: */
     150         [ +  + ]:       2872 :         if (PyTuple_GET_SIZE(bases) == 0) {
     151                 :        789 :             meta = (PyObject *) (&PyType_Type);
     152                 :            :         }
     153                 :            :         /* else get the type of the first base */
     154                 :            :         else {
     155                 :       2083 :             PyObject *base0 = PyTuple_GET_ITEM(bases, 0);
     156                 :       2083 :             meta = (PyObject *)Py_TYPE(base0);
     157                 :            :         }
     158                 :       2872 :         Py_INCREF(meta);
     159                 :       2872 :         isclass = 1;  /* meta is really a class */
     160                 :            :     }
     161                 :            : 
     162         [ +  - ]:       3141 :     if (isclass) {
     163                 :            :         /* meta is really a class, so check for a more derived
     164                 :            :            metaclass, or possible metaclass conflicts: */
     165                 :       3141 :         winner = (PyObject *)_PyType_CalculateMetaclass((PyTypeObject *)meta,
     166                 :            :                                                         bases);
     167         [ -  + ]:       3141 :         if (winner == NULL) {
     168                 :          0 :             goto error;
     169                 :            :         }
     170         [ +  + ]:       3141 :         if (winner != meta) {
     171                 :        104 :             Py_SETREF(meta, Py_NewRef(winner));
     172                 :            :         }
     173                 :            :     }
     174                 :            :     /* else: meta is not a class, so we cannot do the metaclass
     175                 :            :        calculation, so we will use the explicitly given object as it is */
     176         [ -  + ]:       3141 :     if (_PyObject_LookupAttr(meta, &_Py_ID(__prepare__), &prep) < 0) {
     177                 :          0 :         ns = NULL;
     178                 :            :     }
     179         [ -  + ]:       3141 :     else if (prep == NULL) {
     180                 :          0 :         ns = PyDict_New();
     181                 :            :     }
     182                 :            :     else {
     183                 :       3141 :         PyObject *pargs[2] = {name, bases};
     184                 :       3141 :         ns = PyObject_VectorcallDict(prep, pargs, 2, mkw);
     185                 :       3141 :         Py_DECREF(prep);
     186                 :            :     }
     187         [ -  + ]:       3141 :     if (ns == NULL) {
     188                 :          0 :         goto error;
     189                 :            :     }
     190         [ -  + ]:       3141 :     if (!PyMapping_Check(ns)) {
     191         [ #  # ]:          0 :         PyErr_Format(PyExc_TypeError,
     192                 :            :                      "%.200s.__prepare__() must return a mapping, not %.200s",
     193                 :          0 :                      isclass ? ((PyTypeObject *)meta)->tp_name : "<metaclass>",
     194                 :          0 :                      Py_TYPE(ns)->tp_name);
     195                 :          0 :         goto error;
     196                 :            :     }
     197                 :       3141 :     PyThreadState *tstate = _PyThreadState_GET();
     198                 :            :     EVAL_CALL_STAT_INC(EVAL_CALL_BUILD_CLASS);
     199                 :       3141 :     cell = _PyEval_Vector(tstate, (PyFunctionObject *)func, ns, NULL, 0, NULL);
     200         [ -  + ]:       3141 :     if (cell != NULL) {
     201         [ +  + ]:       3141 :         if (bases != orig_bases) {
     202         [ -  + ]:         15 :             if (PyMapping_SetItemString(ns, "__orig_bases__", orig_bases) < 0) {
     203                 :          0 :                 goto error;
     204                 :            :             }
     205                 :            :         }
     206                 :       3141 :         PyObject *margs[3] = {name, bases, ns};
     207                 :       3141 :         cls = PyObject_VectorcallDict(meta, margs, 3, mkw);
     208   [ +  -  +  -  :       3141 :         if (cls != NULL && PyType_Check(cls) && PyCell_Check(cell)) {
                   +  + ]
     209                 :        327 :             PyObject *cell_cls = PyCell_GET(cell);
     210         [ -  + ]:        327 :             if (cell_cls != cls) {
     211         [ #  # ]:          0 :                 if (cell_cls == NULL) {
     212                 :          0 :                     const char *msg =
     213                 :            :                         "__class__ not set defining %.200R as %.200R. "
     214                 :            :                         "Was __classcell__ propagated to type.__new__?";
     215                 :          0 :                     PyErr_Format(PyExc_RuntimeError, msg, name, cls);
     216                 :            :                 } else {
     217                 :          0 :                     const char *msg =
     218                 :            :                         "__class__ set to %.200R defining %.200R as %.200R";
     219                 :          0 :                     PyErr_Format(PyExc_TypeError, msg, cell_cls, name, cls);
     220                 :            :                 }
     221                 :          0 :                 Py_SETREF(cls, NULL);
     222                 :          0 :                 goto error;
     223                 :            :             }
     224                 :            :         }
     225                 :            :     }
     226                 :          0 : error:
     227                 :       3141 :     Py_XDECREF(cell);
     228                 :       3141 :     Py_XDECREF(ns);
     229                 :       3141 :     Py_XDECREF(meta);
     230                 :       3141 :     Py_XDECREF(mkw);
     231         [ +  + ]:       3141 :     if (bases != orig_bases) {
     232                 :         15 :         Py_DECREF(orig_bases);
     233                 :            :     }
     234                 :       3141 :     Py_DECREF(bases);
     235                 :       3141 :     return cls;
     236                 :            : }
     237                 :            : 
     238                 :            : PyDoc_STRVAR(build_class_doc,
     239                 :            : "__build_class__(func, name, /, *bases, [metaclass], **kwds) -> class\n\
     240                 :            : \n\
     241                 :            : Internal helper function used by the class statement.");
     242                 :            : 
     243                 :            : /*[clinic input]
     244                 :            : __import__ as builtin___import__
     245                 :            : 
     246                 :            :     name: object
     247                 :            :     globals: object(c_default="NULL") = None
     248                 :            :     locals: object(c_default="NULL") = None
     249                 :            :     fromlist: object(c_default="NULL") = ()
     250                 :            :     level: int = 0
     251                 :            : 
     252                 :            : Import a module.
     253                 :            : 
     254                 :            : Because this function is meant for use by the Python
     255                 :            : interpreter and not for general use, it is better to use
     256                 :            : importlib.import_module() to programmatically import a module.
     257                 :            : 
     258                 :            : The globals argument is only used to determine the context;
     259                 :            : they are not modified.  The locals argument is unused.  The fromlist
     260                 :            : should be a list of names to emulate ``from name import ...``, or an
     261                 :            : empty list to emulate ``import name``.
     262                 :            : When importing a module from a package, note that __import__('A.B', ...)
     263                 :            : returns package A when fromlist is empty, but its submodule B when
     264                 :            : fromlist is not empty.  The level argument is used to determine whether to
     265                 :            : perform absolute or relative imports: 0 is absolute, while a positive number
     266                 :            : is the number of parent directories to search relative to the current module.
     267                 :            : [clinic start generated code]*/
     268                 :            : 
     269                 :            : static PyObject *
     270                 :       1059 : builtin___import___impl(PyObject *module, PyObject *name, PyObject *globals,
     271                 :            :                         PyObject *locals, PyObject *fromlist, int level)
     272                 :            : /*[clinic end generated code: output=4febeda88a0cd245 input=73f4b960ea5b9dd6]*/
     273                 :            : {
     274                 :       1059 :     return PyImport_ImportModuleLevelObject(name, globals, locals,
     275                 :            :                                             fromlist, level);
     276                 :            : }
     277                 :            : 
     278                 :            : 
     279                 :            : /*[clinic input]
     280                 :            : abs as builtin_abs
     281                 :            : 
     282                 :            :     x: object
     283                 :            :     /
     284                 :            : 
     285                 :            : Return the absolute value of the argument.
     286                 :            : [clinic start generated code]*/
     287                 :            : 
     288                 :            : static PyObject *
     289                 :      81211 : builtin_abs(PyObject *module, PyObject *x)
     290                 :            : /*[clinic end generated code: output=b1b433b9e51356f5 input=bed4ca14e29c20d1]*/
     291                 :            : {
     292                 :      81211 :     return PyNumber_Absolute(x);
     293                 :            : }
     294                 :            : 
     295                 :            : /*[clinic input]
     296                 :            : all as builtin_all
     297                 :            : 
     298                 :            :     iterable: object
     299                 :            :     /
     300                 :            : 
     301                 :            : Return True if bool(x) is True for all values x in the iterable.
     302                 :            : 
     303                 :            : If the iterable is empty, return True.
     304                 :            : [clinic start generated code]*/
     305                 :            : 
     306                 :            : static PyObject *
     307                 :       4238 : builtin_all(PyObject *module, PyObject *iterable)
     308                 :            : /*[clinic end generated code: output=ca2a7127276f79b3 input=1a7c5d1bc3438a21]*/
     309                 :            : {
     310                 :            :     PyObject *it, *item;
     311                 :            :     PyObject *(*iternext)(PyObject *);
     312                 :            :     int cmp;
     313                 :            : 
     314                 :       4238 :     it = PyObject_GetIter(iterable);
     315         [ -  + ]:       4238 :     if (it == NULL)
     316                 :          0 :         return NULL;
     317                 :       4238 :     iternext = *Py_TYPE(it)->tp_iternext;
     318                 :            : 
     319                 :            :     for (;;) {
     320                 :      54171 :         item = iternext(it);
     321         [ +  + ]:      54171 :         if (item == NULL)
     322                 :       2369 :             break;
     323                 :      51802 :         cmp = PyObject_IsTrue(item);
     324                 :      51802 :         Py_DECREF(item);
     325         [ -  + ]:      51802 :         if (cmp < 0) {
     326                 :          0 :             Py_DECREF(it);
     327                 :          0 :             return NULL;
     328                 :            :         }
     329         [ +  + ]:      51802 :         if (cmp == 0) {
     330                 :       1869 :             Py_DECREF(it);
     331                 :       1869 :             Py_RETURN_FALSE;
     332                 :            :         }
     333                 :            :     }
     334                 :       2369 :     Py_DECREF(it);
     335         [ -  + ]:       2369 :     if (PyErr_Occurred()) {
     336         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_StopIteration))
     337                 :          0 :             PyErr_Clear();
     338                 :            :         else
     339                 :          0 :             return NULL;
     340                 :            :     }
     341                 :       2369 :     Py_RETURN_TRUE;
     342                 :            : }
     343                 :            : 
     344                 :            : /*[clinic input]
     345                 :            : any as builtin_any
     346                 :            : 
     347                 :            :     iterable: object
     348                 :            :     /
     349                 :            : 
     350                 :            : Return True if bool(x) is True for any x in the iterable.
     351                 :            : 
     352                 :            : If the iterable is empty, return False.
     353                 :            : [clinic start generated code]*/
     354                 :            : 
     355                 :            : static PyObject *
     356                 :     147788 : builtin_any(PyObject *module, PyObject *iterable)
     357                 :            : /*[clinic end generated code: output=fa65684748caa60e input=41d7451c23384f24]*/
     358                 :            : {
     359                 :            :     PyObject *it, *item;
     360                 :            :     PyObject *(*iternext)(PyObject *);
     361                 :            :     int cmp;
     362                 :            : 
     363                 :     147788 :     it = PyObject_GetIter(iterable);
     364         [ -  + ]:     147788 :     if (it == NULL)
     365                 :          0 :         return NULL;
     366                 :     147788 :     iternext = *Py_TYPE(it)->tp_iternext;
     367                 :            : 
     368                 :            :     for (;;) {
     369                 :     326960 :         item = iternext(it);
     370         [ +  + ]:     326960 :         if (item == NULL)
     371                 :      34139 :             break;
     372                 :     292821 :         cmp = PyObject_IsTrue(item);
     373                 :     292821 :         Py_DECREF(item);
     374         [ -  + ]:     292821 :         if (cmp < 0) {
     375                 :          0 :             Py_DECREF(it);
     376                 :          0 :             return NULL;
     377                 :            :         }
     378         [ +  + ]:     292821 :         if (cmp > 0) {
     379                 :     113649 :             Py_DECREF(it);
     380                 :     113649 :             Py_RETURN_TRUE;
     381                 :            :         }
     382                 :            :     }
     383                 :      34139 :     Py_DECREF(it);
     384         [ -  + ]:      34139 :     if (PyErr_Occurred()) {
     385         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_StopIteration))
     386                 :          0 :             PyErr_Clear();
     387                 :            :         else
     388                 :          0 :             return NULL;
     389                 :            :     }
     390                 :      34139 :     Py_RETURN_FALSE;
     391                 :            : }
     392                 :            : 
     393                 :            : /*[clinic input]
     394                 :            : ascii as builtin_ascii
     395                 :            : 
     396                 :            :     obj: object
     397                 :            :     /
     398                 :            : 
     399                 :            : Return an ASCII-only representation of an object.
     400                 :            : 
     401                 :            : As repr(), return a string containing a printable representation of an
     402                 :            : object, but escape the non-ASCII characters in the string returned by
     403                 :            : repr() using \\x, \\u or \\U escapes. This generates a string similar
     404                 :            : to that returned by repr() in Python 2.
     405                 :            : [clinic start generated code]*/
     406                 :            : 
     407                 :            : static PyObject *
     408                 :          0 : builtin_ascii(PyObject *module, PyObject *obj)
     409                 :            : /*[clinic end generated code: output=6d37b3f0984c7eb9 input=4c62732e1b3a3cc9]*/
     410                 :            : {
     411                 :          0 :     return PyObject_ASCII(obj);
     412                 :            : }
     413                 :            : 
     414                 :            : 
     415                 :            : /*[clinic input]
     416                 :            : bin as builtin_bin
     417                 :            : 
     418                 :            :     number: object
     419                 :            :     /
     420                 :            : 
     421                 :            : Return the binary representation of an integer.
     422                 :            : 
     423                 :            :    >>> bin(2796202)
     424                 :            :    '0b1010101010101010101010'
     425                 :            : [clinic start generated code]*/
     426                 :            : 
     427                 :            : static PyObject *
     428                 :       2000 : builtin_bin(PyObject *module, PyObject *number)
     429                 :            : /*[clinic end generated code: output=b6fc4ad5e649f4f7 input=53f8a0264bacaf90]*/
     430                 :            : {
     431                 :       2000 :     return PyNumber_ToBase(number, 2);
     432                 :            : }
     433                 :            : 
     434                 :            : 
     435                 :            : /*[clinic input]
     436                 :            : callable as builtin_callable
     437                 :            : 
     438                 :            :     obj: object
     439                 :            :     /
     440                 :            : 
     441                 :            : Return whether the object is callable (i.e., some kind of function).
     442                 :            : 
     443                 :            : Note that classes are callable, as are instances of classes with a
     444                 :            : __call__() method.
     445                 :            : [clinic start generated code]*/
     446                 :            : 
     447                 :            : static PyObject *
     448                 :        312 : builtin_callable(PyObject *module, PyObject *obj)
     449                 :            : /*[clinic end generated code: output=2b095d59d934cb7e input=1423bab99cc41f58]*/
     450                 :            : {
     451                 :        312 :     return PyBool_FromLong((long)PyCallable_Check(obj));
     452                 :            : }
     453                 :            : 
     454                 :            : static PyObject *
     455                 :          0 : builtin_breakpoint(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *keywords)
     456                 :            : {
     457                 :          0 :     PyObject *hook = PySys_GetObject("breakpointhook");
     458                 :            : 
     459         [ #  # ]:          0 :     if (hook == NULL) {
     460                 :          0 :         PyErr_SetString(PyExc_RuntimeError, "lost sys.breakpointhook");
     461                 :          0 :         return NULL;
     462                 :            :     }
     463                 :            : 
     464         [ #  # ]:          0 :     if (PySys_Audit("builtins.breakpoint", "O", hook) < 0) {
     465                 :          0 :         return NULL;
     466                 :            :     }
     467                 :            : 
     468                 :          0 :     Py_INCREF(hook);
     469                 :          0 :     PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);
     470                 :          0 :     Py_DECREF(hook);
     471                 :          0 :     return retval;
     472                 :            : }
     473                 :            : 
     474                 :            : PyDoc_STRVAR(breakpoint_doc,
     475                 :            : "breakpoint(*args, **kws)\n\
     476                 :            : \n\
     477                 :            : Call sys.breakpointhook(*args, **kws).  sys.breakpointhook() must accept\n\
     478                 :            : whatever arguments are passed.\n\
     479                 :            : \n\
     480                 :            : By default, this drops you into the pdb debugger.");
     481                 :            : 
     482                 :            : typedef struct {
     483                 :            :     PyObject_HEAD
     484                 :            :     PyObject *func;
     485                 :            :     PyObject *it;
     486                 :            : } filterobject;
     487                 :            : 
     488                 :            : static PyObject *
     489                 :          0 : filter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     490                 :            : {
     491                 :            :     PyObject *func, *seq;
     492                 :            :     PyObject *it;
     493                 :            :     filterobject *lz;
     494                 :            : 
     495   [ #  #  #  #  :          0 :     if ((type == &PyFilter_Type || type->tp_init == PyFilter_Type.tp_init) &&
                   #  # ]
     496         [ #  # ]:          0 :         !_PyArg_NoKeywords("filter", kwds))
     497                 :          0 :         return NULL;
     498                 :            : 
     499         [ #  # ]:          0 :     if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
     500                 :          0 :         return NULL;
     501                 :            : 
     502                 :            :     /* Get iterator. */
     503                 :          0 :     it = PyObject_GetIter(seq);
     504         [ #  # ]:          0 :     if (it == NULL)
     505                 :          0 :         return NULL;
     506                 :            : 
     507                 :            :     /* create filterobject structure */
     508                 :          0 :     lz = (filterobject *)type->tp_alloc(type, 0);
     509         [ #  # ]:          0 :     if (lz == NULL) {
     510                 :          0 :         Py_DECREF(it);
     511                 :          0 :         return NULL;
     512                 :            :     }
     513                 :            : 
     514                 :          0 :     lz->func = Py_NewRef(func);
     515                 :          0 :     lz->it = it;
     516                 :            : 
     517                 :          0 :     return (PyObject *)lz;
     518                 :            : }
     519                 :            : 
     520                 :            : static PyObject *
     521                 :          3 : filter_vectorcall(PyObject *type, PyObject * const*args,
     522                 :            :                 size_t nargsf, PyObject *kwnames)
     523                 :            : {
     524                 :          3 :     PyTypeObject *tp = _PyType_CAST(type);
     525   [ +  -  -  +  :          3 :     if (tp == &PyFilter_Type && !_PyArg_NoKwnames("filter", kwnames)) {
                   -  - ]
     526                 :          0 :         return NULL;
     527                 :            :     }
     528                 :            : 
     529                 :          3 :     Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
     530   [ +  -  -  +  :          3 :     if (!_PyArg_CheckPositional("filter", nargs, 2, 2)) {
                   -  - ]
     531                 :          0 :         return NULL;
     532                 :            :     }
     533                 :            : 
     534                 :          3 :     PyObject *it = PyObject_GetIter(args[1]);
     535         [ -  + ]:          3 :     if (it == NULL) {
     536                 :          0 :         return NULL;
     537                 :            :     }
     538                 :            : 
     539                 :          3 :     filterobject *lz = (filterobject *)tp->tp_alloc(tp, 0);
     540                 :            : 
     541         [ -  + ]:          3 :     if (lz == NULL) {
     542                 :          0 :         Py_DECREF(it);
     543                 :          0 :         return NULL;
     544                 :            :     }
     545                 :            : 
     546                 :          3 :     lz->func = Py_NewRef(args[0]);
     547                 :          3 :     lz->it = it;
     548                 :            : 
     549                 :          3 :     return (PyObject *)lz;
     550                 :            : }
     551                 :            : 
     552                 :            : static void
     553                 :          3 : filter_dealloc(filterobject *lz)
     554                 :            : {
     555                 :          3 :     PyObject_GC_UnTrack(lz);
     556   [ +  -  -  + ]:          3 :     Py_TRASHCAN_BEGIN(lz, filter_dealloc)
     557                 :          3 :     Py_XDECREF(lz->func);
     558                 :          3 :     Py_XDECREF(lz->it);
     559                 :          3 :     Py_TYPE(lz)->tp_free(lz);
     560         [ +  - ]:          3 :     Py_TRASHCAN_END
     561                 :          3 : }
     562                 :            : 
     563                 :            : static int
     564                 :          0 : filter_traverse(filterobject *lz, visitproc visit, void *arg)
     565                 :            : {
     566   [ #  #  #  # ]:          0 :     Py_VISIT(lz->it);
     567   [ #  #  #  # ]:          0 :     Py_VISIT(lz->func);
     568                 :          0 :     return 0;
     569                 :            : }
     570                 :            : 
     571                 :            : static PyObject *
     572                 :         84 : filter_next(filterobject *lz)
     573                 :            : {
     574                 :            :     PyObject *item;
     575                 :         84 :     PyObject *it = lz->it;
     576                 :            :     long ok;
     577                 :            :     PyObject *(*iternext)(PyObject *);
     578   [ +  -  -  + ]:         84 :     int checktrue = lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type;
     579                 :            : 
     580                 :         84 :     iternext = *Py_TYPE(it)->tp_iternext;
     581                 :            :     for (;;) {
     582                 :        286 :         item = iternext(it);
     583         [ +  + ]:        286 :         if (item == NULL)
     584                 :          3 :             return NULL;
     585                 :            : 
     586         [ -  + ]:        283 :         if (checktrue) {
     587                 :          0 :             ok = PyObject_IsTrue(item);
     588                 :            :         } else {
     589                 :            :             PyObject *good;
     590                 :        283 :             good = PyObject_CallOneArg(lz->func, item);
     591         [ -  + ]:        283 :             if (good == NULL) {
     592                 :          0 :                 Py_DECREF(item);
     593                 :          0 :                 return NULL;
     594                 :            :             }
     595                 :        283 :             ok = PyObject_IsTrue(good);
     596                 :        283 :             Py_DECREF(good);
     597                 :            :         }
     598         [ +  + ]:        283 :         if (ok > 0)
     599                 :         81 :             return item;
     600                 :        202 :         Py_DECREF(item);
     601         [ -  + ]:        202 :         if (ok < 0)
     602                 :          0 :             return NULL;
     603                 :            :     }
     604                 :            : }
     605                 :            : 
     606                 :            : static PyObject *
     607                 :          0 : filter_reduce(filterobject *lz, PyObject *Py_UNUSED(ignored))
     608                 :            : {
     609                 :          0 :     return Py_BuildValue("O(OO)", Py_TYPE(lz), lz->func, lz->it);
     610                 :            : }
     611                 :            : 
     612                 :            : PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
     613                 :            : 
     614                 :            : static PyMethodDef filter_methods[] = {
     615                 :            :     {"__reduce__", _PyCFunction_CAST(filter_reduce), METH_NOARGS, reduce_doc},
     616                 :            :     {NULL,           NULL}           /* sentinel */
     617                 :            : };
     618                 :            : 
     619                 :            : PyDoc_STRVAR(filter_doc,
     620                 :            : "filter(function or None, iterable) --> filter object\n\
     621                 :            : \n\
     622                 :            : Return an iterator yielding those items of iterable for which function(item)\n\
     623                 :            : is true. If function is None, return the items that are true.");
     624                 :            : 
     625                 :            : PyTypeObject PyFilter_Type = {
     626                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     627                 :            :     "filter",                           /* tp_name */
     628                 :            :     sizeof(filterobject),               /* tp_basicsize */
     629                 :            :     0,                                  /* tp_itemsize */
     630                 :            :     /* methods */
     631                 :            :     (destructor)filter_dealloc,         /* tp_dealloc */
     632                 :            :     0,                                  /* tp_vectorcall_offset */
     633                 :            :     0,                                  /* tp_getattr */
     634                 :            :     0,                                  /* tp_setattr */
     635                 :            :     0,                                  /* tp_as_async */
     636                 :            :     0,                                  /* tp_repr */
     637                 :            :     0,                                  /* tp_as_number */
     638                 :            :     0,                                  /* tp_as_sequence */
     639                 :            :     0,                                  /* tp_as_mapping */
     640                 :            :     0,                                  /* tp_hash */
     641                 :            :     0,                                  /* tp_call */
     642                 :            :     0,                                  /* tp_str */
     643                 :            :     PyObject_GenericGetAttr,            /* tp_getattro */
     644                 :            :     0,                                  /* tp_setattro */
     645                 :            :     0,                                  /* tp_as_buffer */
     646                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
     647                 :            :         Py_TPFLAGS_BASETYPE,            /* tp_flags */
     648                 :            :     filter_doc,                         /* tp_doc */
     649                 :            :     (traverseproc)filter_traverse,      /* tp_traverse */
     650                 :            :     0,                                  /* tp_clear */
     651                 :            :     0,                                  /* tp_richcompare */
     652                 :            :     0,                                  /* tp_weaklistoffset */
     653                 :            :     PyObject_SelfIter,                  /* tp_iter */
     654                 :            :     (iternextfunc)filter_next,          /* tp_iternext */
     655                 :            :     filter_methods,                     /* tp_methods */
     656                 :            :     0,                                  /* tp_members */
     657                 :            :     0,                                  /* tp_getset */
     658                 :            :     0,                                  /* tp_base */
     659                 :            :     0,                                  /* tp_dict */
     660                 :            :     0,                                  /* tp_descr_get */
     661                 :            :     0,                                  /* tp_descr_set */
     662                 :            :     0,                                  /* tp_dictoffset */
     663                 :            :     0,                                  /* tp_init */
     664                 :            :     PyType_GenericAlloc,                /* tp_alloc */
     665                 :            :     filter_new,                         /* tp_new */
     666                 :            :     PyObject_GC_Del,                    /* tp_free */
     667                 :            :     .tp_vectorcall = (vectorcallfunc)filter_vectorcall
     668                 :            : };
     669                 :            : 
     670                 :            : 
     671                 :            : /*[clinic input]
     672                 :            : format as builtin_format
     673                 :            : 
     674                 :            :     value: object
     675                 :            :     format_spec: unicode(c_default="NULL") = ''
     676                 :            :     /
     677                 :            : 
     678                 :            : Return type(value).__format__(value, format_spec)
     679                 :            : 
     680                 :            : Many built-in types implement format_spec according to the
     681                 :            : Format Specification Mini-language. See help('FORMATTING').
     682                 :            : 
     683                 :            : If type(value) does not supply a method named __format__
     684                 :            : and format_spec is empty, then str(value) is returned.
     685                 :            : See also help('SPECIALMETHODS').
     686                 :            : [clinic start generated code]*/
     687                 :            : 
     688                 :            : static PyObject *
     689                 :          0 : builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec)
     690                 :            : /*[clinic end generated code: output=2f40bdfa4954b077 input=45ef3934b86d5624]*/
     691                 :            : {
     692                 :          0 :     return PyObject_Format(value, format_spec);
     693                 :            : }
     694                 :            : 
     695                 :            : /*[clinic input]
     696                 :            : chr as builtin_chr
     697                 :            : 
     698                 :            :     i: int
     699                 :            :     /
     700                 :            : 
     701                 :            : Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
     702                 :            : [clinic start generated code]*/
     703                 :            : 
     704                 :            : static PyObject *
     705                 :         96 : builtin_chr_impl(PyObject *module, int i)
     706                 :            : /*[clinic end generated code: output=c733afcd200afcb7 input=3f604ef45a70750d]*/
     707                 :            : {
     708                 :         96 :     return PyUnicode_FromOrdinal(i);
     709                 :            : }
     710                 :            : 
     711                 :            : 
     712                 :            : /*[clinic input]
     713                 :            : compile as builtin_compile
     714                 :            : 
     715                 :            :     source: object
     716                 :            :     filename: object(converter="PyUnicode_FSDecoder")
     717                 :            :     mode: str
     718                 :            :     flags: int = 0
     719                 :            :     dont_inherit: bool = False
     720                 :            :     optimize: int = -1
     721                 :            :     *
     722                 :            :     _feature_version as feature_version: int = -1
     723                 :            : 
     724                 :            : Compile source into a code object that can be executed by exec() or eval().
     725                 :            : 
     726                 :            : The source code may represent a Python module, statement or expression.
     727                 :            : The filename will be used for run-time error messages.
     728                 :            : The mode must be 'exec' to compile a module, 'single' to compile a
     729                 :            : single (interactive) statement, or 'eval' to compile an expression.
     730                 :            : The flags argument, if present, controls which future statements influence
     731                 :            : the compilation of the code.
     732                 :            : The dont_inherit argument, if true, stops the compilation inheriting
     733                 :            : the effects of any future statements in effect in the code calling
     734                 :            : compile; if absent or false these statements do influence the compilation,
     735                 :            : in addition to any features explicitly specified.
     736                 :            : [clinic start generated code]*/
     737                 :            : 
     738                 :            : static PyObject *
     739                 :        267 : builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
     740                 :            :                      const char *mode, int flags, int dont_inherit,
     741                 :            :                      int optimize, int feature_version)
     742                 :            : /*[clinic end generated code: output=b0c09c84f116d3d7 input=cc78e20e7c7682ba]*/
     743                 :            : {
     744                 :            :     PyObject *source_copy;
     745                 :            :     const char *str;
     746                 :        267 :     int compile_mode = -1;
     747                 :            :     int is_ast;
     748                 :        267 :     int start[] = {Py_file_input, Py_eval_input, Py_single_input, Py_func_type_input};
     749                 :            :     PyObject *result;
     750                 :            : 
     751                 :        267 :     PyCompilerFlags cf = _PyCompilerFlags_INIT;
     752                 :        267 :     cf.cf_flags = flags | PyCF_SOURCE_IS_UTF8;
     753   [ -  +  -  - ]:        267 :     if (feature_version >= 0 && (flags & PyCF_ONLY_AST)) {
     754                 :          0 :         cf.cf_feature_version = feature_version;
     755                 :            :     }
     756                 :            : 
     757         [ -  + ]:        267 :     if (flags &
     758                 :            :         ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_COMPILE_MASK))
     759                 :            :     {
     760                 :          0 :         PyErr_SetString(PyExc_ValueError,
     761                 :            :                         "compile(): unrecognised flags");
     762                 :          0 :         goto error;
     763                 :            :     }
     764                 :            :     /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
     765                 :            : 
     766   [ +  -  -  + ]:        267 :     if (optimize < -1 || optimize > 2) {
     767                 :          0 :         PyErr_SetString(PyExc_ValueError,
     768                 :            :                         "compile(): invalid optimize value");
     769                 :          0 :         goto error;
     770                 :            :     }
     771                 :            : 
     772         [ +  + ]:        267 :     if (!dont_inherit) {
     773                 :         32 :         PyEval_MergeCompilerFlags(&cf);
     774                 :            :     }
     775                 :            : 
     776         [ +  + ]:        267 :     if (strcmp(mode, "exec") == 0)
     777                 :        188 :         compile_mode = 0;
     778         [ +  + ]:         79 :     else if (strcmp(mode, "eval") == 0)
     779                 :         23 :         compile_mode = 1;
     780         [ +  - ]:         56 :     else if (strcmp(mode, "single") == 0)
     781                 :         56 :         compile_mode = 2;
     782         [ #  # ]:          0 :     else if (strcmp(mode, "func_type") == 0) {
     783         [ #  # ]:          0 :         if (!(flags & PyCF_ONLY_AST)) {
     784                 :          0 :             PyErr_SetString(PyExc_ValueError,
     785                 :            :                             "compile() mode 'func_type' requires flag PyCF_ONLY_AST");
     786                 :          0 :             goto error;
     787                 :            :         }
     788                 :          0 :         compile_mode = 3;
     789                 :            :     }
     790                 :            :     else {
     791                 :            :         const char *msg;
     792         [ #  # ]:          0 :         if (flags & PyCF_ONLY_AST)
     793                 :          0 :             msg = "compile() mode must be 'exec', 'eval', 'single' or 'func_type'";
     794                 :            :         else
     795                 :          0 :             msg = "compile() mode must be 'exec', 'eval' or 'single'";
     796                 :          0 :         PyErr_SetString(PyExc_ValueError, msg);
     797                 :          0 :         goto error;
     798                 :            :     }
     799                 :            : 
     800                 :        267 :     is_ast = PyAST_Check(source);
     801         [ -  + ]:        267 :     if (is_ast == -1)
     802                 :          0 :         goto error;
     803         [ -  + ]:        267 :     if (is_ast) {
     804         [ #  # ]:          0 :         if (flags & PyCF_ONLY_AST) {
     805                 :          0 :             result = Py_NewRef(source);
     806                 :            :         }
     807                 :            :         else {
     808                 :            :             PyArena *arena;
     809                 :            :             mod_ty mod;
     810                 :            : 
     811                 :          0 :             arena = _PyArena_New();
     812         [ #  # ]:          0 :             if (arena == NULL)
     813                 :          0 :                 goto error;
     814                 :          0 :             mod = PyAST_obj2mod(source, arena, compile_mode);
     815   [ #  #  #  # ]:          0 :             if (mod == NULL || !_PyAST_Validate(mod)) {
     816                 :          0 :                 _PyArena_Free(arena);
     817                 :          0 :                 goto error;
     818                 :            :             }
     819                 :          0 :             result = (PyObject*)_PyAST_Compile(mod, filename,
     820                 :            :                                                &cf, optimize, arena);
     821                 :          0 :             _PyArena_Free(arena);
     822                 :            :         }
     823                 :          0 :         goto finally;
     824                 :            :     }
     825                 :            : 
     826                 :        267 :     str = _Py_SourceAsString(source, "compile", "string, bytes or AST", &cf, &source_copy);
     827         [ -  + ]:        267 :     if (str == NULL)
     828                 :          0 :         goto error;
     829                 :            : 
     830                 :        267 :     result = Py_CompileStringObject(str, filename, start[compile_mode], &cf, optimize);
     831                 :            : 
     832                 :        267 :     Py_XDECREF(source_copy);
     833                 :        267 :     goto finally;
     834                 :            : 
     835                 :          0 : error:
     836                 :          0 :     result = NULL;
     837                 :        267 : finally:
     838                 :        267 :     Py_DECREF(filename);
     839                 :        267 :     return result;
     840                 :            : }
     841                 :            : 
     842                 :            : /*[clinic input]
     843                 :            : dir as builtin_dir
     844                 :            : 
     845                 :            :     arg: object = NULL
     846                 :            :     /
     847                 :            : 
     848                 :            : Show attributes of an object.
     849                 :            : 
     850                 :            : If called without an argument, return the names in the current scope.
     851                 :            : Else, return an alphabetized list of names comprising (some of) the attributes
     852                 :            : of the given object, and of attributes reachable from it.
     853                 :            : If the object supplies a method named __dir__, it will be used; otherwise
     854                 :            : the default dir() logic is used and returns:
     855                 :            :   for a module object: the module's attributes.
     856                 :            :   for a class object:  its attributes, and recursively the attributes
     857                 :            :     of its bases.
     858                 :            :   for any other object: its attributes, its class's attributes, and
     859                 :            :     recursively the attributes of its class's base classes.
     860                 :            : [clinic start generated code]*/
     861                 :            : 
     862                 :            : static PyObject *
     863                 :         30 : builtin_dir_impl(PyObject *module, PyObject *arg)
     864                 :            : /*[clinic end generated code: output=24f2c7a52c1e3b08 input=ed6d6ccb13d52251]*/
     865                 :            : {
     866                 :         30 :     return PyObject_Dir(arg);
     867                 :            : }
     868                 :            : 
     869                 :            : /*[clinic input]
     870                 :            : divmod as builtin_divmod
     871                 :            : 
     872                 :            :     x: object
     873                 :            :     y: object
     874                 :            :     /
     875                 :            : 
     876                 :            : Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
     877                 :            : [clinic start generated code]*/
     878                 :            : 
     879                 :            : static PyObject *
     880                 :        148 : builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y)
     881                 :            : /*[clinic end generated code: output=b06d8a5f6e0c745e input=175ad9c84ff41a85]*/
     882                 :            : {
     883                 :        148 :     return PyNumber_Divmod(x, y);
     884                 :            : }
     885                 :            : 
     886                 :            : 
     887                 :            : /*[clinic input]
     888                 :            : eval as builtin_eval
     889                 :            : 
     890                 :            :     source: object
     891                 :            :     globals: object = None
     892                 :            :     locals: object = None
     893                 :            :     /
     894                 :            : 
     895                 :            : Evaluate the given source in the context of globals and locals.
     896                 :            : 
     897                 :            : The source may be a string representing a Python expression
     898                 :            : or a code object as returned by compile().
     899                 :            : The globals must be a dictionary and locals can be any mapping,
     900                 :            : defaulting to the current globals and locals.
     901                 :            : If only globals is given, locals defaults to it.
     902                 :            : [clinic start generated code]*/
     903                 :            : 
     904                 :            : static PyObject *
     905                 :         57 : builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
     906                 :            :                   PyObject *locals)
     907                 :            : /*[clinic end generated code: output=0a0824aa70093116 input=11ee718a8640e527]*/
     908                 :            : {
     909                 :            :     PyObject *result, *source_copy;
     910                 :            :     const char *str;
     911                 :            : 
     912   [ -  +  -  - ]:         57 :     if (locals != Py_None && !PyMapping_Check(locals)) {
     913                 :          0 :         PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
     914                 :          0 :         return NULL;
     915                 :            :     }
     916   [ +  -  -  + ]:         57 :     if (globals != Py_None && !PyDict_Check(globals)) {
     917         [ #  # ]:          0 :         PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
     918                 :            :             "globals must be a real dict; try eval(expr, {}, mapping)"
     919                 :            :             : "globals must be a dict");
     920                 :          0 :         return NULL;
     921                 :            :     }
     922         [ -  + ]:         57 :     if (globals == Py_None) {
     923                 :          0 :         globals = PyEval_GetGlobals();
     924         [ #  # ]:          0 :         if (locals == Py_None) {
     925                 :          0 :             locals = PyEval_GetLocals();
     926         [ #  # ]:          0 :             if (locals == NULL)
     927                 :          0 :                 return NULL;
     928                 :            :         }
     929                 :            :     }
     930         [ +  - ]:         57 :     else if (locals == Py_None)
     931                 :         57 :         locals = globals;
     932                 :            : 
     933   [ +  -  -  + ]:         57 :     if (globals == NULL || locals == NULL) {
     934                 :          0 :         PyErr_SetString(PyExc_TypeError,
     935                 :            :             "eval must be given globals and locals "
     936                 :            :             "when called without a frame");
     937                 :          0 :         return NULL;
     938                 :            :     }
     939                 :            : 
     940                 :         57 :     int r = PyDict_Contains(globals, &_Py_ID(__builtins__));
     941         [ -  + ]:         57 :     if (r == 0) {
     942                 :          0 :         r = PyDict_SetItem(globals, &_Py_ID(__builtins__), PyEval_GetBuiltins());
     943                 :            :     }
     944         [ -  + ]:         57 :     if (r < 0) {
     945                 :          0 :         return NULL;
     946                 :            :     }
     947                 :            : 
     948         [ -  + ]:         57 :     if (PyCode_Check(source)) {
     949         [ #  # ]:          0 :         if (PySys_Audit("exec", "O", source) < 0) {
     950                 :          0 :             return NULL;
     951                 :            :         }
     952                 :            : 
     953         [ #  # ]:          0 :         if (PyCode_GetNumFree((PyCodeObject *)source) > 0) {
     954                 :          0 :             PyErr_SetString(PyExc_TypeError,
     955                 :            :                 "code object passed to eval() may not contain free variables");
     956                 :          0 :             return NULL;
     957                 :            :         }
     958                 :          0 :         return PyEval_EvalCode(source, globals, locals);
     959                 :            :     }
     960                 :            : 
     961                 :         57 :     PyCompilerFlags cf = _PyCompilerFlags_INIT;
     962                 :         57 :     cf.cf_flags = PyCF_SOURCE_IS_UTF8;
     963                 :         57 :     str = _Py_SourceAsString(source, "eval", "string, bytes or code", &cf, &source_copy);
     964         [ -  + ]:         57 :     if (str == NULL)
     965                 :          0 :         return NULL;
     966                 :            : 
     967   [ -  +  -  + ]:         57 :     while (*str == ' ' || *str == '\t')
     968                 :          0 :         str++;
     969                 :            : 
     970                 :         57 :     (void)PyEval_MergeCompilerFlags(&cf);
     971                 :         57 :     result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
     972                 :         57 :     Py_XDECREF(source_copy);
     973                 :         57 :     return result;
     974                 :            : }
     975                 :            : 
     976                 :            : /*[clinic input]
     977                 :            : exec as builtin_exec
     978                 :            : 
     979                 :            :     source: object
     980                 :            :     globals: object = None
     981                 :            :     locals: object = None
     982                 :            :     /
     983                 :            :     *
     984                 :            :     closure: object(c_default="NULL") = None
     985                 :            : 
     986                 :            : Execute the given source in the context of globals and locals.
     987                 :            : 
     988                 :            : The source may be a string representing one or more Python statements
     989                 :            : or a code object as returned by compile().
     990                 :            : The globals must be a dictionary and locals can be any mapping,
     991                 :            : defaulting to the current globals and locals.
     992                 :            : If only globals is given, locals defaults to it.
     993                 :            : The closure must be a tuple of cellvars, and can only be used
     994                 :            : when source is a code object requiring exactly that many cellvars.
     995                 :            : [clinic start generated code]*/
     996                 :            : 
     997                 :            : static PyObject *
     998                 :        698 : builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
     999                 :            :                   PyObject *locals, PyObject *closure)
    1000                 :            : /*[clinic end generated code: output=7579eb4e7646743d input=f13a7e2b503d1d9a]*/
    1001                 :            : {
    1002                 :            :     PyObject *v;
    1003                 :            : 
    1004         [ -  + ]:        698 :     if (globals == Py_None) {
    1005                 :          0 :         globals = PyEval_GetGlobals();
    1006         [ #  # ]:          0 :         if (locals == Py_None) {
    1007                 :          0 :             locals = PyEval_GetLocals();
    1008         [ #  # ]:          0 :             if (locals == NULL)
    1009                 :          0 :                 return NULL;
    1010                 :            :         }
    1011   [ #  #  #  # ]:          0 :         if (!globals || !locals) {
    1012                 :          0 :             PyErr_SetString(PyExc_SystemError,
    1013                 :            :                             "globals and locals cannot be NULL");
    1014                 :          0 :             return NULL;
    1015                 :            :         }
    1016                 :            :     }
    1017         [ +  - ]:        698 :     else if (locals == Py_None)
    1018                 :        698 :         locals = globals;
    1019                 :            : 
    1020         [ -  + ]:        698 :     if (!PyDict_Check(globals)) {
    1021                 :          0 :         PyErr_Format(PyExc_TypeError, "exec() globals must be a dict, not %.100s",
    1022                 :          0 :                      Py_TYPE(globals)->tp_name);
    1023                 :          0 :         return NULL;
    1024                 :            :     }
    1025         [ -  + ]:        698 :     if (!PyMapping_Check(locals)) {
    1026                 :          0 :         PyErr_Format(PyExc_TypeError,
    1027                 :            :             "locals must be a mapping or None, not %.100s",
    1028                 :          0 :             Py_TYPE(locals)->tp_name);
    1029                 :          0 :         return NULL;
    1030                 :            :     }
    1031                 :        698 :     int r = PyDict_Contains(globals, &_Py_ID(__builtins__));
    1032         [ +  + ]:        698 :     if (r == 0) {
    1033                 :        641 :         r = PyDict_SetItem(globals, &_Py_ID(__builtins__), PyEval_GetBuiltins());
    1034                 :            :     }
    1035         [ -  + ]:        698 :     if (r < 0) {
    1036                 :          0 :         return NULL;
    1037                 :            :     }
    1038                 :            : 
    1039         [ -  + ]:        698 :     if (closure == Py_None) {
    1040                 :          0 :         closure = NULL;
    1041                 :            :     }
    1042                 :            : 
    1043         [ +  - ]:        698 :     if (PyCode_Check(source)) {
    1044                 :        698 :         Py_ssize_t num_free = PyCode_GetNumFree((PyCodeObject *)source);
    1045         [ +  - ]:        698 :         if (num_free == 0) {
    1046         [ -  + ]:        698 :             if (closure) {
    1047                 :          0 :                 PyErr_SetString(PyExc_TypeError,
    1048                 :            :                     "cannot use a closure with this code object");
    1049                 :          0 :                 return NULL;
    1050                 :            :             }
    1051                 :            :         } else {
    1052                 :          0 :             int closure_is_ok =
    1053                 :            :                 closure
    1054         [ #  # ]:          0 :                 && PyTuple_CheckExact(closure)
    1055   [ #  #  #  # ]:          0 :                 && (PyTuple_GET_SIZE(closure) == num_free);
    1056         [ #  # ]:          0 :             if (closure_is_ok) {
    1057         [ #  # ]:          0 :                 for (Py_ssize_t i = 0; i < num_free; i++) {
    1058                 :          0 :                     PyObject *cell = PyTuple_GET_ITEM(closure, i);
    1059         [ #  # ]:          0 :                     if (!PyCell_Check(cell)) {
    1060                 :          0 :                         closure_is_ok = 0;
    1061                 :          0 :                         break;
    1062                 :            :                     }
    1063                 :            :                 }
    1064                 :            :             }
    1065         [ #  # ]:          0 :             if (!closure_is_ok) {
    1066                 :          0 :                 PyErr_Format(PyExc_TypeError,
    1067                 :            :                     "code object requires a closure of exactly length %zd",
    1068                 :            :                     num_free);
    1069                 :          0 :                 return NULL;
    1070                 :            :             }
    1071                 :            :         }
    1072                 :            : 
    1073         [ -  + ]:        698 :         if (PySys_Audit("exec", "O", source) < 0) {
    1074                 :          0 :             return NULL;
    1075                 :            :         }
    1076                 :            : 
    1077         [ +  - ]:        698 :         if (!closure) {
    1078                 :        698 :             v = PyEval_EvalCode(source, globals, locals);
    1079                 :            :         } else {
    1080                 :          0 :             v = PyEval_EvalCodeEx(source, globals, locals,
    1081                 :            :                 NULL, 0,
    1082                 :            :                 NULL, 0,
    1083                 :            :                 NULL, 0,
    1084                 :            :                 NULL,
    1085                 :            :                 closure);
    1086                 :            :         }
    1087                 :            :     }
    1088                 :            :     else {
    1089         [ #  # ]:          0 :         if (closure != NULL) {
    1090                 :          0 :             PyErr_SetString(PyExc_TypeError,
    1091                 :            :                 "closure can only be used when source is a code object");
    1092                 :            :         }
    1093                 :            :         PyObject *source_copy;
    1094                 :            :         const char *str;
    1095                 :          0 :         PyCompilerFlags cf = _PyCompilerFlags_INIT;
    1096                 :          0 :         cf.cf_flags = PyCF_SOURCE_IS_UTF8;
    1097                 :          0 :         str = _Py_SourceAsString(source, "exec",
    1098                 :            :                                        "string, bytes or code", &cf,
    1099                 :            :                                        &source_copy);
    1100         [ #  # ]:          0 :         if (str == NULL)
    1101                 :          0 :             return NULL;
    1102         [ #  # ]:          0 :         if (PyEval_MergeCompilerFlags(&cf))
    1103                 :          0 :             v = PyRun_StringFlags(str, Py_file_input, globals,
    1104                 :            :                                   locals, &cf);
    1105                 :            :         else
    1106                 :          0 :             v = PyRun_String(str, Py_file_input, globals, locals);
    1107                 :          0 :         Py_XDECREF(source_copy);
    1108                 :            :     }
    1109         [ +  + ]:        698 :     if (v == NULL)
    1110                 :         12 :         return NULL;
    1111                 :        686 :     Py_DECREF(v);
    1112                 :        686 :     Py_RETURN_NONE;
    1113                 :            : }
    1114                 :            : 
    1115                 :            : 
    1116                 :            : /*[clinic input]
    1117                 :            : getattr as builtin_getattr
    1118                 :            : 
    1119                 :            :     object: object
    1120                 :            :     name: object
    1121                 :            :     default: object = NULL
    1122                 :            :     /
    1123                 :            : 
    1124                 :            : Get a named attribute from an object.
    1125                 :            : 
    1126                 :            : getattr(x, 'y') is equivalent to x.y
    1127                 :            : When a default argument is given, it is returned when the attribute doesn't
    1128                 :            : exist; without it, an exception is raised in that case.
    1129                 :            : [clinic start generated code]*/
    1130                 :            : 
    1131                 :            : static PyObject *
    1132                 :     130711 : builtin_getattr_impl(PyObject *module, PyObject *object, PyObject *name,
    1133                 :            :                      PyObject *default_value)
    1134                 :            : /*[clinic end generated code: output=74ad0e225e3f701c input=d7562cd4c3556171]*/
    1135                 :            : {
    1136                 :            :     PyObject *result;
    1137                 :            : 
    1138         [ +  + ]:     130711 :     if (default_value != NULL) {
    1139         [ +  + ]:     106862 :         if (_PyObject_LookupAttr(object, name, &result) == 0) {
    1140                 :       3488 :             return Py_NewRef(default_value);
    1141                 :            :         }
    1142                 :            :     }
    1143                 :            :     else {
    1144                 :      23849 :         result = PyObject_GetAttr(object, name);
    1145                 :            :     }
    1146                 :     127223 :     return result;
    1147                 :            : }
    1148                 :            : 
    1149                 :            : 
    1150                 :            : /*[clinic input]
    1151                 :            : globals as builtin_globals
    1152                 :            : 
    1153                 :            : Return the dictionary containing the current scope's global variables.
    1154                 :            : 
    1155                 :            : NOTE: Updates to this dictionary *will* affect name lookups in the current
    1156                 :            : global scope and vice-versa.
    1157                 :            : [clinic start generated code]*/
    1158                 :            : 
    1159                 :            : static PyObject *
    1160                 :        322 : builtin_globals_impl(PyObject *module)
    1161                 :            : /*[clinic end generated code: output=e5dd1527067b94d2 input=9327576f92bb48ba]*/
    1162                 :            : {
    1163                 :            :     PyObject *d;
    1164                 :            : 
    1165                 :        322 :     d = PyEval_GetGlobals();
    1166                 :        322 :     return Py_XNewRef(d);
    1167                 :            : }
    1168                 :            : 
    1169                 :            : 
    1170                 :            : /*[clinic input]
    1171                 :            : hasattr as builtin_hasattr
    1172                 :            : 
    1173                 :            :     obj: object
    1174                 :            :     name: object
    1175                 :            :     /
    1176                 :            : 
    1177                 :            : Return whether the object has an attribute with the given name.
    1178                 :            : 
    1179                 :            : This is done by calling getattr(obj, name) and catching AttributeError.
    1180                 :            : [clinic start generated code]*/
    1181                 :            : 
    1182                 :            : static PyObject *
    1183                 :       6976 : builtin_hasattr_impl(PyObject *module, PyObject *obj, PyObject *name)
    1184                 :            : /*[clinic end generated code: output=a7aff2090a4151e5 input=0faec9787d979542]*/
    1185                 :            : {
    1186                 :            :     PyObject *v;
    1187                 :            : 
    1188         [ -  + ]:       6976 :     if (_PyObject_LookupAttr(obj, name, &v) < 0) {
    1189                 :          0 :         return NULL;
    1190                 :            :     }
    1191         [ +  + ]:       6976 :     if (v == NULL) {
    1192                 :       2067 :         Py_RETURN_FALSE;
    1193                 :            :     }
    1194                 :       4909 :     Py_DECREF(v);
    1195                 :       4909 :     Py_RETURN_TRUE;
    1196                 :            : }
    1197                 :            : 
    1198                 :            : 
    1199                 :            : /* AC: gdb's integration with CPython relies on builtin_id having
    1200                 :            :  * the *exact* parameter names of "self" and "v", so we ensure we
    1201                 :            :  * preserve those name rather than using the AC defaults.
    1202                 :            :  */
    1203                 :            : /*[clinic input]
    1204                 :            : id as builtin_id
    1205                 :            : 
    1206                 :            :     self: self(type="PyModuleDef *")
    1207                 :            :     obj as v: object
    1208                 :            :     /
    1209                 :            : 
    1210                 :            : Return the identity of an object.
    1211                 :            : 
    1212                 :            : This is guaranteed to be unique among simultaneously existing objects.
    1213                 :            : (CPython uses the object's memory address.)
    1214                 :            : [clinic start generated code]*/
    1215                 :            : 
    1216                 :            : static PyObject *
    1217                 :       1191 : builtin_id(PyModuleDef *self, PyObject *v)
    1218                 :            : /*[clinic end generated code: output=0aa640785f697f65 input=5a534136419631f4]*/
    1219                 :            : {
    1220                 :       1191 :     PyObject *id = PyLong_FromVoidPtr(v);
    1221                 :            : 
    1222   [ +  -  -  + ]:       1191 :     if (id && PySys_Audit("builtins.id", "O", id) < 0) {
    1223                 :          0 :         Py_DECREF(id);
    1224                 :          0 :         return NULL;
    1225                 :            :     }
    1226                 :            : 
    1227                 :       1191 :     return id;
    1228                 :            : }
    1229                 :            : 
    1230                 :            : 
    1231                 :            : /* map object ************************************************************/
    1232                 :            : 
    1233                 :            : typedef struct {
    1234                 :            :     PyObject_HEAD
    1235                 :            :     PyObject *iters;
    1236                 :            :     PyObject *func;
    1237                 :            : } mapobject;
    1238                 :            : 
    1239                 :            : static PyObject *
    1240                 :          0 : map_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    1241                 :            : {
    1242                 :            :     PyObject *it, *iters, *func;
    1243                 :            :     mapobject *lz;
    1244                 :            :     Py_ssize_t numargs, i;
    1245                 :            : 
    1246   [ #  #  #  #  :          0 :     if ((type == &PyMap_Type || type->tp_init == PyMap_Type.tp_init) &&
                   #  # ]
    1247         [ #  # ]:          0 :         !_PyArg_NoKeywords("map", kwds))
    1248                 :          0 :         return NULL;
    1249                 :            : 
    1250                 :          0 :     numargs = PyTuple_Size(args);
    1251         [ #  # ]:          0 :     if (numargs < 2) {
    1252                 :          0 :         PyErr_SetString(PyExc_TypeError,
    1253                 :            :            "map() must have at least two arguments.");
    1254                 :          0 :         return NULL;
    1255                 :            :     }
    1256                 :            : 
    1257                 :          0 :     iters = PyTuple_New(numargs-1);
    1258         [ #  # ]:          0 :     if (iters == NULL)
    1259                 :          0 :         return NULL;
    1260                 :            : 
    1261         [ #  # ]:          0 :     for (i=1 ; i<numargs ; i++) {
    1262                 :            :         /* Get iterator. */
    1263                 :          0 :         it = PyObject_GetIter(PyTuple_GET_ITEM(args, i));
    1264         [ #  # ]:          0 :         if (it == NULL) {
    1265                 :          0 :             Py_DECREF(iters);
    1266                 :          0 :             return NULL;
    1267                 :            :         }
    1268                 :          0 :         PyTuple_SET_ITEM(iters, i-1, it);
    1269                 :            :     }
    1270                 :            : 
    1271                 :            :     /* create mapobject structure */
    1272                 :          0 :     lz = (mapobject *)type->tp_alloc(type, 0);
    1273         [ #  # ]:          0 :     if (lz == NULL) {
    1274                 :          0 :         Py_DECREF(iters);
    1275                 :          0 :         return NULL;
    1276                 :            :     }
    1277                 :          0 :     lz->iters = iters;
    1278                 :          0 :     func = PyTuple_GET_ITEM(args, 0);
    1279                 :          0 :     lz->func = Py_NewRef(func);
    1280                 :            : 
    1281                 :          0 :     return (PyObject *)lz;
    1282                 :            : }
    1283                 :            : 
    1284                 :            : static PyObject *
    1285                 :     148978 : map_vectorcall(PyObject *type, PyObject * const*args,
    1286                 :            :                 size_t nargsf, PyObject *kwnames)
    1287                 :            : {
    1288                 :     148978 :     PyTypeObject *tp = _PyType_CAST(type);
    1289   [ +  -  -  +  :     148978 :     if (tp == &PyMap_Type && !_PyArg_NoKwnames("map", kwnames)) {
                   -  - ]
    1290                 :          0 :         return NULL;
    1291                 :            :     }
    1292                 :            : 
    1293                 :     148978 :     Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
    1294         [ -  + ]:     148978 :     if (nargs < 2) {
    1295                 :          0 :         PyErr_SetString(PyExc_TypeError,
    1296                 :            :            "map() must have at least two arguments.");
    1297                 :          0 :         return NULL;
    1298                 :            :     }
    1299                 :            : 
    1300                 :     148978 :     PyObject *iters = PyTuple_New(nargs-1);
    1301         [ -  + ]:     148978 :     if (iters == NULL) {
    1302                 :          0 :         return NULL;
    1303                 :            :     }
    1304                 :            : 
    1305         [ +  + ]:     297956 :     for (int i=1; i<nargs; i++) {
    1306                 :     148978 :         PyObject *it = PyObject_GetIter(args[i]);
    1307         [ -  + ]:     148978 :         if (it == NULL) {
    1308                 :          0 :             Py_DECREF(iters);
    1309                 :          0 :             return NULL;
    1310                 :            :         }
    1311                 :     148978 :         PyTuple_SET_ITEM(iters, i-1, it);
    1312                 :            :     }
    1313                 :            : 
    1314                 :     148978 :     mapobject *lz = (mapobject *)tp->tp_alloc(tp, 0);
    1315         [ -  + ]:     148978 :     if (lz == NULL) {
    1316                 :          0 :         Py_DECREF(iters);
    1317                 :          0 :         return NULL;
    1318                 :            :     }
    1319                 :     148978 :     lz->iters = iters;
    1320                 :     148978 :     lz->func = Py_NewRef(args[0]);
    1321                 :            : 
    1322                 :     148978 :     return (PyObject *)lz;
    1323                 :            : }
    1324                 :            : 
    1325                 :            : static void
    1326                 :     148978 : map_dealloc(mapobject *lz)
    1327                 :            : {
    1328                 :     148978 :     PyObject_GC_UnTrack(lz);
    1329                 :     148978 :     Py_XDECREF(lz->iters);
    1330                 :     148978 :     Py_XDECREF(lz->func);
    1331                 :     148978 :     Py_TYPE(lz)->tp_free(lz);
    1332                 :     148978 : }
    1333                 :            : 
    1334                 :            : static int
    1335                 :          0 : map_traverse(mapobject *lz, visitproc visit, void *arg)
    1336                 :            : {
    1337   [ #  #  #  # ]:          0 :     Py_VISIT(lz->iters);
    1338   [ #  #  #  # ]:          0 :     Py_VISIT(lz->func);
    1339                 :          0 :     return 0;
    1340                 :            : }
    1341                 :            : 
    1342                 :            : static PyObject *
    1343                 :     739352 : map_next(mapobject *lz)
    1344                 :            : {
    1345                 :            :     PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];
    1346                 :            :     PyObject **stack;
    1347                 :     739352 :     PyObject *result = NULL;
    1348                 :     739352 :     PyThreadState *tstate = _PyThreadState_GET();
    1349                 :            : 
    1350                 :     739352 :     const Py_ssize_t niters = PyTuple_GET_SIZE(lz->iters);
    1351         [ +  - ]:     739352 :     if (niters <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) {
    1352                 :     739352 :         stack = small_stack;
    1353                 :            :     }
    1354                 :            :     else {
    1355                 :          0 :         stack = PyMem_Malloc(niters * sizeof(stack[0]));
    1356         [ #  # ]:          0 :         if (stack == NULL) {
    1357                 :          0 :             _PyErr_NoMemory(tstate);
    1358                 :          0 :             return NULL;
    1359                 :            :         }
    1360                 :            :     }
    1361                 :            : 
    1362                 :     739352 :     Py_ssize_t nargs = 0;
    1363         [ +  + ]:    1443290 :     for (Py_ssize_t i=0; i < niters; i++) {
    1364                 :     739352 :         PyObject *it = PyTuple_GET_ITEM(lz->iters, i);
    1365                 :     739352 :         PyObject *val = Py_TYPE(it)->tp_iternext(it);
    1366         [ +  + ]:     739352 :         if (val == NULL) {
    1367                 :      35414 :             goto exit;
    1368                 :            :         }
    1369                 :     703938 :         stack[i] = val;
    1370                 :     703938 :         nargs++;
    1371                 :            :     }
    1372                 :            : 
    1373                 :     703938 :     result = _PyObject_VectorcallTstate(tstate, lz->func, stack, nargs, NULL);
    1374                 :            : 
    1375                 :     739352 : exit:
    1376         [ +  + ]:    1443290 :     for (Py_ssize_t i=0; i < nargs; i++) {
    1377                 :     703938 :         Py_DECREF(stack[i]);
    1378                 :            :     }
    1379         [ -  + ]:     739352 :     if (stack != small_stack) {
    1380                 :          0 :         PyMem_Free(stack);
    1381                 :            :     }
    1382                 :     739352 :     return result;
    1383                 :            : }
    1384                 :            : 
    1385                 :            : static PyObject *
    1386                 :          0 : map_reduce(mapobject *lz, PyObject *Py_UNUSED(ignored))
    1387                 :            : {
    1388                 :          0 :     Py_ssize_t numargs = PyTuple_GET_SIZE(lz->iters);
    1389                 :          0 :     PyObject *args = PyTuple_New(numargs+1);
    1390                 :            :     Py_ssize_t i;
    1391         [ #  # ]:          0 :     if (args == NULL)
    1392                 :          0 :         return NULL;
    1393                 :          0 :     PyTuple_SET_ITEM(args, 0, Py_NewRef(lz->func));
    1394         [ #  # ]:          0 :     for (i = 0; i<numargs; i++){
    1395                 :          0 :         PyObject *it = PyTuple_GET_ITEM(lz->iters, i);
    1396                 :          0 :         PyTuple_SET_ITEM(args, i+1, Py_NewRef(it));
    1397                 :            :     }
    1398                 :            : 
    1399                 :          0 :     return Py_BuildValue("ON", Py_TYPE(lz), args);
    1400                 :            : }
    1401                 :            : 
    1402                 :            : static PyMethodDef map_methods[] = {
    1403                 :            :     {"__reduce__", _PyCFunction_CAST(map_reduce), METH_NOARGS, reduce_doc},
    1404                 :            :     {NULL,           NULL}           /* sentinel */
    1405                 :            : };
    1406                 :            : 
    1407                 :            : 
    1408                 :            : PyDoc_STRVAR(map_doc,
    1409                 :            : "map(func, *iterables) --> map object\n\
    1410                 :            : \n\
    1411                 :            : Make an iterator that computes the function using arguments from\n\
    1412                 :            : each of the iterables.  Stops when the shortest iterable is exhausted.");
    1413                 :            : 
    1414                 :            : PyTypeObject PyMap_Type = {
    1415                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
    1416                 :            :     "map",                              /* tp_name */
    1417                 :            :     sizeof(mapobject),                  /* tp_basicsize */
    1418                 :            :     0,                                  /* tp_itemsize */
    1419                 :            :     /* methods */
    1420                 :            :     (destructor)map_dealloc,            /* tp_dealloc */
    1421                 :            :     0,                                  /* tp_vectorcall_offset */
    1422                 :            :     0,                                  /* tp_getattr */
    1423                 :            :     0,                                  /* tp_setattr */
    1424                 :            :     0,                                  /* tp_as_async */
    1425                 :            :     0,                                  /* tp_repr */
    1426                 :            :     0,                                  /* tp_as_number */
    1427                 :            :     0,                                  /* tp_as_sequence */
    1428                 :            :     0,                                  /* tp_as_mapping */
    1429                 :            :     0,                                  /* tp_hash */
    1430                 :            :     0,                                  /* tp_call */
    1431                 :            :     0,                                  /* tp_str */
    1432                 :            :     PyObject_GenericGetAttr,            /* tp_getattro */
    1433                 :            :     0,                                  /* tp_setattro */
    1434                 :            :     0,                                  /* tp_as_buffer */
    1435                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
    1436                 :            :         Py_TPFLAGS_BASETYPE,            /* tp_flags */
    1437                 :            :     map_doc,                            /* tp_doc */
    1438                 :            :     (traverseproc)map_traverse,         /* tp_traverse */
    1439                 :            :     0,                                  /* tp_clear */
    1440                 :            :     0,                                  /* tp_richcompare */
    1441                 :            :     0,                                  /* tp_weaklistoffset */
    1442                 :            :     PyObject_SelfIter,                  /* tp_iter */
    1443                 :            :     (iternextfunc)map_next,     /* tp_iternext */
    1444                 :            :     map_methods,                        /* tp_methods */
    1445                 :            :     0,                                  /* tp_members */
    1446                 :            :     0,                                  /* tp_getset */
    1447                 :            :     0,                                  /* tp_base */
    1448                 :            :     0,                                  /* tp_dict */
    1449                 :            :     0,                                  /* tp_descr_get */
    1450                 :            :     0,                                  /* tp_descr_set */
    1451                 :            :     0,                                  /* tp_dictoffset */
    1452                 :            :     0,                                  /* tp_init */
    1453                 :            :     PyType_GenericAlloc,                /* tp_alloc */
    1454                 :            :     map_new,                            /* tp_new */
    1455                 :            :     PyObject_GC_Del,                    /* tp_free */
    1456                 :            :     .tp_vectorcall = (vectorcallfunc)map_vectorcall
    1457                 :            : };
    1458                 :            : 
    1459                 :            : 
    1460                 :            : /*[clinic input]
    1461                 :            : next as builtin_next
    1462                 :            : 
    1463                 :            :     iterator: object
    1464                 :            :     default: object = NULL
    1465                 :            :     /
    1466                 :            : 
    1467                 :            : Return the next item from the iterator.
    1468                 :            : 
    1469                 :            : If default is given and the iterator is exhausted,
    1470                 :            : it is returned instead of raising StopIteration.
    1471                 :            : [clinic start generated code]*/
    1472                 :            : 
    1473                 :            : static PyObject *
    1474                 :     196835 : builtin_next_impl(PyObject *module, PyObject *iterator,
    1475                 :            :                   PyObject *default_value)
    1476                 :            : /*[clinic end generated code: output=a38a94eeb447fef9 input=180f9984f182020f]*/
    1477                 :            : {
    1478                 :            :     PyObject *res;
    1479                 :            : 
    1480         [ -  + ]:     196835 :     if (!PyIter_Check(iterator)) {
    1481                 :          0 :         PyErr_Format(PyExc_TypeError,
    1482                 :            :             "'%.200s' object is not an iterator",
    1483                 :          0 :             Py_TYPE(iterator)->tp_name);
    1484                 :          0 :         return NULL;
    1485                 :            :     }
    1486                 :            : 
    1487                 :     196835 :     res = (*Py_TYPE(iterator)->tp_iternext)(iterator);
    1488         [ +  + ]:     196835 :     if (res != NULL) {
    1489                 :      99171 :         return res;
    1490         [ -  + ]:      97664 :     } else if (default_value != NULL) {
    1491         [ #  # ]:          0 :         if (PyErr_Occurred()) {
    1492         [ #  # ]:          0 :             if(!PyErr_ExceptionMatches(PyExc_StopIteration))
    1493                 :          0 :                 return NULL;
    1494                 :          0 :             PyErr_Clear();
    1495                 :            :         }
    1496                 :          0 :         return Py_NewRef(default_value);
    1497         [ -  + ]:      97664 :     } else if (PyErr_Occurred()) {
    1498                 :          0 :         return NULL;
    1499                 :            :     } else {
    1500                 :      97664 :         PyErr_SetNone(PyExc_StopIteration);
    1501                 :      97664 :         return NULL;
    1502                 :            :     }
    1503                 :            : }
    1504                 :            : 
    1505                 :            : 
    1506                 :            : /*[clinic input]
    1507                 :            : setattr as builtin_setattr
    1508                 :            : 
    1509                 :            :     obj: object
    1510                 :            :     name: object
    1511                 :            :     value: object
    1512                 :            :     /
    1513                 :            : 
    1514                 :            : Sets the named attribute on the given object to the specified value.
    1515                 :            : 
    1516                 :            : setattr(x, 'y', v) is equivalent to ``x.y = v``
    1517                 :            : [clinic start generated code]*/
    1518                 :            : 
    1519                 :            : static PyObject *
    1520                 :       2427 : builtin_setattr_impl(PyObject *module, PyObject *obj, PyObject *name,
    1521                 :            :                      PyObject *value)
    1522                 :            : /*[clinic end generated code: output=dc2ce1d1add9acb4 input=5e26417f2e8598d4]*/
    1523                 :            : {
    1524         [ -  + ]:       2427 :     if (PyObject_SetAttr(obj, name, value) != 0)
    1525                 :          0 :         return NULL;
    1526                 :       2427 :     Py_RETURN_NONE;
    1527                 :            : }
    1528                 :            : 
    1529                 :            : 
    1530                 :            : /*[clinic input]
    1531                 :            : delattr as builtin_delattr
    1532                 :            : 
    1533                 :            :     obj: object
    1534                 :            :     name: object
    1535                 :            :     /
    1536                 :            : 
    1537                 :            : Deletes the named attribute from the given object.
    1538                 :            : 
    1539                 :            : delattr(x, 'y') is equivalent to ``del x.y``
    1540                 :            : [clinic start generated code]*/
    1541                 :            : 
    1542                 :            : static PyObject *
    1543                 :        187 : builtin_delattr_impl(PyObject *module, PyObject *obj, PyObject *name)
    1544                 :            : /*[clinic end generated code: output=85134bc58dff79fa input=164865623abe7216]*/
    1545                 :            : {
    1546         [ -  + ]:        187 :     if (PyObject_SetAttr(obj, name, (PyObject *)NULL) != 0)
    1547                 :          0 :         return NULL;
    1548                 :        187 :     Py_RETURN_NONE;
    1549                 :            : }
    1550                 :            : 
    1551                 :            : 
    1552                 :            : /*[clinic input]
    1553                 :            : hash as builtin_hash
    1554                 :            : 
    1555                 :            :     obj: object
    1556                 :            :     /
    1557                 :            : 
    1558                 :            : Return the hash value for the given object.
    1559                 :            : 
    1560                 :            : Two objects that compare equal must also have the same hash value, but the
    1561                 :            : reverse is not necessarily true.
    1562                 :            : [clinic start generated code]*/
    1563                 :            : 
    1564                 :            : static PyObject *
    1565                 :        317 : builtin_hash(PyObject *module, PyObject *obj)
    1566                 :            : /*[clinic end generated code: output=237668e9d7688db7 input=58c48be822bf9c54]*/
    1567                 :            : {
    1568                 :            :     Py_hash_t x;
    1569                 :            : 
    1570                 :        317 :     x = PyObject_Hash(obj);
    1571         [ -  + ]:        317 :     if (x == -1)
    1572                 :          0 :         return NULL;
    1573                 :        317 :     return PyLong_FromSsize_t(x);
    1574                 :            : }
    1575                 :            : 
    1576                 :            : 
    1577                 :            : /*[clinic input]
    1578                 :            : hex as builtin_hex
    1579                 :            : 
    1580                 :            :     number: object
    1581                 :            :     /
    1582                 :            : 
    1583                 :            : Return the hexadecimal representation of an integer.
    1584                 :            : 
    1585                 :            :    >>> hex(12648430)
    1586                 :            :    '0xc0ffee'
    1587                 :            : [clinic start generated code]*/
    1588                 :            : 
    1589                 :            : static PyObject *
    1590                 :          0 : builtin_hex(PyObject *module, PyObject *number)
    1591                 :            : /*[clinic end generated code: output=e46b612169099408 input=e645aff5fc7d540e]*/
    1592                 :            : {
    1593                 :          0 :     return PyNumber_ToBase(number, 16);
    1594                 :            : }
    1595                 :            : 
    1596                 :            : 
    1597                 :            : /*[clinic input]
    1598                 :            : iter as builtin_iter
    1599                 :            : 
    1600                 :            :     object: object
    1601                 :            :     sentinel: object = NULL
    1602                 :            :     /
    1603                 :            : 
    1604                 :            : Get an iterator from an object.
    1605                 :            : 
    1606                 :            : In the first form, the argument must supply its own iterator, or be a sequence.
    1607                 :            : In the second form, the callable is called until it returns the sentinel.
    1608                 :            : [clinic start generated code]*/
    1609                 :            : 
    1610                 :            : static PyObject *
    1611                 :        428 : builtin_iter_impl(PyObject *module, PyObject *object, PyObject *sentinel)
    1612                 :            : /*[clinic end generated code: output=12cf64203c195a94 input=a5d64d9d81880ba6]*/
    1613                 :            : {
    1614         [ +  - ]:        428 :     if (sentinel == NULL)
    1615                 :        428 :         return PyObject_GetIter(object);
    1616         [ #  # ]:          0 :     if (!PyCallable_Check(object)) {
    1617                 :          0 :         PyErr_SetString(PyExc_TypeError,
    1618                 :            :                         "iter(object, sentinel): object must be callable");
    1619                 :          0 :         return NULL;
    1620                 :            :     }
    1621                 :          0 :     return PyCallIter_New(object, sentinel);
    1622                 :            : }
    1623                 :            : 
    1624                 :            : 
    1625                 :            : /*[clinic input]
    1626                 :            : aiter as builtin_aiter
    1627                 :            : 
    1628                 :            :     async_iterable: object
    1629                 :            :     /
    1630                 :            : 
    1631                 :            : Return an AsyncIterator for an AsyncIterable object.
    1632                 :            : [clinic start generated code]*/
    1633                 :            : 
    1634                 :            : static PyObject *
    1635                 :          0 : builtin_aiter(PyObject *module, PyObject *async_iterable)
    1636                 :            : /*[clinic end generated code: output=1bae108d86f7960e input=473993d0cacc7d23]*/
    1637                 :            : {
    1638                 :          0 :     return PyObject_GetAIter(async_iterable);
    1639                 :            : }
    1640                 :            : 
    1641                 :            : PyObject *PyAnextAwaitable_New(PyObject *, PyObject *);
    1642                 :            : 
    1643                 :            : /*[clinic input]
    1644                 :            : anext as builtin_anext
    1645                 :            : 
    1646                 :            :     aiterator: object
    1647                 :            :     default: object = NULL
    1648                 :            :     /
    1649                 :            : 
    1650                 :            : async anext(aiterator[, default])
    1651                 :            : 
    1652                 :            : Return the next item from the async iterator.  If default is given and the async
    1653                 :            : iterator is exhausted, it is returned instead of raising StopAsyncIteration.
    1654                 :            : [clinic start generated code]*/
    1655                 :            : 
    1656                 :            : static PyObject *
    1657                 :          0 : builtin_anext_impl(PyObject *module, PyObject *aiterator,
    1658                 :            :                    PyObject *default_value)
    1659                 :            : /*[clinic end generated code: output=f02c060c163a81fa input=8f63f4f78590bb4c]*/
    1660                 :            : {
    1661                 :            :     PyTypeObject *t;
    1662                 :            :     PyObject *awaitable;
    1663                 :            : 
    1664                 :          0 :     t = Py_TYPE(aiterator);
    1665   [ #  #  #  # ]:          0 :     if (t->tp_as_async == NULL || t->tp_as_async->am_anext == NULL) {
    1666                 :          0 :         PyErr_Format(PyExc_TypeError,
    1667                 :            :             "'%.200s' object is not an async iterator",
    1668                 :            :             t->tp_name);
    1669                 :          0 :         return NULL;
    1670                 :            :     }
    1671                 :            : 
    1672                 :          0 :     awaitable = (*t->tp_as_async->am_anext)(aiterator);
    1673         [ #  # ]:          0 :     if (default_value == NULL) {
    1674                 :          0 :         return awaitable;
    1675                 :            :     }
    1676                 :            : 
    1677                 :          0 :     PyObject* new_awaitable = PyAnextAwaitable_New(
    1678                 :            :             awaitable, default_value);
    1679                 :          0 :     Py_DECREF(awaitable);
    1680                 :          0 :     return new_awaitable;
    1681                 :            : }
    1682                 :            : 
    1683                 :            : 
    1684                 :            : /*[clinic input]
    1685                 :            : len as builtin_len
    1686                 :            : 
    1687                 :            :     obj: object
    1688                 :            :     /
    1689                 :            : 
    1690                 :            : Return the number of items in a container.
    1691                 :            : [clinic start generated code]*/
    1692                 :            : 
    1693                 :            : static PyObject *
    1694                 :        627 : builtin_len(PyObject *module, PyObject *obj)
    1695                 :            : /*[clinic end generated code: output=fa7a270d314dfb6c input=bc55598da9e9c9b5]*/
    1696                 :            : {
    1697                 :            :     Py_ssize_t res;
    1698                 :            : 
    1699                 :        627 :     res = PyObject_Size(obj);
    1700         [ -  + ]:        627 :     if (res < 0) {
    1701                 :            :         assert(PyErr_Occurred());
    1702                 :          0 :         return NULL;
    1703                 :            :     }
    1704                 :        627 :     return PyLong_FromSsize_t(res);
    1705                 :            : }
    1706                 :            : 
    1707                 :            : 
    1708                 :            : /*[clinic input]
    1709                 :            : locals as builtin_locals
    1710                 :            : 
    1711                 :            : Return a dictionary containing the current scope's local variables.
    1712                 :            : 
    1713                 :            : NOTE: Whether or not updates to this dictionary will affect name lookups in
    1714                 :            : the local scope and vice-versa is *implementation dependent* and not
    1715                 :            : covered by any backwards compatibility guarantees.
    1716                 :            : [clinic start generated code]*/
    1717                 :            : 
    1718                 :            : static PyObject *
    1719                 :          2 : builtin_locals_impl(PyObject *module)
    1720                 :            : /*[clinic end generated code: output=b46c94015ce11448 input=7874018d478d5c4b]*/
    1721                 :            : {
    1722                 :            :     PyObject *d;
    1723                 :            : 
    1724                 :          2 :     d = PyEval_GetLocals();
    1725                 :          2 :     return Py_XNewRef(d);
    1726                 :            : }
    1727                 :            : 
    1728                 :            : 
    1729                 :            : static PyObject *
    1730                 :     112860 : min_max(PyObject *args, PyObject *kwds, int op)
    1731                 :            : {
    1732                 :     112860 :     PyObject *v, *it, *item, *val, *maxitem, *maxval, *keyfunc=NULL;
    1733                 :     112860 :     PyObject *emptytuple, *defaultval = NULL;
    1734                 :            :     static char *kwlist[] = {"key", "default", NULL};
    1735         [ +  + ]:     112860 :     const char *name = op == Py_LT ? "min" : "max";
    1736                 :     112860 :     const int positional = PyTuple_Size(args) > 1;
    1737                 :            :     int ret;
    1738                 :            : 
    1739         [ +  + ]:     112860 :     if (positional) {
    1740                 :     111415 :         v = args;
    1741                 :            :     }
    1742         [ -  + ]:       1445 :     else if (!PyArg_UnpackTuple(args, name, 1, 1, &v)) {
    1743   [ #  #  #  # ]:          0 :         if (PyExceptionClass_Check(PyExc_TypeError)) {
    1744                 :          0 :             PyErr_Format(PyExc_TypeError, "%s expected at least 1 argument, got 0", name);
    1745                 :            :         }
    1746                 :          0 :         return NULL;
    1747                 :            :     }
    1748                 :            : 
    1749                 :     112860 :     emptytuple = PyTuple_New(0);
    1750         [ -  + ]:     112860 :     if (emptytuple == NULL)
    1751                 :          0 :         return NULL;
    1752         [ +  + ]:     112860 :     ret = PyArg_ParseTupleAndKeywords(emptytuple, kwds,
    1753                 :            :                                       (op == Py_LT) ? "|$OO:min" : "|$OO:max",
    1754                 :            :                                       kwlist, &keyfunc, &defaultval);
    1755                 :     112860 :     Py_DECREF(emptytuple);
    1756         [ -  + ]:     112860 :     if (!ret)
    1757                 :          0 :         return NULL;
    1758                 :            : 
    1759   [ +  +  -  + ]:     112860 :     if (positional && defaultval != NULL) {
    1760                 :          0 :         PyErr_Format(PyExc_TypeError,
    1761                 :            :                         "Cannot specify a default for %s() with multiple "
    1762                 :            :                         "positional arguments", name);
    1763                 :          0 :         return NULL;
    1764                 :            :     }
    1765                 :            : 
    1766                 :     112860 :     it = PyObject_GetIter(v);
    1767         [ -  + ]:     112860 :     if (it == NULL) {
    1768                 :          0 :         return NULL;
    1769                 :            :     }
    1770                 :            : 
    1771         [ -  + ]:     112860 :     if (keyfunc == Py_None) {
    1772                 :          0 :         keyfunc = NULL;
    1773                 :            :     }
    1774                 :            : 
    1775                 :     112860 :     maxitem = NULL; /* the result */
    1776                 :     112860 :     maxval = NULL;  /* the value associated with the result */
    1777         [ +  + ]:     337400 :     while (( item = PyIter_Next(it) )) {
    1778                 :            :         /* get the value from the key function */
    1779         [ -  + ]:     224540 :         if (keyfunc != NULL) {
    1780                 :          0 :             val = PyObject_CallOneArg(keyfunc, item);
    1781         [ #  # ]:          0 :             if (val == NULL)
    1782                 :          0 :                 goto Fail_it_item;
    1783                 :            :         }
    1784                 :            :         /* no key function; the value is the item */
    1785                 :            :         else {
    1786                 :     224540 :             val = Py_NewRef(item);
    1787                 :            :         }
    1788                 :            : 
    1789                 :            :         /* maximum value and item are unset; set them */
    1790         [ +  + ]:     224540 :         if (maxval == NULL) {
    1791                 :     112860 :             maxitem = item;
    1792                 :     112860 :             maxval = val;
    1793                 :            :         }
    1794                 :            :         /* maximum value and item are set; update them as necessary */
    1795                 :            :         else {
    1796                 :     111680 :             int cmp = PyObject_RichCompareBool(val, maxval, op);
    1797         [ -  + ]:     111680 :             if (cmp < 0)
    1798                 :          0 :                 goto Fail_it_item_and_val;
    1799         [ +  + ]:     111680 :             else if (cmp > 0) {
    1800                 :       8817 :                 Py_DECREF(maxval);
    1801                 :       8817 :                 Py_DECREF(maxitem);
    1802                 :       8817 :                 maxval = val;
    1803                 :       8817 :                 maxitem = item;
    1804                 :            :             }
    1805                 :            :             else {
    1806                 :     102863 :                 Py_DECREF(item);
    1807                 :     102863 :                 Py_DECREF(val);
    1808                 :            :             }
    1809                 :            :         }
    1810                 :            :     }
    1811         [ -  + ]:     112860 :     if (PyErr_Occurred())
    1812                 :          0 :         goto Fail_it;
    1813         [ -  + ]:     112860 :     if (maxval == NULL) {
    1814                 :            :         assert(maxitem == NULL);
    1815         [ #  # ]:          0 :         if (defaultval != NULL) {
    1816                 :          0 :             maxitem = Py_NewRef(defaultval);
    1817                 :            :         } else {
    1818                 :          0 :             PyErr_Format(PyExc_ValueError,
    1819                 :            :                          "%s() iterable argument is empty", name);
    1820                 :            :         }
    1821                 :            :     }
    1822                 :            :     else
    1823                 :     112860 :         Py_DECREF(maxval);
    1824                 :     112860 :     Py_DECREF(it);
    1825                 :     112860 :     return maxitem;
    1826                 :            : 
    1827                 :          0 : Fail_it_item_and_val:
    1828                 :          0 :     Py_DECREF(val);
    1829                 :          0 : Fail_it_item:
    1830                 :          0 :     Py_DECREF(item);
    1831                 :          0 : Fail_it:
    1832                 :          0 :     Py_XDECREF(maxval);
    1833                 :          0 :     Py_XDECREF(maxitem);
    1834                 :          0 :     Py_DECREF(it);
    1835                 :          0 :     return NULL;
    1836                 :            : }
    1837                 :            : 
    1838                 :            : /* AC: cannot convert yet, waiting for *args support */
    1839                 :            : static PyObject *
    1840                 :       1324 : builtin_min(PyObject *self, PyObject *args, PyObject *kwds)
    1841                 :            : {
    1842                 :       1324 :     return min_max(args, kwds, Py_LT);
    1843                 :            : }
    1844                 :            : 
    1845                 :            : PyDoc_STRVAR(min_doc,
    1846                 :            : "min(iterable, *[, default=obj, key=func]) -> value\n\
    1847                 :            : min(arg1, arg2, *args, *[, key=func]) -> value\n\
    1848                 :            : \n\
    1849                 :            : With a single iterable argument, return its smallest item. The\n\
    1850                 :            : default keyword-only argument specifies an object to return if\n\
    1851                 :            : the provided iterable is empty.\n\
    1852                 :            : With two or more arguments, return the smallest argument.");
    1853                 :            : 
    1854                 :            : 
    1855                 :            : /* AC: cannot convert yet, waiting for *args support */
    1856                 :            : static PyObject *
    1857                 :     111536 : builtin_max(PyObject *self, PyObject *args, PyObject *kwds)
    1858                 :            : {
    1859                 :     111536 :     return min_max(args, kwds, Py_GT);
    1860                 :            : }
    1861                 :            : 
    1862                 :            : PyDoc_STRVAR(max_doc,
    1863                 :            : "max(iterable, *[, default=obj, key=func]) -> value\n\
    1864                 :            : max(arg1, arg2, *args, *[, key=func]) -> value\n\
    1865                 :            : \n\
    1866                 :            : With a single iterable argument, return its biggest item. The\n\
    1867                 :            : default keyword-only argument specifies an object to return if\n\
    1868                 :            : the provided iterable is empty.\n\
    1869                 :            : With two or more arguments, return the largest argument.");
    1870                 :            : 
    1871                 :            : 
    1872                 :            : /*[clinic input]
    1873                 :            : oct as builtin_oct
    1874                 :            : 
    1875                 :            :     number: object
    1876                 :            :     /
    1877                 :            : 
    1878                 :            : Return the octal representation of an integer.
    1879                 :            : 
    1880                 :            :    >>> oct(342391)
    1881                 :            :    '0o1234567'
    1882                 :            : [clinic start generated code]*/
    1883                 :            : 
    1884                 :            : static PyObject *
    1885                 :          0 : builtin_oct(PyObject *module, PyObject *number)
    1886                 :            : /*[clinic end generated code: output=40a34656b6875352 input=ad6b274af4016c72]*/
    1887                 :            : {
    1888                 :          0 :     return PyNumber_ToBase(number, 8);
    1889                 :            : }
    1890                 :            : 
    1891                 :            : 
    1892                 :            : /*[clinic input]
    1893                 :            : ord as builtin_ord
    1894                 :            : 
    1895                 :            :     c: object
    1896                 :            :     /
    1897                 :            : 
    1898                 :            : Return the Unicode code point for a one-character string.
    1899                 :            : [clinic start generated code]*/
    1900                 :            : 
    1901                 :            : static PyObject *
    1902                 :       2504 : builtin_ord(PyObject *module, PyObject *c)
    1903                 :            : /*[clinic end generated code: output=4fa5e87a323bae71 input=3064e5d6203ad012]*/
    1904                 :            : {
    1905                 :            :     long ord;
    1906                 :            :     Py_ssize_t size;
    1907                 :            : 
    1908         [ -  + ]:       2504 :     if (PyBytes_Check(c)) {
    1909                 :          0 :         size = PyBytes_GET_SIZE(c);
    1910         [ #  # ]:          0 :         if (size == 1) {
    1911                 :          0 :             ord = (long)((unsigned char)*PyBytes_AS_STRING(c));
    1912                 :          0 :             return PyLong_FromLong(ord);
    1913                 :            :         }
    1914                 :            :     }
    1915         [ +  - ]:       2504 :     else if (PyUnicode_Check(c)) {
    1916         [ -  + ]:       2504 :         if (PyUnicode_READY(c) == -1)
    1917                 :          0 :             return NULL;
    1918                 :       2504 :         size = PyUnicode_GET_LENGTH(c);
    1919         [ +  - ]:       2504 :         if (size == 1) {
    1920                 :       2504 :             ord = (long)PyUnicode_READ_CHAR(c, 0);
    1921                 :       2504 :             return PyLong_FromLong(ord);
    1922                 :            :         }
    1923                 :            :     }
    1924         [ #  # ]:          0 :     else if (PyByteArray_Check(c)) {
    1925                 :            :         /* XXX Hopefully this is temporary */
    1926                 :          0 :         size = PyByteArray_GET_SIZE(c);
    1927         [ #  # ]:          0 :         if (size == 1) {
    1928                 :          0 :             ord = (long)((unsigned char)*PyByteArray_AS_STRING(c));
    1929                 :          0 :             return PyLong_FromLong(ord);
    1930                 :            :         }
    1931                 :            :     }
    1932                 :            :     else {
    1933                 :          0 :         PyErr_Format(PyExc_TypeError,
    1934                 :            :                      "ord() expected string of length 1, but " \
    1935                 :          0 :                      "%.200s found", Py_TYPE(c)->tp_name);
    1936                 :          0 :         return NULL;
    1937                 :            :     }
    1938                 :            : 
    1939                 :          0 :     PyErr_Format(PyExc_TypeError,
    1940                 :            :                  "ord() expected a character, "
    1941                 :            :                  "but string of length %zd found",
    1942                 :            :                  size);
    1943                 :          0 :     return NULL;
    1944                 :            : }
    1945                 :            : 
    1946                 :            : 
    1947                 :            : /*[clinic input]
    1948                 :            : pow as builtin_pow
    1949                 :            : 
    1950                 :            :     base: object
    1951                 :            :     exp: object
    1952                 :            :     mod: object = None
    1953                 :            : 
    1954                 :            : Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
    1955                 :            : 
    1956                 :            : Some types, such as ints, are able to use a more efficient algorithm when
    1957                 :            : invoked using the three argument form.
    1958                 :            : [clinic start generated code]*/
    1959                 :            : 
    1960                 :            : static PyObject *
    1961                 :          0 : builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp,
    1962                 :            :                  PyObject *mod)
    1963                 :            : /*[clinic end generated code: output=3ca1538221bbf15f input=435dbd48a12efb23]*/
    1964                 :            : {
    1965                 :          0 :     return PyNumber_Power(base, exp, mod);
    1966                 :            : }
    1967                 :            : 
    1968                 :            : /*[clinic input]
    1969                 :            : print as builtin_print
    1970                 :            : 
    1971                 :            :     *args: object
    1972                 :            :     sep: object(c_default="Py_None") = ' '
    1973                 :            :         string inserted between values, default a space.
    1974                 :            :     end: object(c_default="Py_None") = '\n'
    1975                 :            :         string appended after the last value, default a newline.
    1976                 :            :     file: object = None
    1977                 :            :         a file-like object (stream); defaults to the current sys.stdout.
    1978                 :            :     flush: bool = False
    1979                 :            :         whether to forcibly flush the stream.
    1980                 :            : 
    1981                 :            : Prints the values to a stream, or to sys.stdout by default.
    1982                 :            : 
    1983                 :            : [clinic start generated code]*/
    1984                 :            : 
    1985                 :            : static PyObject *
    1986                 :         48 : builtin_print_impl(PyObject *module, PyObject *args, PyObject *sep,
    1987                 :            :                    PyObject *end, PyObject *file, int flush)
    1988                 :            : /*[clinic end generated code: output=3cfc0940f5bc237b input=c143c575d24fe665]*/
    1989                 :            : {
    1990                 :            :     int i, err;
    1991                 :            : 
    1992         [ +  + ]:         48 :     if (file == Py_None) {
    1993                 :         12 :         PyThreadState *tstate = _PyThreadState_GET();
    1994                 :         12 :         file = _PySys_GetAttr(tstate, &_Py_ID(stdout));
    1995         [ -  + ]:         12 :         if (file == NULL) {
    1996                 :          0 :             PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
    1997                 :          0 :             return NULL;
    1998                 :            :         }
    1999                 :            : 
    2000                 :            :         /* sys.stdout may be None when FILE* stdout isn't connected */
    2001         [ -  + ]:         12 :         if (file == Py_None) {
    2002                 :          0 :             Py_RETURN_NONE;
    2003                 :            :         }
    2004                 :            :     }
    2005                 :            : 
    2006         [ +  - ]:         48 :     if (sep == Py_None) {
    2007                 :         48 :         sep = NULL;
    2008                 :            :     }
    2009   [ #  #  #  # ]:          0 :     else if (sep && !PyUnicode_Check(sep)) {
    2010                 :          0 :         PyErr_Format(PyExc_TypeError,
    2011                 :            :                      "sep must be None or a string, not %.200s",
    2012                 :          0 :                      Py_TYPE(sep)->tp_name);
    2013                 :          0 :         return NULL;
    2014                 :            :     }
    2015         [ +  + ]:         48 :     if (end == Py_None) {
    2016                 :         12 :         end = NULL;
    2017                 :            :     }
    2018   [ +  -  -  + ]:         36 :     else if (end && !PyUnicode_Check(end)) {
    2019                 :          0 :         PyErr_Format(PyExc_TypeError,
    2020                 :            :                      "end must be None or a string, not %.200s",
    2021                 :          0 :                      Py_TYPE(end)->tp_name);
    2022                 :          0 :         return NULL;
    2023                 :            :     }
    2024                 :            : 
    2025         [ +  + ]:         94 :     for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
    2026         [ +  + ]:         46 :         if (i > 0) {
    2027         [ +  - ]:          1 :             if (sep == NULL) {
    2028                 :          1 :                 err = PyFile_WriteString(" ", file);
    2029                 :            :             }
    2030                 :            :             else {
    2031                 :          0 :                 err = PyFile_WriteObject(sep, file, Py_PRINT_RAW);
    2032                 :            :             }
    2033         [ -  + ]:          1 :             if (err) {
    2034                 :          0 :                 return NULL;
    2035                 :            :             }
    2036                 :            :         }
    2037                 :         46 :         err = PyFile_WriteObject(PyTuple_GET_ITEM(args, i), file, Py_PRINT_RAW);
    2038         [ -  + ]:         46 :         if (err) {
    2039                 :          0 :             return NULL;
    2040                 :            :         }
    2041                 :            :     }
    2042                 :            : 
    2043         [ +  + ]:         48 :     if (end == NULL) {
    2044                 :         12 :         err = PyFile_WriteString("\n", file);
    2045                 :            :     }
    2046                 :            :     else {
    2047                 :         36 :         err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
    2048                 :            :     }
    2049         [ -  + ]:         48 :     if (err) {
    2050                 :          0 :         return NULL;
    2051                 :            :     }
    2052                 :            : 
    2053         [ +  + ]:         48 :     if (flush) {
    2054                 :          2 :         PyObject *tmp = PyObject_CallMethodNoArgs(file, &_Py_ID(flush));
    2055         [ -  + ]:          2 :         if (tmp == NULL) {
    2056                 :          0 :             return NULL;
    2057                 :            :         }
    2058                 :          2 :         Py_DECREF(tmp);
    2059                 :            :     }
    2060                 :            : 
    2061                 :         48 :     Py_RETURN_NONE;
    2062                 :            : }
    2063                 :            : 
    2064                 :            : 
    2065                 :            : /*[clinic input]
    2066                 :            : input as builtin_input
    2067                 :            : 
    2068                 :            :     prompt: object(c_default="NULL") = ""
    2069                 :            :     /
    2070                 :            : 
    2071                 :            : Read a string from standard input.  The trailing newline is stripped.
    2072                 :            : 
    2073                 :            : The prompt string, if given, is printed to standard output without a
    2074                 :            : trailing newline before reading input.
    2075                 :            : 
    2076                 :            : If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
    2077                 :            : On *nix systems, readline is used if available.
    2078                 :            : [clinic start generated code]*/
    2079                 :            : 
    2080                 :            : static PyObject *
    2081                 :          0 : builtin_input_impl(PyObject *module, PyObject *prompt)
    2082                 :            : /*[clinic end generated code: output=83db5a191e7a0d60 input=159c46d4ae40977e]*/
    2083                 :            : {
    2084                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2085                 :          0 :     PyObject *fin = _PySys_GetAttr(
    2086                 :            :         tstate, &_Py_ID(stdin));
    2087                 :          0 :     PyObject *fout = _PySys_GetAttr(
    2088                 :            :         tstate, &_Py_ID(stdout));
    2089                 :          0 :     PyObject *ferr = _PySys_GetAttr(
    2090                 :            :         tstate, &_Py_ID(stderr));
    2091                 :            :     PyObject *tmp;
    2092                 :            :     long fd;
    2093                 :            :     int tty;
    2094                 :            : 
    2095                 :            :     /* Check that stdin/out/err are intact */
    2096   [ #  #  #  # ]:          0 :     if (fin == NULL || fin == Py_None) {
    2097                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
    2098                 :            :                         "input(): lost sys.stdin");
    2099                 :          0 :         return NULL;
    2100                 :            :     }
    2101   [ #  #  #  # ]:          0 :     if (fout == NULL || fout == Py_None) {
    2102                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
    2103                 :            :                         "input(): lost sys.stdout");
    2104                 :          0 :         return NULL;
    2105                 :            :     }
    2106   [ #  #  #  # ]:          0 :     if (ferr == NULL || ferr == Py_None) {
    2107                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
    2108                 :            :                         "input(): lost sys.stderr");
    2109                 :          0 :         return NULL;
    2110                 :            :     }
    2111                 :            : 
    2112   [ #  #  #  # ]:          0 :     if (PySys_Audit("builtins.input", "O", prompt ? prompt : Py_None) < 0) {
    2113                 :          0 :         return NULL;
    2114                 :            :     }
    2115                 :            : 
    2116                 :            :     /* First of all, flush stderr */
    2117                 :          0 :     tmp = PyObject_CallMethodNoArgs(ferr, &_Py_ID(flush));
    2118         [ #  # ]:          0 :     if (tmp == NULL)
    2119                 :          0 :         PyErr_Clear();
    2120                 :            :     else
    2121                 :          0 :         Py_DECREF(tmp);
    2122                 :            : 
    2123                 :            :     /* We should only use (GNU) readline if Python's sys.stdin and
    2124                 :            :        sys.stdout are the same as C's stdin and stdout, because we
    2125                 :            :        need to pass it those. */
    2126                 :          0 :     tmp = PyObject_CallMethodNoArgs(fin, &_Py_ID(fileno));
    2127         [ #  # ]:          0 :     if (tmp == NULL) {
    2128                 :          0 :         PyErr_Clear();
    2129                 :          0 :         tty = 0;
    2130                 :            :     }
    2131                 :            :     else {
    2132                 :          0 :         fd = PyLong_AsLong(tmp);
    2133                 :          0 :         Py_DECREF(tmp);
    2134   [ #  #  #  # ]:          0 :         if (fd < 0 && PyErr_Occurred())
    2135                 :          0 :             return NULL;
    2136   [ #  #  #  # ]:          0 :         tty = fd == fileno(stdin) && isatty(fd);
    2137                 :            :     }
    2138         [ #  # ]:          0 :     if (tty) {
    2139                 :          0 :         tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(fileno));
    2140         [ #  # ]:          0 :         if (tmp == NULL) {
    2141                 :          0 :             PyErr_Clear();
    2142                 :          0 :             tty = 0;
    2143                 :            :         }
    2144                 :            :         else {
    2145                 :          0 :             fd = PyLong_AsLong(tmp);
    2146                 :          0 :             Py_DECREF(tmp);
    2147   [ #  #  #  # ]:          0 :             if (fd < 0 && PyErr_Occurred())
    2148                 :          0 :                 return NULL;
    2149   [ #  #  #  # ]:          0 :             tty = fd == fileno(stdout) && isatty(fd);
    2150                 :            :         }
    2151                 :            :     }
    2152                 :            : 
    2153                 :            :     /* If we're interactive, use (GNU) readline */
    2154         [ #  # ]:          0 :     if (tty) {
    2155                 :          0 :         PyObject *po = NULL;
    2156                 :            :         const char *promptstr;
    2157                 :          0 :         char *s = NULL;
    2158                 :          0 :         PyObject *stdin_encoding = NULL, *stdin_errors = NULL;
    2159                 :          0 :         PyObject *stdout_encoding = NULL, *stdout_errors = NULL;
    2160                 :            :         const char *stdin_encoding_str, *stdin_errors_str;
    2161                 :            :         PyObject *result;
    2162                 :            :         size_t len;
    2163                 :            : 
    2164                 :            :         /* stdin is a text stream, so it must have an encoding. */
    2165                 :          0 :         stdin_encoding = PyObject_GetAttr(fin, &_Py_ID(encoding));
    2166                 :          0 :         stdin_errors = PyObject_GetAttr(fin, &_Py_ID(errors));
    2167   [ #  #  #  #  :          0 :         if (!stdin_encoding || !stdin_errors ||
                   #  # ]
    2168         [ #  # ]:          0 :                 !PyUnicode_Check(stdin_encoding) ||
    2169                 :          0 :                 !PyUnicode_Check(stdin_errors)) {
    2170                 :          0 :             tty = 0;
    2171                 :          0 :             goto _readline_errors;
    2172                 :            :         }
    2173                 :          0 :         stdin_encoding_str = PyUnicode_AsUTF8(stdin_encoding);
    2174                 :          0 :         stdin_errors_str = PyUnicode_AsUTF8(stdin_errors);
    2175   [ #  #  #  # ]:          0 :         if (!stdin_encoding_str || !stdin_errors_str)
    2176                 :          0 :             goto _readline_errors;
    2177                 :          0 :         tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(flush));
    2178         [ #  # ]:          0 :         if (tmp == NULL)
    2179                 :          0 :             PyErr_Clear();
    2180                 :            :         else
    2181                 :          0 :             Py_DECREF(tmp);
    2182         [ #  # ]:          0 :         if (prompt != NULL) {
    2183                 :            :             /* We have a prompt, encode it as stdout would */
    2184                 :            :             const char *stdout_encoding_str, *stdout_errors_str;
    2185                 :            :             PyObject *stringpo;
    2186                 :          0 :             stdout_encoding = PyObject_GetAttr(fout, &_Py_ID(encoding));
    2187                 :          0 :             stdout_errors = PyObject_GetAttr(fout, &_Py_ID(errors));
    2188   [ #  #  #  #  :          0 :             if (!stdout_encoding || !stdout_errors ||
                   #  # ]
    2189         [ #  # ]:          0 :                     !PyUnicode_Check(stdout_encoding) ||
    2190                 :          0 :                     !PyUnicode_Check(stdout_errors)) {
    2191                 :          0 :                 tty = 0;
    2192                 :          0 :                 goto _readline_errors;
    2193                 :            :             }
    2194                 :          0 :             stdout_encoding_str = PyUnicode_AsUTF8(stdout_encoding);
    2195                 :          0 :             stdout_errors_str = PyUnicode_AsUTF8(stdout_errors);
    2196   [ #  #  #  # ]:          0 :             if (!stdout_encoding_str || !stdout_errors_str)
    2197                 :          0 :                 goto _readline_errors;
    2198                 :          0 :             stringpo = PyObject_Str(prompt);
    2199         [ #  # ]:          0 :             if (stringpo == NULL)
    2200                 :          0 :                 goto _readline_errors;
    2201                 :          0 :             po = PyUnicode_AsEncodedString(stringpo,
    2202                 :            :                 stdout_encoding_str, stdout_errors_str);
    2203         [ #  # ]:          0 :             Py_CLEAR(stdout_encoding);
    2204         [ #  # ]:          0 :             Py_CLEAR(stdout_errors);
    2205         [ #  # ]:          0 :             Py_CLEAR(stringpo);
    2206         [ #  # ]:          0 :             if (po == NULL)
    2207                 :          0 :                 goto _readline_errors;
    2208                 :            :             assert(PyBytes_Check(po));
    2209                 :          0 :             promptstr = PyBytes_AS_STRING(po);
    2210                 :            :         }
    2211                 :            :         else {
    2212                 :          0 :             po = NULL;
    2213                 :          0 :             promptstr = "";
    2214                 :            :         }
    2215                 :          0 :         s = PyOS_Readline(stdin, stdout, promptstr);
    2216         [ #  # ]:          0 :         if (s == NULL) {
    2217                 :          0 :             PyErr_CheckSignals();
    2218         [ #  # ]:          0 :             if (!PyErr_Occurred())
    2219                 :          0 :                 PyErr_SetNone(PyExc_KeyboardInterrupt);
    2220                 :          0 :             goto _readline_errors;
    2221                 :            :         }
    2222                 :            : 
    2223                 :          0 :         len = strlen(s);
    2224         [ #  # ]:          0 :         if (len == 0) {
    2225                 :          0 :             PyErr_SetNone(PyExc_EOFError);
    2226                 :          0 :             result = NULL;
    2227                 :            :         }
    2228                 :            :         else {
    2229         [ #  # ]:          0 :             if (len > PY_SSIZE_T_MAX) {
    2230                 :          0 :                 PyErr_SetString(PyExc_OverflowError,
    2231                 :            :                                 "input: input too long");
    2232                 :          0 :                 result = NULL;
    2233                 :            :             }
    2234                 :            :             else {
    2235                 :          0 :                 len--;   /* strip trailing '\n' */
    2236   [ #  #  #  # ]:          0 :                 if (len != 0 && s[len-1] == '\r')
    2237                 :          0 :                     len--;   /* strip trailing '\r' */
    2238                 :          0 :                 result = PyUnicode_Decode(s, len, stdin_encoding_str,
    2239                 :            :                                                   stdin_errors_str);
    2240                 :            :             }
    2241                 :            :         }
    2242                 :          0 :         Py_DECREF(stdin_encoding);
    2243                 :          0 :         Py_DECREF(stdin_errors);
    2244                 :          0 :         Py_XDECREF(po);
    2245                 :          0 :         PyMem_Free(s);
    2246                 :            : 
    2247         [ #  # ]:          0 :         if (result != NULL) {
    2248         [ #  # ]:          0 :             if (PySys_Audit("builtins.input/result", "O", result) < 0) {
    2249                 :          0 :                 return NULL;
    2250                 :            :             }
    2251                 :            :         }
    2252                 :            : 
    2253                 :          0 :         return result;
    2254                 :            : 
    2255                 :          0 :     _readline_errors:
    2256                 :          0 :         Py_XDECREF(stdin_encoding);
    2257                 :          0 :         Py_XDECREF(stdout_encoding);
    2258                 :          0 :         Py_XDECREF(stdin_errors);
    2259                 :          0 :         Py_XDECREF(stdout_errors);
    2260                 :          0 :         Py_XDECREF(po);
    2261         [ #  # ]:          0 :         if (tty)
    2262                 :          0 :             return NULL;
    2263                 :            : 
    2264                 :          0 :         PyErr_Clear();
    2265                 :            :     }
    2266                 :            : 
    2267                 :            :     /* Fallback if we're not interactive */
    2268         [ #  # ]:          0 :     if (prompt != NULL) {
    2269         [ #  # ]:          0 :         if (PyFile_WriteObject(prompt, fout, Py_PRINT_RAW) != 0)
    2270                 :          0 :             return NULL;
    2271                 :            :     }
    2272                 :          0 :     tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(flush));
    2273         [ #  # ]:          0 :     if (tmp == NULL)
    2274                 :          0 :         PyErr_Clear();
    2275                 :            :     else
    2276                 :          0 :         Py_DECREF(tmp);
    2277                 :          0 :     return PyFile_GetLine(fin, -1);
    2278                 :            : }
    2279                 :            : 
    2280                 :            : 
    2281                 :            : /*[clinic input]
    2282                 :            : repr as builtin_repr
    2283                 :            : 
    2284                 :            :     obj: object
    2285                 :            :     /
    2286                 :            : 
    2287                 :            : Return the canonical string representation of the object.
    2288                 :            : 
    2289                 :            : For many object types, including most builtins, eval(repr(obj)) == obj.
    2290                 :            : [clinic start generated code]*/
    2291                 :            : 
    2292                 :            : static PyObject *
    2293                 :      21681 : builtin_repr(PyObject *module, PyObject *obj)
    2294                 :            : /*[clinic end generated code: output=7ed3778c44fd0194 input=1c9e6d66d3e3be04]*/
    2295                 :            : {
    2296                 :      21681 :     return PyObject_Repr(obj);
    2297                 :            : }
    2298                 :            : 
    2299                 :            : 
    2300                 :            : /*[clinic input]
    2301                 :            : round as builtin_round
    2302                 :            : 
    2303                 :            :     number: object
    2304                 :            :     ndigits: object = None
    2305                 :            : 
    2306                 :            : Round a number to a given precision in decimal digits.
    2307                 :            : 
    2308                 :            : The return value is an integer if ndigits is omitted or None.  Otherwise
    2309                 :            : the return value has the same type as the number.  ndigits may be negative.
    2310                 :            : [clinic start generated code]*/
    2311                 :            : 
    2312                 :            : static PyObject *
    2313                 :         18 : builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits)
    2314                 :            : /*[clinic end generated code: output=ff0d9dd176c02ede input=275678471d7aca15]*/
    2315                 :            : {
    2316                 :            :     PyObject *round, *result;
    2317                 :            : 
    2318         [ -  + ]:         18 :     if (Py_TYPE(number)->tp_dict == NULL) {
    2319         [ #  # ]:          0 :         if (PyType_Ready(Py_TYPE(number)) < 0)
    2320                 :          0 :             return NULL;
    2321                 :            :     }
    2322                 :            : 
    2323                 :         18 :     round = _PyObject_LookupSpecial(number, &_Py_ID(__round__));
    2324         [ -  + ]:         18 :     if (round == NULL) {
    2325         [ #  # ]:          0 :         if (!PyErr_Occurred())
    2326                 :          0 :             PyErr_Format(PyExc_TypeError,
    2327                 :            :                          "type %.100s doesn't define __round__ method",
    2328                 :          0 :                          Py_TYPE(number)->tp_name);
    2329                 :          0 :         return NULL;
    2330                 :            :     }
    2331                 :            : 
    2332         [ +  + ]:         18 :     if (ndigits == Py_None)
    2333                 :         12 :         result = _PyObject_CallNoArgs(round);
    2334                 :            :     else
    2335                 :          6 :         result = PyObject_CallOneArg(round, ndigits);
    2336                 :         18 :     Py_DECREF(round);
    2337                 :         18 :     return result;
    2338                 :            : }
    2339                 :            : 
    2340                 :            : 
    2341                 :            : /*AC: we need to keep the kwds dict intact to easily call into the
    2342                 :            :  * list.sort method, which isn't currently supported in AC. So we just use
    2343                 :            :  * the initially generated signature with a custom implementation.
    2344                 :            :  */
    2345                 :            : /* [disabled clinic input]
    2346                 :            : sorted as builtin_sorted
    2347                 :            : 
    2348                 :            :     iterable as seq: object
    2349                 :            :     key as keyfunc: object = None
    2350                 :            :     reverse: object = False
    2351                 :            : 
    2352                 :            : Return a new list containing all items from the iterable in ascending order.
    2353                 :            : 
    2354                 :            : A custom key function can be supplied to customize the sort order, and the
    2355                 :            : reverse flag can be set to request the result in descending order.
    2356                 :            : [end disabled clinic input]*/
    2357                 :            : 
    2358                 :            : PyDoc_STRVAR(builtin_sorted__doc__,
    2359                 :            : "sorted($module, iterable, /, *, key=None, reverse=False)\n"
    2360                 :            : "--\n"
    2361                 :            : "\n"
    2362                 :            : "Return a new list containing all items from the iterable in ascending order.\n"
    2363                 :            : "\n"
    2364                 :            : "A custom key function can be supplied to customize the sort order, and the\n"
    2365                 :            : "reverse flag can be set to request the result in descending order.");
    2366                 :            : 
    2367                 :            : #define BUILTIN_SORTED_METHODDEF    \
    2368                 :            :     {"sorted", _PyCFunction_CAST(builtin_sorted), METH_FASTCALL | METH_KEYWORDS, builtin_sorted__doc__},
    2369                 :            : 
    2370                 :            : static PyObject *
    2371                 :         35 : builtin_sorted(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    2372                 :            : {
    2373                 :            :     PyObject *newlist, *v, *seq, *callable;
    2374                 :            : 
    2375                 :            :     /* Keyword arguments are passed through list.sort() which will check
    2376                 :            :        them. */
    2377         [ -  + ]:         35 :     if (!_PyArg_UnpackStack(args, nargs, "sorted", 1, 1, &seq))
    2378                 :          0 :         return NULL;
    2379                 :            : 
    2380                 :         35 :     newlist = PySequence_List(seq);
    2381         [ -  + ]:         35 :     if (newlist == NULL)
    2382                 :          0 :         return NULL;
    2383                 :            : 
    2384                 :         35 :     callable = PyObject_GetAttr(newlist, &_Py_ID(sort));
    2385         [ -  + ]:         35 :     if (callable == NULL) {
    2386                 :          0 :         Py_DECREF(newlist);
    2387                 :          0 :         return NULL;
    2388                 :            :     }
    2389                 :            : 
    2390                 :            :     assert(nargs >= 1);
    2391                 :         35 :     v = PyObject_Vectorcall(callable, args + 1, nargs - 1, kwnames);
    2392                 :         35 :     Py_DECREF(callable);
    2393         [ -  + ]:         35 :     if (v == NULL) {
    2394                 :          0 :         Py_DECREF(newlist);
    2395                 :          0 :         return NULL;
    2396                 :            :     }
    2397                 :         35 :     Py_DECREF(v);
    2398                 :         35 :     return newlist;
    2399                 :            : }
    2400                 :            : 
    2401                 :            : 
    2402                 :            : /*[clinic input]
    2403                 :            : vars as builtin_vars
    2404                 :            : 
    2405                 :            :     object: object = NULL
    2406                 :            :     /
    2407                 :            : 
    2408                 :            : Show vars.
    2409                 :            : 
    2410                 :            : Without arguments, equivalent to locals().
    2411                 :            : With an argument, equivalent to object.__dict__.
    2412                 :            : [clinic start generated code]*/
    2413                 :            : 
    2414                 :            : static PyObject *
    2415                 :         25 : builtin_vars_impl(PyObject *module, PyObject *object)
    2416                 :            : /*[clinic end generated code: output=840a7f64007a3e0a input=80cbdef9182c4ba3]*/
    2417                 :            : {
    2418                 :            :     PyObject *d;
    2419                 :            : 
    2420         [ -  + ]:         25 :     if (object == NULL) {
    2421                 :          0 :         d = Py_XNewRef(PyEval_GetLocals());
    2422                 :            :     }
    2423                 :            :     else {
    2424         [ -  + ]:         25 :         if (_PyObject_LookupAttr(object, &_Py_ID(__dict__), &d) == 0) {
    2425                 :          0 :             PyErr_SetString(PyExc_TypeError,
    2426                 :            :                 "vars() argument must have __dict__ attribute");
    2427                 :            :         }
    2428                 :            :     }
    2429                 :         25 :     return d;
    2430                 :            : }
    2431                 :            : 
    2432                 :            : 
    2433                 :            : /*[clinic input]
    2434                 :            : sum as builtin_sum
    2435                 :            : 
    2436                 :            :     iterable: object
    2437                 :            :     /
    2438                 :            :     start: object(c_default="NULL") = 0
    2439                 :            : 
    2440                 :            : Return the sum of a 'start' value (default: 0) plus an iterable of numbers
    2441                 :            : 
    2442                 :            : When the iterable is empty, return the start value.
    2443                 :            : This function is intended specifically for use with numeric values and may
    2444                 :            : reject non-numeric types.
    2445                 :            : [clinic start generated code]*/
    2446                 :            : 
    2447                 :            : static PyObject *
    2448                 :        835 : builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start)
    2449                 :            : /*[clinic end generated code: output=df758cec7d1d302f input=162b50765250d222]*/
    2450                 :            : {
    2451                 :        835 :     PyObject *result = start;
    2452                 :            :     PyObject *temp, *item, *iter;
    2453                 :            : 
    2454                 :        835 :     iter = PyObject_GetIter(iterable);
    2455         [ -  + ]:        835 :     if (iter == NULL)
    2456                 :          0 :         return NULL;
    2457                 :            : 
    2458         [ +  - ]:        835 :     if (result == NULL) {
    2459                 :        835 :         result = PyLong_FromLong(0);
    2460         [ -  + ]:        835 :         if (result == NULL) {
    2461                 :          0 :             Py_DECREF(iter);
    2462                 :          0 :             return NULL;
    2463                 :            :         }
    2464                 :            :     } else {
    2465                 :            :         /* reject string values for 'start' parameter */
    2466         [ #  # ]:          0 :         if (PyUnicode_Check(result)) {
    2467                 :          0 :             PyErr_SetString(PyExc_TypeError,
    2468                 :            :                 "sum() can't sum strings [use ''.join(seq) instead]");
    2469                 :          0 :             Py_DECREF(iter);
    2470                 :          0 :             return NULL;
    2471                 :            :         }
    2472         [ #  # ]:          0 :         if (PyBytes_Check(result)) {
    2473                 :          0 :             PyErr_SetString(PyExc_TypeError,
    2474                 :            :                 "sum() can't sum bytes [use b''.join(seq) instead]");
    2475                 :          0 :             Py_DECREF(iter);
    2476                 :          0 :             return NULL;
    2477                 :            :         }
    2478         [ #  # ]:          0 :         if (PyByteArray_Check(result)) {
    2479                 :          0 :             PyErr_SetString(PyExc_TypeError,
    2480                 :            :                 "sum() can't sum bytearray [use b''.join(seq) instead]");
    2481                 :          0 :             Py_DECREF(iter);
    2482                 :          0 :             return NULL;
    2483                 :            :         }
    2484                 :          0 :         Py_INCREF(result);
    2485                 :            :     }
    2486                 :            : 
    2487                 :            : #ifndef SLOW_SUM
    2488                 :            :     /* Fast addition by keeping temporary sums in C instead of new Python objects.
    2489                 :            :        Assumes all inputs are the same type.  If the assumption fails, default
    2490                 :            :        to the more general routine.
    2491                 :            :     */
    2492         [ +  - ]:        835 :     if (PyLong_CheckExact(result)) {
    2493                 :            :         int overflow;
    2494                 :        835 :         long i_result = PyLong_AsLongAndOverflow(result, &overflow);
    2495                 :            :         /* If this already overflowed, don't even enter the loop. */
    2496         [ +  - ]:        835 :         if (overflow == 0) {
    2497                 :        835 :             Py_SETREF(result, NULL);
    2498                 :            :         }
    2499         [ +  + ]:        974 :         while(result == NULL) {
    2500                 :        915 :             item = PyIter_Next(iter);
    2501         [ +  + ]:        915 :             if (item == NULL) {
    2502                 :        776 :                 Py_DECREF(iter);
    2503         [ -  + ]:        776 :                 if (PyErr_Occurred())
    2504                 :        776 :                     return NULL;
    2505                 :        776 :                 return PyLong_FromLong(i_result);
    2506                 :            :             }
    2507   [ +  +  -  + ]:        139 :             if (PyLong_CheckExact(item) || PyBool_Check(item)) {
    2508                 :            :                 long b;
    2509                 :         80 :                 overflow = 0;
    2510                 :            :                 /* Single digits are common, fast, and cannot overflow on unpacking. */
    2511   [ -  -  +  - ]:         80 :                 switch (Py_SIZE(item)) {
    2512                 :          0 :                     case -1: b = -(sdigit) ((PyLongObject*)item)->long_value.ob_digit[0]; break;
    2513                 :            :                     // Note: the continue goes to the top of the "while" loop that iterates over the elements
    2514                 :          0 :                     case  0: Py_DECREF(item); continue;
    2515                 :         80 :                     case  1: b = ((PyLongObject*)item)->long_value.ob_digit[0]; break;
    2516                 :          0 :                     default: b = PyLong_AsLongAndOverflow(item, &overflow); break;
    2517                 :            :                 }
    2518   [ +  -  +  -  :        160 :                 if (overflow == 0 &&
                   +  - ]
    2519                 :         80 :                     (i_result >= 0 ? (b <= LONG_MAX - i_result)
    2520                 :          0 :                                    : (b >= LONG_MIN - i_result)))
    2521                 :            :                 {
    2522                 :         80 :                     i_result += b;
    2523                 :         80 :                     Py_DECREF(item);
    2524                 :         80 :                     continue;
    2525                 :            :                 }
    2526                 :            :             }
    2527                 :            :             /* Either overflowed or is not an int. Restore real objects and process normally */
    2528                 :         59 :             result = PyLong_FromLong(i_result);
    2529         [ -  + ]:         59 :             if (result == NULL) {
    2530                 :          0 :                 Py_DECREF(item);
    2531                 :          0 :                 Py_DECREF(iter);
    2532                 :          0 :                 return NULL;
    2533                 :            :             }
    2534                 :         59 :             temp = PyNumber_Add(result, item);
    2535                 :         59 :             Py_DECREF(result);
    2536                 :         59 :             Py_DECREF(item);
    2537                 :         59 :             result = temp;
    2538         [ -  + ]:         59 :             if (result == NULL) {
    2539                 :          0 :                 Py_DECREF(iter);
    2540                 :          0 :                 return NULL;
    2541                 :            :             }
    2542                 :            :         }
    2543                 :            :     }
    2544                 :            : 
    2545         [ +  + ]:         59 :     if (PyFloat_CheckExact(result)) {
    2546                 :         51 :         double f_result = PyFloat_AS_DOUBLE(result);
    2547                 :         51 :         double c = 0.0;
    2548                 :         51 :         Py_SETREF(result, NULL);
    2549         [ +  + ]:        207 :         while(result == NULL) {
    2550                 :        206 :             item = PyIter_Next(iter);
    2551         [ +  + ]:        206 :             if (item == NULL) {
    2552                 :         50 :                 Py_DECREF(iter);
    2553         [ -  + ]:         50 :                 if (PyErr_Occurred())
    2554                 :          0 :                     return NULL;
    2555                 :            :                 /* Avoid losing the sign on a negative result,
    2556                 :            :                    and don't let adding the compensation convert
    2557                 :            :                    an infinite or overflowed sum to a NaN. */
    2558   [ +  +  +  - ]:         50 :                 if (c && Py_IS_FINITE(c)) {
    2559                 :         38 :                     f_result += c;
    2560                 :            :                 }
    2561                 :         50 :                 return PyFloat_FromDouble(f_result);
    2562                 :            :             }
    2563         [ +  + ]:        156 :             if (PyFloat_CheckExact(item)) {
    2564                 :            :                 // Improved Kahan–Babuška algorithm by Arnold Neumaier
    2565                 :            :                 // https://www.mat.univie.ac.at/~neum/scan/01.pdf
    2566                 :        154 :                 double x = PyFloat_AS_DOUBLE(item);
    2567                 :        154 :                 double t = f_result + x;
    2568         [ +  + ]:        154 :                 if (fabs(f_result) >= fabs(x)) {
    2569                 :        113 :                     c += (f_result - t) + x;
    2570                 :            :                 } else {
    2571                 :         41 :                     c += (x - t) + f_result;
    2572                 :            :                 }
    2573                 :        154 :                 f_result = t;
    2574                 :        154 :                 _Py_DECREF_SPECIALIZED(item, _PyFloat_ExactDealloc);
    2575                 :        154 :                 continue;
    2576                 :            :             }
    2577         [ +  + ]:          2 :             if (PyLong_Check(item)) {
    2578                 :            :                 long value;
    2579                 :            :                 int overflow;
    2580                 :          1 :                 value = PyLong_AsLongAndOverflow(item, &overflow);
    2581         [ +  - ]:          1 :                 if (!overflow) {
    2582                 :          1 :                     f_result += (double)value;
    2583                 :          1 :                     Py_DECREF(item);
    2584                 :          1 :                     continue;
    2585                 :            :                 }
    2586                 :            :             }
    2587   [ -  +  -  - ]:          1 :             if (c && Py_IS_FINITE(c)) {
    2588                 :          0 :                 f_result += c;
    2589                 :            :             }
    2590                 :          1 :             result = PyFloat_FromDouble(f_result);
    2591         [ -  + ]:          1 :             if (result == NULL) {
    2592                 :          0 :                 Py_DECREF(item);
    2593                 :          0 :                 Py_DECREF(iter);
    2594                 :          0 :                 return NULL;
    2595                 :            :             }
    2596                 :          1 :             temp = PyNumber_Add(result, item);
    2597                 :          1 :             Py_DECREF(result);
    2598                 :          1 :             Py_DECREF(item);
    2599                 :          1 :             result = temp;
    2600         [ -  + ]:          1 :             if (result == NULL) {
    2601                 :          0 :                 Py_DECREF(iter);
    2602                 :          0 :                 return NULL;
    2603                 :            :             }
    2604                 :            :         }
    2605                 :            :     }
    2606                 :            : #endif
    2607                 :            : 
    2608                 :            :     for(;;) {
    2609                 :         15 :         item = PyIter_Next(iter);
    2610         [ +  + ]:         15 :         if (item == NULL) {
    2611                 :            :             /* error, or end-of-sequence */
    2612         [ -  + ]:          9 :             if (PyErr_Occurred()) {
    2613                 :          0 :                 Py_SETREF(result, NULL);
    2614                 :            :             }
    2615                 :          9 :             break;
    2616                 :            :         }
    2617                 :            :         /* It's tempting to use PyNumber_InPlaceAdd instead of
    2618                 :            :            PyNumber_Add here, to avoid quadratic running time
    2619                 :            :            when doing 'sum(list_of_lists, [])'.  However, this
    2620                 :            :            would produce a change in behaviour: a snippet like
    2621                 :            : 
    2622                 :            :              empty = []
    2623                 :            :              sum([[x] for x in range(10)], empty)
    2624                 :            : 
    2625                 :            :            would change the value of empty. In fact, using
    2626                 :            :            in-place addition rather that binary addition for
    2627                 :            :            any of the steps introduces subtle behavior changes:
    2628                 :            : 
    2629                 :            :            https://bugs.python.org/issue18305 */
    2630                 :          6 :         temp = PyNumber_Add(result, item);
    2631                 :          6 :         Py_DECREF(result);
    2632                 :          6 :         Py_DECREF(item);
    2633                 :          6 :         result = temp;
    2634         [ -  + ]:          6 :         if (result == NULL)
    2635                 :          0 :             break;
    2636                 :            :     }
    2637                 :          9 :     Py_DECREF(iter);
    2638                 :          9 :     return result;
    2639                 :            : }
    2640                 :            : 
    2641                 :            : 
    2642                 :            : /*[clinic input]
    2643                 :            : isinstance as builtin_isinstance
    2644                 :            : 
    2645                 :            :     obj: object
    2646                 :            :     class_or_tuple: object
    2647                 :            :     /
    2648                 :            : 
    2649                 :            : Return whether an object is an instance of a class or of a subclass thereof.
    2650                 :            : 
    2651                 :            : A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
    2652                 :            : check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
    2653                 :            : or ...`` etc.
    2654                 :            : [clinic start generated code]*/
    2655                 :            : 
    2656                 :            : static PyObject *
    2657                 :        595 : builtin_isinstance_impl(PyObject *module, PyObject *obj,
    2658                 :            :                         PyObject *class_or_tuple)
    2659                 :            : /*[clinic end generated code: output=6faf01472c13b003 input=ffa743db1daf7549]*/
    2660                 :            : {
    2661                 :            :     int retval;
    2662                 :            : 
    2663                 :        595 :     retval = PyObject_IsInstance(obj, class_or_tuple);
    2664         [ -  + ]:        595 :     if (retval < 0)
    2665                 :          0 :         return NULL;
    2666                 :        595 :     return PyBool_FromLong(retval);
    2667                 :            : }
    2668                 :            : 
    2669                 :            : 
    2670                 :            : /*[clinic input]
    2671                 :            : issubclass as builtin_issubclass
    2672                 :            : 
    2673                 :            :     cls: object
    2674                 :            :     class_or_tuple: object
    2675                 :            :     /
    2676                 :            : 
    2677                 :            : Return whether 'cls' is derived from another class or is the same class.
    2678                 :            : 
    2679                 :            : A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
    2680                 :            : check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
    2681                 :            : or ...``.
    2682                 :            : [clinic start generated code]*/
    2683                 :            : 
    2684                 :            : static PyObject *
    2685                 :       2274 : builtin_issubclass_impl(PyObject *module, PyObject *cls,
    2686                 :            :                         PyObject *class_or_tuple)
    2687                 :            : /*[clinic end generated code: output=358412410cd7a250 input=a24b9f3d58c370d6]*/
    2688                 :            : {
    2689                 :            :     int retval;
    2690                 :            : 
    2691                 :       2274 :     retval = PyObject_IsSubclass(cls, class_or_tuple);
    2692         [ -  + ]:       2274 :     if (retval < 0)
    2693                 :          0 :         return NULL;
    2694                 :       2274 :     return PyBool_FromLong(retval);
    2695                 :            : }
    2696                 :            : 
    2697                 :            : typedef struct {
    2698                 :            :     PyObject_HEAD
    2699                 :            :     Py_ssize_t tuplesize;
    2700                 :            :     PyObject *ittuple;     /* tuple of iterators */
    2701                 :            :     PyObject *result;
    2702                 :            :     int strict;
    2703                 :            : } zipobject;
    2704                 :            : 
    2705                 :            : static PyObject *
    2706                 :     124704 : zip_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    2707                 :            : {
    2708                 :            :     zipobject *lz;
    2709                 :            :     Py_ssize_t i;
    2710                 :            :     PyObject *ittuple;  /* tuple of iterators */
    2711                 :            :     PyObject *result;
    2712                 :            :     Py_ssize_t tuplesize;
    2713                 :     124704 :     int strict = 0;
    2714                 :            : 
    2715         [ +  + ]:     124704 :     if (kwds) {
    2716                 :         16 :         PyObject *empty = PyTuple_New(0);
    2717         [ -  + ]:         16 :         if (empty == NULL) {
    2718                 :          0 :             return NULL;
    2719                 :            :         }
    2720                 :            :         static char *kwlist[] = {"strict", NULL};
    2721                 :         16 :         int parsed = PyArg_ParseTupleAndKeywords(
    2722                 :            :                 empty, kwds, "|$p:zip", kwlist, &strict);
    2723                 :         16 :         Py_DECREF(empty);
    2724         [ -  + ]:         16 :         if (!parsed) {
    2725                 :          0 :             return NULL;
    2726                 :            :         }
    2727                 :            :     }
    2728                 :            : 
    2729                 :            :     /* args must be a tuple */
    2730                 :            :     assert(PyTuple_Check(args));
    2731                 :     124704 :     tuplesize = PyTuple_GET_SIZE(args);
    2732                 :            : 
    2733                 :            :     /* obtain iterators */
    2734                 :     124704 :     ittuple = PyTuple_New(tuplesize);
    2735         [ -  + ]:     124704 :     if (ittuple == NULL)
    2736                 :          0 :         return NULL;
    2737         [ +  + ]:     374062 :     for (i=0; i < tuplesize; ++i) {
    2738                 :     249358 :         PyObject *item = PyTuple_GET_ITEM(args, i);
    2739                 :     249358 :         PyObject *it = PyObject_GetIter(item);
    2740         [ -  + ]:     249358 :         if (it == NULL) {
    2741                 :          0 :             Py_DECREF(ittuple);
    2742                 :          0 :             return NULL;
    2743                 :            :         }
    2744                 :     249358 :         PyTuple_SET_ITEM(ittuple, i, it);
    2745                 :            :     }
    2746                 :            : 
    2747                 :            :     /* create a result holder */
    2748                 :     124704 :     result = PyTuple_New(tuplesize);
    2749         [ -  + ]:     124704 :     if (result == NULL) {
    2750                 :          0 :         Py_DECREF(ittuple);
    2751                 :          0 :         return NULL;
    2752                 :            :     }
    2753         [ +  + ]:     374062 :     for (i=0 ; i < tuplesize ; i++) {
    2754                 :     249358 :         PyTuple_SET_ITEM(result, i, Py_NewRef(Py_None));
    2755                 :            :     }
    2756                 :            : 
    2757                 :            :     /* create zipobject structure */
    2758                 :     124704 :     lz = (zipobject *)type->tp_alloc(type, 0);
    2759         [ -  + ]:     124704 :     if (lz == NULL) {
    2760                 :          0 :         Py_DECREF(ittuple);
    2761                 :          0 :         Py_DECREF(result);
    2762                 :          0 :         return NULL;
    2763                 :            :     }
    2764                 :     124704 :     lz->ittuple = ittuple;
    2765                 :     124704 :     lz->tuplesize = tuplesize;
    2766                 :     124704 :     lz->result = result;
    2767                 :     124704 :     lz->strict = strict;
    2768                 :            : 
    2769                 :     124704 :     return (PyObject *)lz;
    2770                 :            : }
    2771                 :            : 
    2772                 :            : static void
    2773                 :     124704 : zip_dealloc(zipobject *lz)
    2774                 :            : {
    2775                 :     124704 :     PyObject_GC_UnTrack(lz);
    2776                 :     124704 :     Py_XDECREF(lz->ittuple);
    2777                 :     124704 :     Py_XDECREF(lz->result);
    2778                 :     124704 :     Py_TYPE(lz)->tp_free(lz);
    2779                 :     124704 : }
    2780                 :            : 
    2781                 :            : static int
    2782                 :          0 : zip_traverse(zipobject *lz, visitproc visit, void *arg)
    2783                 :            : {
    2784   [ #  #  #  # ]:          0 :     Py_VISIT(lz->ittuple);
    2785   [ #  #  #  # ]:          0 :     Py_VISIT(lz->result);
    2786                 :          0 :     return 0;
    2787                 :            : }
    2788                 :            : 
    2789                 :            : static PyObject *
    2790                 :     498149 : zip_next(zipobject *lz)
    2791                 :            : {
    2792                 :            :     Py_ssize_t i;
    2793                 :     498149 :     Py_ssize_t tuplesize = lz->tuplesize;
    2794                 :     498149 :     PyObject *result = lz->result;
    2795                 :            :     PyObject *it;
    2796                 :            :     PyObject *item;
    2797                 :            :     PyObject *olditem;
    2798                 :            : 
    2799         [ -  + ]:     498149 :     if (tuplesize == 0)
    2800                 :          0 :         return NULL;
    2801         [ +  + ]:     498149 :     if (Py_REFCNT(result) == 1) {
    2802                 :     498130 :         Py_INCREF(result);
    2803         [ +  + ]:    1245051 :         for (i=0 ; i < tuplesize ; i++) {
    2804                 :     871592 :             it = PyTuple_GET_ITEM(lz->ittuple, i);
    2805                 :     871592 :             item = (*Py_TYPE(it)->tp_iternext)(it);
    2806         [ +  + ]:     871592 :             if (item == NULL) {
    2807                 :     124671 :                 Py_DECREF(result);
    2808         [ +  + ]:     124671 :                 if (lz->strict) {
    2809                 :         16 :                     goto check;
    2810                 :            :                 }
    2811                 :     124655 :                 return NULL;
    2812                 :            :             }
    2813                 :     746921 :             olditem = PyTuple_GET_ITEM(result, i);
    2814                 :     746921 :             PyTuple_SET_ITEM(result, i, item);
    2815                 :     746921 :             Py_DECREF(olditem);
    2816                 :            :         }
    2817                 :            :         // bpo-42536: The GC may have untracked this result tuple. Since we're
    2818                 :            :         // recycling it, make sure it's tracked again:
    2819         [ -  + ]:     373459 :         if (!_PyObject_GC_IS_TRACKED(result)) {
    2820                 :          0 :             _PyObject_GC_TRACK(result);
    2821                 :            :         }
    2822                 :            :     } else {
    2823                 :         19 :         result = PyTuple_New(tuplesize);
    2824         [ -  + ]:         19 :         if (result == NULL)
    2825                 :          0 :             return NULL;
    2826         [ +  + ]:         46 :         for (i=0 ; i < tuplesize ; i++) {
    2827                 :         35 :             it = PyTuple_GET_ITEM(lz->ittuple, i);
    2828                 :         35 :             item = (*Py_TYPE(it)->tp_iternext)(it);
    2829         [ +  + ]:         35 :             if (item == NULL) {
    2830                 :          8 :                 Py_DECREF(result);
    2831         [ -  + ]:          8 :                 if (lz->strict) {
    2832                 :          0 :                     goto check;
    2833                 :            :                 }
    2834                 :          8 :                 return NULL;
    2835                 :            :             }
    2836                 :         27 :             PyTuple_SET_ITEM(result, i, item);
    2837                 :            :         }
    2838                 :            :     }
    2839                 :     373470 :     return result;
    2840                 :         16 : check:
    2841         [ -  + ]:         16 :     if (PyErr_Occurred()) {
    2842         [ #  # ]:          0 :         if (!PyErr_ExceptionMatches(PyExc_StopIteration)) {
    2843                 :            :             // next() on argument i raised an exception (not StopIteration)
    2844                 :          0 :             return NULL;
    2845                 :            :         }
    2846                 :          0 :         PyErr_Clear();
    2847                 :            :     }
    2848         [ -  + ]:         16 :     if (i) {
    2849                 :            :         // ValueError: zip() argument 2 is shorter than argument 1
    2850                 :            :         // ValueError: zip() argument 3 is shorter than arguments 1-2
    2851         [ #  # ]:          0 :         const char* plural = i == 1 ? " " : "s 1-";
    2852                 :          0 :         return PyErr_Format(PyExc_ValueError,
    2853                 :            :                             "zip() argument %d is shorter than argument%s%d",
    2854                 :            :                             i + 1, plural, i);
    2855                 :            :     }
    2856         [ +  + ]:         32 :     for (i = 1; i < tuplesize; i++) {
    2857                 :         16 :         it = PyTuple_GET_ITEM(lz->ittuple, i);
    2858                 :         16 :         item = (*Py_TYPE(it)->tp_iternext)(it);
    2859         [ -  + ]:         16 :         if (item) {
    2860                 :          0 :             Py_DECREF(item);
    2861         [ #  # ]:          0 :             const char* plural = i == 1 ? " " : "s 1-";
    2862                 :          0 :             return PyErr_Format(PyExc_ValueError,
    2863                 :            :                                 "zip() argument %d is longer than argument%s%d",
    2864                 :            :                                 i + 1, plural, i);
    2865                 :            :         }
    2866         [ -  + ]:         16 :         if (PyErr_Occurred()) {
    2867         [ #  # ]:          0 :             if (!PyErr_ExceptionMatches(PyExc_StopIteration)) {
    2868                 :            :                 // next() on argument i raised an exception (not StopIteration)
    2869                 :          0 :                 return NULL;
    2870                 :            :             }
    2871                 :          0 :             PyErr_Clear();
    2872                 :            :         }
    2873                 :            :         // Argument i is exhausted. So far so good...
    2874                 :            :     }
    2875                 :            :     // All arguments are exhausted. Success!
    2876                 :         16 :     return NULL;
    2877                 :            : }
    2878                 :            : 
    2879                 :            : static PyObject *
    2880                 :          0 : zip_reduce(zipobject *lz, PyObject *Py_UNUSED(ignored))
    2881                 :            : {
    2882                 :            :     /* Just recreate the zip with the internal iterator tuple */
    2883         [ #  # ]:          0 :     if (lz->strict) {
    2884                 :          0 :         return PyTuple_Pack(3, Py_TYPE(lz), lz->ittuple, Py_True);
    2885                 :            :     }
    2886                 :          0 :     return PyTuple_Pack(2, Py_TYPE(lz), lz->ittuple);
    2887                 :            : }
    2888                 :            : 
    2889                 :            : PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");
    2890                 :            : 
    2891                 :            : static PyObject *
    2892                 :          0 : zip_setstate(zipobject *lz, PyObject *state)
    2893                 :            : {
    2894                 :          0 :     int strict = PyObject_IsTrue(state);
    2895         [ #  # ]:          0 :     if (strict < 0) {
    2896                 :          0 :         return NULL;
    2897                 :            :     }
    2898                 :          0 :     lz->strict = strict;
    2899                 :          0 :     Py_RETURN_NONE;
    2900                 :            : }
    2901                 :            : 
    2902                 :            : static PyMethodDef zip_methods[] = {
    2903                 :            :     {"__reduce__", _PyCFunction_CAST(zip_reduce), METH_NOARGS, reduce_doc},
    2904                 :            :     {"__setstate__", _PyCFunction_CAST(zip_setstate), METH_O, setstate_doc},
    2905                 :            :     {NULL}  /* sentinel */
    2906                 :            : };
    2907                 :            : 
    2908                 :            : PyDoc_STRVAR(zip_doc,
    2909                 :            : "zip(*iterables, strict=False) --> Yield tuples until an input is exhausted.\n\
    2910                 :            : \n\
    2911                 :            :    >>> list(zip('abcdefg', range(3), range(4)))\n\
    2912                 :            :    [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]\n\
    2913                 :            : \n\
    2914                 :            : The zip object yields n-length tuples, where n is the number of iterables\n\
    2915                 :            : passed as positional arguments to zip().  The i-th element in every tuple\n\
    2916                 :            : comes from the i-th iterable argument to zip().  This continues until the\n\
    2917                 :            : shortest argument is exhausted.\n\
    2918                 :            : \n\
    2919                 :            : If strict is true and one of the arguments is exhausted before the others,\n\
    2920                 :            : raise a ValueError.");
    2921                 :            : 
    2922                 :            : PyTypeObject PyZip_Type = {
    2923                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
    2924                 :            :     "zip",                              /* tp_name */
    2925                 :            :     sizeof(zipobject),                  /* tp_basicsize */
    2926                 :            :     0,                                  /* tp_itemsize */
    2927                 :            :     /* methods */
    2928                 :            :     (destructor)zip_dealloc,            /* tp_dealloc */
    2929                 :            :     0,                                  /* tp_vectorcall_offset */
    2930                 :            :     0,                                  /* tp_getattr */
    2931                 :            :     0,                                  /* tp_setattr */
    2932                 :            :     0,                                  /* tp_as_async */
    2933                 :            :     0,                                  /* tp_repr */
    2934                 :            :     0,                                  /* tp_as_number */
    2935                 :            :     0,                                  /* tp_as_sequence */
    2936                 :            :     0,                                  /* tp_as_mapping */
    2937                 :            :     0,                                  /* tp_hash */
    2938                 :            :     0,                                  /* tp_call */
    2939                 :            :     0,                                  /* tp_str */
    2940                 :            :     PyObject_GenericGetAttr,            /* tp_getattro */
    2941                 :            :     0,                                  /* tp_setattro */
    2942                 :            :     0,                                  /* tp_as_buffer */
    2943                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
    2944                 :            :         Py_TPFLAGS_BASETYPE,            /* tp_flags */
    2945                 :            :     zip_doc,                            /* tp_doc */
    2946                 :            :     (traverseproc)zip_traverse,    /* tp_traverse */
    2947                 :            :     0,                                  /* tp_clear */
    2948                 :            :     0,                                  /* tp_richcompare */
    2949                 :            :     0,                                  /* tp_weaklistoffset */
    2950                 :            :     PyObject_SelfIter,                  /* tp_iter */
    2951                 :            :     (iternextfunc)zip_next,     /* tp_iternext */
    2952                 :            :     zip_methods,                        /* tp_methods */
    2953                 :            :     0,                                  /* tp_members */
    2954                 :            :     0,                                  /* tp_getset */
    2955                 :            :     0,                                  /* tp_base */
    2956                 :            :     0,                                  /* tp_dict */
    2957                 :            :     0,                                  /* tp_descr_get */
    2958                 :            :     0,                                  /* tp_descr_set */
    2959                 :            :     0,                                  /* tp_dictoffset */
    2960                 :            :     0,                                  /* tp_init */
    2961                 :            :     PyType_GenericAlloc,                /* tp_alloc */
    2962                 :            :     zip_new,                            /* tp_new */
    2963                 :            :     PyObject_GC_Del,                    /* tp_free */
    2964                 :            : };
    2965                 :            : 
    2966                 :            : 
    2967                 :            : static PyMethodDef builtin_methods[] = {
    2968                 :            :     {"__build_class__", _PyCFunction_CAST(builtin___build_class__),
    2969                 :            :      METH_FASTCALL | METH_KEYWORDS, build_class_doc},
    2970                 :            :     BUILTIN___IMPORT___METHODDEF
    2971                 :            :     BUILTIN_ABS_METHODDEF
    2972                 :            :     BUILTIN_ALL_METHODDEF
    2973                 :            :     BUILTIN_ANY_METHODDEF
    2974                 :            :     BUILTIN_ASCII_METHODDEF
    2975                 :            :     BUILTIN_BIN_METHODDEF
    2976                 :            :     {"breakpoint", _PyCFunction_CAST(builtin_breakpoint), METH_FASTCALL | METH_KEYWORDS, breakpoint_doc},
    2977                 :            :     BUILTIN_CALLABLE_METHODDEF
    2978                 :            :     BUILTIN_CHR_METHODDEF
    2979                 :            :     BUILTIN_COMPILE_METHODDEF
    2980                 :            :     BUILTIN_DELATTR_METHODDEF
    2981                 :            :     BUILTIN_DIR_METHODDEF
    2982                 :            :     BUILTIN_DIVMOD_METHODDEF
    2983                 :            :     BUILTIN_EVAL_METHODDEF
    2984                 :            :     BUILTIN_EXEC_METHODDEF
    2985                 :            :     BUILTIN_FORMAT_METHODDEF
    2986                 :            :     BUILTIN_GETATTR_METHODDEF
    2987                 :            :     BUILTIN_GLOBALS_METHODDEF
    2988                 :            :     BUILTIN_HASATTR_METHODDEF
    2989                 :            :     BUILTIN_HASH_METHODDEF
    2990                 :            :     BUILTIN_HEX_METHODDEF
    2991                 :            :     BUILTIN_ID_METHODDEF
    2992                 :            :     BUILTIN_INPUT_METHODDEF
    2993                 :            :     BUILTIN_ISINSTANCE_METHODDEF
    2994                 :            :     BUILTIN_ISSUBCLASS_METHODDEF
    2995                 :            :     BUILTIN_ITER_METHODDEF
    2996                 :            :     BUILTIN_AITER_METHODDEF
    2997                 :            :     BUILTIN_LEN_METHODDEF
    2998                 :            :     BUILTIN_LOCALS_METHODDEF
    2999                 :            :     {"max", _PyCFunction_CAST(builtin_max), METH_VARARGS | METH_KEYWORDS, max_doc},
    3000                 :            :     {"min", _PyCFunction_CAST(builtin_min), METH_VARARGS | METH_KEYWORDS, min_doc},
    3001                 :            :     BUILTIN_NEXT_METHODDEF
    3002                 :            :     BUILTIN_ANEXT_METHODDEF
    3003                 :            :     BUILTIN_OCT_METHODDEF
    3004                 :            :     BUILTIN_ORD_METHODDEF
    3005                 :            :     BUILTIN_POW_METHODDEF
    3006                 :            :     BUILTIN_PRINT_METHODDEF
    3007                 :            :     BUILTIN_REPR_METHODDEF
    3008                 :            :     BUILTIN_ROUND_METHODDEF
    3009                 :            :     BUILTIN_SETATTR_METHODDEF
    3010                 :            :     BUILTIN_SORTED_METHODDEF
    3011                 :            :     BUILTIN_SUM_METHODDEF
    3012                 :            :     BUILTIN_VARS_METHODDEF
    3013                 :            :     {NULL,              NULL},
    3014                 :            : };
    3015                 :            : 
    3016                 :            : PyDoc_STRVAR(builtin_doc,
    3017                 :            : "Built-in functions, exceptions, and other objects.\n\
    3018                 :            : \n\
    3019                 :            : Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.");
    3020                 :            : 
    3021                 :            : static struct PyModuleDef builtinsmodule = {
    3022                 :            :     PyModuleDef_HEAD_INIT,
    3023                 :            :     "builtins",
    3024                 :            :     builtin_doc,
    3025                 :            :     -1, /* multiple "initialization" just copies the module dict. */
    3026                 :            :     builtin_methods,
    3027                 :            :     NULL,
    3028                 :            :     NULL,
    3029                 :            :     NULL,
    3030                 :            :     NULL
    3031                 :            : };
    3032                 :            : 
    3033                 :            : 
    3034                 :            : PyObject *
    3035                 :         29 : _PyBuiltin_Init(PyInterpreterState *interp)
    3036                 :            : {
    3037                 :            :     PyObject *mod, *dict, *debug;
    3038                 :            : 
    3039                 :         29 :     const PyConfig *config = _PyInterpreterState_GetConfig(interp);
    3040                 :            : 
    3041                 :         29 :     mod = _PyModule_CreateInitialized(&builtinsmodule, PYTHON_API_VERSION);
    3042         [ -  + ]:         29 :     if (mod == NULL)
    3043                 :          0 :         return NULL;
    3044                 :         29 :     dict = PyModule_GetDict(mod);
    3045                 :            : 
    3046                 :            : #ifdef Py_TRACE_REFS
    3047                 :            :     /* "builtins" exposes a number of statically allocated objects
    3048                 :            :      * that, before this code was added in 2.3, never showed up in
    3049                 :            :      * the list of "all objects" maintained by Py_TRACE_REFS.  As a
    3050                 :            :      * result, programs leaking references to None and False (etc)
    3051                 :            :      * couldn't be diagnosed by examining sys.getobjects(0).
    3052                 :            :      */
    3053                 :            : #define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
    3054                 :            : #else
    3055                 :            : #define ADD_TO_ALL(OBJECT) (void)0
    3056                 :            : #endif
    3057                 :            : 
    3058                 :            : #define SETBUILTIN(NAME, OBJECT) \
    3059                 :            :     if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0)       \
    3060                 :            :         return NULL;                                                    \
    3061                 :            :     ADD_TO_ALL(OBJECT)
    3062                 :            : 
    3063         [ -  + ]:         29 :     SETBUILTIN("None",                  Py_None);
    3064         [ -  + ]:         29 :     SETBUILTIN("Ellipsis",              Py_Ellipsis);
    3065         [ -  + ]:         29 :     SETBUILTIN("NotImplemented",        Py_NotImplemented);
    3066         [ -  + ]:         29 :     SETBUILTIN("False",                 Py_False);
    3067         [ -  + ]:         29 :     SETBUILTIN("True",                  Py_True);
    3068         [ -  + ]:         29 :     SETBUILTIN("bool",                  &PyBool_Type);
    3069         [ -  + ]:         29 :     SETBUILTIN("memoryview",        &PyMemoryView_Type);
    3070         [ -  + ]:         29 :     SETBUILTIN("bytearray",             &PyByteArray_Type);
    3071         [ -  + ]:         29 :     SETBUILTIN("bytes",                 &PyBytes_Type);
    3072         [ -  + ]:         29 :     SETBUILTIN("classmethod",           &PyClassMethod_Type);
    3073         [ -  + ]:         29 :     SETBUILTIN("complex",               &PyComplex_Type);
    3074         [ -  + ]:         29 :     SETBUILTIN("dict",                  &PyDict_Type);
    3075         [ -  + ]:         29 :     SETBUILTIN("enumerate",             &PyEnum_Type);
    3076         [ -  + ]:         29 :     SETBUILTIN("filter",                &PyFilter_Type);
    3077         [ -  + ]:         29 :     SETBUILTIN("float",                 &PyFloat_Type);
    3078         [ -  + ]:         29 :     SETBUILTIN("frozenset",             &PyFrozenSet_Type);
    3079         [ -  + ]:         29 :     SETBUILTIN("property",              &PyProperty_Type);
    3080         [ -  + ]:         29 :     SETBUILTIN("int",                   &PyLong_Type);
    3081         [ -  + ]:         29 :     SETBUILTIN("list",                  &PyList_Type);
    3082         [ -  + ]:         29 :     SETBUILTIN("map",                   &PyMap_Type);
    3083         [ -  + ]:         29 :     SETBUILTIN("object",                &PyBaseObject_Type);
    3084         [ -  + ]:         29 :     SETBUILTIN("range",                 &PyRange_Type);
    3085         [ -  + ]:         29 :     SETBUILTIN("reversed",              &PyReversed_Type);
    3086         [ -  + ]:         29 :     SETBUILTIN("set",                   &PySet_Type);
    3087         [ -  + ]:         29 :     SETBUILTIN("slice",                 &PySlice_Type);
    3088         [ -  + ]:         29 :     SETBUILTIN("staticmethod",          &PyStaticMethod_Type);
    3089         [ -  + ]:         29 :     SETBUILTIN("str",                   &PyUnicode_Type);
    3090         [ -  + ]:         29 :     SETBUILTIN("super",                 &PySuper_Type);
    3091         [ -  + ]:         29 :     SETBUILTIN("tuple",                 &PyTuple_Type);
    3092         [ -  + ]:         29 :     SETBUILTIN("type",                  &PyType_Type);
    3093         [ -  + ]:         29 :     SETBUILTIN("zip",                   &PyZip_Type);
    3094                 :         29 :     debug = PyBool_FromLong(config->optimization_level == 0);
    3095         [ -  + ]:         29 :     if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
    3096                 :          0 :         Py_DECREF(debug);
    3097                 :          0 :         return NULL;
    3098                 :            :     }
    3099                 :         29 :     Py_DECREF(debug);
    3100                 :            : 
    3101                 :         29 :     return mod;
    3102                 :            : #undef ADD_TO_ALL
    3103                 :            : #undef SETBUILTIN
    3104                 :            : }

Generated by: LCOV version 1.14