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