#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "code.h"

#include "asdl.h"

#include "ast.h"

#include <ctype.h>

#if defined(__APPLE__)

const char *Py_FileSystemDefaultEncoding = "utf-8";

int Py_HasFileSystemDefaultEncoding = 1;

#elif defined(MS_WINDOWS)

const char *Py_FileSystemDefaultEncoding = "utf-8";

int Py_HasFileSystemDefaultEncoding = 1;

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

int Py_HasFileSystemDefaultEncoding = 0;

const char *Py_FileSystemDefaultEncodeErrors = "surrogateescape";

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

#include "clinic/bltinmodule.c.h"

static PyObject *

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

PyObject *kwnames)

{

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

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;

}

bases = _PyStack_AsTupleSlice(args, nargs, 2, nargs);

if (bases == NULL)

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

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

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[2] = {name, bases};

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

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[3] = {name, bases, ns};

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

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

PyObject *cell_cls = PyCell_GET(cell);

if (cell_cls != cls) {

/* TODO: In 3.7, DeprecationWarning will become RuntimeError.

int cell_error;

if (cell_cls == NULL) {

const char *msg =

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

"Was __classcell__ propagated to type.__new__?";

cell_error = PyErr_WarnFormat(

PyExc_DeprecationWarning, 1, msg, name, cls);

} else {

const char *msg =

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

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

cell_error = 1;

}

if (cell_error) {

Py_DECREF(cls);

cls = NULL;

goto error;

} else {

/* Fill in the cell, since type.__new__ didn't do it */

PyCell_Set(cell, cls);

}

}

}

}

error:

Py_XDECREF(cell);

Py_DECREF(ns);

Py_DECREF(meta);

Py_XDECREF(mkw);

Py_DECREF(bases);

return cls;

}

PyDoc_STRVAR(build_class_doc,

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,

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

static PyObject *

builtin_abs(PyObject *module, PyObject *x)

{

return PyNumber_Absolute(x);

}

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

{

return PyNumber_ToBase(number, 2);

}

static PyObject *

builtin_callable(PyObject *module, PyObject *obj)

{

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

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_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,

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

};

static PyObject *

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

{

return PyObject_Format(value, format_spec);

}

static PyObject *

builtin_chr_impl(PyObject *module, int i)

{

return PyUnicode_FromOrdinal(i);

}

static const char *

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

{

const char *str;

Py_ssize_t size;

Py_buffer view;

*cmd_copy = NULL;

if (PyUnicode_Check(cmd)) {

cf->cf_flags |= PyCF_IGNORE_COOKIE;

str = PyUnicode_AsUTF8AndSize(cmd, &size);

if (str == NULL)

return NULL;

}

else if (PyBytes_Check(cmd)) {

str = PyBytes_AS_STRING(cmd);

size = PyBytes_GET_SIZE(cmd);

}

else if (PyByteArray_Check(cmd)) {

str = PyByteArray_AS_STRING(cmd);

size = PyByteArray_GET_SIZE(cmd);

}

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

/* Copy to NUL-terminated buffer. */

*cmd_copy = PyBytes_FromStringAndSize(

(const char *)view.buf, view.len);

PyBuffer_Release(&view);

if (*cmd_copy == NULL) {

return NULL;

}

str = PyBytes_AS_STRING(*cmd_copy);

size = PyBytes_GET_SIZE(*cmd_copy);

}

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

Py_CLEAR(*cmd_copy);

return NULL;

}

return str;

}

static PyObject *

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

const char *mode, int flags, int dont_inherit,

int optimize)

{

PyObject *source_copy;

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, &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;

}

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

static PyObject *

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

{

return PyNumber_Divmod(x, y);

}

static PyObject *

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

PyObject *locals)

{

PyObject *result, *source_copy;

const char *str;

PyCompilerFlags cf;

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;

}

if (_PyDict_GetItemId(globals, &PyId___builtins__) == NULL) {

if (_PyDict_SetItemId(globals, &PyId___builtins__,

PyEval_GetBuiltins()) != 0)

return NULL;

}

if (PyCode_Check(source)) {

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

}

cf.cf_flags = PyCF_SOURCE_IS_UTF8;

str = source_as_string(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;

}

static PyObject *

builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,

PyObject *locals)

{

PyObject *v;

if (globals == Py_None) {

globals = PyEval_GetGlobals();

if (locals == Py_None) {

locals = PyEval_GetLocals();

if (locals == NULL)

return NULL;

}

if (!globals || !locals) {

PyErr_SetString(PyExc_SystemError,

"globals and locals cannot be NULL");

return NULL;

}

}

else if (locals == Py_None)

locals = globals;

if (!PyDict_Check(globals)) {

PyErr_Format(PyExc_TypeError, "exec() globals must be a dict, not %.100s",

globals->ob_type->tp_name);

return NULL;

}

if (!PyMapping_Check(locals)) {

PyErr_Format(PyExc_TypeError,

"locals must be a mapping or None, not %.100s",

locals->ob_type->tp_name);

return NULL;

}

if (_PyDict_GetItemId(globals, &PyId___builtins__) == NULL) {

if (_PyDict_SetItemId(globals, &PyId___builtins__,

PyEval_GetBuiltins()) != 0)

return NULL;

}

if (PyCode_Check(source)) {

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

PyErr_SetString(PyExc_TypeError,

"code object passed to exec() may not "

"contain free variables");

return NULL;

}

v = PyEval_EvalCode(source, globals, locals);

}

else {

PyObject *source_copy;

const char *str;

PyCompilerFlags cf;

cf.cf_flags = PyCF_SOURCE_IS_UTF8;

str = source_as_string(source, "exec",

"string, bytes or code", &cf,

&source_copy);

if (str == NULL)

return NULL;

if (PyEval_MergeCompilerFlags(&cf))

v = PyRun_StringFlags(str, Py_file_input, globals,

locals, &cf);

else

v = PyRun_String(str, Py_file_input, globals, locals);

Py_XDECREF(source_copy);

}

if (v == NULL)

return NULL;

Py_DECREF(v);

Py_RETURN_NONE;

}

static PyObject *

builtin_getattr(PyObject *self, PyObject **args, Py_ssize_t nargs,

PyObject *kwnames)

{

PyObject *v, *result, *dflt = NULL;

PyObject *name;

if (!_PyArg_UnpackStack(args, nargs, "getattr", 2, 3, &v, &name, &dflt))

return NULL;