/* Built-in functions */

#include "Python.h"

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

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_cell.h" // PyCell_GetRef()

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

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

#include "pycore_fileutils.h" // _PyFile_Flush

#include "pycore_floatobject.h" // _PyFloat_ExactDealloc()

#include "pycore_interp.h" // _PyInterpreterState_GetConfig()

#include "pycore_import.h" // _PyImport_LazyImportModuleLevelObject ()

#include "pycore_long.h" // _PyLong_CompactValue

#include "pycore_modsupport.h" // _PyArg_NoKwnames()

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

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

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

#include "pycore_pythonrun.h" // _Py_SourceAsString()

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

#include "clinic/bltinmodule.c.h"

#ifdef HAVE_UNISTD_H

# include <unistd.h> // isatty()

#endif

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_GetOptionalAttr(base, &_Py_ID(__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))) {

Py_DECREF(new_base);

goto error;

}

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

base = args[j];

PyList_SET_ITEM(new_bases, j, Py_NewRef(base));

}

}

j = PyList_GET_SIZE(new_bases);

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

Py_DECREF(new_base);

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, *winner, *prep;

PyObject *cls = NULL, *cell = NULL, *ns = NULL, *meta = NULL, *orig_bases = NULL;

PyObject *mkw = NULL, *bases = 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) {

goto error;

}

if (PyDict_Pop(mkw, &_Py_ID(metaclass), &meta) < 0) {

goto error;

}

if (meta != NULL) {

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

isclass = PyType_Check(meta);

}

}

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) {

goto error;

}

if (winner != meta) {

Py_SETREF(meta, Py_NewRef(winner));

}

}

/* 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_GetOptionalAttr(meta, &_Py_ID(__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) {

goto error;

}

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;

}

PyThreadState *tstate = _PyThreadState_GET();

EVAL_CALL_STAT_INC(EVAL_CALL_BUILD_CLASS);

cell = _PyEval_Vector(tstate, (PyFunctionObject *)func, 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_GetRef((PyCellObject *)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_XDECREF(cell_cls);

Py_SETREF(cls, NULL);

goto error;

}

else {

Py_DECREF(cell_cls);

}

}

}

error:

Py_XDECREF(cell);

Py_XDECREF(ns);

Py_XDECREF(meta);

Py_XDECREF(mkw);

if (bases != orig_bases) {

Py_DECREF(orig_bases);

}

Py_DECREF(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.");

/*[clinic input]

__import__ as builtin___import__

name: object

globals: object(c_default="NULL") = None

locals: object(c_default="NULL") = None

fromlist: object(c_default="NULL") = ()

level: int = 0

Import a module.

Because this function is meant for use by the Python

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

importlib.import_module() to programmatically import a module.

The globals argument is only used to determine the context;

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

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

empty list to emulate ``import name``.

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

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

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

to perform absolute or relative imports: 0 is absolute, while a positive

number is the number of parent directories to search relative to the

current module.

[clinic start generated code]*/

static PyObject *

builtin___import___impl(PyObject *module, PyObject *name, PyObject *globals,

PyObject *locals, PyObject *fromlist, int level)

/*[clinic end generated code: output=4febeda88a0cd245 input=e3096a230383f72d]*/

{

return PyImport_ImportModuleLevelObject(name, globals, locals,

fromlist, level);

}

/*[clinic input]

__lazy_import__ as builtin___lazy_import__

name: object

globals: object(c_default="NULL") = None

locals: object(c_default="NULL") = None

fromlist: object(c_default="NULL") = ()

level: int = 0

Lazily imports a module.

Returns either the module to be imported or a imp.lazy_module object

which indicates the module to be lazily imported.

[clinic start generated code]*/

static PyObject *

builtin___lazy_import___impl(PyObject *module, PyObject *name,

PyObject *globals, PyObject *locals,

PyObject *fromlist, int level)

/*[clinic end generated code: output=300f1771094b9e8c input=9c85cccd6a885b9b]*/

{

PyObject *builtins;

PyThreadState *tstate = PyThreadState_GET();

if (globals == NULL) {

globals = PyEval_GetGlobals();

if (globals == NULL) {

PyErr_SetString(PyExc_TypeError,

"__lazy_import__() missing globals "

"when called without a frame");

return NULL;

}

}

if (locals == NULL) {

locals = globals;

}

if (!PyDict_Check(globals)) {

PyErr_Format(PyExc_TypeError,

"expect dict for globals, got %T", globals);

return NULL;

}

if (PyDict_GetItemRef(globals, &_Py_ID(__builtins__), &builtins) < 0) {

return NULL;

}

if (builtins == NULL) {

PyErr_SetString(PyExc_ValueError,

"unable to get builtins for lazy import");

return NULL;

}

if (PyModule_Check(builtins)) {

PyObject *builtins_dict = Py_XNewRef(PyModule_GetDict(builtins));

if (builtins_dict == NULL) {

Py_DECREF(builtins);

PyErr_SetString(PyExc_AttributeError,

"builtins module has no dict");

return NULL;

}

Py_SETREF(builtins, builtins_dict);

}

PyObject *res = _PyImport_LazyImportModuleLevelObject(

tstate, name, builtins, globals, locals, fromlist, level);

Py_DECREF(builtins);

return res;

}

/*[clinic input]

abs as builtin_abs

number: object

/

Return the absolute value of the argument.

[clinic start generated code]*/

static PyObject *

builtin_abs(PyObject *module, PyObject *number)

/*[clinic end generated code: output=861a9db97dee0595 input=a356196903543505]*/

{

return PyNumber_Absolute(number);

}

