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

int Py_UTF8Mode = -1;

_Py_IDENTIFIER(__builtins__);

_Py_IDENTIFIER(__dict__);

_Py_IDENTIFIER(__prepare__);

_Py_IDENTIFIER(__round__);

_Py_IDENTIFIER(__mro_entries__);

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

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;

PyObject *stack[1] = {bases};

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_LookupAttrId(base, &PyId___mro_entries__, &meth) < 0) {

goto error;

}

if (!meth) {

if (new_bases) {

if (PyList_Append(new_bases, base) < 0) {

goto error;

}

}

continue;

}

new_base = _PyObject_FastCall(meth, stack, 1);

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

goto error;

}

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

base = args[j];

PyList_SET_ITEM(new_bases, j, base);

Py_INCREF(base);

}

}

j = PyList_GET_SIZE(new_bases);

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

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, *bases, *mkw, *meta, *winner, *prep, *ns, *orig_bases;

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;

}

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

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

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

if (_PyObject_LookupAttrId(meta, &PyId___prepare__, &prep) < 0) {

ns = NULL;

}

else if (prep == NULL) {

ns = PyDict_New();

}

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;

}

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;

}

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

if (bases != orig_bases) {

if (PyMapping_SetItemString(ns, "__orig_bases__", orig_bases) < 0) {

goto error;

}

}

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

if (bases != orig_bases) {

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

}

static PyObject *

builtin_breakpoint(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *keywords)

{

PyObject *hook = PySys_GetObject("breakpointhook");

if (hook == NULL) {

PyErr_SetString(PyExc_RuntimeError, "lost sys.breakpointhook");

return NULL;

}

Py_INCREF(hook);

PyObject *retval = _PyObject_FastCallKeywords(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;

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

}