#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "code.h"

#include "eval.h"

#include <ctype.h>

#include <float.h> /* for DBL_MANT_DIG and friends */

#ifdef RISCOS

#include "unixstuff.h"

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

const char *Py_FileSystemDefaultEncoding = "mbcs";

#elif defined(__APPLE__)

const char *Py_FileSystemDefaultEncoding = "utf-8";

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

static PyObject *filterstring(PyObject *, PyObject *);

#ifdef Py_USING_UNICODE

static PyObject *filterunicode(PyObject *, PyObject *);

static PyObject *filtertuple (PyObject *, PyObject *);

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

{

PyObject *func, *alist = NULL, *kwdict = NULL;

PyObject *t = NULL, *retval = NULL;

if (PyErr_WarnPy3k("apply() not supported in 3.x; "

"use func(*args, **kwargs)", 1) < 0)

return NULL;

if (!PyArg_UnpackTuple(args, "apply", 1, 3, &func, &alist, &kwdict))

return NULL;

if (alist != NULL) {

if (!PyTuple_Check(alist)) {

if (!PySequence_Check(alist)) {

PyErr_Format(PyExc_TypeError,

"apply() arg 2 expected sequence, found %s",

alist->ob_type->tp_name);

return NULL;

}

t = PySequence_Tuple(alist);

if (t == NULL)

return NULL;

alist = t;

}

}

if (kwdict != NULL && !PyDict_Check(kwdict)) {

PyErr_Format(PyExc_TypeError,

"apply() arg 3 expected dictionary, found %s",

kwdict->ob_type->tp_name);

goto finally;

}

retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);

finally:

Py_XDECREF(t);

return retval;

}

PyDoc_STRVAR(apply_doc,

function(*args, **keywords).");

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

static PyObject *

builtin_callable(PyObject *self, PyObject *v)

{

return PyBool_FromLong((long)PyCallable_Check(v));

}

PyDoc_STRVAR(callable_doc,

Note that classes are callable, as are instances with a __call__() method.");

static PyObject *

builtin_filter(PyObject *self, PyObject *args)

{

PyObject *func, *seq, *result, *it, *arg;

Py_ssize_t len; /* guess for result list size */

register Py_ssize_t j;

if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))

return NULL;

/* Strings and tuples return a result of the same type. */

if (PyString_Check(seq))

return filterstring(func, seq);

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(seq))

return filterunicode(func, seq);

if (PyTuple_Check(seq))

return filtertuple(func, seq);

/* Pre-allocate argument list tuple. */

arg = PyTuple_New(1);

if (arg == NULL)

return NULL;

/* Get iterator. */

it = PyObject_GetIter(seq);

if (it == NULL)

goto Fail_arg;

/* Guess a result list size. */

len = _PyObject_LengthHint(seq, 8);

if (len == -1)

goto Fail_it;

/* Get a result list. */

if (PyList_Check(seq) && seq->ob_refcnt == 1) {

/* Eww - can modify the list in-place. */

Py_INCREF(seq);

result = seq;

}

else {

result = PyList_New(len);

if (result == NULL)

goto Fail_it;

}

/* Build the result list. */

j = 0;

for (;;) {

PyObject *item;

int ok;

item = PyIter_Next(it);

if (item == NULL) {

if (PyErr_Occurred())

goto Fail_result_it;

break;

}

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

ok = PyObject_IsTrue(item);

}

else {

PyObject *good;

PyTuple_SET_ITEM(arg, 0, item);

good = PyObject_Call(func, arg, NULL);

PyTuple_SET_ITEM(arg, 0, NULL);

if (good == NULL) {

Py_DECREF(item);

goto Fail_result_it;

}

ok = PyObject_IsTrue(good);

Py_DECREF(good);

}

if (ok) {

if (j < len)

PyList_SET_ITEM(result, j, item);

else {

int status = PyList_Append(result, item);

Py_DECREF(item);

if (status < 0)

goto Fail_result_it;

}

++j;

}

else

Py_DECREF(item);

}

/* Cut back result list if len is too big. */

if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)

goto Fail_result_it;

Py_DECREF(it);

Py_DECREF(arg);

