/* Built-in functions */

#include "Python.h"

#include <ctype.h>

#include "pycore_ast.h" // _PyAST_Validate()

#include "pycore_compile.h" // _PyAST_Compile()

#include "pycore_object.h" // _Py_AddToAllObjects()

#include "pycore_pyerrors.h" // _PyErr_NoMemory()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_tuple.h" // _PyTuple_FromArray()

#include "pycore_ceval.h" // _PyEval_Vector()

_Py_IDENTIFIER(__builtins__);

_Py_IDENTIFIER(__dict__);

_Py_IDENTIFIER(__prepare__);

_Py_IDENTIFIER(__round__);

_Py_IDENTIFIER(__mro_entries__);

_Py_IDENTIFIER(encoding);

_Py_IDENTIFIER(errors);

_Py_IDENTIFIER(fileno);

_Py_IDENTIFIER(flush);

_Py_IDENTIFIER(metaclass);

_Py_IDENTIFIER(sort);

_Py_IDENTIFIER(stdin);

_Py_IDENTIFIER(stdout);

_Py_IDENTIFIER(stderr);

#include "clinic/bltinmodule.c.h"

static PyObject*

update_bases(PyObject *bases, PyObject *const *args, Py_ssize_t nargs)

{

Py_ssize_t i, j;

PyObject *base, *meth, *new_base, *result, *new_bases = NULL;

assert(PyTuple_Check(bases));

for (i = 0; i < nargs; i++) {

base = args[i];

if (PyType_Check(base)) {

if (new_bases) {

/* If we already have made a replacement, then we append every normal base,

otherwise just skip it. */

if (PyList_Append(new_bases, base) < 0) {

goto error;

}

}

continue;

}

if (_PyObject_LookupAttrId(base, &PyId___mro_entries__, &meth) < 0) {

goto error;

}

if (!meth) {

if (new_bases) {

if (PyList_Append(new_bases, base) < 0) {

goto error;

}

}

continue;

}

new_base = PyObject_CallOneArg(meth, bases);

Py_DECREF(meth);

if (!new_base) {

goto error;

}

if (!PyTuple_Check(new_base)) {

PyErr_SetString(PyExc_TypeError,

"__mro_entries__ must return a tuple");

Py_DECREF(new_base);

goto error;

}

if (!new_bases) {

/* If this is a first successful replacement, create new_bases list and

copy previously encountered bases. */

if (!(new_bases = PyList_New(i))) {

goto error;

}

for (j = 0; j < i; j++) {

base = args[j];

PyList_SET_ITEM(new_bases, j, base);

Py_INCREF(base);

}

}

j = PyList_GET_SIZE(new_bases);

if (PyList_SetSlice(new_bases, j, j, new_base) < 0) {

goto error;

}

Py_DECREF(new_base);

}

if (!new_bases) {

return bases;

}

result = PyList_AsTuple(new_bases);

Py_DECREF(new_bases);

return result;

error:

Py_XDECREF(new_bases);

return NULL;

}

/* AC: cannot convert yet, waiting for *args support */

static PyObject *

builtin___build_class__(PyObject *self, PyObject *const *args, Py_ssize_t nargs,

PyObject *kwnames)

