1 | /*[clinic input] |
2 | preserve |
3 | [clinic start generated code]*/ |
4 | |
5 | PyDoc_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 | |
14 | PyDoc_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 | |
25 | PyDoc_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 | |
36 | PyDoc_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 | |
50 | PyDoc_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 | |
62 | PyDoc_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 | |
74 | PyDoc_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 | |
87 | static PyObject * |
88 | builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec); |
89 | |
90 | static PyObject * |
91 | builtin_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]; |
112 | skip_optional: |
113 | return_value = builtin_format_impl(module, value, format_spec); |
114 | |
115 | exit: |
116 | return return_value; |
117 | } |
118 | |
119 | PyDoc_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 | |
128 | static PyObject * |
129 | builtin_chr_impl(PyObject *module, int i); |
130 | |
131 | static PyObject * |
132 | builtin_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 | |
143 | exit: |
144 | return return_value; |
145 | } |
146 | |
147 | PyDoc_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 | |
168 | static PyObject * |
169 | builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename, |
170 | const char *mode, int flags, int dont_inherit, |
171 | int optimize, int feature_version); |
172 | |
173 | static PyObject * |
174 | builtin_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 | } |
240 | skip_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 | } |
248 | skip_optional_kwonly: |
249 | return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize, feature_version); |
250 | |
251 | exit: |
252 | return return_value; |
253 | } |
254 | |
255 | PyDoc_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 | |
264 | static PyObject * |
265 | builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y); |
266 | |
267 | static PyObject * |
268 | builtin_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 | |
281 | exit: |
282 | return return_value; |
283 | } |
284 | |
285 | PyDoc_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 | |
300 | static PyObject * |
301 | builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals, |
302 | PyObject *locals); |
303 | |
304 | static PyObject * |
305 | builtin_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]; |
324 | skip_optional: |
325 | return_value = builtin_eval_impl(module, source, globals, locals); |
326 | |
327 | exit: |
328 | return return_value; |
329 | } |
330 | |
331 | PyDoc_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 | |
346 | static PyObject * |
347 | builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals, |
348 | PyObject *locals); |
349 | |
350 | static PyObject * |
351 | builtin_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]; |
370 | skip_optional: |
371 | return_value = builtin_exec_impl(module, source, globals, locals); |
372 | |
373 | exit: |
374 | return return_value; |
375 | } |
376 | |
377 | PyDoc_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 | |
389 | static PyObject * |
390 | builtin_globals_impl(PyObject *module); |
391 | |
392 | static PyObject * |
393 | builtin_globals(PyObject *module, PyObject *Py_UNUSED(ignored)) |
394 | { |
395 | return builtin_globals_impl(module); |
396 | } |
397 | |
398 | PyDoc_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 | |
409 | static PyObject * |
410 | builtin_hasattr_impl(PyObject *module, PyObject *obj, PyObject *name); |
411 | |
412 | static PyObject * |
413 | builtin_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 | |
426 | exit: |
427 | return return_value; |
428 | } |
429 | |
430 | PyDoc_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 | |
442 | PyDoc_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 | |
453 | static PyObject * |
454 | builtin_setattr_impl(PyObject *module, PyObject *obj, PyObject *name, |
455 | PyObject *value); |
456 | |
457 | static PyObject * |
458 | builtin_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 | |
473 | exit: |
474 | return return_value; |
475 | } |
476 | |
477 | PyDoc_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 | |
488 | static PyObject * |
489 | builtin_delattr_impl(PyObject *module, PyObject *obj, PyObject *name); |
490 | |
491 | static PyObject * |
492 | builtin_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 | |
505 | exit: |
506 | return return_value; |
507 | } |
508 | |
509 | PyDoc_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 | |
521 | PyDoc_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 | |
533 | PyDoc_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 | |
542 | PyDoc_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 | |
551 | static PyObject * |
552 | builtin_anext_impl(PyObject *module, PyObject *aiterator, |
553 | PyObject *default_value); |
554 | |
555 | static PyObject * |
556 | builtin_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]; |
570 | skip_optional: |
571 | return_value = builtin_anext_impl(module, aiterator, default_value); |
572 | |
573 | exit: |
574 | return return_value; |
575 | } |
576 | |
577 | PyDoc_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 | |
586 | PyDoc_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 | |
599 | static PyObject * |
600 | builtin_locals_impl(PyObject *module); |
601 | |
602 | static PyObject * |
603 | builtin_locals(PyObject *module, PyObject *Py_UNUSED(ignored)) |
604 | { |
605 | return builtin_locals_impl(module); |
606 | } |
607 | |
608 | PyDoc_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 | |
620 | PyDoc_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 | |
629 | PyDoc_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 | |
641 | static PyObject * |
642 | builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp, |
643 | PyObject *mod); |
644 | |
645 | static PyObject * |
646 | builtin_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]; |
667 | skip_optional_pos: |
668 | return_value = builtin_pow_impl(module, base, exp, mod); |
669 | |
670 | exit: |
671 | return return_value; |
672 | } |
673 | |
674 | PyDoc_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 | |
689 | static PyObject * |
690 | builtin_input_impl(PyObject *module, PyObject *prompt); |
691 | |
692 | static PyObject * |
693 | builtin_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]; |
705 | skip_optional: |
706 | return_value = builtin_input_impl(module, prompt); |
707 | |
708 | exit: |
709 | return return_value; |
710 | } |
711 | |
712 | PyDoc_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 | |
723 | PyDoc_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 | |
735 | static PyObject * |
736 | builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits); |
737 | |
738 | static PyObject * |
739 | builtin_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]; |
758 | skip_optional_pos: |
759 | return_value = builtin_round_impl(module, number, ndigits); |
760 | |
761 | exit: |
762 | return return_value; |
763 | } |
764 | |
765 | PyDoc_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 | |
778 | static PyObject * |
779 | builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start); |
780 | |
781 | static PyObject * |
782 | builtin_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]; |
801 | skip_optional_pos: |
802 | return_value = builtin_sum_impl(module, iterable, start); |
803 | |
804 | exit: |
805 | return return_value; |
806 | } |
807 | |
808 | PyDoc_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 | |
821 | static PyObject * |
822 | builtin_isinstance_impl(PyObject *module, PyObject *obj, |
823 | PyObject *class_or_tuple); |
824 | |
825 | static PyObject * |
826 | builtin_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 | |
839 | exit: |
840 | return return_value; |
841 | } |
842 | |
843 | PyDoc_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 | |
856 | static PyObject * |
857 | builtin_issubclass_impl(PyObject *module, PyObject *cls, |
858 | PyObject *class_or_tuple); |
859 | |
860 | static PyObject * |
861 | builtin_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 | |
874 | exit: |
875 | return return_value; |
876 | } |
877 | /*[clinic end generated code: output=da9ae459e9233259 input=a9049054013a1b77]*/ |
878 | |