return result;

Fail_result_it:

Py_DECREF(result);

Fail_it:

Py_DECREF(it);

Fail_arg:

Py_DECREF(arg);

return NULL;

}

PyDoc_STRVAR(filter_doc,

"or string, return the same type, else return a list.");

static PyObject *

builtin_format(PyObject *self, PyObject *args)

{

PyObject *value;

PyObject *format_spec = NULL;

if (!PyArg_ParseTuple(args, "O|O: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)

{

long x;

char s[1];

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

return NULL;

if (x < 0 || x >= 256) {

PyErr_SetString(PyExc_ValueError,

"chr() arg not in range(256)");

return NULL;

}

s[0] = (char)x;

return PyString_FromStringAndSize(s, 1);

}

PyDoc_STRVAR(chr_doc,

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

#ifdef Py_USING_UNICODE

static PyObject *

builtin_unichr(PyObject *self, PyObject *args)

{

int x;

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

return NULL;

return PyUnicode_FromOrdinal(x);

}

PyDoc_STRVAR(unichr_doc,

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

static PyObject *

builtin_cmp(PyObject *self, PyObject *args)

{

PyObject *a, *b;

int c;

if (!PyArg_UnpackTuple(args, "cmp", 2, 2, &a, &b))

return NULL;

if (PyObject_Cmp(a, b, &c) < 0)

return NULL;

return PyInt_FromLong((long)c);

}

PyDoc_STRVAR(cmp_doc,

Return negative if x<y, zero if x==y, positive if x>y.");

static PyObject *

builtin_coerce(PyObject *self, PyObject *args)

{

PyObject *v, *w;

PyObject *res;

if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)

return NULL;

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

return NULL;

if (PyNumber_Coerce(&v, &w) < 0)

return NULL;

res = PyTuple_Pack(2, v, w);

Py_DECREF(v);

Py_DECREF(w);

return res;

}

PyDoc_STRVAR(coerce_doc,

If coercion is not possible, raise TypeError.");

static PyObject *

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

{

char *str;

char *filename;

char *startstr;

int mode = -1;

int dont_inherit = 0;

int supplied_flags = 0;

int is_ast;

PyCompilerFlags cf;

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

Py_ssize_t length;

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

"dont_inherit", NULL};

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

if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oss|ii:compile",

kwlist, &cmd, &filename, &startstr,

&supplied_flags, &dont_inherit))

return NULL;

cf.cf_flags = supplied_flags;

if (supplied_flags &

~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))

{

PyErr_SetString(PyExc_ValueError,

"compile(): unrecognised flags");

return NULL;

}

/* 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'");

return NULL;

}

is_ast = PyAST_Check(cmd);

if (is_ast == -1)

return NULL;

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

return NULL;

}

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

&cf, arena);

PyArena_Free(arena);

}

return result;

}

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(cmd)) {

tmp = PyUnicode_AsUTF8String(cmd);

if (tmp == NULL)

return NULL;

cmd = tmp;

cf.cf_flags |= PyCF_SOURCE_IS_UTF8;

}

if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))

goto cleanup;

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

PyErr_SetString(PyExc_TypeError,

"compile() expected string without null bytes");

goto cleanup;

}

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

cleanup:

Py_XDECREF(tmp);

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

}

if (!PyString_Check(cmd) &&

!PyUnicode_Check(cmd)) {

PyErr_SetString(PyExc_TypeError,

"eval() arg 1 must be a string or code object");

return NULL;

}

cf.cf_flags = 0;

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(cmd)) {

tmp = PyUnicode_AsUTF8String(cmd);

if (tmp == NULL)

return NULL;

cmd = tmp;

cf.cf_flags |= PyCF_SOURCE_IS_UTF8;

}

if (PyString_AsStringAndSize(cmd, &str, NULL)) {

Py_XDECREF(tmp);

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

{

char *filename;

PyObject *globals = Py_None, *locals = Py_None;

PyObject *res;

FILE* fp = NULL;

PyCompilerFlags cf;

int exists;

if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",

1) < 0)

return NULL;

if (!PyArg_ParseTuple(args, "s|O!O:execfile",

&filename,

&PyDict_Type, &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) {

globals = PyEval_GetGlobals();

if (locals == Py_None)

locals = PyEval_GetLocals();

}

else if (locals == Py_None)

locals = globals;

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

if (PyDict_SetItemString(globals, "__builtins__",

PyEval_GetBuiltins()) != 0)

return NULL;

}

exists = 0;

/* Test for existence or directory. */

#if defined(PLAN9)

{

Dir *d;

if ((d = dirstat(filename))!=nil) {

if(d->mode & DMDIR)

werrstr("is a directory");

else

exists = 1;

free(d);

}

}

#elif defined(RISCOS)

if (object_exists(filename)) {

if (isdir(filename))

errno = EISDIR;

else

exists = 1;

}

#else /* standard Posix */

{

struct stat s;

if (stat(filename, &s) == 0) {

if (S_ISDIR(s.st_mode))

# if defined(PYOS_OS2) && defined(PYCC_VACPP)

errno = EOS2ERR;

errno = EISDIR;

else

exists = 1;

}

}

if (exists) {

Py_BEGIN_ALLOW_THREADS

fp = fopen(filename, "r" PY_STDIOTEXTMODE);

Py_END_ALLOW_THREADS

if (fp == NULL) {

exists = 0;

}

}

if (!exists) {

PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);

return NULL;

}

cf.cf_flags = 0;

if (PyEval_MergeCompilerFlags(&cf))

res = PyRun_FileExFlags(fp, filename, Py_file_input, globals,

locals, 1, &cf);

else

res = PyRun_FileEx(fp, filename, Py_file_input, globals,

locals, 1);

return res;

}

PyDoc_STRVAR(execfile_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;

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(name)) {

name = _PyUnicode_AsDefaultEncodedString(name, NULL);

if (name == NULL)

return NULL;

}

if (!PyString_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;

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(name)) {

name = _PyUnicode_AsDefaultEncodedString(name, NULL);

if (name == NULL)

return NULL;

}

if (!PyString_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.)");

static PyObject *

builtin_map(PyObject *self, PyObject *args)

{

typedef struct {

PyObject *it; /* the iterator object */

int saw_StopIteration; /* bool: did the iterator end? */

} sequence;

PyObject *func, *result;

sequence *seqs = NULL, *sqp;

Py_ssize_t n, len;

register int i, j;

n = PyTuple_Size(args);

if (n < 2) {

PyErr_SetString(PyExc_TypeError,

"map() requires at least two args");

return NULL;

}

func = PyTuple_GetItem(args, 0);

n--;

if (func == Py_None) {

if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "

"use list(...)", 1) < 0)

return NULL;

if (n == 1) {

/* map(None, S) is the same as list(S). */

return PySequence_List(PyTuple_GetItem(args, 1));

}

}