{

PyObject *func, *name, *bases, *mkw, *meta, *winner, *prep, *ns, *orig_bases;

PyObject *cls = NULL, *cell = NULL;

int isclass = 0; /* initialize to prevent gcc warning */

if (nargs < 2) {

PyErr_SetString(PyExc_TypeError,

"__build_class__: not enough arguments");

return NULL;

}

func = args[0]; /* Better be callable */

if (!PyFunction_Check(func)) {

PyErr_SetString(PyExc_TypeError,

"__build_class__: func must be a function");

return NULL;

}

name = args[1];

if (!PyUnicode_Check(name)) {

PyErr_SetString(PyExc_TypeError,

"__build_class__: name is not a string");

return NULL;

}

orig_bases = _PyTuple_FromArray(args + 2, nargs - 2);

if (orig_bases == NULL)

return NULL;

bases = update_bases(orig_bases, args + 2, nargs - 2);

if (bases == NULL) {

Py_DECREF(orig_bases);

return NULL;

}

if (kwnames == NULL) {

meta = NULL;

mkw = NULL;

}

else {

mkw = _PyStack_AsDict(args + nargs, kwnames);

if (mkw == NULL) {

Py_DECREF(bases);

return NULL;

}

meta = _PyDict_GetItemIdWithError(mkw, &PyId_metaclass);

if (meta != NULL) {

Py_INCREF(meta);

if (_PyDict_DelItemId(mkw, &PyId_metaclass) < 0) {

Py_DECREF(meta);

Py_DECREF(mkw);

Py_DECREF(bases);

return NULL;

}

/* metaclass is explicitly given, check if it's indeed a class */

isclass = PyType_Check(meta);

}

else if (PyErr_Occurred()) {

Py_DECREF(mkw);

Py_DECREF(bases);

return NULL;

}

}

if (meta == NULL) {

/* if there are no bases, use type: */

if (PyTuple_GET_SIZE(bases) == 0) {

meta = (PyObject *) (&PyType_Type);

}

/* else get the type of the first base */

else {

PyObject *base0 = PyTuple_GET_ITEM(bases, 0);

meta = (PyObject *)Py_TYPE(base0);

}

Py_INCREF(meta);

isclass = 1; /* meta is really a class */

}

if (isclass) {

/* meta is really a class, so check for a more derived

metaclass, or possible metaclass conflicts: */

winner = (PyObject *)_PyType_CalculateMetaclass((PyTypeObject *)meta,

bases);

if (winner == NULL) {

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

return NULL;

}

if (winner != meta) {

Py_DECREF(meta);

meta = winner;

Py_INCREF(meta);

}

}

/* else: meta is not a class, so we cannot do the metaclass

calculation, so we will use the explicitly given object as it is */

if (_PyObject_LookupAttrId(meta, &PyId___prepare__, &prep) < 0) {

ns = NULL;

}

else if (prep == NULL) {

ns = PyDict_New();

}

else {

PyObject *pargs[2] = {name, bases};

ns = PyObject_VectorcallDict(prep, pargs, 2, mkw);

Py_DECREF(prep);

}

if (ns == NULL) {

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

return NULL;

}

if (!PyMapping_Check(ns)) {

PyErr_Format(PyExc_TypeError,

"%.200s.__prepare__() must return a mapping, not %.200s",

isclass ? ((PyTypeObject *)meta)->tp_name : "<metaclass>",

Py_TYPE(ns)->tp_name);

goto error;

}

PyFrameConstructor *f = PyFunction_AS_FRAME_CONSTRUCTOR(func);

PyThreadState *tstate = PyThreadState_GET();

cell = _PyEval_Vector(tstate, f, ns, NULL, 0, NULL);

if (cell != NULL) {

if (bases != orig_bases) {

if (PyMapping_SetItemString(ns, "__orig_bases__", orig_bases) < 0) {

goto error;

}

}

PyObject *margs[3] = {name, bases, ns};

cls = PyObject_VectorcallDict(meta, margs, 3, mkw);

if (cls != NULL && PyType_Check(cls) && PyCell_Check(cell)) {

PyObject *cell_cls = PyCell_GET(cell);

if (cell_cls != cls) {

if (cell_cls == NULL) {

const char *msg =

"__class__ not set defining %.200R as %.200R. "

"Was __classcell__ propagated to type.__new__?";

PyErr_Format(PyExc_RuntimeError, msg, name, cls);

} else {

const char *msg =

"__class__ set to %.200R defining %.200R as %.200R";

PyErr_Format(PyExc_TypeError, msg, cell_cls, name, cls);

}

Py_DECREF(cls);

cls = NULL;

goto error;

}

}

}

error:

Py_XDECREF(cell);

Py_DECREF(ns);

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

if (bases != orig_bases) {

Py_DECREF(orig_bases);

}

return cls;

}

PyDoc_STRVAR(build_class_doc,

"__build_class__(func, name, /, *bases, [metaclass], **kwds) -> class\n\

\n\

Internal helper function used by the class statement.");

static PyObject *

builtin___import__(PyObject *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"name", "globals", "locals", "fromlist",

"level", 0};

PyObject *name, *globals = NULL, *locals = NULL, *fromlist = NULL;

int level = 0;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "U|OOOi:__import__",

kwlist, &name, &globals, &locals, &fromlist, &level))

return NULL;

return PyImport_ImportModuleLevelObject(name, globals, locals,

fromlist, level);

}