/*[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

integer: object

/

Return the binary representation of an integer.

>>> bin(2796202)

'0b1010101010101010101010'

[clinic start generated code]*/

static PyObject *

builtin_bin(PyObject *module, PyObject *integer)

/*[clinic end generated code: output=533f9388441805cc input=d16518f148341e70]*/

{

return PyNumber_ToBase(integer, 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_GetAttrString("breakpointhook");

if (hook == NULL) {

return NULL;

}

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

Py_DECREF(hook);

return NULL;

}

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

Py_DECREF(hook);

return retval;

}

PyDoc_STRVAR(breakpoint_doc,

"breakpoint($module, /, *args, **kws)\n\

--\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;

#define _filterobject_CAST(op) ((filterobject *)(op))

static PyObject *

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

{

PyObject *func, *seq;

PyObject *it;

filterobject *lz;

if ((type == &PyFilter_Type || type->tp_init == PyFilter_Type.tp_init) &&

!_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 = _PyType_CAST(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(PyObject *self)

{

filterobject *lz = _filterobject_CAST(self);

PyObject_GC_UnTrack(lz);

Py_XDECREF(lz->func);

Py_XDECREF(lz->it);

Py_TYPE(lz)->tp_free(lz);

}

static int

filter_traverse(PyObject *self, visitproc visit, void *arg)

{

filterobject *lz = _filterobject_CAST(self);

Py_VISIT(lz->it);

Py_VISIT(lz->func);

return 0;

}

static PyObject *

filter_next(PyObject *self)

{

filterobject *lz = _filterobject_CAST(self);

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(PyObject *self, PyObject *Py_UNUSED(ignored))

{

filterobject *lz = _filterobject_CAST(self);

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__", filter_reduce, METH_NOARGS, reduce_doc},

{NULL, NULL} /* sentinel */

};

PyDoc_STRVAR(filter_doc,

"filter(function, iterable, /)\n\

--\n\

\n\

Return an iterator yielding those items of iterable for which\n\

function(item) is true. If function is None, return the items that\n\

are true.");

PyTypeObject PyFilter_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"filter", /* tp_name */

sizeof(filterobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

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 */

filter_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

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 = filter_vectorcall

};

/*[clinic input]

format as builtin_format

value: object

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

/

Return type(value).__format__(value, format_spec)

Many built-in types implement format_spec according to the

Format Specification Mini-language. See help('FORMATTING').

If type(value) does not supply a method named __format__

and format_spec is empty, then str(value) is returned.

See also help('SPECIALMETHODS').

[clinic start generated code]*/

static PyObject *

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

/*[clinic end generated code: output=2f40bdfa4954b077 input=45ef3934b86d5624]*/

{

return PyObject_Format(value, format_spec);

}

/*[clinic input]

@permit_long_summary

chr as builtin_chr

i: object

/

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

[clinic start generated code]*/

static PyObject *

builtin_chr(PyObject *module, PyObject *i)

/*[clinic end generated code: output=d34f25b8035a9b10 input=a9b255f2d2e503f0]*/

{

int overflow;

long v = PyLong_AsLongAndOverflow(i, &overflow);

if (v == -1 && PyErr_Occurred()) {

return NULL;

}

if (overflow) {

v = overflow < 0 ? INT_MIN : INT_MAX;

/* Allow PyUnicode_FromOrdinal() to raise an exception */

}

#if SIZEOF_INT < SIZEOF_LONG

else if (v < INT_MIN) {

v = INT_MIN;

}

else if (v > INT_MAX) {

v = INT_MAX;

}

#endif

return PyUnicode_FromOrdinal(v);

}

/*[clinic input]

@permit_long_summary

compile as builtin_compile

source: object

filename: unicode_fs_decoded

mode: str

flags: int = 0

dont_inherit: bool = False

optimize: int = -1

*

module as modname: object = None

_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, PyObject *modname, int feature_version)

/*[clinic end generated code: output=9a0dce1945917a86 input=444c4fe466a97279]*/

{

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 (modname == Py_None) {

modname = NULL;

}

else if (!PyUnicode_Check(modname)) {

PyErr_Format(PyExc_TypeError,

"compile() argument 'module' must be str or None, not %T",

modname);

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) {

PyArena *arena = _PyArena_New();

if (arena == NULL) {

goto error;

}

if (flags & PyCF_ONLY_AST) {

mod_ty mod = PyAST_obj2mod(source, arena, compile_mode);

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

_PyArena_Free(arena);

goto error;

}

int syntax_check_only = ((flags & PyCF_OPTIMIZED_AST) == PyCF_ONLY_AST); /* unoptiomized AST */

if (_PyCompile_AstPreprocess(mod, filename, &cf, optimize, arena,

syntax_check_only, modname) < 0)

{

_PyArena_Free(arena);

goto error;

}

result = PyAST_mod2obj(mod);

}

else {

mod_ty 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, modname);

}

_PyArena_Free(arena);

goto finally;

}

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

if (str == NULL)

goto error;

#ifdef Py_GIL_DISABLED

// Disable immortalization of code constants for explicit

// compile() calls to get consistent frozen outputs between the default

// and free-threaded builds.

_PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET();

tstate->suppress_co_const_immortalization++;

#endif

result = _Py_CompileString(str, filename,

start[compile_mode], &cf,

optimize, modname);

#ifdef Py_GIL_DISABLED

tstate->suppress_co_const_immortalization--;

#endif

Py_XDECREF(source_copy);

goto finally;

error:

result = NULL;

finally:

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\n"

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

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

"otherwise 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"