/* Built-in functions */

#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "code.h"

#include "asdl.h"

#include "ast.h"

#include <ctype.h>

#ifdef HAVE_LANGINFO_H

#include <langinfo.h> /* CODESET */

#endif

/* The default encoding used by the platform file system APIs

Can remain NULL for all platforms that don't have such a concept

Don't forget to modify PyUnicode_DecodeFSDefault() if you touch any of the

values for Py_FileSystemDefaultEncoding!

*/

#ifdef HAVE_MBCS

const char *Py_FileSystemDefaultEncoding = "mbcs";

int Py_HasFileSystemDefaultEncoding = 1;

#elif defined(__APPLE__)

const char *Py_FileSystemDefaultEncoding = "utf-8";

int Py_HasFileSystemDefaultEncoding = 1;

#else

const char *Py_FileSystemDefaultEncoding = NULL; /* set by initfsencoding() */

int Py_HasFileSystemDefaultEncoding = 0;

#endif

_Py_IDENTIFIER(__builtins__);

_Py_IDENTIFIER(__dict__);

_Py_IDENTIFIER(__prepare__);

_Py_IDENTIFIER(__round__);

_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);

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

static PyObject *

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

{

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

PyObject *cls = NULL;

Py_ssize_t nargs;

int isclass;

assert(args != NULL);

if (!PyTuple_Check(args)) {

PyErr_SetString(PyExc_TypeError,

"__build_class__: args is not a tuple");

return NULL;

}

nargs = PyTuple_GET_SIZE(args);

if (nargs < 2) {

PyErr_SetString(PyExc_TypeError,

"__build_class__: not enough arguments");

return NULL;

}

func = PyTuple_GET_ITEM(args, 0); /* Better be callable */

if (!PyFunction_Check(func)) {

PyErr_SetString(PyExc_TypeError,

"__build_class__: func must be a function");

return NULL;

}

name = PyTuple_GET_ITEM(args, 1);

if (!PyUnicode_Check(name)) {

PyErr_SetString(PyExc_TypeError,

"__build_class__: name is not a string");

return NULL;

}

bases = PyTuple_GetSlice(args, 2, nargs);

if (bases == NULL)

return NULL;

if (kwds == NULL) {

meta = NULL;

mkw = NULL;

}

else {

mkw = PyDict_Copy(kwds); /* Don't modify kwds passed in! */

if (mkw == NULL) {

Py_DECREF(bases);

return NULL;

}

meta = _PyDict_GetItemId(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);

}

}

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 *) (base0->ob_type);

}

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

prep = _PyObject_GetAttrId(meta, &PyId___prepare__);

if (prep == NULL) {

if (PyErr_ExceptionMatches(PyExc_AttributeError)) {

PyErr_Clear();

ns = PyDict_New();

}

else {

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

return NULL;

}

}

else {

PyObject *pargs = PyTuple_Pack(2, name, bases);

if (pargs == NULL) {

Py_DECREF(prep);

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

return NULL;

}

ns = PyEval_CallObjectWithKeywords(prep, pargs, mkw);

Py_DECREF(pargs);

Py_DECREF(prep);

}

if (ns == NULL) {

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

return NULL;

}

cell = PyEval_EvalCodeEx(PyFunction_GET_CODE(func), PyFunction_GET_GLOBALS(func), ns,

NULL, 0, NULL, 0, NULL, 0, NULL,

PyFunction_GET_CLOSURE(func));

if (cell != NULL) {

PyObject *margs;

margs = PyTuple_Pack(3, name, bases, ns);

if (margs != NULL) {

cls = PyEval_CallObjectWithKeywords(meta, margs, mkw);

Py_DECREF(margs);

}

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

PyCell_Set(cell, cls);

Py_DECREF(cell);

}

Py_DECREF(ns);

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

return cls;

}