PyDoc_STRVAR(import_doc,

"__import__(name, globals=None, locals=None, fromlist=(), level=0) -> module\n\

\n\

Import a module. Because this function is meant for use by the Python\n\

interpreter and not for general use, it is better to use\n\

importlib.import_module() to programmatically import a module.\n\

\n\

The globals argument is only used to determine the context;\n\

they are not modified. The locals argument is unused. The fromlist\n\

should be a list of names to emulate ``from name import ...'', or an\n\

empty list to emulate ``import name''.\n\

When importing a module from a package, note that __import__('A.B', ...)\n\

returns package A when fromlist is empty, but its submodule B when\n\

fromlist is not empty. The level argument is used to determine whether to\n\

perform absolute or relative imports: 0 is absolute, while a positive number\n\

is the number of parent directories to search relative to the current module.");

/*[clinic input]

abs as builtin_abs

x: object

/

Return the absolute value of the argument.

[clinic start generated code]*/

static PyObject *

builtin_abs(PyObject *module, PyObject *x)

/*[clinic end generated code: output=b1b433b9e51356f5 input=bed4ca14e29c20d1]*/

{

return PyNumber_Absolute(x);

}

/*[clinic input]

all as builtin_all

iterable: object

/

Return True if bool(x) is True for all values x in the iterable.

If the iterable is empty, return True.

[clinic start generated code]*/

static PyObject *

builtin_all(PyObject *module, PyObject *iterable)

/*[clinic end generated code: output=ca2a7127276f79b3 input=1a7c5d1bc3438a21]*/

{

PyObject *it, *item;

PyObject *(*iternext)(PyObject *);

int cmp;

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

iternext = *Py_TYPE(it)->tp_iternext;

for (;;) {

item = iternext(it);

if (item == NULL)

break;

cmp = PyObject_IsTrue(item);

Py_DECREF(item);

if (cmp < 0) {

Py_DECREF(it);

return NULL;

}

if (cmp == 0) {

Py_DECREF(it);

Py_RETURN_FALSE;

}

}

Py_DECREF(it);

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_StopIteration))

PyErr_Clear();

else

return NULL;

}

Py_RETURN_TRUE;

}

/*[clinic input]

any as builtin_any

iterable: object

/

Return True if bool(x) is True for any x in the iterable.

If the iterable is empty, return False.

[clinic start generated code]*/

static PyObject *

builtin_any(PyObject *module, PyObject *iterable)

/*[clinic end generated code: output=fa65684748caa60e input=41d7451c23384f24]*/

{

PyObject *it, *item;

PyObject *(*iternext)(PyObject *);

int cmp;

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

iternext = *Py_TYPE(it)->tp_iternext;

for (;;) {

item = iternext(it);

if (item == NULL)

break;

cmp = PyObject_IsTrue(item);

Py_DECREF(item);

if (cmp < 0) {

Py_DECREF(it);

return NULL;

}

if (cmp > 0) {

Py_DECREF(it);

Py_RETURN_TRUE;

}

}

Py_DECREF(it);

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_StopIteration))

PyErr_Clear();

else

return NULL;

}

Py_RETURN_FALSE;

}

/*[clinic input]

ascii as builtin_ascii

obj: object

/

Return an ASCII-only representation of an object.

As repr(), return a string containing a printable representation of an

object, but escape the non-ASCII characters in the string returned by

repr() using \\x, \\u or \\U escapes. This generates a string similar

to that returned by repr() in Python 2.

[clinic start generated code]*/

static PyObject *

builtin_ascii(PyObject *module, PyObject *obj)

/*[clinic end generated code: output=6d37b3f0984c7eb9 input=4c62732e1b3a3cc9]*/

{

return PyObject_ASCII(obj);

}

/*[clinic input]

bin as builtin_bin

number: object

/

Return the binary representation of an integer.

>>> bin(2796202)

'0b1010101010101010101010'

[clinic start generated code]*/

static PyObject *

builtin_bin(PyObject *module, PyObject *number)

/*[clinic end generated code: output=b6fc4ad5e649f4f7 input=53f8a0264bacaf90]*/

{

return PyNumber_ToBase(number, 2);

}

/*[clinic input]

callable as builtin_callable

obj: object

/

Return whether the object is callable (i.e., some kind of function).

Note that classes are callable, as are instances of classes with a

__call__() method.

[clinic start generated code]*/

static PyObject *

