1/*[clinic input]
2preserve
3[clinic start generated code]*/
4
5PyDoc_STRVAR(builtin_abs__doc__,
6"abs($module, x, /)\n"
7"--\n"
8"\n"
9"Return the absolute value of the argument.");
10
11#define BUILTIN_ABS_METHODDEF \
12 {"abs", (PyCFunction)builtin_abs, METH_O, builtin_abs__doc__},
13
14PyDoc_STRVAR(builtin_all__doc__,
15"all($module, iterable, /)\n"
16"--\n"
17"\n"
18"Return True if bool(x) is True for all values x in the iterable.\n"
19"\n"
20"If the iterable is empty, return True.");
21
22#define BUILTIN_ALL_METHODDEF \
23 {"all", (PyCFunction)builtin_all, METH_O, builtin_all__doc__},
24
25PyDoc_STRVAR(builtin_any__doc__,
26"any($module, iterable, /)\n"
27"--\n"
28"\n"
29"Return True if bool(x) is True for any x in the iterable.\n"
30"\n"
31"If the iterable is empty, return False.");
32
33#define BUILTIN_ANY_METHODDEF \
34 {"any", (PyCFunction)builtin_any, METH_O, builtin_any__doc__},
35
36PyDoc_STRVAR(builtin_ascii__doc__,
37"ascii($module, obj, /)\n"
38"--\n"
39"\n"
40"Return an ASCII-only representation of an object.\n"
41"\n"
42"As repr(), return a string containing a printable representation of an\n"
43"object, but escape the non-ASCII characters in the string returned by\n"
44"repr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar\n"
45"to that returned by repr() in Python 2.");
46
47#define BUILTIN_ASCII_METHODDEF \
48 {"ascii", (PyCFunction)builtin_ascii, METH_O, builtin_ascii__doc__},
49
50PyDoc_STRVAR(builtin_bin__doc__,
51"bin($module, number, /)\n"
52"--\n"
53"\n"
54"Return the binary representation of an integer.\n"
55"\n"
56" >>> bin(2796202)\n"
57" \'0b1010101010101010101010\'");
58
59#define BUILTIN_BIN_METHODDEF \
60 {"bin", (PyCFunction)builtin_bin, METH_O, builtin_bin__doc__},
61
62PyDoc_STRVAR(builtin_callable__doc__,
63"callable($module, obj, /)\n"
64"--\n"
65"\n"
66"Return whether the object is callable (i.e., some kind of function).\n"
67"\n"
68"Note that classes are callable, as are instances of classes with a\n"
69"__call__() method.");
70
71#define BUILTIN_CALLABLE_METHODDEF \
72 {"callable", (PyCFunction)builtin_callable, METH_O, builtin_callable__doc__},
73
74PyDoc_STRVAR(builtin_format__doc__,
75"format($module, value, format_spec=\'\', /)\n"
76"--\n"
77"\n"
78"Return value.__format__(format_spec)\n"
79"\n"
80"format_spec defaults to the empty string.\n"
81"See the Format Specification Mini-Language section of help(\'FORMATTING\') for\n"
82"details.");
83
84#define BUILTIN_FORMAT_METHODDEF \
85 {"format", (PyCFunction)(void(*)(void))builtin_format, METH_FASTCALL, builtin_format__doc__},
86
87static PyObject *
88builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec);
89
90static PyObject *
91builtin_format(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
92{
93 PyObject *return_value = NULL;
94 PyObject *value;
95 PyObject *format_spec = NULL;
96
97 if (!_PyArg_CheckPositional("format", nargs, 1, 2)) {
98 goto exit;
99 }
100 value = args[0];
101 if (nargs < 2) {
102 goto skip_optional;
103 }
104 if (!PyUnicode_Check(args[1])) {
105 _PyArg_BadArgument("format", "argument 2", "str", args[1]);
106 goto exit;
107 }
108 if (PyUnicode_READY(args[1]) == -1) {
109 goto exit;
110 }
111 format_spec = args[1];
112skip_optional:
113 return_value = builtin_format_impl(module, value, format_spec);
114
115exit:
116 return return_value;
117}
118
119PyDoc_STRVAR(builtin_chr__doc__,
120"chr($module, i, /)\n"
121"--\n"
122"\n"
123"Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
124
125#define BUILTIN_CHR_METHODDEF \
126 {"chr", (PyCFunction)builtin_chr, METH_O, builtin_chr__doc__},
127
128static PyObject *
129builtin_chr_impl(PyObject *module, int i);
130
131static PyObject *
132builtin_chr(PyObject *module, PyObject *arg)
133{
134 PyObject *return_value = NULL;
135 int i;
136
137 i = _PyLong_AsInt(arg);
138 if (i == -1 && PyErr_Occurred()) {
139 goto exit;
140 }
141 return_value = builtin_chr_impl(module, i);
142
143exit:
144 return return_value;
145}
146
147PyDoc_STRVAR(builtin_compile__doc__,
148"compile($module, /, source, filename, mode, flags=0,\n"
149" dont_inherit=False, optimize=-1, *, _feature_version=-1)\n"
150"--\n"
151"\n"
152"Compile source into a code object that can be executed by exec() or eval().\n"
153"\n"
154"The source code may represent a Python module, statement or expression.\n"
155"The filename will be used for run-time error messages.\n"
156"The mode must be \'exec\' to compile a module, \'single\' to compile a\n"
157"single (interactive) statement, or \'eval\' to compile an expression.\n"
158"The flags argument, if present, controls which future statements influence\n"
159"the compilation of the code.\n"
160"The dont_inherit argument, if true, stops the compilation inheriting\n"
161"the effects of any future statements in effect in the code calling\n"
162"compile; if absent or false these statements do influence the compilation,\n"
163"in addition to any features explicitly specified.");
164
165#define BUILTIN_COMPILE_METHODDEF \
166 {"compile", (PyCFunction)(void(*)(void))builtin_compile, METH_FASTCALL|METH_KEYWORDS, builtin_compile__doc__},
167
168static PyObject *
169builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
170 const char *mode, int flags, int dont_inherit,
171 int optimize, int feature_version);
172
173static PyObject *
174builtin_compile(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
175{
176 PyObject *return_value = NULL;
177 static const char * const _keywords[] = {"source", "filename", "mode", "flags", "dont_inherit", "optimize", "_feature_version", NULL};
178 static _PyArg_Parser _parser = {NULL, _keywords, "compile", 0};
179 PyObject *argsbuf[7];
180 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
181 PyObject *source;
182 PyObject *filename;
183 const char *mode;
184 int flags = 0;
185 int dont_inherit = 0;
186 int optimize = -1;
187 int feature_version = -1;
188
189 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 6, 0, argsbuf);
190 if (!args) {
191 goto exit;
192 }
193 source = args[0];
194 if (!PyUnicode_FSDecoder(args[1], &filename)) {
195 goto exit;
196 }
197 if (!PyUnicode_Check(args[2])) {
198 _PyArg_BadArgument("compile", "argument 'mode'", "str", args[2]);
199 goto exit;
200 }
201 Py_ssize_t mode_length;
202 mode = PyUnicode_AsUTF8AndSize(args[2], &mode_length);
203 if (mode == NULL) {
204 goto exit;
205 }
206 if (strlen(mode) != (size_t)mode_length) {
207 PyErr_SetString(PyExc_ValueError, "embedded null character");
208 goto exit;
209 }
210 if (!noptargs) {
211 goto skip_optional_pos;
212 }
213 if (args[3]) {
214 flags = _PyLong_AsInt(args[3]);
215 if (flags == -1 && PyErr_Occurred()) {
216 goto exit;
217 }
218 if (!--noptargs) {
219 goto skip_optional_pos;
220 }
221 }
222 if (args[4]) {
223 dont_inherit = _PyLong_AsInt(args[4]);
224 if (dont_inherit == -1 && PyErr_Occurred()) {
225 goto exit;
226 }
227 if (!--noptargs) {
228 goto skip_optional_pos;
229 }
230 }
231 if (args[5]) {
232 optimize = _PyLong_AsInt(args[5]);
233 if (optimize == -1 && PyErr_Occurred()) {
234 goto exit;
235 }
236 if (!--noptargs) {
237 goto skip_optional_pos;
238 }
239 }
240skip_optional_pos:
241 if (!noptargs) {
242 goto skip_optional_kwonly;
243 }
244 feature_version = _PyLong_AsInt(args[6]);
245 if (feature_version == -1 && PyErr_Occurred()) {
246 goto exit;
247 }
248skip_optional_kwonly:
249 return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize, feature_version);
250
251exit:
252 return return_value;
253}
254
255PyDoc_STRVAR(builtin_divmod__doc__,
256"divmod($module, x, y, /)\n"
257"--\n"
258"\n"
259"Return the tuple (x//y, x%y). Invariant: div*y + mod == x.");
260
261#define BUILTIN_DIVMOD_METHODDEF \
262 {"divmod", (PyCFunction)(void(*)(void))builtin_divmod, METH_FASTCALL, builtin_divmod__doc__},
263
264static PyObject *
265builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y);
266
267static PyObject *
268builtin_divmod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
269{
270 PyObject *return_value = NULL;
271 PyObject *x;
272 PyObject *y;
273
274 if (!_PyArg_CheckPositional("divmod", nargs, 2, 2)) {
275 goto exit;
276 }
277 x = args[0];
278 y = args[1];
279 return_value = builtin_divmod_impl(module, x, y);
280
281exit:
282 return return_value;
283}
284
285PyDoc_STRVAR(builtin_eval__doc__,
286"eval($module, source, globals=None, locals=None, /)\n"
287"--\n"
288"\n"
289"Evaluate the given source in the context of globals and locals.\n"
290"\n"
291"The source may be a string representing a Python expression\n"
292"or a code object as returned by compile().\n"
293"The globals must be a dictionary and locals can be any mapping,\n"
294"defaulting to the current globals and locals.\n"
295"If only globals is given, locals defaults to it.");
296
297#define BUILTIN_EVAL_METHODDEF \
298 {"eval", (PyCFunction)(void(*)(void))builtin_eval, METH_FASTCALL, builtin_eval__doc__},
299
300static PyObject *
301builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
302 PyObject *locals);
303
304static PyObject *
305builtin_eval(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
306{
307 PyObject *return_value = NULL;
308 PyObject *source;
309 PyObject *globals = Py_None;
310 PyObject *locals = Py_None;
311
312 if (!_PyArg_CheckPositional("eval", nargs, 1, 3)) {
313 goto exit;
314 }
315 source = args[0];
316 if (nargs < 2) {
317 goto skip_optional;
318 }
319 globals = args[1];
320 if (nargs < 3) {
321 goto skip_optional;
322 }
323 locals = args[2];
324skip_optional:
325 return_value = builtin_eval_impl(module, source, globals, locals);
326
327exit:
328 return return_value;
329}
330
331PyDoc_STRVAR(builtin_exec__doc__,
332"exec($module, source, globals=None, locals=None, /)\n"
333"--\n"
334"\n"
335"Execute the given source in the context of globals and locals.\n"
336"\n"
337"The source may be a string representing one or more Python statements\n"
338"or a code object as returned by compile().\n"
339"The globals must be a dictionary and locals can be any mapping,\n"
340"defaulting to the current globals and locals.\n"
341"If only globals is given, locals defaults to it.");
342
343#define BUILTIN_EXEC_METHODDEF \
344 {"exec", (PyCFunction)(void(*)(void))builtin_exec, METH_FASTCALL, builtin_exec__doc__},
345
346static PyObject *
347builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
348 PyObject *locals);
349
350static PyObject *
351builtin_exec(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
352{
353 PyObject *return_value = NULL;
354 PyObject *source;
355 PyObject *globals = Py_None;
356 PyObject *locals = Py_None;
357
358 if (!_PyArg_CheckPositional("exec", nargs, 1, 3)) {
359 goto exit;
360 }
361 source = args[0];
362 if (nargs < 2) {
363 goto skip_optional;
364 }
365 globals = args[1];
366 if (nargs < 3) {
367 goto skip_optional;
368 }
369 locals = args[2];
370skip_optional:
371 return_value = builtin_exec_impl(module, source, globals, locals);
372
373exit:
374 return return_value;
375}
376
377PyDoc_STRVAR(builtin_globals__doc__,
378"globals($module, /)\n"
379"--\n"
380"\n"
381"Return the dictionary containing the current scope\'s global variables.\n"
382"\n"
383"NOTE: Updates to this dictionary *will* affect name lookups in the current\n"
384"global scope and vice-versa.");
385
386#define BUILTIN_GLOBALS_METHODDEF \
387 {"globals", (PyCFunction)builtin_globals, METH_NOARGS, builtin_globals__doc__},
388
389static PyObject *
390builtin_globals_impl(PyObject *module);
391
392static PyObject *
393builtin_globals(PyObject *module, PyObject *Py_UNUSED(ignored))
394{
395 return builtin_globals_impl(module);
396}
397
398PyDoc_STRVAR(builtin_hasattr__doc__,
399"hasattr($module, obj, name, /)\n"
400"--\n"
401"\n"
402"Return whether the object has an attribute with the given name.\n"
403"\n"
404"This is done by calling getattr(obj, name) and catching AttributeError.");
405
406#define BUILTIN_HASATTR_METHODDEF \
407 {"hasattr", (PyCFunction)(void(*)(void))builtin_hasattr, METH_FASTCALL, builtin_hasattr__doc__},
408
409static PyObject *
410builtin_hasattr_impl(PyObject *module, PyObject *obj, PyObject *name);
411
412static PyObject *
413builtin_hasattr(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
414{
415 PyObject *return_value = NULL;
416 PyObject *obj;
417 PyObject *name;
418
419 if (!_PyArg_CheckPositional("hasattr", nargs, 2, 2)) {
420 goto exit;
421 }
422 obj = args[0];
423 name = args[1];
424 return_value = builtin_hasattr_impl(module, obj, name);
425
426exit:
427 return return_value;
428}
429
430PyDoc_STRVAR(builtin_id__doc__,
431"id($module, obj, /)\n"
432"--\n"
433"\n"
434"Return the identity of an object.\n"
435"\n"
436"This is guaranteed to be unique among simultaneously existing objects.\n"
437"(CPython uses the object\'s memory address.)");
438
439#define BUILTIN_ID_METHODDEF \
440 {"id", (PyCFunction)builtin_id, METH_O, builtin_id__doc__},
441
442PyDoc_STRVAR(builtin_setattr__doc__,
443"setattr($module, obj, name, value, /)\n"
444"--\n"
445"\n"
446"Sets the named attribute on the given object to the specified value.\n"
447"\n"
448"setattr(x, \'y\', v) is equivalent to ``x.y = v\'\'");
449
450#define BUILTIN_SETATTR_METHODDEF \
451 {"setattr", (PyCFunction)(void(*)(void))builtin_setattr, METH_FASTCALL, builtin_setattr__doc__},
452
453static PyObject *
454builtin_setattr_impl(PyObject *module, PyObject *obj, PyObject *name,
455 PyObject *value);
456
457static PyObject *
458builtin_setattr(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
459{
460 PyObject *return_value = NULL;
461 PyObject *obj;
462 PyObject *name;
463 PyObject *value;
464
465 if (!_PyArg_CheckPositional("setattr", nargs, 3, 3)) {
466 goto exit;
467 }
468 obj = args[0];
469 name = args[1];
470 value = args[2];
471 return_value = builtin_setattr_impl(module, obj, name, value);
472
473exit:
474 return return_value;
475}
476
477PyDoc_STRVAR(builtin_delattr__doc__,
478"delattr($module, obj, name, /)\n"
479"--\n"
480"\n"
481"Deletes the named attribute from the given object.\n"
482"\n"
483"delattr(x, \'y\') is equivalent to ``del x.y\'\'");
484
485#define BUILTIN_DELATTR_METHODDEF \
486 {"delattr", (PyCFunction)(void(*)(void))builtin_delattr, METH_FASTCALL, builtin_delattr__doc__},
487
488static PyObject *
489builtin_delattr_impl(PyObject *module, PyObject *obj, PyObject *name);
490
491static PyObject *
492builtin_delattr(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
493{
494 PyObject *return_value = NULL;
495 PyObject *obj;
496 PyObject *name;
497
498 if (!_PyArg_CheckPositional("delattr", nargs, 2, 2)) {
499 goto exit;
500 }
501 obj = args[0];
502 name = args[1];
503 return_value = builtin_delattr_impl(module, obj, name);
504
505exit:
506 return return_value;
507}
508
509PyDoc_STRVAR(builtin_hash__doc__,
510"hash($module, obj, /)\n"
511"--\n"
512"\n"
513"Return the hash value for the given object.\n"
514"\n"
515"Two objects that compare equal must also have the same hash value, but the\n"
516"reverse is not necessarily true.");
517
518#define BUILTIN_HASH_METHODDEF \
519 {"hash", (PyCFunction)builtin_hash, METH_O, builtin_hash__doc__},
520
521PyDoc_STRVAR(builtin_hex__doc__,
522"hex($module, number, /)\n"
523"--\n"
524"\n"
525"Return the hexadecimal representation of an integer.\n"
526"\n"
527" >>> hex(12648430)\n"
528" \'0xc0ffee\'");
529
530#define BUILTIN_HEX_METHODDEF \
531 {"hex", (PyCFunction)builtin_hex, METH_O, builtin_hex__doc__},
532
533PyDoc_STRVAR(builtin_aiter__doc__,
534"aiter($module, async_iterable, /)\n"
535"--\n"
536"\n"
537"Return an AsyncIterator for an AsyncIterable object.");
538
539#define BUILTIN_AITER_METHODDEF \
540 {"aiter", (PyCFunction)builtin_aiter, METH_O, builtin_aiter__doc__},
541
542PyDoc_STRVAR(builtin_anext__doc__,
543"anext($module, aiterator, default=<unrepresentable>, /)\n"
544"--\n"
545"\n"
546"Return the next item from the async iterator.");
547
548#define BUILTIN_ANEXT_METHODDEF \
549 {"anext", (PyCFunction)(void(*)(void))builtin_anext, METH_FASTCALL, builtin_anext__doc__},
550
551static PyObject *
552builtin_anext_impl(PyObject *module, PyObject *aiterator,
553 PyObject *default_value);
554
555static PyObject *
556builtin_anext(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
557{
558 PyObject *return_value = NULL;
559 PyObject *aiterator;
560 PyObject *default_value = NULL;
561
562 if (!_PyArg_CheckPositional("anext", nargs, 1, 2)) {
563 goto exit;
564 }
565 aiterator = args[0];
566 if (nargs < 2) {
567 goto skip_optional;
568 }
569 default_value = args[1];
570skip_optional:
571 return_value = builtin_anext_impl(module, aiterator, default_value);
572
573exit:
574 return return_value;
575}
576
577PyDoc_STRVAR(builtin_len__doc__,
578"len($module, obj, /)\n"
579"--\n"
580"\n"
581"Return the number of items in a container.");
582
583#define BUILTIN_LEN_METHODDEF \
584 {"len", (PyCFunction)builtin_len, METH_O, builtin_len__doc__},
585
586PyDoc_STRVAR(builtin_locals__doc__,
587"locals($module, /)\n"
588"--\n"
589"\n"
590"Return a dictionary containing the current scope\'s local variables.\n"
591"\n"
592"NOTE: Whether or not updates to this dictionary will affect name lookups in\n"
593"the local scope and vice-versa is *implementation dependent* and not\n"
594"covered by any backwards compatibility guarantees.");
595
596#define BUILTIN_LOCALS_METHODDEF \
597 {"locals", (PyCFunction)builtin_locals, METH_NOARGS, builtin_locals__doc__},
598
599static PyObject *
600builtin_locals_impl(PyObject *module);
601
602static PyObject *
603builtin_locals(PyObject *module, PyObject *Py_UNUSED(ignored))
604{
605 return builtin_locals_impl(module);
606}
607
608PyDoc_STRVAR(builtin_oct__doc__,
609"oct($module, number, /)\n"
610"--\n"
611"\n"
612"Return the octal representation of an integer.\n"
613"\n"
614" >>> oct(342391)\n"
615" \'0o1234567\'");
616
617#define BUILTIN_OCT_METHODDEF \
618 {"oct", (PyCFunction)builtin_oct, METH_O, builtin_oct__doc__},
619
620PyDoc_STRVAR(builtin_ord__doc__,
621"ord($module, c, /)\n"
622"--\n"
623"\n"
624"Return the Unicode code point for a one-character string.");
625
626#define BUILTIN_ORD_METHODDEF \
627 {"ord", (PyCFunction)builtin_ord, METH_O, builtin_ord__doc__},
628
629PyDoc_STRVAR(builtin_pow__doc__,
630"pow($module, /, base, exp, mod=None)\n"
631"--\n"
632"\n"
633"Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments\n"
634"\n"
635"Some types, such as ints, are able to use a more efficient algorithm when\n"
636"invoked using the three argument form.");
637
638#define BUILTIN_POW_METHODDEF \
639 {"pow", (PyCFunction)(void(*)(void))builtin_pow, METH_FASTCALL|METH_KEYWORDS, builtin_pow__doc__},
640
641static PyObject *
642builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp,
643 PyObject *mod);
644
645static PyObject *
646builtin_pow(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
647{
648 PyObject *return_value = NULL;
649 static const char * const _keywords[] = {"base", "exp", "mod", NULL};
650 static _PyArg_Parser _parser = {NULL, _keywords, "pow", 0};
651 PyObject *argsbuf[3];
652 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
653 PyObject *base;
654 PyObject *exp;
655 PyObject *mod = Py_None;
656
657 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
658 if (!args) {
659 goto exit;
660 }
661 base = args[0];
662 exp = args[1];
663 if (!noptargs) {
664 goto skip_optional_pos;
665 }
666 mod = args[2];
667skip_optional_pos:
668 return_value = builtin_pow_impl(module, base, exp, mod);
669
670exit:
671 return return_value;
672}
673
674PyDoc_STRVAR(builtin_input__doc__,
675"input($module, prompt=None, /)\n"
676"--\n"
677"\n"
678"Read a string from standard input. The trailing newline is stripped.\n"
679"\n"
680"The prompt string, if given, is printed to standard output without a\n"
681"trailing newline before reading input.\n"
682"\n"
683"If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.\n"
684"On *nix systems, readline is used if available.");
685
686#define BUILTIN_INPUT_METHODDEF \
687 {"input", (PyCFunction)(void(*)(void))builtin_input, METH_FASTCALL, builtin_input__doc__},
688
689static PyObject *
690builtin_input_impl(PyObject *module, PyObject *prompt);
691
692static PyObject *
693builtin_input(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
694{
695 PyObject *return_value = NULL;
696 PyObject *prompt = NULL;
697
698 if (!_PyArg_CheckPositional("input", nargs, 0, 1)) {
699 goto exit;
700 }
701 if (nargs < 1) {
702 goto skip_optional;
703 }
704 prompt = args[0];
705skip_optional:
706 return_value = builtin_input_impl(module, prompt);
707
708exit:
709 return return_value;
710}
711
712PyDoc_STRVAR(builtin_repr__doc__,
713"repr($module, obj, /)\n"
714"--\n"
715"\n"
716"Return the canonical string representation of the object.\n"
717"\n"
718"For many object types, including most builtins, eval(repr(obj)) == obj.");
719
720#define BUILTIN_REPR_METHODDEF \
721 {"repr", (PyCFunction)builtin_repr, METH_O, builtin_repr__doc__},
722
723PyDoc_STRVAR(builtin_round__doc__,
724"round($module, /, number, ndigits=None)\n"
725"--\n"
726"\n"
727"Round a number to a given precision in decimal digits.\n"
728"\n"
729"The return value is an integer if ndigits is omitted or None. Otherwise\n"
730"the return value has the same type as the number. ndigits may be negative.");
731
732#define BUILTIN_ROUND_METHODDEF \
733 {"round", (PyCFunction)(void(*)(void))builtin_round, METH_FASTCALL|METH_KEYWORDS, builtin_round__doc__},
734
735static PyObject *
736builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits);
737
738static PyObject *
739builtin_round(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
740{
741 PyObject *return_value = NULL;
742 static const char * const _keywords[] = {"number", "ndigits", NULL};
743 static _PyArg_Parser _parser = {NULL, _keywords, "round", 0};
744 PyObject *argsbuf[2];
745 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
746 PyObject *number;
747 PyObject *ndigits = Py_None;
748
749 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
750 if (!args) {
751 goto exit;
752 }
753 number = args[0];
754 if (!noptargs) {
755 goto skip_optional_pos;
756 }
757 ndigits = args[1];
758skip_optional_pos:
759 return_value = builtin_round_impl(module, number, ndigits);
760
761exit:
762 return return_value;
763}
764
765PyDoc_STRVAR(builtin_sum__doc__,
766"sum($module, iterable, /, start=0)\n"
767"--\n"
768"\n"
769"Return the sum of a \'start\' value (default: 0) plus an iterable of numbers\n"
770"\n"
771"When the iterable is empty, return the start value.\n"
772"This function is intended specifically for use with numeric values and may\n"
773"reject non-numeric types.");
774
775#define BUILTIN_SUM_METHODDEF \
776 {"sum", (PyCFunction)(void(*)(void))builtin_sum, METH_FASTCALL|METH_KEYWORDS, builtin_sum__doc__},
777
778static PyObject *
779builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start);
780
781static PyObject *
782builtin_sum(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
783{
784 PyObject *return_value = NULL;
785 static const char * const _keywords[] = {"", "start", NULL};
786 static _PyArg_Parser _parser = {NULL, _keywords, "sum", 0};
787 PyObject *argsbuf[2];
788 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
789 PyObject *iterable;
790 PyObject *start = NULL;
791
792 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
793 if (!args) {
794 goto exit;
795 }
796 iterable = args[0];
797 if (!noptargs) {
798 goto skip_optional_pos;
799 }
800 start = args[1];
801skip_optional_pos:
802 return_value = builtin_sum_impl(module, iterable, start);
803
804exit:
805 return return_value;
806}
807
808PyDoc_STRVAR(builtin_isinstance__doc__,
809"isinstance($module, obj, class_or_tuple, /)\n"
810"--\n"
811"\n"
812"Return whether an object is an instance of a class or of a subclass thereof.\n"
813"\n"
814"A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\n"
815"check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\n"
816"or ...`` etc.");
817
818#define BUILTIN_ISINSTANCE_METHODDEF \
819 {"isinstance", (PyCFunction)(void(*)(void))builtin_isinstance, METH_FASTCALL, builtin_isinstance__doc__},
820
821static PyObject *
822builtin_isinstance_impl(PyObject *module, PyObject *obj,
823 PyObject *class_or_tuple);
824
825static PyObject *
826builtin_isinstance(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
827{
828 PyObject *return_value = NULL;
829 PyObject *obj;
830 PyObject *class_or_tuple;
831
832 if (!_PyArg_CheckPositional("isinstance", nargs, 2, 2)) {
833 goto exit;
834 }
835 obj = args[0];
836 class_or_tuple = args[1];
837 return_value = builtin_isinstance_impl(module, obj, class_or_tuple);
838
839exit:
840 return return_value;
841}
842
843PyDoc_STRVAR(builtin_issubclass__doc__,
844"issubclass($module, cls, class_or_tuple, /)\n"
845"--\n"
846"\n"
847"Return whether \'cls\' is derived from another class or is the same class.\n"
848"\n"
849"A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\n"
850"check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\n"
851"or ...``.");
852
853#define BUILTIN_ISSUBCLASS_METHODDEF \
854 {"issubclass", (PyCFunction)(void(*)(void))builtin_issubclass, METH_FASTCALL, builtin_issubclass__doc__},
855
856static PyObject *
857builtin_issubclass_impl(PyObject *module, PyObject *cls,
858 PyObject *class_or_tuple);
859
860static PyObject *
861builtin_issubclass(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
862{
863 PyObject *return_value = NULL;
864 PyObject *cls;
865 PyObject *class_or_tuple;
866
867 if (!_PyArg_CheckPositional("issubclass", nargs, 2, 2)) {
868 goto exit;
869 }
870 cls = args[0];
871 class_or_tuple = args[1];
872 return_value = builtin_issubclass_impl(module, cls, class_or_tuple);
873
874exit:
875 return return_value;
876}
877/*[clinic end generated code: output=da9ae459e9233259 input=a9049054013a1b77]*/
878