#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "code.h"

#include "eval.h"

#include <ctype.h>

#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)

const char *Py_FileSystemDefaultEncoding = "mbcs";

int Py_HasFileSystemDefaultEncoding = 1;

#elif defined(__APPLE__)

const char *Py_FileSystemDefaultEncoding = "utf-8";

int Py_HasFileSystemDefaultEncoding = 1;

const char *Py_FileSystemDefaultEncoding = NULL; /* use default */

int Py_HasFileSystemDefaultEncoding = 0;

_Py_SetFileSystemEncoding(PyObject *s)

{

PyObject *defenc, *codec;

if (!PyUnicode_Check(s)) {

PyErr_BadInternalCall();

return -1;

}

defenc = _PyUnicode_AsDefaultEncodedString(s, NULL);

if (!defenc)

return -1;

codec = _PyCodec_Lookup(PyBytes_AsString(defenc));

if (codec == NULL)

return -1;

Py_DECREF(codec);

if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding)

/* A file system encoding was set at run-time */

free((char*)Py_FileSystemDefaultEncoding);

Py_FileSystemDefaultEncoding = strdup(PyBytes_AsString(defenc));

Py_HasFileSystemDefaultEncoding = 0;

return 0;

}

static PyObject *

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

{

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

PyObject *cls = NULL;

Py_ssize_t nargs, nbases;

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

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;

nbases = nargs - 2;

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_GetItemString(mkw, "metaclass");

if (meta != NULL) {

Py_INCREF(meta);

if (PyDict_DelItemString(mkw, "metaclass") < 0) {

Py_DECREF(meta);

Py_DECREF(mkw);

Py_DECREF(bases);

return NULL;

}

}

}

if (meta == NULL) {

if (PyTuple_GET_SIZE(bases) == 0)

meta = (PyObject *) (&PyType_Type);

else {

PyObject *base0 = PyTuple_GET_ITEM(bases, 0);

meta = (PyObject *) (base0->ob_type);

}

Py_INCREF(meta);

}

prep = PyObject_GetAttrString(meta, "__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 = PyObject_CallFunctionObjArgs(func, ns, NULL);

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

Py_INCREF(cls);

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,

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

char *name;

PyObject *globals = NULL;

PyObject *locals = NULL;

PyObject *fromlist = NULL;

int level = -1;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOi:__import__",

kwlist, &name, &globals, &locals, &fromlist, &level))

return NULL;

return PyImport_ImportModuleLevel(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 *self, PyObject *v)

{

return PyNumber_Absolute(v);

}