builtin_callable(PyObject *module, PyObject *obj)

/*[clinic end generated code: output=2b095d59d934cb7e input=1423bab99cc41f58]*/

{

return PyBool_FromLong((long)PyCallable_Check(obj));

}

static PyObject *

builtin_breakpoint(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *keywords)

{

PyObject *hook = PySys_GetObject("breakpointhook");

if (hook == NULL) {

PyErr_SetString(PyExc_RuntimeError, "lost sys.breakpointhook");

return NULL;

}

if (PySys_Audit("builtins.breakpoint", "O", hook) < 0) {

return NULL;

}

Py_INCREF(hook);

PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);

Py_DECREF(hook);

return retval;

}

PyDoc_STRVAR(breakpoint_doc,

"breakpoint(*args, **kws)\n\

\n\

Call sys.breakpointhook(*args, **kws). sys.breakpointhook() must accept\n\

whatever arguments are passed.\n\

\n\

By default, this drops you into the pdb debugger.");

typedef struct {

PyObject_HEAD

PyObject *func;

PyObject *it;

} filterobject;

static PyObject *

filter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyObject *func, *seq;

PyObject *it;

filterobject *lz;

if (type == &PyFilter_Type && !_PyArg_NoKeywords("filter", kwds))

return NULL;

if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))

return NULL;

/* Get iterator. */

it = PyObject_GetIter(seq);

if (it == NULL)

return NULL;

/* create filterobject structure */

lz = (filterobject *)type->tp_alloc(type, 0);

if (lz == NULL) {

Py_DECREF(it);

return NULL;

}

lz->func = Py_NewRef(func);

lz->it = it;

return (PyObject *)lz;

}

static PyObject *

filter_vectorcall(PyObject *type, PyObject * const*args,

size_t nargsf, PyObject *kwnames)

{

PyTypeObject *tp = (PyTypeObject *)type;

if (tp == &PyFilter_Type && !_PyArg_NoKwnames("filter", kwnames)) {

return NULL;

}

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (!_PyArg_CheckPositional("filter", nargs, 2, 2)) {

return NULL;

}

PyObject *it = PyObject_GetIter(args[1]);

if (it == NULL) {

return NULL;

}

filterobject *lz = (filterobject *)tp->tp_alloc(tp, 0);

if (lz == NULL) {

Py_DECREF(it);

return NULL;

}

lz->func = Py_NewRef(args[0]);

lz->it = it;

return (PyObject *)lz;

}

static void

filter_dealloc(filterobject *lz)

{

PyObject_GC_UnTrack(lz);

Py_XDECREF(lz->func);

Py_XDECREF(lz->it);

Py_TYPE(lz)->tp_free(lz);

}

static int

filter_traverse(filterobject *lz, visitproc visit, void *arg)

{

Py_VISIT(lz->it);

Py_VISIT(lz->func);

return 0;

}

static PyObject *

filter_next(filterobject *lz)

{

PyObject *item;

PyObject *it = lz->it;

long ok;

PyObject *(*iternext)(PyObject *);

int checktrue = lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type;

iternext = *Py_TYPE(it)->tp_iternext;

for (;;) {

item = iternext(it);

if (item == NULL)

return NULL;

if (checktrue) {

ok = PyObject_IsTrue(item);

} else {

PyObject *good;

good = PyObject_CallOneArg(lz->func, item);

if (good == NULL) {

Py_DECREF(item);

return NULL;

}

ok = PyObject_IsTrue(good);

Py_DECREF(good);

}

if (ok > 0)

return item;

Py_DECREF(item);

if (ok < 0)

return NULL;

}

}

static PyObject *

filter_reduce(filterobject *lz, PyObject *Py_UNUSED(ignored))

{

return Py_BuildValue("O(OO)", Py_TYPE(lz), lz->func, lz->it);

}

PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");

static PyMethodDef filter_methods[] = {

{"__reduce__", (PyCFunction)filter_reduce, METH_NOARGS, reduce_doc},

{NULL, NULL} /* sentinel */

};

PyDoc_STRVAR(filter_doc,

"filter(function or None, iterable) --> filter object\n\

\n\

Return an iterator yielding those items of iterable for which function(item)\n\

is true. If function is None, return the items that are true.");

PyTypeObject PyFilter_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"filter", /* tp_name */

sizeof(filterobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)filter_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_BASETYPE, /* tp_flags */

filter_doc, /* tp_doc */

(traverseproc)filter_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc)filter_next, /* tp_iternext */