PyDoc_STRVAR(build_class_doc,

"__build_class__(func, name, *bases, metaclass=None, **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. Level is used to determine whether to perform \n\

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: 'O'

/

Return the absolute value of the argument.

[clinic start generated code]*/

PyDoc_STRVAR(builtin_abs__doc__,

"abs($module, x, /)\n"

"--\n"

"\n"

"Return the absolute value of the argument.");

#define BUILTIN_ABS_METHODDEF \

{"abs", (PyCFunction)builtin_abs, METH_O, builtin_abs__doc__},

static PyObject *

builtin_abs(PyModuleDef *module, PyObject *x)

/*[clinic end generated code: output=f85095528ce7e2e5 input=aa29cc07869b4732]*/

{

return PyNumber_Absolute(x);

}

/*[clinic input]

all as builtin_all

iterable: 'O'

/

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

PyDoc_STRVAR(builtin_all__doc__,

"all($module, iterable, /)\n"

"--\n"

"\n"

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

"\n"

"If the iterable is empty, return True.");

#define BUILTIN_ALL_METHODDEF \

{"all", (PyCFunction)builtin_all, METH_O, builtin_all__doc__},

static PyObject *

builtin_all(PyModuleDef *module, PyObject *iterable)

/*[clinic end generated code: output=d001db739ba83b46 input=dd506dc9998d42bd]*/

{

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: 'O'

/

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

If the iterable is empty, return False.

[clinic start generated code]*/

PyDoc_STRVAR(builtin_any__doc__,

"any($module, iterable, /)\n"

"--\n"

"\n"

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

"\n"

"If the iterable is empty, return False.");

#define BUILTIN_ANY_METHODDEF \

{"any", (PyCFunction)builtin_any, METH_O, builtin_any__doc__},

static PyObject *

builtin_any(PyModuleDef *module, PyObject *iterable)

/*[clinic end generated code: output=3a4b6dbe6a0d6f61 input=8fe8460f3fbbced8]*/

{

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

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: 'O'

/

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

PyDoc_STRVAR(builtin_ascii__doc__,

"ascii($module, obj, /)\n"

"--\n"

"\n"

"Return an ASCII-only representation of an object.\n"

"\n"

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

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

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

"to that returned by repr() in Python 2.");

#define BUILTIN_ASCII_METHODDEF \

{"ascii", (PyCFunction)builtin_ascii, METH_O, builtin_ascii__doc__},

static PyObject *

builtin_ascii(PyModuleDef *module, PyObject *obj)

/*[clinic end generated code: output=f0e6754154c2d30b input=0cbdc1420a306325]*/

{

return PyObject_ASCII(obj);

}

/*[clinic input]

bin as builtin_bin

number: 'O'

/

Return the binary representation of an integer.

>>> bin(2796202)

'0b1010101010101010101010'

[clinic start generated code]*/

PyDoc_STRVAR(builtin_bin__doc__,

"bin($module, number, /)\n"

"--\n"

"\n"

"Return the binary representation of an integer.\n"

"\n"

" >>> bin(2796202)\n"

" \'0b1010101010101010101010\'");

#define BUILTIN_BIN_METHODDEF \

{"bin", (PyCFunction)builtin_bin, METH_O, builtin_bin__doc__},

static PyObject *

builtin_bin(PyModuleDef *module, PyObject *number)

/*[clinic end generated code: output=18fed0e943650da1 input=2a6362ae9a9c9203]*/

{

return PyNumber_ToBase(number, 2);

}

/*[clinic input]

callable as builtin_callable

obj: 'O'

/

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

PyDoc_STRVAR(builtin_callable__doc__,

"callable($module, obj, /)\n"

"--\n"

"\n"

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

"\n"

"Note that classes are callable, as are instances of classes with a\n"

"__call__() method.");

#define BUILTIN_CALLABLE_METHODDEF \

{"callable", (PyCFunction)builtin_callable, METH_O, builtin_callable__doc__},

static PyObject *

builtin_callable(PyModuleDef *module, PyObject *obj)

/*[clinic end generated code: output=b3a92cbe635f32af input=bb3bb528fffdade4]*/

{

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

}

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;

}

Py_INCREF(func);

lz->func = func;

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

iternext = *Py_TYPE(it)->tp_iternext;

for (;;) {

item = iternext(it);

if (item == NULL)

return NULL;

if (lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type) {

ok = PyObject_IsTrue(item);

} else {

PyObject *good;

good = PyObject_CallFunctionObjArgs(lz->func,

item, NULL);

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)

{

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

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

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

};

/*[clinic input]

format as builtin_format

value: 'O'

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

/

Return value.__format__(format_spec)

format_spec defaults to the empty string

[clinic start generated code]*/

PyDoc_STRVAR(builtin_format__doc__,

"format($module, value, format_spec=\'\', /)\n"

"--\n"

"\n"

"Return value.__format__(format_spec)\n"

"\n"

"format_spec defaults to the empty string");

#define BUILTIN_FORMAT_METHODDEF \

{"format", (PyCFunction)builtin_format, METH_VARARGS, builtin_format__doc__},

static PyObject *

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

static PyObject *

builtin_format(PyModuleDef *module, PyObject *args)

{

PyObject *return_value = NULL;

PyObject *value;

PyObject *format_spec = NULL;

if (!PyArg_ParseTuple(args,

"O|U:format",

&value, &format_spec))

goto exit;

return_value = builtin_format_impl(module, value, format_spec);

exit:

return return_value;

}

static PyObject *

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

/*[clinic end generated code: output=39723a58c72e8871 input=e23f2f11e0098c64]*/

{

return PyObject_Format(value, format_spec);

}

/*[clinic input]

chr as builtin_chr

i: 'i'

/

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

[clinic start generated code]*/

PyDoc_STRVAR(builtin_chr__doc__,

"chr($module, i, /)\n"

"--\n"

"\n"

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

#define BUILTIN_CHR_METHODDEF \

{"chr", (PyCFunction)builtin_chr, METH_VARARGS, builtin_chr__doc__},

static PyObject *

builtin_chr_impl(PyModuleDef *module, int i);

static PyObject *

builtin_chr(PyModuleDef *module, PyObject *args)

{

PyObject *return_value = NULL;

int i;

if (!PyArg_ParseTuple(args,

"i:chr",

&i))

goto exit;

return_value = builtin_chr_impl(module, i);

exit:

return return_value;

}

static PyObject *

builtin_chr_impl(PyModuleDef *module, int i)

/*[clinic end generated code: output=4d6bbe948f56e2ae input=9b1ced29615adf66]*/

{

return PyUnicode_FromOrdinal(i);

}

static const char *

source_as_string(PyObject *cmd, const char *funcname, const char *what, PyCompilerFlags *cf, Py_buffer *view)

{

const char *str;

Py_ssize_t size;

if (PyUnicode_Check(cmd)) {

cf->cf_flags |= PyCF_IGNORE_COOKIE;

str = PyUnicode_AsUTF8AndSize(cmd, &size);

if (str == NULL)

return NULL;

}

else if (PyObject_GetBuffer(cmd, view, PyBUF_SIMPLE) == 0) {

str = (const char *)view->buf;

size = view->len;

}

else {

PyErr_Format(PyExc_TypeError,

"%s() arg 1 must be a %s object",

funcname, what);

return NULL;

}

if (strlen(str) != (size_t)size) {

PyErr_SetString(PyExc_ValueError,

"source code string cannot contain null bytes");

PyBuffer_Release(view);

return NULL;

}

return str;

}

/*[clinic input]

compile as builtin_compile

source: 'O'

filename: object(converter="PyUnicode_FSDecoder")

mode: 's'

flags: 'i' = 0

dont_inherit: 'i' = 0

optimize: 'i' = -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 non-zero, stops the compilation inheriting

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

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

in addition to any features explicitly specified.

[clinic start generated code]*/

PyDoc_STRVAR(builtin_compile__doc__,

"compile($module, /, source, filename, mode, flags=0, dont_inherit=0,\n"

" optimize=-1)\n"

"--\n"

"\n"

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

"\n"

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

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

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

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

"The flags argument, if present, controls which future statements influence\n"

"the compilation of the code.\n"

"The dont_inherit argument, if non-zero, stops the compilation inheriting\n"

"the effects of any future statements in effect in the code calling\n"

"compile; if absent or zero these statements do influence the compilation,\n"

"in addition to any features explicitly specified.");

#define BUILTIN_COMPILE_METHODDEF \

{"compile", (PyCFunction)builtin_compile, METH_VARARGS|METH_KEYWORDS, builtin_compile__doc__},

static PyObject *

builtin_compile_impl(PyModuleDef *module, PyObject *source, PyObject *filename, const char *mode, int flags, int dont_inherit, int optimize);

static PyObject *

builtin_compile(PyModuleDef *module, PyObject *args, PyObject *kwargs)

{

PyObject *return_value = NULL;

static char *_keywords[] = {"source", "filename", "mode", "flags", "dont_inherit", "optimize", NULL};

PyObject *source;

PyObject *filename;

const char *mode;

int flags = 0;

int dont_inherit = 0;

int optimize = -1;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,

"OO&s|iii:compile", _keywords,

&source, PyUnicode_FSDecoder, &filename, &mode, &flags, &dont_inherit, &optimize))

goto exit;

return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize);

exit:

return return_value;

}

static PyObject *

builtin_compile_impl(PyModuleDef *module, PyObject *source, PyObject *filename, const char *mode, int flags, int dont_inherit, int optimize)

/*[clinic end generated code: output=c72d197809d178fc input=c6212a9d21472f7e]*/

{

Py_buffer view = {NULL, NULL};

const char *str;

int compile_mode = -1;

int is_ast;

PyCompilerFlags cf;

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

PyObject *result;

cf.cf_flags = flags | PyCF_SOURCE_IS_UTF8;

if (flags &

~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))

{

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 {

PyErr_SetString(PyExc_ValueError,

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

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

PyArena_Free(arena);

goto error;

}

if (!PyAST_Validate(mod)) {

PyArena_Free(arena);

goto error;

}

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

&cf, optimize, arena);

PyArena_Free(arena);

}

goto finally;

}

str = source_as_string(source, "compile", "string, bytes or AST", &cf, &view);

if (str == NULL)

goto error;

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

PyBuffer_Release(&view);

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: 'O'

y: 'O'

/

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

[clinic start generated code]*/

PyDoc_STRVAR(builtin_divmod__doc__,

"divmod($module, x, y, /)\n"

"--\n"

"\n"

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

#define BUILTIN_DIVMOD_METHODDEF \

{"divmod", (PyCFunction)builtin_divmod, METH_VARARGS, builtin_divmod__doc__},

static PyObject *

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

static PyObject *

builtin_divmod(PyModuleDef *module, PyObject *args)

{

PyObject *return_value = NULL;

PyObject *x;

PyObject *y;

if (!PyArg_UnpackTuple(args, "divmod",

2, 2,

&x, &y))

goto exit;

return_value = builtin_divmod_impl(module, x, y);

exit:

return return_value;

}

static PyObject *

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

/*[clinic end generated code: output=77e8d408b1338886 input=c9c617b7bb74c615]*/

{

return PyNumber_Divmod(x, y);

}

/*[clinic input]

eval as builtin_eval

source: 'O'

globals: 'O' = None

locals: 'O' = None

/

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