#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()

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,

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

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;

}

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

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

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,

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

static PyObject *

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

PyObject *locals, PyObject *fromlist, int level)

{

return PyImport_ImportModuleLevelObject(name, globals, locals,

fromlist, level);

}

static PyObject *

builtin___lazy_import___impl(PyObject *module, PyObject *name,

PyObject *globals, PyObject *locals,

PyObject *fromlist, int level)

{

PyObject *builtins;

PyThreadState *tstate = PyThreadState_GET();

if (globals == NULL) {

globals = PyEval_GetGlobals();

}

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;

}

static PyObject *

builtin_abs(PyObject *module, PyObject *number)

{

return PyNumber_Absolute(number);

}

static PyObject *

builtin_all(PyObject *module, PyObject *iterable)

{

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;

}

static PyObject *

builtin_any(PyObject *module, PyObject *iterable)

{

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;

}

static PyObject *

builtin_ascii(PyObject *module, PyObject *obj)

{

return PyObject_ASCII(obj);

}

static PyObject *

builtin_bin(PyObject *module, PyObject *integer)

{

return PyNumber_ToBase(integer, 2);

}

static PyObject *

builtin_callable(PyObject *module, PyObject *obj)

{

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,

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,

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

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

};

static PyObject *

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

{

return PyObject_Format(value, format_spec);

}

static PyObject *

builtin_chr(PyObject *module, PyObject *i)

{

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;

}

return PyUnicode_FromOrdinal(v);

}

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)

{

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

result = _Py_CompileStringObjectWithModule(str, filename,

start[compile_mode], &cf,

optimize, modname);

#ifdef Py_GIL_DISABLED

tstate->suppress_co_const_immortalization--;

Py_XDECREF(source_copy);

goto finally;

error:

result = NULL;

finally:

return result;

}

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,

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