filter_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

PyType_GenericAlloc, /* tp_alloc */

filter_new, /* tp_new */

PyObject_GC_Del, /* tp_free */

.tp_vectorcall = (vectorcallfunc)filter_vectorcall

};

/*[clinic input]

format as builtin_format

value: object

format_spec: unicode(c_default="NULL") = ''

/

Return value.__format__(format_spec)

format_spec defaults to the empty string.

See the Format Specification Mini-Language section of help('FORMATTING') for

details.

[clinic start generated code]*/

static PyObject *

builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec)

/*[clinic end generated code: output=2f40bdfa4954b077 input=88339c93ea522b33]*/

{

return PyObject_Format(value, format_spec);

}

/*[clinic input]

chr as builtin_chr

i: int

/

Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.

[clinic start generated code]*/

static PyObject *

builtin_chr_impl(PyObject *module, int i)

/*[clinic end generated code: output=c733afcd200afcb7 input=3f604ef45a70750d]*/

{

return PyUnicode_FromOrdinal(i);

}

/*[clinic input]

compile as builtin_compile

source: object

filename: object(converter="PyUnicode_FSDecoder")

mode: str

flags: int = 0

dont_inherit: bool(accept={int}) = False

optimize: int = -1

*

_feature_version as feature_version: int = -1

Compile source into a code object that can be executed by exec() or eval().

The source code may represent a Python module, statement or expression.

The filename will be used for run-time error messages.

The mode must be 'exec' to compile a module, 'single' to compile a

single (interactive) statement, or 'eval' to compile an expression.

The flags argument, if present, controls which future statements influence

the compilation of the code.

The dont_inherit argument, if true, stops the compilation inheriting

the effects of any future statements in effect in the code calling

compile; if absent or false these statements do influence the compilation,

in addition to any features explicitly specified.

[clinic start generated code]*/

static PyObject *

builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,

const char *mode, int flags, int dont_inherit,

int optimize, int feature_version)

/*[clinic end generated code: output=b0c09c84f116d3d7 input=40171fb92c1d580d]*/

{

PyObject *source_copy;

const char *str;

int compile_mode = -1;

int is_ast;

int start[] = {Py_file_input, Py_eval_input, Py_single_input, Py_func_type_input};

PyObject *result;

PyCompilerFlags cf = _PyCompilerFlags_INIT;

cf.cf_flags = flags | PyCF_SOURCE_IS_UTF8;

if (feature_version >= 0 && (flags & PyCF_ONLY_AST)) {

cf.cf_feature_version = feature_version;

}

if (flags &

~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_COMPILE_MASK))

{

PyErr_SetString(PyExc_ValueError,

"compile(): unrecognised flags");

goto error;

}

/* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */

if (optimize < -1 || optimize > 2) {

PyErr_SetString(PyExc_ValueError,

"compile(): invalid optimize value");

goto error;

}

if (!dont_inherit) {

PyEval_MergeCompilerFlags(&cf);

}

if (strcmp(mode, "exec") == 0)

compile_mode = 0;

else if (strcmp(mode, "eval") == 0)

compile_mode = 1;

else if (strcmp(mode, "single") == 0)

compile_mode = 2;

else if (strcmp(mode, "func_type") == 0) {

if (!(flags & PyCF_ONLY_AST)) {

PyErr_SetString(PyExc_ValueError,

"compile() mode 'func_type' requires flag PyCF_ONLY_AST");

goto error;

}

compile_mode = 3;

}

else {

const char *msg;

if (flags & PyCF_ONLY_AST)

msg = "compile() mode must be 'exec', 'eval', 'single' or 'func_type'";

else

msg = "compile() mode must be 'exec', 'eval' or 'single'";

PyErr_SetString(PyExc_ValueError, msg);

goto error;

}

is_ast = PyAST_Check(source);

if (is_ast == -1)

goto error;

if (is_ast) {

if (flags & PyCF_ONLY_AST) {

Py_INCREF(source);

result = source;

}

else {

PyArena *arena;

mod_ty mod;

arena = _PyArena_New();

if (arena == NULL)

goto error;

mod = PyAST_obj2mod(source, arena, compile_mode);

if (mod == NULL || !_PyAST_Validate(mod)) {

_PyArena_Free(arena);

goto error;

}

result = (PyObject*)_PyAST_Compile(mod, filename,

&cf, optimize, arena);

_PyArena_Free(arena);

}

goto finally;

}

