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