/* Get space for sequence descriptors. Must NULL out the iterator

if ((seqs = PyMem_NEW(sequence, n)) == NULL) {

PyErr_NoMemory();

return NULL;

}

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

seqs[i].it = (PyObject*)NULL;

seqs[i].saw_StopIteration = 0;

}

/* Do a first pass to obtain iterators for the arguments, and set len

len = 0;

for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {

PyObject *curseq;

Py_ssize_t curlen;

/* Get iterator. */

curseq = PyTuple_GetItem(args, i+1);

sqp->it = PyObject_GetIter(curseq);

if (sqp->it == NULL) {

static char errmsg[] =

"argument %d to map() must support iteration";

char errbuf[sizeof(errmsg) + 25];

PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);

PyErr_SetString(PyExc_TypeError, errbuf);

goto Fail_2;

}

/* Update len. */

curlen = _PyObject_LengthHint(curseq, 8);

if (curlen > len)

len = curlen;

}

/* Get space for the result list. */

if ((result = (PyObject *) PyList_New(len)) == NULL)

goto Fail_2;

/* Iterate over the sequences until all have stopped. */

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

PyObject *alist, *item=NULL, *value;

int numactive = 0;

if (func == Py_None && n == 1)

alist = NULL;

else if ((alist = PyTuple_New(n)) == NULL)

goto Fail_1;