bltinmodule.c

/* Built-in functions */

#include"Python.h"
#include"pycore_ast.h"// _PyAST_Validate()
#include"pycore_call.h"// _PyObject_CallNoArgs()
#include"pycore_ceval.h"// _PyEval_Vector()
#include"pycore_compile.h"// _PyAST_Compile()
#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_sysmodule.h"// _PySys_GetRequiredAttr()
#include"pycore_tuple.h"// _PyTuple_FromArray()

#include"clinic/bltinmodule.c.h"

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


staticPyObject*
update_bases(PyObject*bases, PyObject*const*args, Py_ssize_tnargs)
{
Py_ssize_ti, 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) {
returnbases;
 }
result=PyList_AsTuple(new_bases);
Py_DECREF(new_bases);
returnresult;

error:
Py_XDECREF(new_bases);
returnNULL;
}

/* AC: cannot convert yet, waiting for *args support */
staticPyObject*
builtin___build_class__(PyObject*self, PyObject*const*args, Py_ssize_tnargs,
PyObject*kwnames)
{
PyObject*func, *name, *winner, *prep;
PyObject*cls=NULL, *cell=NULL, *ns=NULL, *meta=NULL, *orig_bases=NULL;
PyObject*mkw=NULL, *bases=NULL;
intisclass=0; /* initialize to prevent gcc warning */

if (nargs<2) {
PyErr_SetString(PyExc_TypeError,
"__build_class__: not enough arguments");
returnNULL;
 }
func=args[0]; /* Better be callable */
if (!PyFunction_Check(func)) {
PyErr_SetString(PyExc_TypeError,
"__build_class__: func must be a function");
returnNULL;
 }
name=args[1];
if (!PyUnicode_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"__build_class__: name is not a string");
returnNULL;
 }
orig_bases=_PyTuple_FromArray(args+2, nargs-2);
if (orig_bases==NULL)
returnNULL;

bases=update_bases(orig_bases, args+2, nargs-2);
if (bases==NULL) {
Py_DECREF(orig_bases);
returnNULL;
 }

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;
 }
elseif (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_GET(cell);
if (cell_cls!=cls) {
if (cell_cls==NULL) {
constchar*msg=
"__class__ not set defining %.200R as %.200R. "
"Was __classcell__ propagated to type.__new__?";
PyErr_Format(PyExc_RuntimeError, msg, name, cls);
 } else {
constchar*msg=
"__class__ set to %.200R defining %.200R as %.200R";
PyErr_Format(PyExc_TypeError, msg, cell_cls, name, cls);
 }
Py_SETREF(cls, NULL);
 goto error;
 }
 }
 }
error:
Py_XDECREF(cell);
Py_XDECREF(ns);
Py_XDECREF(meta);
Py_XDECREF(mkw);
if (bases!=orig_bases) {
Py_DECREF(orig_bases);
 }
Py_DECREF(bases);
returncls;
}

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

staticPyObject*
builtin___import___impl(PyObject*module, PyObject*name, PyObject*globals,
PyObject*locals, PyObject*fromlist, intlevel)
/*[clinic end generated code: output=4febeda88a0cd245 input=73f4b960ea5b9dd6]*/
{
returnPyImport_ImportModuleLevelObject(name, globals, locals,
fromlist, level);
}


/*[clinic input]
abs as builtin_abs

 x: object
 /

Return the absolute value of the argument.
[clinic start generated code]*/

staticPyObject*
builtin_abs(PyObject*module, PyObject*x)
/*[clinic end generated code: output=b1b433b9e51356f5 input=bed4ca14e29c20d1]*/
{
returnPyNumber_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]*/

staticPyObject*
builtin_all(PyObject*module, PyObject*iterable)
/*[clinic end generated code: output=ca2a7127276f79b3 input=1a7c5d1bc3438a21]*/
{
PyObject*it, *item;
PyObject*(*iternext)(PyObject*);
intcmp;

it=PyObject_GetIter(iterable);
if (it==NULL)
returnNULL;
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);
returnNULL;
 }
if (cmp==0) {
Py_DECREF(it);
Py_RETURN_FALSE;
 }
 }
Py_DECREF(it);
if (PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_StopIteration))
PyErr_Clear();
else
returnNULL;
 }
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]*/

staticPyObject*
builtin_any(PyObject*module, PyObject*iterable)
/*[clinic end generated code: output=fa65684748caa60e input=41d7451c23384f24]*/
{
PyObject*it, *item;
PyObject*(*iternext)(PyObject*);
intcmp;

it=PyObject_GetIter(iterable);
if (it==NULL)
returnNULL;
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);
returnNULL;
 }
if (cmp>0) {
Py_DECREF(it);
Py_RETURN_TRUE;
 }
 }
Py_DECREF(it);
if (PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_StopIteration))
PyErr_Clear();
else
returnNULL;
 }
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]*/