PyDoc_STRVAR(abs_doc,

Return the absolute value of the argument.");

static PyObject *

builtin_all(PyObject *self, PyObject *v)

{

PyObject *it, *item;

PyObject *(*iternext)(PyObject *);

int cmp;

it = PyObject_GetIter(v);

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;

}

PyDoc_STRVAR(all_doc,

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

static PyObject *

builtin_any(PyObject *self, PyObject *v)

{

PyObject *it, *item;

PyObject *(*iternext)(PyObject *);

int cmp;

it = PyObject_GetIter(v);

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;

}

PyDoc_STRVAR(any_doc,

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

static PyObject *

builtin_ascii(PyObject *self, PyObject *v)

{

return PyObject_ASCII(v);

}

PyDoc_STRVAR(ascii_doc,

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

static PyObject *

builtin_bin(PyObject *self, PyObject *v)

{

return PyNumber_ToBase(v, 2);

}

PyDoc_STRVAR(bin_doc,

Return the binary representation of an integer or long integer.");

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)

return item;

Py_DECREF(item);

}

}

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

0, /* 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(PyObject *self, PyObject *args)

{

PyObject *value;

PyObject *format_spec = NULL;

if (!PyArg_ParseTuple(args, "O|U:format", &value, &format_spec))

return NULL;

return PyObject_Format(value, format_spec);

}

PyDoc_STRVAR(format_doc,

format_spec defaults to \"\"");

static PyObject *

builtin_chr(PyObject *self, PyObject *args)

{

int x;

if (!PyArg_ParseTuple(args, "i:chr", &x))

return NULL;

return PyUnicode_FromOrdinal(x);

}

PyDoc_VAR(chr_doc) = PyDoc_STR(

)

#ifndef Py_UNICODE_WIDE

PyDoc_STR(

)

;

static char *

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

{

char *str;

Py_ssize_t size;

if (PyUnicode_Check(cmd)) {

cf->cf_flags |= PyCF_IGNORE_COOKIE;

cmd = _PyUnicode_AsDefaultEncodedString(cmd, NULL);

if (cmd == NULL)

return NULL;

}

else if (!PyObject_CheckReadBuffer(cmd)) {

PyErr_Format(PyExc_TypeError,

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

funcname, what);

return NULL;

}

if (PyObject_AsReadBuffer(cmd, (const void **)&str, &size) < 0) {

return NULL;

}

if (strlen(str) != size) {

PyErr_SetString(PyExc_TypeError,

"source code string cannot contain null bytes");

return NULL;

}

return str;

}

static PyObject *

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

{

char *str;

PyObject *filename_obj;

char *filename;

char *startstr;

int mode = -1;

int dont_inherit = 0;

int supplied_flags = 0;

int is_ast;

PyCompilerFlags cf;

PyObject *cmd;

static char *kwlist[] = {"source", "filename", "mode", "flags",

"dont_inherit", NULL};

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

PyObject *result;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&s|ii:compile", kwlist,

&cmd,

PyUnicode_FSConverter, &filename_obj,

&startstr, &supplied_flags,

&dont_inherit))

return NULL;

filename = PyBytes_AS_STRING(filename_obj);

cf.cf_flags = supplied_flags | PyCF_SOURCE_IS_UTF8;

if (supplied_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 (!dont_inherit) {

PyEval_MergeCompilerFlags(&cf);

}

if (strcmp(startstr, "exec") == 0)

mode = 0;

else if (strcmp(startstr, "eval") == 0)

mode = 1;

else if (strcmp(startstr, "single") == 0)

mode = 2;

else {

PyErr_SetString(PyExc_ValueError,

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

goto error;

}

is_ast = PyAST_Check(cmd);

if (is_ast == -1)

goto error;

if (is_ast) {

if (supplied_flags & PyCF_ONLY_AST) {

Py_INCREF(cmd);

result = cmd;

}

else {

PyArena *arena;

mod_ty mod;

arena = PyArena_New();

mod = PyAST_obj2mod(cmd, arena, mode);

if (mod == NULL) {

PyArena_Free(arena);

goto error;

}

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

&cf, arena);

PyArena_Free(arena);

}

goto finally;

}

str = source_as_string(cmd, "compile", "string, bytes, AST or code", &cf);

if (str == NULL)

goto error;

result = Py_CompileStringFlags(str, filename, start[mode], &cf);

goto finally;

error:

result = NULL;

finally:

Py_DECREF(filename_obj);

return result;

}

PyDoc_STRVAR(compile_doc,

in addition to any features explicitly specified.");

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(PyObject *self, PyObject *args)

{

PyObject *v, *w;

if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))

return NULL;

return PyNumber_Divmod(v, w);

}

PyDoc_STRVAR(divmod_doc,

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

static PyObject *

builtin_eval(PyObject *self, PyObject *args)

{

PyObject *cmd, *result, *tmp = NULL;

PyObject *globals = Py_None, *locals = Py_None;

char *str;

PyCompilerFlags cf;

if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))

return NULL;

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

}

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_GetItemString(globals, "__builtins__") == NULL) {

if (PyDict_SetItemString(globals, "__builtins__",

PyEval_GetBuiltins()) != 0)

return NULL;

}

if (PyCode_Check(cmd)) {

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

PyErr_SetString(PyExc_TypeError,

"code object passed to eval() may not contain free variables");

return NULL;

}

return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);

}

cf.cf_flags = PyCF_SOURCE_IS_UTF8;

str = source_as_string(cmd, "eval", "string, bytes or code", &cf);

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

return result;

}

PyDoc_STRVAR(eval_doc,

If only globals is given, locals defaults to it.\n");

static PyObject *

builtin_exec(PyObject *self, PyObject *args)

{

PyObject *v;

PyObject *prog, *globals = Py_None, *locals = Py_None;

int plain = 0;

if (!PyArg_UnpackTuple(args, "exec", 1, 3, &prog, &globals, &locals))

return NULL;

if (globals == Py_None) {

globals = PyEval_GetGlobals();

if (locals == Py_None) {

locals = PyEval_GetLocals();

plain = 1;

}

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() arg 2 must be a dict, not %.100s",

globals->ob_type->tp_name);

return NULL;

}

if (!PyMapping_Check(locals)) {

PyErr_Format(PyExc_TypeError,

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

locals->ob_type->tp_name);

return NULL;

}

if (PyDict_GetItemString(globals, "__builtins__") == NULL) {

if (PyDict_SetItemString(globals, "__builtins__",

PyEval_GetBuiltins()) != 0)

return NULL;

}

if (PyCode_Check(prog)) {

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

PyErr_SetString(PyExc_TypeError,

"code object passed to exec() may not "

"contain free variables");

return NULL;

}

v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);

}

else {

char *str;

PyCompilerFlags cf;

cf.cf_flags = PyCF_SOURCE_IS_UTF8;

str = source_as_string(prog, "exec",

"string, bytes or code", &cf);

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

}

if (v == NULL)

return NULL;

Py_DECREF(v);

Py_RETURN_NONE;

}

PyDoc_STRVAR(exec_doc,

globals and locals. If only globals is given, locals defaults to it.");

static PyObject *

builtin_getattr(PyObject *self, PyObject *args)

{

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

PyObject *name;

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

return NULL;

if (!PyUnicode_Check(name)) {

PyErr_SetString(PyExc_TypeError,

"getattr(): attribute name must be string");

return NULL;

}

result = PyObject_GetAttr(v, name);

if (result == NULL && dflt != NULL &&

PyErr_ExceptionMatches(PyExc_AttributeError))

{

PyErr_Clear();

Py_INCREF(dflt);

result = dflt;

}

return result;

}

PyDoc_STRVAR(getattr_doc,

exist; without it, an exception is raised in that case.");

static PyObject *

builtin_globals(PyObject *self)

{

PyObject *d;

d = PyEval_GetGlobals();

Py_XINCREF(d);

return d;

}

PyDoc_STRVAR(globals_doc,

Return the dictionary containing the current scope's global variables.");

static PyObject *

builtin_hasattr(PyObject *self, PyObject *args)

{

PyObject *v;

PyObject *name;

if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))

return NULL;

if (!PyUnicode_Check(name)) {

PyErr_SetString(PyExc_TypeError,

"hasattr(): attribute name must be string");

return NULL;

}

v = PyObject_GetAttr(v, name);

if (v == NULL) {

if (!PyErr_ExceptionMatches(PyExc_Exception))

return NULL;

else {

PyErr_Clear();

Py_INCREF(Py_False);

return Py_False;

}

}

Py_DECREF(v);

Py_INCREF(Py_True);

return Py_True;

}

PyDoc_STRVAR(hasattr_doc,

(This is done by calling getattr(object, name) and catching exceptions.)");

static PyObject *

builtin_id(PyObject *self, PyObject *v)

{

return PyLong_FromVoidPtr(v);

}

PyDoc_STRVAR(id_doc,

simultaneously existing objects. (Hint: it's the object's memory address.)");

typedef struct {

PyObject_HEAD

PyObject *iters;

PyObject *func;

} mapobject;

static PyObject *

map_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyObject *it, *iters, *func;

mapobject *lz;

Py_ssize_t numargs, i;

if (type == &PyMap_Type && !_PyArg_NoKeywords("map()", kwds))

return NULL;

numargs = PyTuple_Size(args);

if (numargs < 2) {

PyErr_SetString(PyExc_TypeError,

"map() must have at least two arguments.");

return NULL;

}

iters = PyTuple_New(numargs-1);

if (iters == NULL)

return NULL;

for (i=1 ; i<numargs ; i++) {

/* Get iterator. */

it = PyObject_GetIter(PyTuple_GET_ITEM(args, i));

if (it == NULL) {

Py_DECREF(iters);

return NULL;

}

PyTuple_SET_ITEM(iters, i-1, it);

}

/* create mapobject structure */

lz = (mapobject *)type->tp_alloc(type, 0);

if (lz == NULL) {

Py_DECREF(iters);

return NULL;

}

lz->iters = iters;

func = PyTuple_GET_ITEM(args, 0);

Py_INCREF(func);

lz->func = func;

return (PyObject *)lz;

}

static void

map_dealloc(mapobject *lz)

{

PyObject_GC_UnTrack(lz);

Py_XDECREF(lz->iters);

Py_XDECREF(lz->func);

Py_TYPE(lz)->tp_free(lz);

}

static int

map_traverse(mapobject *lz, visitproc visit, void *arg)

{

Py_VISIT(lz->iters);

Py_VISIT(lz->func);

return 0;