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