staticPyObject*
builtin_ascii(PyObject*module, PyObject*obj)
/*[clinic end generated code: output=6d37b3f0984c7eb9 input=4c62732e1b3a3cc9]*/
{
returnPyObject_ASCII(obj);
}


/*[clinic input]
bin as builtin_bin

 number: object
 /

Return the binary representation of an integer.

 >>> bin(2796202)
 '0b1010101010101010101010'
[clinic start generated code]*/

staticPyObject*
builtin_bin(PyObject*module, PyObject*number)
/*[clinic end generated code: output=b6fc4ad5e649f4f7 input=53f8a0264bacaf90]*/
{
returnPyNumber_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]*/

staticPyObject*
builtin_callable(PyObject*module, PyObject*obj)
/*[clinic end generated code: output=2b095d59d934cb7e input=1423bab99cc41f58]*/
{
returnPyBool_FromLong((long)PyCallable_Check(obj));
}

staticPyObject*
builtin_breakpoint(PyObject*self, PyObject*const*args, Py_ssize_tnargs, PyObject*keywords)
{
PyObject*hook=_PySys_GetRequiredAttrString("breakpointhook");
if (hook==NULL) {
returnNULL;
 }

if (PySys_Audit("builtins.breakpoint", "O", hook) <0) {
Py_DECREF(hook);
returnNULL;
 }

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

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

typedefstruct {
PyObject_HEAD
PyObject*func;
PyObject*it;
} filterobject;

staticPyObject*
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))
returnNULL;

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

/* Get iterator. */
it=PyObject_GetIter(seq);
if (it==NULL)
returnNULL;

/* create filterobject structure */
lz= (filterobject*)type->tp_alloc(type, 0);
if (lz==NULL) {
Py_DECREF(it);
returnNULL;
 }

lz->func=Py_NewRef(func);
lz->it=it;

return (PyObject*)lz;
}

staticPyObject*
filter_vectorcall(PyObject*type, PyObject*const*args,
size_tnargsf, PyObject*kwnames)
{
PyTypeObject*tp=_PyType_CAST(type);
if (tp==&PyFilter_Type&& !_PyArg_NoKwnames("filter", kwnames)) {
returnNULL;
 }

Py_ssize_tnargs=PyVectorcall_NARGS(nargsf);
if (!_PyArg_CheckPositional("filter", nargs, 2, 2)) {
returnNULL;
 }

PyObject*it=PyObject_GetIter(args[1]);
if (it==NULL) {
returnNULL;
 }

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

if (lz==NULL) {
Py_DECREF(it);
returnNULL;
 }

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

return (PyObject*)lz;
}

staticvoid
filter_dealloc(filterobject*lz)
{
PyObject_GC_UnTrack(lz);
Py_TRASHCAN_BEGIN(lz, filter_dealloc)
Py_XDECREF(lz->func);
Py_XDECREF(lz->it);
Py_TYPE(lz)->tp_free(lz);
Py_TRASHCAN_END
}

staticint
filter_traverse(filterobject*lz, visitprocvisit, void*arg)
{
Py_VISIT(lz->it);
Py_VISIT(lz->func);
return0;
}

staticPyObject*
filter_next(filterobject*lz)
{
PyObject*item;
PyObject*it=lz->it;
longok;
PyObject*(*iternext)(PyObject*);
intchecktrue=lz->func==Py_None||lz->func== (PyObject*)&PyBool_Type;

iternext=*Py_TYPE(it)->tp_iternext;
for (;;) {
item=iternext(it);
if (item==NULL)
returnNULL;

if (checktrue) {
ok=PyObject_IsTrue(item);
 } else {
PyObject*good;
good=PyObject_CallOneArg(lz->func, item);
if (good==NULL) {
Py_DECREF(item);
returnNULL;
 }
ok=PyObject_IsTrue(good);
Py_DECREF(good);
 }
if (ok>0)
returnitem;
Py_DECREF(item);
if (ok<0)
returnNULL;
 }
}

staticPyObject*
filter_reduce(filterobject*lz, PyObject*Py_UNUSED(ignored))
{
returnPy_BuildValue("O(OO)", Py_TYPE(lz), lz->func, lz->it);
}

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