str = _Py_SourceAsString(source, "compile", "string, bytes or AST", &cf, &source_copy);

if (str == NULL)

goto error;

result = Py_CompileStringObject(str, filename, start[compile_mode], &cf, optimize);

Py_XDECREF(source_copy);

goto finally;

error:

result = NULL;

finally:

Py_DECREF(filename);

return result;

}

/* AC: cannot convert yet, as needs PEP 457 group support in inspect */

static PyObject *

builtin_dir(PyObject *self, PyObject *args)

{

PyObject *arg = NULL;

if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))

return NULL;

return PyObject_Dir(arg);

}

PyDoc_STRVAR(dir_doc,

"dir([object]) -> list of strings\n"

"\n"

"If called without an argument, return the names in the current scope.\n"

"Else, return an alphabetized list of names comprising (some of) the attributes\n"

"of the given object, and of attributes reachable from it.\n"

"If the object supplies a method named __dir__, it will be used; otherwise\n"

"the default dir() logic is used and returns:\n"

" for a module object: the module's attributes.\n"

" for a class object: its attributes, and recursively the attributes\n"

" of its bases.\n"

" for any other object: its attributes, its class's attributes, and\n"

" recursively the attributes of its class's base classes.");

/*[clinic input]

divmod as builtin_divmod

x: object

y: object

/

Return the tuple (x//y, x%y). Invariant: div*y + mod == x.

[clinic start generated code]*/

static PyObject *

builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y)

/*[clinic end generated code: output=b06d8a5f6e0c745e input=175ad9c84ff41a85]*/

{

return PyNumber_Divmod(x, y);

}

/*[clinic input]

eval as builtin_eval

source: object

globals: object = None

locals: object = None

/

Evaluate the given source in the context of globals and locals.

The source may be a string representing a Python expression

or a code object as returned by compile().

The globals must be a dictionary and locals can be any mapping,

defaulting to the current globals and locals.

If only globals is given, locals defaults to it.

[clinic start generated code]*/

static PyObject *

builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,

PyObject *locals)

/*[clinic end generated code: output=0a0824aa70093116 input=11ee718a8640e527]*/

{

PyObject *result, *source_copy;

const char *str;

if (locals != Py_None && !PyMapping_Check(locals)) {

PyErr_SetString(PyExc_TypeError, "locals must be a mapping");

return NULL;

}

if (globals != Py_None && !PyDict_Check(globals)) {

PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?

"globals must be a real dict; try eval(expr, {}, mapping)"

: "globals must be a dict");

return NULL;

}

if (globals == Py_None) {

globals = PyEval_GetGlobals();

if (locals == Py_None) {

locals = PyEval_GetLocals();

if (locals == NULL)

return NULL;

}

}

else if (locals == Py_None)

locals = globals;

if (globals == NULL || locals == NULL) {

PyErr_SetString(PyExc_TypeError,

"eval must be given globals and locals "

"when called without a frame");

return NULL;

}

int r = _PyDict_ContainsId(globals, &PyId___builtins__);

if (r == 0) {

r = _PyDict_SetItemId(globals, &PyId___builtins__,

PyEval_GetBuiltins());

}

if (r < 0) {

return NULL;

}

if (PyCode_Check(source)) {

if (PySys_Audit("exec", "O", source) < 0) {

return NULL;

}

if (PyCode_GetNumFree((PyCodeObject *)source) > 0) {

PyErr_SetString(PyExc_TypeError,

"code object passed to eval() may not contain free variables");

return NULL;

}

return PyEval_EvalCode(source, globals, locals);

}

PyCompilerFlags cf = _PyCompilerFlags_INIT;

cf.cf_flags = PyCF_SOURCE_IS_UTF8;

str = _Py_SourceAsString(source, "eval", "string, bytes or code", &cf, &source_copy);

if (str == NULL)

return NULL;

while (*str == ' ' || *str == '\t')

str++;

(void)PyEval_MergeCompilerFlags(&cf);

result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);

Py_XDECREF(source_copy);

return result;

}

/*[clinic input]

exec as builtin_exec

source: object

globals: object = None

locals: object = None

/