mirror of https://github.com/python/cpython.git
895 lines
18 KiB
C
895 lines
18 KiB
C
/***********************************************************
|
|
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
|
|
Amsterdam, The Netherlands.
|
|
|
|
All Rights Reserved
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
documentation for any purpose and without fee is hereby granted,
|
|
provided that the above copyright notice appear in all copies and that
|
|
both that copyright notice and this permission notice appear in
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
|
Centrum or CWI not be used in advertising or publicity pertaining to
|
|
distribution of the software without specific, written prior permission.
|
|
|
|
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
|
|
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
|
|
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
|
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
******************************************************************/
|
|
|
|
/* Built-in functions */
|
|
|
|
#include "allobjects.h"
|
|
|
|
#include "node.h"
|
|
#include "graminit.h"
|
|
#include "sysmodule.h"
|
|
#include "bltinmodule.h"
|
|
#include "import.h"
|
|
#include "pythonrun.h"
|
|
#include "ceval.h"
|
|
#include "modsupport.h"
|
|
#include "compile.h"
|
|
#include "eval.h"
|
|
|
|
static object *
|
|
builtin_abs(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
number_methods *nm;
|
|
if (v == NULL || (nm = v->ob_type->tp_as_number) == NULL) {
|
|
err_setstr(TypeError, "abs() requires numeric argument");
|
|
return NULL;
|
|
}
|
|
return (*nm->nb_absolute)(v);
|
|
}
|
|
|
|
static object *
|
|
builtin_apply(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *func, *arglist;
|
|
if (!getargs(args, "(OO)", &func, &arglist))
|
|
return NULL;
|
|
return call_object(func, arglist);
|
|
}
|
|
|
|
static object *
|
|
builtin_chr(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
long x;
|
|
char s[1];
|
|
if (!getargs(args, "l", &x))
|
|
return NULL;
|
|
if (x < 0 || x >= 256) {
|
|
err_setstr(ValueError, "chr() arg not in range(256)");
|
|
return NULL;
|
|
}
|
|
s[0] = x;
|
|
return newsizedstringobject(s, 1);
|
|
}
|
|
|
|
static object *
|
|
builtin_cmp(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *a, *b;
|
|
if (!getargs(args, "(OO)", &a, &b))
|
|
return NULL;
|
|
return newintobject((long)cmpobject(a, b));
|
|
}
|
|
|
|
static object *
|
|
builtin_coerce(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v, *w;
|
|
object *res;
|
|
|
|
if (!getargs(args, "(OO)", &v, &w))
|
|
return NULL;
|
|
if (coerce(&v, &w) < 0)
|
|
return NULL;
|
|
res = mkvalue("(OO)", v, w);
|
|
DECREF(v);
|
|
DECREF(w);
|
|
return res;
|
|
}
|
|
|
|
static object *
|
|
builtin_compile(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
char *str;
|
|
char *filename;
|
|
char *startstr;
|
|
int start;
|
|
if (!getargs(args, "(sss)", &str, &filename, &startstr))
|
|
return NULL;
|
|
if (strcmp(startstr, "exec") == 0)
|
|
start = file_input;
|
|
else if (strcmp(startstr, "eval") == 0)
|
|
start = eval_input;
|
|
else {
|
|
err_setstr(ValueError,
|
|
"compile() mode must be 'exec' or 'eval'");
|
|
return NULL;
|
|
}
|
|
return compile_string(str, filename, start);
|
|
}
|
|
|
|
static object *
|
|
builtin_dir(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
object *d;
|
|
if (v == NULL) {
|
|
d = getlocals();
|
|
INCREF(d);
|
|
}
|
|
else {
|
|
d = getattr(v, "__dict__");
|
|
if (d == NULL) {
|
|
err_setstr(TypeError,
|
|
"dir() argument must have __dict__ attribute");
|
|
return NULL;
|
|
}
|
|
}
|
|
if (is_dictobject(d)) {
|
|
v = getdictkeys(d);
|
|
if (sortlist(v) != 0) {
|
|
DECREF(v);
|
|
v = NULL;
|
|
}
|
|
}
|
|
else {
|
|
v = newlistobject(0);
|
|
}
|
|
DECREF(d);
|
|
return v;
|
|
}
|
|
|
|
static object *
|
|
builtin_divmod(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v, *w, *x;
|
|
if (!getargs(args, "(OO)", &v, &w))
|
|
return NULL;
|
|
if (v->ob_type->tp_as_number == NULL ||
|
|
w->ob_type->tp_as_number == NULL) {
|
|
err_setstr(TypeError, "divmod() requires numeric arguments");
|
|
return NULL;
|
|
}
|
|
if (coerce(&v, &w) != 0)
|
|
return NULL;
|
|
x = (*v->ob_type->tp_as_number->nb_divmod)(v, w);
|
|
DECREF(v);
|
|
DECREF(w);
|
|
return x;
|
|
}
|
|
|
|
static object *
|
|
exec_eval(v, start)
|
|
object *v;
|
|
int start;
|
|
{
|
|
object *str = NULL, *globals = NULL, *locals = NULL;
|
|
char *s;
|
|
int n;
|
|
if (v != NULL) {
|
|
if (is_tupleobject(v) &&
|
|
((n = gettuplesize(v)) == 2 || n == 3)) {
|
|
str = gettupleitem(v, 0);
|
|
globals = gettupleitem(v, 1);
|
|
if (n == 3)
|
|
locals = gettupleitem(v, 2);
|
|
}
|
|
else
|
|
str = v;
|
|
}
|
|
if (str == NULL || (!is_stringobject(str) && !is_codeobject(str)) ||
|
|
globals != NULL && !is_dictobject(globals) ||
|
|
locals != NULL && !is_dictobject(locals)) {
|
|
err_setstr(TypeError,
|
|
"exec/eval arguments must be (string|code)[,dict[,dict]]");
|
|
return NULL;
|
|
}
|
|
if (is_codeobject(str))
|
|
return eval_code((codeobject *) str, globals, locals,
|
|
(object *)NULL, (object *)NULL);
|
|
s = getstringvalue(str);
|
|
if (strlen(s) != getstringsize(str)) {
|
|
err_setstr(ValueError, "embedded '\\0' in string arg");
|
|
return NULL;
|
|
}
|
|
if (start == eval_input) {
|
|
while (*s == ' ' || *s == '\t')
|
|
s++;
|
|
}
|
|
return run_string(s, start, globals, locals);
|
|
}
|
|
|
|
static object *
|
|
builtin_eval(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
return exec_eval(v, eval_input);
|
|
}
|
|
|
|
static object *
|
|
builtin_exec(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
return exec_eval(v, file_input);
|
|
}
|
|
|
|
static object *
|
|
builtin_execfile(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
object *str = NULL, *globals = NULL, *locals = NULL, *w;
|
|
FILE* fp;
|
|
char *s;
|
|
int n;
|
|
if (v != NULL) {
|
|
if (is_stringobject(v))
|
|
str = v;
|
|
else if (is_tupleobject(v) &&
|
|
((n = gettuplesize(v)) == 2 || n == 3)) {
|
|
str = gettupleitem(v, 0);
|
|
globals = gettupleitem(v, 1);
|
|
if (n == 3)
|
|
locals = gettupleitem(v, 2);
|
|
}
|
|
}
|
|
if (str == NULL || !is_stringobject(str) ||
|
|
globals != NULL && !is_dictobject(globals) ||
|
|
locals != NULL && !is_dictobject(locals)) {
|
|
err_setstr(TypeError,
|
|
"execfile arguments must be filename[,dict[,dict]]");
|
|
return NULL;
|
|
}
|
|
s = getstringvalue(str);
|
|
if (strlen(s) != getstringsize(str)) {
|
|
err_setstr(ValueError, "embedded '\\0' in string arg");
|
|
return NULL;
|
|
}
|
|
BGN_SAVE
|
|
fp = fopen(s, "r");
|
|
END_SAVE
|
|
if (fp == NULL) {
|
|
err_setstr(IOError, "execfile cannot open the file argument");
|
|
return NULL;
|
|
}
|
|
w = run_file(fp, getstringvalue(str), file_input, globals, locals);
|
|
BGN_SAVE
|
|
fclose(fp);
|
|
END_SAVE
|
|
return w;
|
|
}
|
|
|
|
static object *
|
|
builtin_float(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
number_methods *nb;
|
|
|
|
if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
|
|
nb->nb_float == NULL) {
|
|
err_setstr(TypeError,
|
|
"float() argument can't be converted to float");
|
|
return NULL;
|
|
}
|
|
return (*nb->nb_float)(v);
|
|
}
|
|
|
|
static object *
|
|
builtin_getattr(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v;
|
|
object *name;
|
|
if (!getargs(args, "(OS)", &v, &name))
|
|
return NULL;
|
|
return getattro(v, name);
|
|
}
|
|
|
|
static object *
|
|
builtin_hasattr(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v;
|
|
object *name;
|
|
if (!getargs(args, "(OS)", &v, &name))
|
|
return NULL;
|
|
v = getattro(v, name);
|
|
if (v == NULL) {
|
|
err_clear();
|
|
return newintobject(0L);
|
|
}
|
|
DECREF(v);
|
|
return newintobject(1L);
|
|
}
|
|
|
|
static object *
|
|
builtin_id(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v;
|
|
if (!getargs(args, "O", &v))
|
|
return NULL;
|
|
return newintobject((long)v);
|
|
}
|
|
|
|
static object *
|
|
builtin_setattr(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v;
|
|
object *name;
|
|
object *value;
|
|
if (!getargs(args, "(OSO)", &v, &name, &value))
|
|
return NULL;
|
|
if (setattro(v, name, value) != 0)
|
|
return NULL;
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
builtin_hash(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v;
|
|
long x;
|
|
if (!getargs(args, "O", &v))
|
|
return NULL;
|
|
x = hashobject(v);
|
|
if (x == -1)
|
|
return NULL;
|
|
return newintobject(x);
|
|
}
|
|
|
|
static object *
|
|
builtin_hex(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
number_methods *nb;
|
|
|
|
if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
|
|
nb->nb_hex == NULL) {
|
|
err_setstr(TypeError,
|
|
"hex() argument can't be converted to hex");
|
|
return NULL;
|
|
}
|
|
return (*nb->nb_hex)(v);
|
|
}
|
|
|
|
static object *builtin_raw_input PROTO((object *, object *));
|
|
|
|
static object *
|
|
builtin_input(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
object *line = builtin_raw_input(self, v);
|
|
if (line == NULL)
|
|
return line;
|
|
v = exec_eval(line, eval_input);
|
|
DECREF(line);
|
|
return v;
|
|
}
|
|
|
|
static object *
|
|
builtin_int(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
number_methods *nb;
|
|
|
|
if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
|
|
nb->nb_int == NULL) {
|
|
err_setstr(TypeError,
|
|
"int() argument can't be converted to int");
|
|
return NULL;
|
|
}
|
|
return (*nb->nb_int)(v);
|
|
}
|
|
|
|
static object *
|
|
builtin_len(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
long len;
|
|
typeobject *tp;
|
|
if (v == NULL) {
|
|
err_setstr(TypeError, "len() without argument");
|
|
return NULL;
|
|
}
|
|
tp = v->ob_type;
|
|
if (tp->tp_as_sequence != NULL) {
|
|
len = (*tp->tp_as_sequence->sq_length)(v);
|
|
}
|
|
else if (tp->tp_as_mapping != NULL) {
|
|
len = (*tp->tp_as_mapping->mp_length)(v);
|
|
}
|
|
else {
|
|
err_setstr(TypeError, "len() of unsized object");
|
|
return NULL;
|
|
}
|
|
if (len < 0)
|
|
return NULL;
|
|
else
|
|
return newintobject(len);
|
|
}
|
|
|
|
static object *
|
|
builtin_long(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
number_methods *nb;
|
|
|
|
if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
|
|
nb->nb_long == NULL) {
|
|
err_setstr(TypeError,
|
|
"long() argument can't be converted to long");
|
|
return NULL;
|
|
}
|
|
return (*nb->nb_long)(v);
|
|
}
|
|
|
|
static object *
|
|
min_max(v, sign)
|
|
object *v;
|
|
int sign;
|
|
{
|
|
int i, n, cmp;
|
|
object *w, *x;
|
|
sequence_methods *sq;
|
|
if (v == NULL) {
|
|
err_setstr(TypeError, "min() or max() without argument");
|
|
return NULL;
|
|
}
|
|
sq = v->ob_type->tp_as_sequence;
|
|
if (sq == NULL) {
|
|
err_setstr(TypeError, "min() or max() of non-sequence");
|
|
return NULL;
|
|
}
|
|
n = (*sq->sq_length)(v);
|
|
if (n < 0)
|
|
return NULL;
|
|
if (n == 0) {
|
|
err_setstr(ValueError, "min() or max() of empty sequence");
|
|
return NULL;
|
|
}
|
|
w = (*sq->sq_item)(v, 0); /* Implies INCREF */
|
|
for (i = 1; i < n; i++) {
|
|
x = (*sq->sq_item)(v, i); /* Implies INCREF */
|
|
cmp = cmpobject(x, w);
|
|
if (cmp * sign > 0) {
|
|
DECREF(w);
|
|
w = x;
|
|
}
|
|
else
|
|
DECREF(x);
|
|
}
|
|
return w;
|
|
}
|
|
|
|
static object *
|
|
builtin_min(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
return min_max(v, -1);
|
|
}
|
|
|
|
static object *
|
|
builtin_max(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
return min_max(v, 1);
|
|
}
|
|
|
|
static object *
|
|
builtin_oct(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
number_methods *nb;
|
|
|
|
if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
|
|
nb->nb_oct == NULL) {
|
|
err_setstr(TypeError,
|
|
"oct() argument can't be converted to oct");
|
|
return NULL;
|
|
}
|
|
return (*nb->nb_oct)(v);
|
|
}
|
|
|
|
static object *
|
|
builtin_open(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
char *name, *mode;
|
|
if (!getargs(args, "(ss)", &name, &mode))
|
|
return NULL;
|
|
return newfileobject(name, mode);
|
|
}
|
|
|
|
static object *
|
|
builtin_ord(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
char *s;
|
|
int len;
|
|
if (!getargs(args, "s#", &s, &len))
|
|
return NULL;
|
|
if (len != 1) {
|
|
err_setstr(ValueError, "ord() arg must have length 1");
|
|
return NULL;
|
|
}
|
|
return newintobject((long)(s[0] & 0xff));
|
|
}
|
|
|
|
static object *
|
|
builtin_pow(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v, *w, *x;
|
|
if (!getargs(args, "(OO)", &v, &w))
|
|
return NULL;
|
|
if (v->ob_type->tp_as_number == NULL ||
|
|
w->ob_type->tp_as_number == NULL) {
|
|
err_setstr(TypeError, "pow() requires numeric arguments");
|
|
return NULL;
|
|
}
|
|
if (coerce(&v, &w) != 0)
|
|
return NULL;
|
|
x = (*v->ob_type->tp_as_number->nb_power)(v, w);
|
|
DECREF(v);
|
|
DECREF(w);
|
|
return x;
|
|
}
|
|
|
|
static object *
|
|
builtin_range(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
static char *errmsg = "range() requires 1-3 int arguments";
|
|
int i, n;
|
|
long ilow, ihigh, istep;
|
|
if (v != NULL && is_intobject(v)) {
|
|
ilow = 0; ihigh = getintvalue(v); istep = 1;
|
|
}
|
|
else if (v == NULL || !is_tupleobject(v)) {
|
|
err_setstr(TypeError, errmsg);
|
|
return NULL;
|
|
}
|
|
else {
|
|
n = gettuplesize(v);
|
|
if (n < 1 || n > 3) {
|
|
err_setstr(TypeError, errmsg);
|
|
return NULL;
|
|
}
|
|
for (i = 0; i < n; i++) {
|
|
if (!is_intobject(gettupleitem(v, i))) {
|
|
err_setstr(TypeError, errmsg);
|
|
return NULL;
|
|
}
|
|
}
|
|
if (n == 3) {
|
|
istep = getintvalue(gettupleitem(v, 2));
|
|
--n;
|
|
}
|
|
else
|
|
istep = 1;
|
|
ihigh = getintvalue(gettupleitem(v, --n));
|
|
if (n > 0)
|
|
ilow = getintvalue(gettupleitem(v, 0));
|
|
else
|
|
ilow = 0;
|
|
}
|
|
if (istep == 0) {
|
|
err_setstr(ValueError, "zero step for range()");
|
|
return NULL;
|
|
}
|
|
/* XXX ought to check overflow of subtraction */
|
|
if (istep > 0)
|
|
n = (ihigh - ilow + istep - 1) / istep;
|
|
else
|
|
n = (ihigh - ilow + istep + 1) / istep;
|
|
if (n < 0)
|
|
n = 0;
|
|
v = newlistobject(n);
|
|
if (v == NULL)
|
|
return NULL;
|
|
for (i = 0; i < n; i++) {
|
|
object *w = newintobject(ilow);
|
|
if (w == NULL) {
|
|
DECREF(v);
|
|
return NULL;
|
|
}
|
|
setlistitem(v, i, w);
|
|
ilow += istep;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
static object *
|
|
builtin_raw_input(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
object *f = sysget("stdout");
|
|
if (f == NULL) {
|
|
err_setstr(RuntimeError, "lost sys.stdout");
|
|
return NULL;
|
|
}
|
|
flushline();
|
|
if (v != NULL) {
|
|
if (writeobject(v, f, PRINT_RAW) != 0)
|
|
return NULL;
|
|
}
|
|
return filegetline(sysget("stdin"), -1);
|
|
}
|
|
|
|
static object *
|
|
builtin_reload(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
return reload_module(v);
|
|
}
|
|
|
|
static object *
|
|
builtin_repr(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
if (v == NULL) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
return reprobject(v);
|
|
}
|
|
|
|
static object *
|
|
builtin_round(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
extern double floor PROTO((double));
|
|
extern double ceil PROTO((double));
|
|
double x;
|
|
double f;
|
|
int ndigits = 0;
|
|
int sign = 1;
|
|
int i;
|
|
if (!getargs(args, "d", &x)) {
|
|
err_clear();
|
|
if (!getargs(args, "(di)", &x, &ndigits))
|
|
return NULL;
|
|
}
|
|
f = 1.0;
|
|
for (i = ndigits; --i >= 0; )
|
|
f = f*10.0;
|
|
for (i = ndigits; ++i <= 0; )
|
|
f = f*0.1;
|
|
if (x >= 0.0)
|
|
return newfloatobject(floor(x*f + 0.5) / f);
|
|
else
|
|
return newfloatobject(ceil(x*f - 0.5) / f);
|
|
}
|
|
|
|
static object *
|
|
builtin_str(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
if (v == NULL) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
if (is_stringobject(v)) {
|
|
INCREF(v);
|
|
return v;
|
|
}
|
|
else
|
|
return reprobject(v);
|
|
}
|
|
|
|
static object *
|
|
builtin_type(self, v)
|
|
object *self;
|
|
object *v;
|
|
{
|
|
if (v == NULL) {
|
|
err_setstr(TypeError, "type() requires an argument");
|
|
return NULL;
|
|
}
|
|
v = (object *)v->ob_type;
|
|
INCREF(v);
|
|
return v;
|
|
}
|
|
|
|
static struct methodlist builtin_methods[] = {
|
|
{"abs", builtin_abs},
|
|
{"apply", builtin_apply},
|
|
{"chr", builtin_chr},
|
|
{"cmp", builtin_cmp},
|
|
{"coerce", builtin_coerce},
|
|
{"compile", builtin_compile},
|
|
{"dir", builtin_dir},
|
|
{"divmod", builtin_divmod},
|
|
{"eval", builtin_eval},
|
|
{"exec", builtin_exec},
|
|
{"execfile", builtin_execfile},
|
|
{"float", builtin_float},
|
|
{"getattr", builtin_getattr},
|
|
{"hasattr", builtin_hasattr},
|
|
{"hash", builtin_hash},
|
|
{"hex", builtin_hex},
|
|
{"id", builtin_id},
|
|
{"input", builtin_input},
|
|
{"int", builtin_int},
|
|
{"len", builtin_len},
|
|
{"long", builtin_long},
|
|
{"max", builtin_max},
|
|
{"min", builtin_min},
|
|
{"oct", builtin_oct},
|
|
{"open", builtin_open},
|
|
{"ord", builtin_ord},
|
|
{"pow", builtin_pow},
|
|
{"range", builtin_range},
|
|
{"raw_input", builtin_raw_input},
|
|
{"reload", builtin_reload},
|
|
{"repr", builtin_repr},
|
|
{"round", builtin_round},
|
|
{"setattr", builtin_setattr},
|
|
{"str", builtin_str},
|
|
{"type", builtin_type},
|
|
{NULL, NULL},
|
|
};
|
|
|
|
static object *builtin_dict;
|
|
|
|
object *
|
|
getbuiltin(name)
|
|
object *name;
|
|
{
|
|
return dict2lookup(builtin_dict, name);
|
|
}
|
|
|
|
/* Predefined exceptions */
|
|
|
|
object *AccessError;
|
|
object *AttributeError;
|
|
object *ConflictError;
|
|
object *EOFError;
|
|
object *IOError;
|
|
object *ImportError;
|
|
object *IndexError;
|
|
object *KeyError;
|
|
object *KeyboardInterrupt;
|
|
object *MemoryError;
|
|
object *NameError;
|
|
object *OverflowError;
|
|
object *RuntimeError;
|
|
object *SyntaxError;
|
|
object *SystemError;
|
|
object *SystemExit;
|
|
object *TypeError;
|
|
object *ValueError;
|
|
object *ZeroDivisionError;
|
|
|
|
static object *
|
|
newstdexception(name)
|
|
char *name;
|
|
{
|
|
object *v = newstringobject(name);
|
|
if (v == NULL || dictinsert(builtin_dict, name, v) != 0)
|
|
fatal("no mem for new standard exception");
|
|
return v;
|
|
}
|
|
|
|
static void
|
|
initerrors()
|
|
{
|
|
AccessError = newstdexception("AccessError");
|
|
AttributeError = newstdexception("AttributeError");
|
|
ConflictError = newstdexception("ConflictError");
|
|
EOFError = newstdexception("EOFError");
|
|
IOError = newstdexception("IOError");
|
|
ImportError = newstdexception("ImportError");
|
|
IndexError = newstdexception("IndexError");
|
|
KeyError = newstdexception("KeyError");
|
|
KeyboardInterrupt = newstdexception("KeyboardInterrupt");
|
|
MemoryError = newstdexception("MemoryError");
|
|
NameError = newstdexception("NameError");
|
|
OverflowError = newstdexception("OverflowError");
|
|
RuntimeError = newstdexception("RuntimeError");
|
|
SyntaxError = newstdexception("SyntaxError");
|
|
SystemError = newstdexception("SystemError");
|
|
SystemExit = newstdexception("SystemExit");
|
|
TypeError = newstdexception("TypeError");
|
|
ValueError = newstdexception("ValueError");
|
|
ZeroDivisionError = newstdexception("ZeroDivisionError");
|
|
}
|
|
|
|
void
|
|
initbuiltin()
|
|
{
|
|
object *m;
|
|
m = initmodule("builtin", builtin_methods);
|
|
builtin_dict = getmoduledict(m);
|
|
INCREF(builtin_dict);
|
|
initerrors();
|
|
(void) dictinsert(builtin_dict, "None", None);
|
|
}
|
|
|
|
/* Coerce two numeric types to the "larger" one.
|
|
Increment the reference count on each argument.
|
|
Return -1 and raise an exception if no coercion is possible
|
|
(and then no reference count is incremented).
|
|
*/
|
|
|
|
int
|
|
coerce(pv, pw)
|
|
object **pv, **pw;
|
|
{
|
|
register object *v = *pv;
|
|
register object *w = *pw;
|
|
int res;
|
|
|
|
if (v->ob_type == w->ob_type && !is_instanceobject(v)) {
|
|
INCREF(v);
|
|
INCREF(w);
|
|
return 0;
|
|
}
|
|
if (v->ob_type->tp_as_number && v->ob_type->tp_as_number->nb_coerce) {
|
|
res = (*v->ob_type->tp_as_number->nb_coerce)(pv, pw);
|
|
if (res <= 0)
|
|
return res;
|
|
}
|
|
if (w->ob_type->tp_as_number && w->ob_type->tp_as_number->nb_coerce) {
|
|
res = (*w->ob_type->tp_as_number->nb_coerce)(pw, pv);
|
|
if (res <= 0)
|
|
return res;
|
|
}
|
|
err_setstr(TypeError, "number coercion failed");
|
|
return -1;
|
|
}
|