/* Built-in functions */

#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "code.h"

#include "eval.h"

#include <ctype.h>

#ifdef RISCOS

#include "unixstuff.h"

#endif

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

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

*/

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

const char *Py_FileSystemDefaultEncoding = "mbcs";

#elif defined(__APPLE__)

const char *Py_FileSystemDefaultEncoding = "utf-8";

#else

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

#endif

/* Forward */

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

#ifdef Py_USING_UNICODE

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

#endif

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,

"__import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module\n\

\n\

Import a module.  The globals are only used to determine the context;\n\

they are not modified.  The locals are currently 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.  -1 is the original strategy of attempting\n\

both absolute and relative imports, 0 is absolute, a positive number\n\

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,

"abs(number) -> number\n\

\n\

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,

"all(iterable) -> bool\n\

\n\

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,

"any(iterable) -> bool\n\

\n\

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,

"apply(object[, args[, kwargs]]) -> value\n\

\n\

Call a callable object with positional arguments taken from the tuple args,\n\

and keyword arguments taken from the optional dictionary kwargs.\n\

Note that classes are callable, as are instances with a __call__() method.\n\

\n\

Deprecated since release 2.3. Instead, use the extended call syntax:\n\

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

static PyObject *

builtin_bin(PyObject *self, PyObject *v)

{

        return PyNumber_ToBase(v, 2);

}

PyDoc_STRVAR(bin_doc,

"bin(number) -> string\n\

\n\

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

static PyObject *

builtin_callable(PyObject *self, PyObject *v)

{

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

			   "use hasattr(o, '__call__')", 1) < 0)

		return NULL;

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

}

PyDoc_STRVAR(callable_doc,

"callable(object) -> bool\n\

\n\

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

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

#endif

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

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

"filter(function or None, sequence) -> list, tuple, or string\n"

"\n"

"Return those items of sequence for which function(item) is true.  If\n"

"function is None, return the items that are true.  If sequence is a tuple\n"

"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(value[, format_spec]) -> string\n\

\n\

Returns value.__format__(format_spec)\n\

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,

"chr(i) -> character\n\

\n\

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,

"unichr(i) -> Unicode character\n\

\n\

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

#endif

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,

"cmp(x, y) -> integer\n\

\n\

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,

"coerce(x, y) -> (x1, y1)\n\

\n\

Return a tuple consisting of the two numeric arguments converted to\n\

a common type, using the same rules as used by arithmetic operations.\n\

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;

	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;

	}

	if (PyAST_Check(cmd)) {

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