staticPyMethodDeffilter_methods[] = {
 {"__reduce__", _PyCFunction_CAST(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 function(item)\n\
is true. If function is None, return the items that are true.");

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

staticPyObject*
builtin_format_impl(PyObject*module, PyObject*value, PyObject*format_spec)
/*[clinic end generated code: output=2f40bdfa4954b077 input=45ef3934b86d5624]*/
{
returnPyObject_Format(value, format_spec);
}

/*[clinic input]
chr as builtin_chr

 i: object
 /

Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
[clinic start generated code]*/

staticPyObject*
builtin_chr(PyObject*module, PyObject*i)
/*[clinic end generated code: output=d34f25b8035a9b10 input=f919867f0ba2f496]*/
{
intoverflow;
longv=PyLong_AsLongAndOverflow(i, &overflow);
if (v==-1&&PyErr_Occurred()) {
returnNULL;
 }
if (overflow) {
v=overflow<0 ? INT_MIN : INT_MAX;
/* Allow PyUnicode_FromOrdinal() to raise an exception */
 }
#ifSIZEOF_INT<SIZEOF_LONG
elseif (v<INT_MIN) {
v=INT_MIN;
 }
elseif (v>INT_MAX) {
v=INT_MAX;
 }
#endif
returnPyUnicode_FromOrdinal(v);
}


/*[clinic input]
compile as builtin_compile

 source: object
 filename: object(converter="PyUnicode_FSDecoder")
 mode: str
 flags: int = 0
 dont_inherit: bool = 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]*/

staticPyObject*
builtin_compile_impl(PyObject*module, PyObject*source, PyObject*filename,
constchar*mode, intflags, intdont_inherit,
intoptimize, intfeature_version)
/*[clinic end generated code: output=b0c09c84f116d3d7 input=cc78e20e7c7682ba]*/
{
PyObject*source_copy;
constchar*str;
intcompile_mode=-1;
intis_ast;
intstart[] = {Py_file_input, Py_eval_input, Py_single_input, Py_func_type_input};
PyObject*result;

PyCompilerFlagscf=_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;
elseif (strcmp(mode, "eval") ==0)
compile_mode=1;
elseif (strcmp(mode, "single") ==0)
compile_mode=2;
elseif (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 {
constchar*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_OPTIMIZED_AST) ==PyCF_ONLY_AST) {
// return an un-optimized AST
result=Py_NewRef(source);
 }
else {
// Return an optimized AST or code object

PyArena*arena=_PyArena_New();
if (arena==NULL) {
 goto error;
 }

if (flags&PyCF_ONLY_AST) {
mod_tymod=PyAST_obj2mod(source, arena, compile_mode);
if (mod==NULL|| !_PyAST_Validate(mod)) {
_PyArena_Free(arena);
 goto error;
 }
if (_PyCompile_AstOptimize(mod, filename, &cf, optimize,
arena) <0) {
_PyArena_Free(arena);
 goto error;
 }
result=PyAST_mod2obj(mod);
 }
else {
mod_tymod=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;

#ifdefPy_GIL_DISABLED
// gh-118527: Disable immortalization of code constants for explicit
// compile() calls to get consistent frozen outputs between the default
// and free-threaded builds.
// Subtract two to suppress immortalization (so that 1 -> -1)
PyInterpreterState*interp=_PyInterpreterState_GET();
_Py_atomic_add_int(&interp->gc.immortalize, -2);
#endif

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

#ifdefPy_GIL_DISABLED
_Py_atomic_add_int(&interp->gc.immortalize, 2);
#endif

Py_XDECREF(source_copy);
 goto finally;

error:
result=NULL;
finally:
Py_DECREF(filename);
returnresult;
}

/* AC: cannot convert yet, as needs PEP 457 group support in inspect */
staticPyObject*
builtin_dir(PyObject*self, PyObject*args)
{
PyObject*arg=NULL;

if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
returnNULL;
returnPyObject_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]*/

staticPyObject*
builtin_divmod_impl(PyObject*module, PyObject*x, PyObject*y)
/*[clinic end generated code: output=b06d8a5f6e0c745e input=175ad9c84ff41a85]*/
{
returnPyNumber_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]*/

staticPyObject*
builtin_eval_impl(PyObject*module, PyObject*source, PyObject*globals,
PyObject*locals)
/*[clinic end generated code: output=0a0824aa70093116 input=7c7bce5299a89062]*/
{
PyObject*result=NULL, *source_copy;
constchar*str;

if (locals!=Py_None&& !PyMapping_Check(locals)) {
PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
returnNULL;
 }
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");
returnNULL;
 }
if (globals==Py_None) {
globals=PyEval_GetGlobals();
if (locals==Py_None) {
locals=_PyEval_GetFrameLocals();
if (locals==NULL)
returnNULL;
 }
else {
Py_INCREF(locals);
 }
 }
elseif (locals==Py_None)
locals=Py_NewRef(globals);
else {
Py_INCREF(locals);
 }

if (globals==NULL||locals==NULL) {
PyErr_SetString(PyExc_TypeError,
"eval must be given globals and locals "
"when called without a frame");
 goto error;
 }

intr=PyDict_Contains(globals, &_Py_ID(__builtins__));
if (r==0) {
r=PyDict_SetItem(globals, &_Py_ID(__builtins__), PyEval_GetBuiltins());
 }
if (r<0) {
 goto error;
 }