cpython/Python/bltinmodule.c

2480 lines
58 KiB
C
Raw Normal View History

1990-12-20 11:06:42 -04:00
/* Built-in functions */
#include "Python.h"
1990-12-20 11:06:42 -04:00
#include "node.h"
#include "compile.h"
#include "eval.h"
1990-12-20 11:06:42 -04:00
1997-04-11 17:37:35 -03:00
#include <ctype.h>
2001-10-24 17:42:55 -03:00
#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)
{
char *name;
PyObject *globals = NULL;
PyObject *locals = NULL;
PyObject *fromlist = NULL;
if (!PyArg_ParseTuple(args, "s|OOO:__import__",
&name, &globals, &locals, &fromlist))
return NULL;
First part of package support. This doesn't yet support "import a.b.c" or "from a.b.c import x", but it does recognize directories. When importing a directory, it initializes __path__ to a list containing the directory name, and loads the __init__ module if found. The (internal) find_module() and load_module() functions are restructured so that they both also handle built-in and frozen modules and Mac resources (and directories of course). The imp module's find_module() and (new) load_module() also have this functionality. Moreover, imp unconditionally defines constants for all module types, and has two more new functions: find_module_in_package() and find_module_in_directory(). There's also a new API function, PyImport_ImportModuleEx(), which takes all four __import__ arguments (name, globals, locals, fromlist). The last three may be NULL. This is currently the same as PyImport_ImportModule() but in the future it will be able to do relative dotted-path imports. Other changes: - bltinmodule.c: in __import__, call PyImport_ImportModuleEx(). - ceval.c: always pass the fromlist to __import__, even if it is a C function, so PyImport_ImportModuleEx() is useful. - getmtime.c: the function has a second argument, the FILE*, on which it applies fstat(). According to Sjoerd this is much faster. The first (pathname) argument is ignored, but remains for backward compatibility (so the Mac version still works without changes). By cleverly combining the new imp functionality, the full support for dotted names in Python (mini.py, not checked in) is now about 7K, lavishly commented (vs. 14K for ni plus 11K for ihooks, also lavishly commented). Good night!
1997-09-05 04:33:22 -03:00
return PyImport_ImportModuleEx(name, globals, locals, fromlist);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(import_doc,
1998-06-26 18:23:49 -03:00
"__import__(name, globals, locals, fromlist) -> 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\
2002-06-13 17:33:02 -03:00
fromlist is not empty.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_abs(PyObject *self, PyObject *v)
1990-12-20 11:06:42 -04:00
{
return PyNumber_Absolute(v);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(abs_doc,
1998-06-26 18:23:49 -03:00
"abs(number) -> number\n\
\n\
2002-06-13 17:33:02 -03:00
Return the absolute value of the argument.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_apply(PyObject *self, PyObject *args)
{
PyObject *func, *alist = NULL, *kwdict = NULL;
PyObject *t = NULL, *retval = 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,
2003-04-23 10:34:35 -03:00
"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;
1995-07-18 11:51:37 -03:00
}
retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);
finally:
Py_XDECREF(t);
return retval;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(apply_doc,
"apply(object[, args[, kwargs]]) -> value\n\
1998-06-26 18:23:49 -03:00
\n\
Call a callable object with positional arguments taken from the tuple args,\n\
and keyword arguments taken from the optional dictionary kwargs.\n\
2003-04-06 06:01:11 -03:00
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).");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_callable(PyObject *self, PyObject *v)
{
return PyBool_FromLong((long)PyCallable_Check(v));
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(callable_doc,
"callable(object) -> bool\n\
1998-06-26 18:23:49 -03:00
\n\
Return whether the object is callable (i.e., some kind of function).\n\
2002-06-13 17:33:02 -03:00
Note that classes are callable, as are instances with a __call__() method.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_filter(PyObject *self, PyObject *args)
{
PyObject *func, *seq, *result, *it, *arg;
int len; /* guess for result list size */
register int 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);
/* Get iterator. */
it = PyObject_GetIter(seq);
if (it == NULL)
return NULL;
/* Guess a result list size. */
len = PyObject_Size(seq);
if (len < 0) {
PyErr_Clear();
len = 8; /* arbitrary */
}
/* Pre-allocate argument list tuple. */
arg = PyTuple_New(1);
if (arg == NULL)
goto Fail_arg;
/* 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;
}
2002-06-13 17:33:02 -03:00
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"
2002-06-13 17:33:02 -03:00
"or string, return the same type, else return a list.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_chr(PyObject *self, PyObject *args)
1990-12-20 11:06:42 -04:00
{
long x;
char s[1];
if (!PyArg_ParseTuple(args, "l:chr", &x))
1990-12-20 11:06:42 -04:00
return NULL;
if (x < 0 || x >= 256) {
PyErr_SetString(PyExc_ValueError,
"chr() arg not in range(256)");
1990-12-20 11:06:42 -04:00
return NULL;
}
1997-04-11 17:37:35 -03:00
s[0] = (char)x;
return PyString_FromStringAndSize(s, 1);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(chr_doc,
1998-06-26 18:23:49 -03:00
"chr(i) -> character\n\
\n\
2002-06-13 17:33:02 -03:00
Return a string of one character with ordinal i; 0 <= i < 256.");
1998-06-26 18:23:49 -03:00
#ifdef Py_USING_UNICODE
static PyObject *
builtin_unichr(PyObject *self, PyObject *args)
{
long x;
if (!PyArg_ParseTuple(args, "l:unichr", &x))
return NULL;
return PyUnicode_FromOrdinal(x);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(unichr_doc,
"unichr(i) -> Unicode character\n\
\n\
2002-06-13 17:33:02 -03:00
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);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(cmp_doc,
1998-06-26 18:23:49 -03:00
"cmp(x, y) -> integer\n\
\n\
2002-06-13 17:33:02 -03:00
Return negative if x<y, zero if x==y, positive if x>y.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_coerce(PyObject *self, PyObject *args)
{
PyObject *v, *w;
PyObject *res;
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;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(coerce_doc,
1998-06-26 18:23:49 -03:00
"coerce(x, y) -> None or (x1, y1)\n\
\n\
When x and y can be coerced to values of the same type, return a tuple\n\
2002-06-13 17:33:02 -03:00
containing the coerced values. When they can't be coerced, return None.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_compile(PyObject *self, PyObject *args)
{
char *str;
char *filename;
char *startstr;
int start;
int dont_inherit = 0;
int supplied_flags = 0;
PyCompilerFlags cf;
PyObject *result, *cmd, *tmp = NULL;
int length;
if (!PyArg_ParseTuple(args, "Oss|ii:compile", &cmd, &filename,
&startstr, &supplied_flags, &dont_inherit))
return NULL;
cf.cf_flags = supplied_flags;
#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;
}
#endif
if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))
return NULL;
if ((size_t)length != strlen(str)) {
PyErr_SetString(PyExc_TypeError,
2003-04-23 10:34:35 -03:00
"compile() expected string without null bytes");
return NULL;
}
if (strcmp(startstr, "exec") == 0)
start = Py_file_input;
else if (strcmp(startstr, "eval") == 0)
start = Py_eval_input;
else if (strcmp(startstr, "single") == 0)
start = Py_single_input;
else {
PyErr_SetString(PyExc_ValueError,
"compile() arg 3 must be 'exec' or 'eval' or 'single'");
return NULL;
}
if (supplied_flags &
~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT))
{
PyErr_SetString(PyExc_ValueError,
"compile(): unrecognised flags");
return NULL;
}
/* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
if (!dont_inherit) {
PyEval_MergeCompilerFlags(&cf);
}
result = Py_CompileStringFlags(str, filename, start, &cf);
Py_XDECREF(tmp);
return result;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(compile_doc,
"compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\
1998-06-26 18:23:49 -03:00
\n\
Compile the source string (a Python module, statement or expression)\n\
into a code object that can be executed by the exec statement or eval().\n\
The filename will be used for run-time error messages.\n\
The mode must be 'exec' to compile a module, 'single' to compile a\n\
single (interactive) statement, or 'eval' to compile an expression.\n\
The flags argument, if present, controls which future statements influence\n\
the compilation of the code.\n\
The dont_inherit argument, if non-zero, stops the compilation inheriting\n\
the effects of any future statements in effect in the code calling\n\
compile; if absent or zero these statements do influence the compilation,\n\
2002-06-13 17:33:02 -03:00
in addition to any features explicitly specified.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_dir(PyObject *self, PyObject *args)
1990-12-20 11:06:42 -04:00
{
PyObject *arg = NULL;
if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
return NULL;
return PyObject_Dir(arg);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(dir_doc,
"dir([object]) -> list of strings\n"
"\n"
"Return an alphabetized list of names comprising (some of) the attributes\n"
"of the given object, and of attributes reachable from it:\n"
"\n"
"No argument: the names in the current scope.\n"
"Module object: the module attributes.\n"
"Type or class object: its attributes, and recursively the attributes of\n"
" its bases.\n"
"Otherwise: its attributes, its class's attributes, and recursively the\n"
2002-06-13 17:33:02 -03:00
" attributes of its class's base classes.");
1998-06-26 18:23:49 -03:00
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);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(divmod_doc,
1998-06-26 18:23:49 -03:00
"divmod(x, y) -> (div, mod)\n\
\n\
2002-06-13 17:33:02 -03:00
Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_eval(PyObject *self, PyObject *args)
1990-12-20 11:06:42 -04:00
{
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 (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;
}
#endif
if (PyString_AsStringAndSize(cmd, &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;
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(eval_doc,
1998-06-26 18:23:49 -03:00
"eval(source[, globals[, locals]]) -> value\n\
\n\
Evaluate the source in the context of globals and locals.\n\
The source may be a string representing a Python expression\n\
or a code object as returned by compile().\n\
The globals must be a dictionary and locals can be any mappping,\n\
defaulting to the current globals and locals.\n\
If only globals is given, locals defaults to it.\n");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_execfile(PyObject *self, PyObject *args)
1992-02-25 14:55:05 -04:00
{
char *filename;
PyObject *globals = Py_None, *locals = Py_None;
PyObject *res;
FILE* fp = NULL;
PyCompilerFlags cf;
int exists;
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)
2001-10-24 17:42:55 -03:00
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))
2004-03-29 07:53:38 -04:00
# if defined(PYOS_OS2) && defined(PYCC_VACPP)
errno = EOS2ERR;
# else
errno = EISDIR;
# endif
else
exists = 1;
}
}
#endif
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);
1992-02-25 14:55:05 -04:00
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;
1992-02-25 14:55:05 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(execfile_doc,
1998-06-26 18:23:49 -03:00
"execfile(filename[, globals[, locals]])\n\
\n\
Read and execute a Python script from a file.\n\
The globals and locals are dictionaries, defaulting to the current\n\
2002-06-13 17:33:02 -03:00
globals and locals. If only globals is given, locals defaults to it.");
1998-06-26 18:23:49 -03:00
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;
}
#endif
if (!PyString_Check(name)) {
PyErr_SetString(PyExc_TypeError,
2003-04-23 10:34:35 -03:00
"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;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(getattr_doc,
"getattr(object, name[, default]) -> value\n\
1998-06-26 18:23:49 -03:00
\n\
Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\n\
When a default argument is given, it is returned when the attribute doesn't\n\
2002-06-13 17:33:02 -03:00
exist; without it, an exception is raised in that case.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_globals(PyObject *self)
{
PyObject *d;
d = PyEval_GetGlobals();
Py_INCREF(d);
return d;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(globals_doc,
1998-06-26 18:23:49 -03:00
"globals() -> dictionary\n\
\n\
2002-06-13 17:33:02 -03:00
Return the dictionary containing the current scope's global variables.");
1998-06-26 18:23:49 -03:00
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;
}
#endif
if (!PyString_Check(name)) {
PyErr_SetString(PyExc_TypeError,
2003-04-23 10:34:35 -03:00
"hasattr(): attribute name must be string");
return NULL;
}
v = PyObject_GetAttr(v, name);
if (v == NULL) {
PyErr_Clear();
Py_INCREF(Py_False);
return Py_False;
}
Py_DECREF(v);
Py_INCREF(Py_True);
return Py_True;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(hasattr_doc,
"hasattr(object, name) -> bool\n\
1998-06-26 18:23:49 -03:00
\n\
Return whether the object has an attribute with the given name.\n\
2002-06-13 17:33:02 -03:00
(This is done by calling getattr(object, name) and catching exceptions.)");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_id(PyObject *self, PyObject *v)
{
return PyLong_FromVoidPtr(v);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(id_doc,
1998-06-26 18:23:49 -03:00
"id(object) -> integer\n\
\n\
Return the identity of an object. This is guaranteed to be unique among\n\
2002-06-13 17:33:02 -03:00
simultaneously existing objects. (Hint: it's the object's memory address.)");
1998-06-26 18:23:49 -03:00
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;
int 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 && 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
* pointers so that jumping to Fail_2 later doesn't see trash.
*/
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
* to the largest of their lengths.
*/
len = 0;
for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {
PyObject *curseq;
int 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];
2001-11-28 16:42:20 -04:00
PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);
PyErr_SetString(PyExc_TypeError, errbuf);
goto Fail_2;
}
/* Update len. */
curlen = PyObject_Size(curseq);
if (curlen < 0) {
PyErr_Clear();
curlen = 8; /* arbitrary */
}
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;
for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {
if (sqp->saw_StopIteration) {
Py_INCREF(Py_None);
item = Py_None;
}
else {
item = PyIter_Next(sqp->it);
if (item)
++numactive;
else {
if (PyErr_Occurred()) {
Py_XDECREF(alist);
goto Fail_1;
}
Py_INCREF(Py_None);
item = Py_None;
sqp->saw_StopIteration = 1;
}
}
if (alist)
PyTuple_SET_ITEM(alist, j, item);
else
break;
}
if (!alist)
alist = item;
if (numactive == 0) {
Py_DECREF(alist);
break;
}
if (func == Py_None)
value = alist;
else {
value = PyEval_CallObject(func, alist);
Py_DECREF(alist);
if (value == NULL)
goto Fail_1;
}
if (i >= len) {
int status = PyList_Append(result, value);
Py_DECREF(value);
if (status < 0)
goto Fail_1;
}
else if (PyList_SetItem(result, i, value) < 0)
goto Fail_1;
}
if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)
goto Fail_1;
goto Succeed;
Fail_1:
Py_DECREF(result);
Fail_2:
result = NULL;
Succeed:
assert(seqs);
for (i = 0; i < n; ++i)
Py_XDECREF(seqs[i].it);
PyMem_DEL(seqs);
return result;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(map_doc,
1998-06-26 18:23:49 -03:00
"map(function, sequence[, sequence, ...]) -> list\n\
\n\
Return a list of the results of applying the function to the items of\n\
the argument sequence(s). If more than one sequence is given, the\n\
function is called with an argument list consisting of the corresponding\n\
item of each sequence, substituting None for missing values when not all\n\
sequences have the same length. If the function is None, return a list of\n\
2002-06-13 17:33:02 -03:00
the items of the sequence (or a list of tuples if more than one sequence).");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_setattr(PyObject *self, PyObject *args)
{
PyObject *v;
PyObject *name;
PyObject *value;
if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))
return NULL;
if (PyObject_SetAttr(v, name, value) != 0)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(setattr_doc,
1998-06-26 18:23:49 -03:00
"setattr(object, name, value)\n\
\n\
Set a named attribute on an object; setattr(x, 'y', v) is equivalent to\n\
2002-06-13 17:33:02 -03:00
``x.y = v''.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_delattr(PyObject *self, PyObject *args)
1994-08-29 09:53:40 -03:00
{
PyObject *v;
PyObject *name;
if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name))
1994-08-29 09:53:40 -03:00
return NULL;
if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0)
1994-08-29 09:53:40 -03:00
return NULL;
Py_INCREF(Py_None);
return Py_None;
1994-08-29 09:53:40 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(delattr_doc,
"delattr(object, name)\n\
1998-06-26 18:23:49 -03:00
\n\
Delete a named attribute on an object; delattr(x, 'y') is equivalent to\n\
2002-06-13 17:33:02 -03:00
``del x.y''.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_hash(PyObject *self, PyObject *v)
{
long x;
x = PyObject_Hash(v);
if (x == -1)
return NULL;
return PyInt_FromLong(x);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(hash_doc,
1998-06-26 18:23:49 -03:00
"hash(object) -> integer\n\
\n\
Return a hash value for the object. Two objects with the same value have\n\
2002-06-13 17:33:02 -03:00
the same hash value. The reverse is not necessarily true, but likely.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_hex(PyObject *self, PyObject *v)
{
PyNumberMethods *nb;
PyObject *res;
if ((nb = v->ob_type->tp_as_number) == NULL ||
nb->nb_hex == NULL) {
PyErr_SetString(PyExc_TypeError,
"hex() argument can't be converted to hex");
return NULL;
}
res = (*nb->nb_hex)(v);
if (res && !PyString_Check(res)) {
PyErr_Format(PyExc_TypeError,
"__hex__ returned non-string (type %.200s)",
res->ob_type->tp_name);
Py_DECREF(res);
return NULL;
}
return res;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(hex_doc,
1998-06-26 18:23:49 -03:00
"hex(number) -> string\n\
\n\
2002-06-13 17:33:02 -03:00
Return the hexadecimal representation of an integer or long integer.");
1998-06-26 18:23:49 -03:00
static PyObject *builtin_raw_input(PyObject *, PyObject *);
static PyObject *
builtin_input(PyObject *self, PyObject *args)
1990-12-20 11:06:42 -04:00
{
PyObject *line;
char *str;
PyObject *res;
PyObject *globals, *locals;
PyCompilerFlags cf;
line = builtin_raw_input(self, args);
if (line == NULL)
return line;
if (!PyArg_Parse(line, "s;embedded '\\0' in input line", &str))
return NULL;
while (*str == ' ' || *str == '\t')
str++;
globals = PyEval_GetGlobals();
locals = PyEval_GetLocals();
if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
if (PyDict_SetItemString(globals, "__builtins__",
PyEval_GetBuiltins()) != 0)
return NULL;
}
cf.cf_flags = 0;
PyEval_MergeCompilerFlags(&cf);
res = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
Py_DECREF(line);
return res;
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(input_doc,
1998-06-26 18:23:49 -03:00
"input([prompt]) -> value\n\
\n\
2002-06-13 17:33:02 -03:00
Equivalent to eval(raw_input(prompt)).");
1998-06-26 18:23:49 -03:00
1997-02-14 11:48:05 -04:00
static PyObject *
builtin_intern(PyObject *self, PyObject *args)
1997-02-14 11:48:05 -04:00
{
PyObject *s;
if (!PyArg_ParseTuple(args, "S:intern", &s))
1997-02-14 11:48:05 -04:00
return NULL;
Py_INCREF(s);
PyString_InternInPlace(&s);
return s;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(intern_doc,
1998-06-26 18:23:49 -03:00
"intern(string) -> string\n\
\n\
``Intern'' the given string. This enters the string in the (global)\n\
table of interned strings whose purpose is to speed up dictionary lookups.\n\
Return the string itself or the previously interned string object with the\n\
2002-06-13 17:33:02 -03:00
same value.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_iter(PyObject *self, PyObject *args)
{
PyObject *v, *w = NULL;
if (!PyArg_UnpackTuple(args, "iter", 1, 2, &v, &w))
return NULL;
if (w == NULL)
return PyObject_GetIter(v);
if (!PyCallable_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"iter(v, w): v must be callable");
return NULL;
}
return PyCallIter_New(v, w);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(iter_doc,
"iter(collection) -> iterator\n\
iter(callable, sentinel) -> iterator\n\
\n\
Get an iterator from an object. In the first form, the argument must\n\
supply its own iterator, or be a sequence.\n\
2002-06-13 17:33:02 -03:00
In the second form, the callable is called until it returns the sentinel.");
static PyObject *
builtin_len(PyObject *self, PyObject *v)
1990-12-20 11:06:42 -04:00
{
long res;
res = PyObject_Size(v);
if (res < 0 && PyErr_Occurred())
return NULL;
return PyInt_FromLong(res);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(len_doc,
1998-06-26 18:23:49 -03:00
"len(object) -> integer\n\
\n\
2002-06-13 17:33:02 -03:00
Return the number of items of a sequence or mapping.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_locals(PyObject *self)
{
PyObject *d;
d = PyEval_GetLocals();
Py_INCREF(d);
return d;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(locals_doc,
1998-06-26 18:23:49 -03:00
"locals() -> dictionary\n\
\n\
Update and return a dictionary containing the current scope's local variables.");
1998-06-26 18:23:49 -03:00
static PyObject *
2001-01-17 11:47:24 -04:00
min_max(PyObject *args, int op)
1990-12-20 11:06:42 -04:00
{
PyObject *v, *w, *x, *it;
if (PyTuple_Size(args) > 1)
v = args;
else if (!PyArg_UnpackTuple(args, (op==Py_LT) ? "min" : "max", 1, 1, &v))
1990-12-20 11:06:42 -04:00
return NULL;
it = PyObject_GetIter(v);
if (it == NULL)
1990-12-20 11:06:42 -04:00
return NULL;
w = NULL; /* the result */
for (;;) {
x = PyIter_Next(it);
if (x == NULL) {
if (PyErr_Occurred()) {
Py_XDECREF(w);
Py_DECREF(it);
return NULL;
}
break;
}
if (w == NULL)
1990-12-20 11:06:42 -04:00
w = x;
else {
2001-01-17 11:47:24 -04:00
int cmp = PyObject_RichCompareBool(x, w, op);
if (cmp > 0) {
Py_DECREF(w);
w = x;
}
else if (cmp < 0) {
Py_DECREF(x);
Py_DECREF(w);
Py_DECREF(it);
return NULL;
}
else
Py_DECREF(x);
1990-12-20 11:06:42 -04:00
}
}
if (w == NULL)
PyErr_SetString(PyExc_ValueError,
"min() or max() arg is an empty sequence");
Py_DECREF(it);
1990-12-20 11:06:42 -04:00
return w;
}
static PyObject *
builtin_min(PyObject *self, PyObject *v)
1990-12-20 11:06:42 -04:00
{
2001-01-17 11:47:24 -04:00
return min_max(v, Py_LT);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(min_doc,
1998-06-26 18:23:49 -03:00
"min(sequence) -> value\n\
min(a, b, c, ...) -> value\n\
\n\
With a single sequence argument, return its smallest item.\n\
2002-06-13 17:33:02 -03:00
With two or more arguments, return the smallest argument.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_max(PyObject *self, PyObject *v)
1990-12-20 11:06:42 -04:00
{
2001-01-17 11:47:24 -04:00
return min_max(v, Py_GT);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(max_doc,
1998-06-26 18:23:49 -03:00
"max(sequence) -> value\n\
max(a, b, c, ...) -> value\n\
\n\
With a single sequence argument, return its largest item.\n\
2002-06-13 17:33:02 -03:00
With two or more arguments, return the largest argument.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_oct(PyObject *self, PyObject *v)
{
PyNumberMethods *nb;
PyObject *res;
if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
nb->nb_oct == NULL) {
PyErr_SetString(PyExc_TypeError,
"oct() argument can't be converted to oct");
return NULL;
}
res = (*nb->nb_oct)(v);
if (res && !PyString_Check(res)) {
PyErr_Format(PyExc_TypeError,
"__oct__ returned non-string (type %.200s)",
res->ob_type->tp_name);
Py_DECREF(res);
return NULL;
}
return res;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(oct_doc,
1998-06-26 18:23:49 -03:00
"oct(number) -> string\n\
\n\
2002-06-13 17:33:02 -03:00
Return the octal representation of an integer or long integer.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_ord(PyObject *self, PyObject* obj)
1990-12-20 11:06:42 -04:00
{
long ord;
2000-04-12 18:19:47 -03:00
int size;
2000-04-12 18:19:47 -03:00
if (PyString_Check(obj)) {
size = PyString_GET_SIZE(obj);
if (size == 1) {
2000-04-12 18:19:47 -03:00
ord = (long)((unsigned char)*PyString_AS_STRING(obj));
return PyInt_FromLong(ord);
}
#ifdef Py_USING_UNICODE
2000-04-12 18:19:47 -03:00
} else if (PyUnicode_Check(obj)) {
size = PyUnicode_GET_SIZE(obj);
if (size == 1) {
2000-04-12 18:19:47 -03:00
ord = (long)*PyUnicode_AS_UNICODE(obj);
return PyInt_FromLong(ord);
}
#endif
2000-04-12 18:19:47 -03:00
} else {
PyErr_Format(PyExc_TypeError,
"ord() expected string of length 1, but " \
2000-04-12 18:19:47 -03:00
"%.200s found", obj->ob_type->tp_name);
return NULL;
}
PyErr_Format(PyExc_TypeError,
"ord() expected a character, "
"but string of length %d found",
2000-04-12 18:19:47 -03:00
size);
return NULL;
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(ord_doc,
1998-06-26 18:23:49 -03:00
"ord(c) -> integer\n\
\n\
2002-06-13 17:33:02 -03:00
Return the integer ordinal of a one-character string.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_pow(PyObject *self, PyObject *args)
{
PyObject *v, *w, *z = Py_None;
if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z))
return NULL;
return PyNumber_Power(v, w, z);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(pow_doc,
1998-06-26 18:23:49 -03:00
"pow(x, y[, z]) -> number\n\
\n\
With two arguments, equivalent to x**y. With three arguments,\n\
2002-06-13 17:33:02 -03:00
equivalent to (x**y) % z, but may be more efficient (e.g. for longs).");
1998-06-26 18:23:49 -03:00
/* Return number of items in range (lo, hi, step), when arguments are
* PyInt or PyLong objects. step > 0 required. Return a value < 0 if
* & only if the true value is too large to fit in a signed long.
* Arguments MUST return 1 with either PyInt_Check() or
* PyLong_Check(). Return -1 when there is an error.
*/
static long
get_len_of_range_longs(PyObject *lo, PyObject *hi, PyObject *step)
{
/* -------------------------------------------------------------
Algorithm is equal to that of get_len_of_range(), but it operates
on PyObjects (which are assumed to be PyLong or PyInt objects).
---------------------------------------------------------------*/
long n;
PyObject *diff = NULL;
PyObject *one = NULL;
PyObject *tmp1 = NULL, *tmp2 = NULL, *tmp3 = NULL;
/* holds sub-expression evaluations */
/* if (lo >= hi), return length of 0. */
if (PyObject_Compare(lo, hi) >= 0)
return 0;
if ((one = PyLong_FromLong(1L)) == NULL)
goto Fail;
if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
goto Fail;
if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
goto Fail;
if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
goto Fail;
if ((tmp3 = PyNumber_Add(tmp2, one)) == NULL)
goto Fail;
n = PyLong_AsLong(tmp3);
if (PyErr_Occurred()) { /* Check for Overflow */
PyErr_Clear();
goto Fail;
}
Py_DECREF(tmp3);
Py_DECREF(tmp2);
Py_DECREF(diff);
Py_DECREF(tmp1);
Py_DECREF(one);
return n;
Fail:
Py_XDECREF(tmp3);
Py_XDECREF(tmp2);
Py_XDECREF(diff);
Py_XDECREF(tmp1);
Py_XDECREF(one);
return -1;
}
/* An extension of builtin_range() that handles the case when PyLong
* arguments are given. */
static PyObject *
handle_range_longs(PyObject *self, PyObject *args)
{
PyObject *ilow;
PyObject *ihigh = NULL;
PyObject *istep = NULL;
PyObject *curnum = NULL;
PyObject *v = NULL;
long bign;
int i, n;
int cmp_result;
PyObject *zero = PyLong_FromLong(0);
if (zero == NULL)
return NULL;
if (!PyArg_UnpackTuple(args, "range", 1, 3, &ilow, &ihigh, &istep)) {
Py_DECREF(zero);
return NULL;
}
/* Figure out which way we were called, supply defaults, and be
* sure to incref everything so that the decrefs at the end
* are correct.
*/
assert(ilow != NULL);
if (ihigh == NULL) {
/* only 1 arg -- it's the upper limit */
ihigh = ilow;
ilow = NULL;
}
assert(ihigh != NULL);
Py_INCREF(ihigh);
/* ihigh correct now; do ilow */
if (ilow == NULL)
ilow = zero;
Py_INCREF(ilow);
/* ilow and ihigh correct now; do istep */
if (istep == NULL) {
istep = PyLong_FromLong(1L);
if (istep == NULL)
goto Fail;
}
else {
Py_INCREF(istep);
}
if (!PyInt_Check(ilow) && !PyLong_Check(ilow)) {
PyErr_Format(PyExc_TypeError,
"range() integer start argument expected, got %s.",
ilow->ob_type->tp_name);
goto Fail;
}
if (!PyInt_Check(ihigh) && !PyLong_Check(ihigh)) {
PyErr_Format(PyExc_TypeError,
"range() integer end argument expected, got %s.",
ihigh->ob_type->tp_name);
goto Fail;
}
if (!PyInt_Check(istep) && !PyLong_Check(istep)) {
PyErr_Format(PyExc_TypeError,
"range() integer step argument expected, got %s.",
istep->ob_type->tp_name);
goto Fail;
}
if (PyObject_Cmp(istep, zero, &cmp_result) == -1)
goto Fail;
if (cmp_result == 0) {
PyErr_SetString(PyExc_ValueError,
"range() step argument must not be zero");
goto Fail;
}
if (cmp_result > 0)
bign = get_len_of_range_longs(ilow, ihigh, istep);
else {
PyObject *neg_istep = PyNumber_Negative(istep);
if (neg_istep == NULL)
goto Fail;
bign = get_len_of_range_longs(ihigh, ilow, neg_istep);
Py_DECREF(neg_istep);
}
n = (int)bign;
if (bign < 0 || (long)n != bign) {
PyErr_SetString(PyExc_OverflowError,
"range() result has too many items");
goto Fail;
}
v = PyList_New(n);
if (v == NULL)
goto Fail;
curnum = ilow;
Py_INCREF(curnum);
for (i = 0; i < n; i++) {
PyObject *w = PyNumber_Long(curnum);
PyObject *tmp_num;
if (w == NULL)
goto Fail;
PyList_SET_ITEM(v, i, w);
tmp_num = PyNumber_Add(curnum, istep);
if (tmp_num == NULL)
goto Fail;
Py_DECREF(curnum);
curnum = tmp_num;
}
Py_DECREF(ilow);
Py_DECREF(ihigh);
Py_DECREF(istep);
Py_DECREF(zero);
Py_DECREF(curnum);
return v;
Fail:
Py_DECREF(ilow);
Py_DECREF(ihigh);
Py_XDECREF(istep);
Py_DECREF(zero);
Py_XDECREF(curnum);
Py_XDECREF(v);
return NULL;
}
/* Return number of items in range/xrange (lo, hi, step). step > 0
* required. Return a value < 0 if & only if the true value is too
* large to fit in a signed long.
*/
static long
2000-07-23 19:21:32 -03:00
get_len_of_range(long lo, long hi, long step)
{
/* -------------------------------------------------------------
If lo >= hi, the range is empty.
Else if n values are in the range, the last one is
lo + (n-1)*step, which must be <= hi-1. Rearranging,
n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so
the RHS is non-negative and so truncation is the same as the
floor. Letting M be the largest positive long, the worst case
for the RHS numerator is hi=M, lo=-M-1, and then
hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough
precision to compute the RHS exactly.
---------------------------------------------------------------*/
long n = 0;
if (lo < hi) {
unsigned long uhi = (unsigned long)hi;
unsigned long ulo = (unsigned long)lo;
unsigned long diff = uhi - ulo - 1;
n = (long)(diff / (unsigned long)step + 1);
}
return n;
}
static PyObject *
builtin_range(PyObject *self, PyObject *args)
1990-12-20 11:06:42 -04:00
{
long ilow = 0, ihigh = 0, istep = 1;
long bign;
1990-12-20 11:06:42 -04:00
int i, n;
PyObject *v;
if (PyTuple_Size(args) <= 1) {
if (!PyArg_ParseTuple(args,
"l;range() requires 1-3 int arguments",
&ihigh)) {
PyErr_Clear();
return handle_range_longs(self, args);
}
1990-12-20 11:06:42 -04:00
}
else {
if (!PyArg_ParseTuple(args,
"ll|l;range() requires 1-3 int arguments",
&ilow, &ihigh, &istep)) {
PyErr_Clear();
return handle_range_longs(self, args);
}
1990-12-20 11:06:42 -04:00
}
if (istep == 0) {
PyErr_SetString(PyExc_ValueError,
"range() step argument must not be zero");
1990-12-20 11:06:42 -04:00
return NULL;
}
if (istep > 0)
bign = get_len_of_range(ilow, ihigh, istep);
else
bign = get_len_of_range(ihigh, ilow, -istep);
n = (int)bign;
if (bign < 0 || (long)n != bign) {
PyErr_SetString(PyExc_OverflowError,
"range() result has too many items");
return NULL;
}
v = PyList_New(n);
1990-12-20 11:06:42 -04:00
if (v == NULL)
return NULL;
for (i = 0; i < n; i++) {
PyObject *w = PyInt_FromLong(ilow);
1990-12-20 11:06:42 -04:00
if (w == NULL) {
Py_DECREF(v);
1990-12-20 11:06:42 -04:00
return NULL;
}
PyList_SET_ITEM(v, i, w);
1990-12-20 11:06:42 -04:00
ilow += istep;
}
return v;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(range_doc,
1998-06-26 18:23:49 -03:00
"range([start,] stop[, step]) -> list of integers\n\
\n\
Return a list containing an arithmetic progression of integers.\n\
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.\n\
When step is given, it specifies the increment (or decrement).\n\
For example, range(4) returns [0, 1, 2, 3]. The end point is omitted!\n\
2002-06-13 17:33:02 -03:00
These are exactly the valid indices for a list of 4 elements.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_raw_input(PyObject *self, PyObject *args)
1990-12-20 11:06:42 -04:00
{
PyObject *v = NULL;
PyObject *fin = PySys_GetObject("stdin");
PyObject *fout = PySys_GetObject("stdout");
if (!PyArg_UnpackTuple(args, "[raw_]input", 0, 1, &v))
return NULL;
if (fin == NULL) {
2003-04-23 10:34:35 -03:00
PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdin");
return NULL;
}
if (fout == NULL) {
2003-04-23 10:34:35 -03:00
PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdout");
return NULL;
}
if (PyFile_SoftSpace(fout, 0)) {
if (PyFile_WriteString(" ", fout) != 0)
return NULL;
}
if (PyFile_Check (fin) && PyFile_Check (fout)
&& isatty(fileno(PyFile_AsFile(fin)))
&& isatty(fileno(PyFile_AsFile(fout)))) {
PyObject *po;
char *prompt;
char *s;
PyObject *result;
if (v != NULL) {
po = PyObject_Str(v);
if (po == NULL)
return NULL;
prompt = PyString_AsString(po);
if (prompt == NULL)
return NULL;
}
else {
po = NULL;
prompt = "";
}
s = PyOS_Readline(PyFile_AsFile (fin), PyFile_AsFile (fout),
prompt);
Py_XDECREF(po);
if (s == NULL) {
if (!PyErr_Occurred())
PyErr_SetNone(PyExc_KeyboardInterrupt);
return NULL;
}
if (*s == '\0') {
PyErr_SetNone(PyExc_EOFError);
result = NULL;
}
else { /* strip trailing '\n' */
size_t len = strlen(s);
if (len > INT_MAX) {
PyErr_SetString(PyExc_OverflowError,
2003-04-23 10:34:35 -03:00
"[raw_]input: input too long");
result = NULL;
}
else {
result = PyString_FromStringAndSize(s,
(int)(len-1));
}
}
PyMem_FREE(s);
return result;
}
1991-06-07 13:10:43 -03:00
if (v != NULL) {
if (PyFile_WriteObject(v, fout, Py_PRINT_RAW) != 0)
1991-06-07 13:10:43 -03:00
return NULL;
}
return PyFile_GetLine(fin, -1);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(raw_input_doc,
1998-06-26 18:23:49 -03:00
"raw_input([prompt]) -> string\n\
\n\
Read a string from standard input. The trailing newline is stripped.\n\
If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.\n\
On Unix, GNU readline is used if enabled. The prompt string, if given,\n\
2002-06-13 17:33:02 -03:00
is printed without a trailing newline before reading.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_reduce(PyObject *self, PyObject *args)
{
PyObject *seq, *func, *result = NULL, *it;
if (!PyArg_UnpackTuple(args, "reduce", 2, 3, &func, &seq, &result))
return NULL;
if (result != NULL)
Py_INCREF(result);
it = PyObject_GetIter(seq);
if (it == NULL) {
PyErr_SetString(PyExc_TypeError,
"reduce() arg 2 must support iteration");
Py_XDECREF(result);
return NULL;
}
if ((args = PyTuple_New(2)) == NULL)
goto Fail;
for (;;) {
PyObject *op2;
if (args->ob_refcnt > 1) {
Py_DECREF(args);
if ((args = PyTuple_New(2)) == NULL)
goto Fail;
}
op2 = PyIter_Next(it);
if (op2 == NULL) {
if (PyErr_Occurred())
goto Fail;
break;
}
if (result == NULL)
result = op2;
else {
PyTuple_SetItem(args, 0, result);
PyTuple_SetItem(args, 1, op2);
if ((result = PyEval_CallObject(func, args)) == NULL)
goto Fail;
}
}
Py_DECREF(args);
if (result == NULL)
PyErr_SetString(PyExc_TypeError,
"reduce() of empty sequence with no initial value");
Py_DECREF(it);
return result;
Fail:
Py_XDECREF(args);
Py_XDECREF(result);
Py_DECREF(it);
return NULL;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(reduce_doc,
1998-06-26 18:23:49 -03:00
"reduce(function, sequence[, initial]) -> value\n\
\n\
Apply a function of two arguments cumulatively to the items of a sequence,\n\
from left to right, so as to reduce the sequence to a single value.\n\
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n\
((((1+2)+3)+4)+5). If initial is present, it is placed before the items\n\
of the sequence in the calculation, and serves as a default when the\n\
2002-06-13 17:33:02 -03:00
sequence is empty.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_reload(PyObject *self, PyObject *v)
1990-12-20 11:06:42 -04:00
{
return PyImport_ReloadModule(v);
1990-12-20 11:06:42 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(reload_doc,
1998-06-26 18:23:49 -03:00
"reload(module) -> module\n\
\n\
2002-06-13 17:33:02 -03:00
Reload the module. The module must have been successfully imported before.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_repr(PyObject *self, PyObject *v)
{
return PyObject_Repr(v);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(repr_doc,
1998-06-26 18:23:49 -03:00
"repr(object) -> string\n\
\n\
Return the canonical string representation of the object.\n\
2002-06-13 17:33:02 -03:00
For most object types, eval(repr(object)) == object.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_round(PyObject *self, PyObject *args)
{
double x;
double f;
int ndigits = 0;
int i;
if (!PyArg_ParseTuple(args, "d|i:round", &x, &ndigits))
return NULL;
f = 1.0;
i = abs(ndigits);
while (--i >= 0)
f = f*10.0;
if (ndigits < 0)
x /= f;
else
x *= f;
if (x >= 0.0)
x = floor(x + 0.5);
else
x = ceil(x - 0.5);
if (ndigits < 0)
x *= f;
else
x /= f;
return PyFloat_FromDouble(x);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(round_doc,
1998-06-26 18:23:49 -03:00
"round(number[, ndigits]) -> floating point number\n\
\n\
Round a number to a given precision in decimal digits (default 0 digits).\n\
2002-06-13 17:33:02 -03:00
This always returns a floating point number. Precision may be negative.");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_sorted(PyObject *self, PyObject *args, PyObject *kwds)
{
PyObject *newlist, *v, *seq, *compare=NULL, *keyfunc=NULL, *newargs;
PyObject *callable;
static char *kwlist[] = {"iterable", "cmp", "key", "reverse", 0};
long reverse;
if (args != NULL) {
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOi:sorted",
kwlist, &seq, &compare, &keyfunc, &reverse))
return NULL;
}
newlist = PySequence_List(seq);
if (newlist == NULL)
return NULL;
callable = PyObject_GetAttrString(newlist, "sort");
if (callable == NULL) {
Py_DECREF(newlist);
return NULL;
}
newargs = PyTuple_GetSlice(args, 1, 4);
if (newargs == NULL) {
Py_DECREF(newlist);
Py_DECREF(callable);
return NULL;
}
v = PyObject_Call(callable, newargs, kwds);
Py_DECREF(newargs);
Py_DECREF(callable);
if (v == NULL) {
Py_DECREF(newlist);
return NULL;
}
Py_DECREF(v);
return newlist;
}
PyDoc_STRVAR(sorted_doc,
"sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_vars(PyObject *self, PyObject *args)
{
PyObject *v = NULL;
PyObject *d;
if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
return NULL;
if (v == NULL) {
d = PyEval_GetLocals();
1995-07-26 13:26:31 -03:00
if (d == NULL) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_SystemError,
2003-04-23 10:34:35 -03:00
"vars(): no locals!?");
1995-07-26 13:26:31 -03:00
}
else
Py_INCREF(d);
}
else {
d = PyObject_GetAttrString(v, "__dict__");
if (d == NULL) {
PyErr_SetString(PyExc_TypeError,
"vars() argument must have __dict__ attribute");
return NULL;
}
}
return d;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(vars_doc,
1998-06-26 18:23:49 -03:00
"vars([object]) -> dictionary\n\
\n\
Without arguments, equivalent to locals().\n\
2002-06-13 17:33:02 -03:00
With an argument, equivalent to object.__dict__.");
1998-06-26 18:23:49 -03:00
static PyObject*
builtin_sum(PyObject *self, PyObject *args)
{
PyObject *seq;
PyObject *result = NULL;
PyObject *temp, *item, *iter;
if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result))
return NULL;
iter = PyObject_GetIter(seq);
if (iter == NULL)
return NULL;
if (result == NULL) {
result = PyInt_FromLong(0);
if (result == NULL) {
Py_DECREF(iter);
return NULL;
}
} else {
/* reject string values for 'start' parameter */
if (PyObject_TypeCheck(result, &PyBaseString_Type)) {
PyErr_SetString(PyExc_TypeError,
2003-04-23 10:34:35 -03:00
"sum() can't sum strings [use ''.join(seq) instead]");
Py_DECREF(iter);
return NULL;
}
Py_INCREF(result);
}
for(;;) {
item = PyIter_Next(iter);
if (item == NULL) {
/* error, or end-of-sequence */
if (PyErr_Occurred()) {
Py_DECREF(result);
result = NULL;
}
break;
}
temp = PyNumber_Add(result, item);
Py_DECREF(result);
Py_DECREF(item);
result = temp;
if (result == NULL)
break;
}
Py_DECREF(iter);
return result;
}
PyDoc_STRVAR(sum_doc,
"sum(sequence, start=0) -> value\n\
\n\
Returns the sum of a sequence of numbers (NOT strings) plus the value\n\
of parameter 'start'. When the sequence is empty, returns start.");
static PyObject *
builtin_isinstance(PyObject *self, PyObject *args)
{
PyObject *inst;
PyObject *cls;
int retval;
if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
return NULL;
retval = PyObject_IsInstance(inst, cls);
if (retval < 0)
return NULL;
return PyBool_FromLong(retval);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(isinstance_doc,
"isinstance(object, class-or-type-or-tuple) -> bool\n\
1998-06-26 18:23:49 -03:00
\n\
Return whether an object is an instance of a class or of a subclass thereof.\n\
With a type as second argument, return whether that is the object's type.\n\
The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\n\
2002-06-13 17:33:02 -03:00
isinstance(x, A) or isinstance(x, B) or ... (etc.).");
1998-06-26 18:23:49 -03:00
static PyObject *
builtin_issubclass(PyObject *self, PyObject *args)
{
PyObject *derived;
PyObject *cls;
int retval;
if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls))
return NULL;
retval = PyObject_IsSubclass(derived, cls);
if (retval < 0)
return NULL;
return PyBool_FromLong(retval);
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(issubclass_doc,
"issubclass(C, B) -> bool\n\
1998-06-26 18:23:49 -03:00
\n\
Return whether class C is a subclass (i.e., a derived class) of class B.\n\
When using a tuple as the second argument issubclass(X, (A, B, ...)),\n\
is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).");
1998-06-26 18:23:49 -03:00
static PyObject*
builtin_zip(PyObject *self, PyObject *args)
{
PyObject *ret;
const int itemsize = PySequence_Length(args);
int i;
PyObject *itlist; /* tuple of iterators */
int len; /* guess at result length */
if (itemsize == 0)
return PyList_New(0);
/* args must be a tuple */
assert(PyTuple_Check(args));
/* Guess at result length: the shortest of the input lengths.
If some argument refuses to say, we refuse to guess too, lest
an argument like xrange(sys.maxint) lead us astray.*/
len = -1; /* unknown */
for (i = 0; i < itemsize; ++i) {
PyObject *item = PyTuple_GET_ITEM(args, i);
int thislen = PyObject_Size(item);
if (thislen < 0) {
PyErr_Clear();
len = -1;
break;
}
else if (len < 0 || thislen < len)
len = thislen;
}
/* allocate result list */
if (len < 0)
len = 10; /* arbitrary */
if ((ret = PyList_New(len)) == NULL)
return NULL;
/* obtain iterators */
itlist = PyTuple_New(itemsize);
if (itlist == NULL)
goto Fail_ret;
for (i = 0; i < itemsize; ++i) {
PyObject *item = PyTuple_GET_ITEM(args, i);
PyObject *it = PyObject_GetIter(item);
if (it == NULL) {
if (PyErr_ExceptionMatches(PyExc_TypeError))
PyErr_Format(PyExc_TypeError,
"zip argument #%d must support iteration",
i+1);
goto Fail_ret_itlist;
}
PyTuple_SET_ITEM(itlist, i, it);
}
/* build result into ret list */
for (i = 0; ; ++i) {
int j;
PyObject *next = PyTuple_New(itemsize);
if (!next)
goto Fail_ret_itlist;
for (j = 0; j < itemsize; j++) {
PyObject *it = PyTuple_GET_ITEM(itlist, j);
PyObject *item = PyIter_Next(it);
if (!item) {
if (PyErr_Occurred()) {
Py_DECREF(ret);
ret = NULL;
}
Py_DECREF(next);
Py_DECREF(itlist);
goto Done;
}
PyTuple_SET_ITEM(next, j, item);
}
if (i < len)
PyList_SET_ITEM(ret, i, next);
else {
int status = PyList_Append(ret, next);
Py_DECREF(next);
++len;
if (status < 0)
goto Fail_ret_itlist;
}
}
Done:
if (ret != NULL && i < len) {
/* The list is too big. */
if (PyList_SetSlice(ret, i, len, NULL) < 0)
return NULL;
}
return ret;
Fail_ret_itlist:
Py_DECREF(itlist);
Fail_ret:
Py_DECREF(ret);
return NULL;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(zip_doc,
"zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]\n\
\n\
Return a list of tuples, where each tuple contains the i-th element\n\
from each of the argument sequences. The returned list is truncated\n\
2002-06-13 17:33:02 -03:00
in length to the length of the shortest argument sequence.");
static PyMethodDef builtin_methods[] = {
{"__import__", builtin___import__, METH_VARARGS, import_doc},
{"abs", builtin_abs, METH_O, abs_doc},
{"apply", builtin_apply, METH_VARARGS, apply_doc},
{"callable", builtin_callable, METH_O, callable_doc},
{"chr", builtin_chr, METH_VARARGS, chr_doc},
{"cmp", builtin_cmp, METH_VARARGS, cmp_doc},
{"coerce", builtin_coerce, METH_VARARGS, coerce_doc},
{"compile", builtin_compile, METH_VARARGS, compile_doc},
{"delattr", builtin_delattr, METH_VARARGS, delattr_doc},
{"dir", builtin_dir, METH_VARARGS, dir_doc},
{"divmod", builtin_divmod, METH_VARARGS, divmod_doc},
{"eval", builtin_eval, METH_VARARGS, eval_doc},
{"execfile", builtin_execfile, METH_VARARGS, execfile_doc},
{"filter", builtin_filter, METH_VARARGS, filter_doc},
{"getattr", builtin_getattr, METH_VARARGS, getattr_doc},
{"globals", (PyCFunction)builtin_globals, METH_NOARGS, globals_doc},
{"hasattr", builtin_hasattr, METH_VARARGS, hasattr_doc},
{"hash", builtin_hash, METH_O, hash_doc},
{"hex", builtin_hex, METH_O, hex_doc},
{"id", builtin_id, METH_O, id_doc},
{"input", builtin_input, METH_VARARGS, input_doc},
{"intern", builtin_intern, METH_VARARGS, intern_doc},
{"isinstance", builtin_isinstance, METH_VARARGS, isinstance_doc},
{"issubclass", builtin_issubclass, METH_VARARGS, issubclass_doc},
{"iter", builtin_iter, METH_VARARGS, iter_doc},
{"len", builtin_len, METH_O, len_doc},
{"locals", (PyCFunction)builtin_locals, METH_NOARGS, locals_doc},
{"map", builtin_map, METH_VARARGS, map_doc},
{"max", builtin_max, METH_VARARGS, max_doc},
{"min", builtin_min, METH_VARARGS, min_doc},
{"oct", builtin_oct, METH_O, oct_doc},
{"ord", builtin_ord, METH_O, ord_doc},
{"pow", builtin_pow, METH_VARARGS, pow_doc},
{"range", builtin_range, METH_VARARGS, range_doc},
{"raw_input", builtin_raw_input, METH_VARARGS, raw_input_doc},
{"reduce", builtin_reduce, METH_VARARGS, reduce_doc},
{"reload", builtin_reload, METH_O, reload_doc},
{"repr", builtin_repr, METH_O, repr_doc},
{"round", builtin_round, METH_VARARGS, round_doc},
{"setattr", builtin_setattr, METH_VARARGS, setattr_doc},
{"sorted", (PyCFunction)builtin_sorted, METH_VARARGS | METH_KEYWORDS, sorted_doc},
{"sum", builtin_sum, METH_VARARGS, sum_doc},
#ifdef Py_USING_UNICODE
{"unichr", builtin_unichr, METH_VARARGS, unichr_doc},
#endif
{"vars", builtin_vars, METH_VARARGS, vars_doc},
{"zip", builtin_zip, METH_VARARGS, zip_doc},
{NULL, NULL},
1990-12-20 11:06:42 -04:00
};
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR(builtin_doc,
1998-06-26 18:23:49 -03:00
"Built-in functions, exceptions, and other objects.\n\
\n\
2002-06-13 17:33:02 -03:00
Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.");
1998-06-26 18:23:49 -03:00
PyObject *
_PyBuiltin_Init(void)
{
PyObject *mod, *dict, *debug;
1998-06-26 18:23:49 -03:00
mod = Py_InitModule4("__builtin__", builtin_methods,
builtin_doc, (PyObject *)NULL,
PYTHON_API_VERSION);
if (mod == NULL)
return NULL;
dict = PyModule_GetDict(mod);
#ifdef Py_TRACE_REFS
/* __builtin__ exposes a number of statically allocated objects
* that, before this code was added in 2.3, never showed up in
* the list of "all objects" maintained by Py_TRACE_REFS. As a
* result, programs leaking references to None and False (etc)
* couldn't be diagnosed by examining sys.getobjects(0).
*/
#define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
#else
#define ADD_TO_ALL(OBJECT) (void)0
#endif
#define SETBUILTIN(NAME, OBJECT) \
if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \
return NULL; \
ADD_TO_ALL(OBJECT)
SETBUILTIN("None", Py_None);
SETBUILTIN("Ellipsis", Py_Ellipsis);
SETBUILTIN("NotImplemented", Py_NotImplemented);
SETBUILTIN("False", Py_False);
SETBUILTIN("True", Py_True);
2002-05-31 16:58:02 -03:00
SETBUILTIN("basestring", &PyBaseString_Type);
SETBUILTIN("bool", &PyBool_Type);
SETBUILTIN("buffer", &PyBuffer_Type);
SETBUILTIN("classmethod", &PyClassMethod_Type);
2001-08-02 01:15:00 -03:00
#ifndef WITHOUT_COMPLEX
SETBUILTIN("complex", &PyComplex_Type);
2001-08-02 01:15:00 -03:00
#endif
SETBUILTIN("dict", &PyDict_Type);
SETBUILTIN("enumerate", &PyEnum_Type);
SETBUILTIN("float", &PyFloat_Type);
SETBUILTIN("frozenset", &PyFrozenSet_Type);
SETBUILTIN("property", &PyProperty_Type);
SETBUILTIN("int", &PyInt_Type);
SETBUILTIN("list", &PyList_Type);
SETBUILTIN("long", &PyLong_Type);
SETBUILTIN("object", &PyBaseObject_Type);
SETBUILTIN("reversed", &PyReversed_Type);
SETBUILTIN("set", &PySet_Type);
SETBUILTIN("slice", &PySlice_Type);
SETBUILTIN("staticmethod", &PyStaticMethod_Type);
SETBUILTIN("str", &PyString_Type);
SETBUILTIN("super", &PySuper_Type);
SETBUILTIN("tuple", &PyTuple_Type);
SETBUILTIN("type", &PyType_Type);
SETBUILTIN("xrange", &PyRange_Type);
/* Note that open() is just an alias of file(). */
SETBUILTIN("open", &PyFile_Type);
SETBUILTIN("file", &PyFile_Type);
#ifdef Py_USING_UNICODE
SETBUILTIN("unicode", &PyUnicode_Type);
#endif
debug = PyBool_FromLong(Py_OptimizeFlag == 0);
if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
Py_XDECREF(debug);
return NULL;
}
Py_XDECREF(debug);
return mod;
#undef ADD_TO_ALL
#undef SETBUILTIN
1990-12-20 11:06:42 -04:00
}
/* Helper for filter(): filter a tuple through a function */
static PyObject *
filtertuple(PyObject *func, PyObject *tuple)
{
PyObject *result;
register int i, j;
int len = PyTuple_Size(tuple);
1995-08-04 01:07:45 -03:00
if (len == 0) {
if (PyTuple_CheckExact(tuple))
Py_INCREF(tuple);
else
tuple = PyTuple_New(0);
1995-08-04 01:07:45 -03:00
return tuple;
}
if ((result = PyTuple_New(len)) == NULL)
return NULL;
for (i = j = 0; i < len; ++i) {
PyObject *item, *good;
int ok;
if (tuple->ob_type->tp_as_sequence &&
tuple->ob_type->tp_as_sequence->sq_item) {
item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i);
if (item == NULL)
goto Fail_1;
} else {
2003-04-23 10:34:35 -03:00
PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple");
goto Fail_1;
}
if (func == Py_None) {
Py_INCREF(item);
good = item;
}
else {
PyObject *arg = PyTuple_Pack(1, item);
if (arg == NULL) {
Py_DECREF(item);
goto Fail_1;
}
good = PyEval_CallObject(func, arg);
Py_DECREF(arg);
if (good == NULL) {
Py_DECREF(item);
goto Fail_1;
}
}
ok = PyObject_IsTrue(good);
Py_DECREF(good);
if (ok) {
if (PyTuple_SetItem(result, j++, item) < 0)
goto Fail_1;
}
else
Py_DECREF(item);
}
if (_PyTuple_Resize(&result, j) < 0)
return NULL;
return result;
Fail_1:
Py_DECREF(result);
return NULL;
}
/* Helper for filter(): filter a string through a function */
static PyObject *
filterstring(PyObject *func, PyObject *strobj)
{
PyObject *result;
register int i, j;
int len = PyString_Size(strobj);
int outlen = len;
if (func == Py_None) {
/* If it's a real string we can return the original,
* as no character is ever false and __getitem__
* does return this character. If it's a subclass
* we must go through the __getitem__ loop */
if (PyString_CheckExact(strobj)) {
Py_INCREF(strobj);
return strobj;
}
}
if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
return NULL;
for (i = j = 0; i < len; ++i) {
PyObject *item;
int ok;
item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
if (item == NULL)
goto Fail_1;
if (func==Py_None) {
ok = 1;
} else {
PyObject *arg, *good;
arg = PyTuple_Pack(1, item);
if (arg == NULL) {
Py_DECREF(item);
goto Fail_1;
}
good = PyEval_CallObject(func, arg);
Py_DECREF(arg);
if (good == NULL) {
Py_DECREF(item);
goto Fail_1;
}
ok = PyObject_IsTrue(good);
Py_DECREF(good);
}
if (ok) {
int reslen;
if (!PyString_Check(item)) {
PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
" __getitem__ returned different type");
Py_DECREF(item);
goto Fail_1;
}
reslen = PyString_GET_SIZE(item);
if (reslen == 1) {
PyString_AS_STRING(result)[j++] =
PyString_AS_STRING(item)[0];
} else {
/* do we need more space? */
int need = j + reslen + len-i-1;
if (need > outlen) {
/* overallocate, to avoid reallocations */
if (need<2*outlen)
need = 2*outlen;
if (_PyString_Resize(&result, need)) {
Py_DECREF(item);
return NULL;
}
outlen = need;
}
memcpy(
PyString_AS_STRING(result) + j,
PyString_AS_STRING(item),
reslen
);
j += reslen;
}
}
Py_DECREF(item);
}
if (j < outlen)
_PyString_Resize(&result, j);
return result;
Fail_1:
Py_DECREF(result);
return NULL;
}
#ifdef Py_USING_UNICODE
/* Helper for filter(): filter a Unicode object through a function */
static PyObject *
filterunicode(PyObject *func, PyObject *strobj)
{
PyObject *result;
register int i, j;
int len = PyUnicode_GetSize(strobj);
int outlen = len;
if (func == Py_None) {
/* If it's a real string we can return the original,
* as no character is ever false and __getitem__
* does return this character. If it's a subclass
* we must go through the __getitem__ loop */
if (PyUnicode_CheckExact(strobj)) {
Py_INCREF(strobj);
return strobj;
}
}
if ((result = PyUnicode_FromUnicode(NULL, len)) == NULL)
return NULL;
for (i = j = 0; i < len; ++i) {
PyObject *item, *arg, *good;
int ok;
item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
if (item == NULL)
goto Fail_1;
if (func == Py_None) {
ok = 1;
} else {
arg = PyTuple_Pack(1, item);
if (arg == NULL) {
Py_DECREF(item);
goto Fail_1;
}
good = PyEval_CallObject(func, arg);
Py_DECREF(arg);
if (good == NULL) {
Py_DECREF(item);
goto Fail_1;
}
ok = PyObject_IsTrue(good);
Py_DECREF(good);
}
if (ok) {
int reslen;
if (!PyUnicode_Check(item)) {
2003-09-16 00:10:59 -03:00
PyErr_SetString(PyExc_TypeError,
"can't filter unicode to unicode:"
" __getitem__ returned different type");
Py_DECREF(item);
goto Fail_1;
}
reslen = PyUnicode_GET_SIZE(item);
2003-09-16 00:10:59 -03:00
if (reslen == 1)
PyUnicode_AS_UNICODE(result)[j++] =
PyUnicode_AS_UNICODE(item)[0];
2003-09-16 00:10:59 -03:00
else {
/* do we need more space? */
2003-09-16 00:10:59 -03:00
int need = j + reslen + len - i - 1;
if (need > outlen) {
2003-09-16 00:10:59 -03:00
/* overallocate,
to avoid reallocations */
if (need < 2 * outlen)
need = 2 * outlen;
if (PyUnicode_Resize(
&result, need) < 0) {
Py_DECREF(item);
goto Fail_1;
}
outlen = need;
}
2003-09-16 00:10:59 -03:00
memcpy(PyUnicode_AS_UNICODE(result) + j,
PyUnicode_AS_UNICODE(item),
reslen*sizeof(Py_UNICODE));
j += reslen;
}
}
Py_DECREF(item);
}
if (j < outlen)
PyUnicode_Resize(&result, j);
return result;
Fail_1:
Py_DECREF(result);
return NULL;
}
#endif