/* Evaluate compiled expression nodes */

#include <stdio.h>

#include <ctype.h>

#include "string.h"

#include "PROTO.h"

#include "object.h"

#include "objimpl.h"

#include "intobject.h"

#include "stringobject.h"

#include "tupleobject.h"

#include "listobject.h"

#include "dictobject.h"

#include "builtinobject.h"

#include "methodobject.h"

#include "moduleobject.h"

#include "context.h"

#include "funcobject.h"

#include "classobject.h"

#include "token.h"

#include "graminit.h"

#include "run.h"

#include "import.h"

#include "support.h"

#include "sysmodule.h"

#include "compile.h"

#include "opcode.h"

/* List access macros */

#ifdef NDEBUG

#define GETITEM(v, i) GETLISTITEM((listobject *)(v), (i))

#define GETITEMNAME(v, i) GETSTRINGVALUE((stringobject *)GETITEM((v), (i)))

#else

#define GETITEM(v, i) getlistitem((v), (i))

#define GETITEMNAME(v, i) getstringvalue(getlistitem((v), (i)))

#endif

typedef struct {

int b_type; /* what kind of block this is */

int b_handler; /* where to jump to find handler */

int b_level; /* value stack level to pop to */

} block;

typedef struct _frame {

OB_HEAD

struct _frame *f_back; /* previous frame, or NULL */

codeobject *f_code; /* code segment */

object *f_locals; /* local symbol table (dictobject) */

object *f_globals; /* global symbol table (dictobject) */

object **f_valuestack; /* malloc'ed array */

block *f_blockstack; /* malloc'ed array */

int f_nvalues; /* size of f_valuestack */

int f_nblocks; /* size of f_blockstack */

int f_ivalue; /* index in f_valuestack */

int f_iblock; /* index in f_blockstack */

int f_nexti; /* index in f_code (next instruction) */

} frameobject;

#define is_frameobject(op) ((op)->ob_type == &Frametype)

static void

frame_dealloc(f)

frameobject *f;

{

XDECREF(f->f_back);

XDECREF(f->f_code);

XDECREF(f->f_locals);

XDECREF(f->f_globals);

XDEL(f->f_valuestack);

XDEL(f->f_blockstack);

DEL(f);

}

typeobject Frametype = {

OB_HEAD_INIT(&Typetype)

0,

"frame",

sizeof(frameobject),

0,

frame_dealloc, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_compare*/

0, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

};

static frameobject * newframeobject PROTO(

(frameobject *, codeobject *, object *, object *, int, int));

static frameobject *

newframeobject(back, code, locals, globals, nvalues, nblocks)

frameobject *back;

codeobject *code;

object *locals;

object *globals;

int nvalues;

int nblocks;

{

frameobject *f;

if ((back != NULL && !is_frameobject(back)) ||

code == NULL || !is_codeobject(code) ||

locals == NULL || !is_dictobject(locals) ||

globals == NULL || !is_dictobject(globals) ||

nvalues < 0 || nblocks < 0) {

err_badcall();

return NULL;

}

f = NEWOBJ(frameobject, &Frametype);

if (f != NULL) {

if (back)

INCREF(back);

f->f_back = back;

INCREF(code);

f->f_code = code;

INCREF(locals);

f->f_locals = locals;

INCREF(globals);

f->f_globals = globals;

f->f_valuestack = NEW(object *, nvalues+1);

f->f_blockstack = NEW(block, nblocks+1);

f->f_nvalues = nvalues;

f->f_nblocks = nblocks;

f->f_ivalue = f->f_iblock = f->f_nexti = 0;

if (f->f_valuestack == NULL || f->f_blockstack == NULL) {

err_nomem();

DECREF(f);

f = NULL;

}

}

return f;

}

#define GETUSTRINGVALUE(s) ((unsigned char *)GETSTRINGVALUE(s))

#define Push(f, v) ((f)->f_valuestack[(f)->f_ivalue++] = (v))

#define Pop(f) ((f)->f_valuestack[--(f)->f_ivalue])

#define Top(f) ((f)->f_valuestack[(f)->f_ivalue-1])

#define Empty(f) ((f)->f_ivalue == 0)

#define Full(f) ((f)->f_ivalue == (f)->f_nvalues)

#define Nextbyte(f) (GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti++])

#define Peekbyte(f) (GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti])

#define Peekint(f) \

(GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti] + \

GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti+1])

#define Prevbyte(f) (GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti-1])

#define Jumpto(f, x) ((f)->f_nexti = (x))

#define Jumpby(f, x) ((f)->f_nexti += (x))

#define Getconst(f, i) (GETITEM((f)->f_code->co_consts, (i)))

#define Getname(f, i) (GETITEMNAME((f)->f_code->co_names, (i)))

/* Corresponding functions, for debugging */

static void

push(f, v)

frameobject *f;

object *v;

{

if (Full(f)) {

printf("stack overflow\n");

abort();

}

Push(f, v);

}

static object *

pop(f)

frameobject *f;

{

if (Empty(f)) {

printf("stack underflow\n");

abort();

}

return Pop(f);

}

static object *

top(f)

frameobject *f;

{

if (Empty(f)) {

printf("stack underflow\n");

abort();

}

return Top(f);

}

static int

nextbyte(f)

frameobject *f;

{

stringobject *code = (f)->f_code->co_code;

if (f->f_nexti >= getstringsize((object *)code)) {

printf("ran off end of instructions\n");

abort();

}

return GETUSTRINGVALUE(code)[f->f_nexti++];

}

static int

nextint(f)

frameobject *f;

{

int a, b;

#ifdef NDEBUG

a = Nextbyte(f);

b = Nextbyte(f);

#else

a = nextbyte(f);

b = nextbyte(f);

#endif

return a + (b << 8);

}

/* Tracing versions */

static void

trace_push(f, v)

frameobject *f;

object *v;

{

printf("\tpush ");

printobject(v, stdout, 0);

printf("\n");

push(f, v);

}

static object *

trace_pop(f)

frameobject *f;

{

object *v;

v = pop(f);

printf("\tpop ");

printobject(v, stdout, 0);

printf("\n");

return v;

}

static object *

trace_top(f)

frameobject *f;

{

object *v;

v = top(f);

printf("\ttop ");

printobject(v, stdout, 0);

printf("\n");

return v;

}

static int

trace_nextop(f)

frameobject *f;

{

int op;

int arg;

printf("%d: ", f->f_nexti);

op = nextbyte(f);

if (op < HAVE_ARGUMENT)

printf("op %3d\n", op);

else {

arg = Peekint(f);

printf("op %d arg %d\n", op, arg);

}

return op;

}

/* Block management */

static void

setup_block(f, type, handler)

frameobject *f;

int type;

int handler;

{

block *b;

if (f->f_iblock >= f->f_nblocks) {

printf("block stack overflow\n");

abort();

}

b = &f->f_blockstack[f->f_iblock++];

b->b_type = type;

b->b_level = f->f_ivalue;

b->b_handler = handler + f->f_nexti;

}

static block *

pop_block(f)

frameobject *f;

{

block *b;

if (f->f_iblock <= 0) {

printf("block stack underflow\n");

abort();

}

b = &f->f_blockstack[--f->f_iblock];

while (f->f_ivalue > b->b_level) {

object *v = Pop(f);

XDECREF(v);

}

return b;

}

/* XXX Mixing "print ...," and direct file I/O on stdin/stdout

XXX has some bad consequences. The needspace flag should

XXX really be part of the file object. */

static int needspace;

void

flushline()

{

FILE *fp = sysgetfile("stdout", stdout);

if (needspace) {

fprintf(fp, "\n");

needspace = 0;

}

}

static object *

checkerror(ctx, v)

context *ctx;

object *v;

{

if (v == NULL)

puterrno(ctx);

return v;

}

static object *

add(ctx, v, w)

context *ctx;

object *v, *w;

{

if (v->ob_type->tp_as_number != NULL)

v = (*v->ob_type->tp_as_number->nb_add)(v, w);

else if (v->ob_type->tp_as_sequence != NULL)

v = (*v->ob_type->tp_as_sequence->sq_concat)(v, w);

else {

type_error(ctx, "+ not supported by operands");

return NULL;

}

return checkerror(ctx, v);

}

static object *

sub(ctx, v, w)

context *ctx;

object *v, *w;

{

if (v->ob_type->tp_as_number != NULL)

return checkerror(ctx,

(*v->ob_type->tp_as_number->nb_subtract)(v, w));

type_error(ctx, "bad operand type(s) for -");

return NULL;

}

static object *

mul(ctx, v, w)

context *ctx;

object *v, *w;

{

typeobject *tp;

if (is_intobject(v) && w->ob_type->tp_as_sequence != NULL) {

/* int*sequence -- swap v and w */

object *tmp = v;

v = w;

w = tmp;

}

tp = v->ob_type;

if (tp->tp_as_number != NULL)

return checkerror(ctx, (*tp->tp_as_number->nb_multiply)(v, w));

if (tp->tp_as_sequence != NULL) {

if (!is_intobject(w)) {

type_error(ctx, "can't multiply sequence with non-int");

return NULL;

}

if (tp->tp_as_sequence->sq_repeat == NULL) {

type_error(ctx, "sequence does not support *");

return NULL;

}

return checkerror(ctx, (*tp->tp_as_sequence->sq_repeat)

(v, (int)getintvalue(w)));

}

type_error(ctx, "bad operand type(s) for *");

return NULL;

}

static object *

div(ctx, v, w)

context *ctx;

object *v, *w;

{

if (v->ob_type->tp_as_number != NULL)

return checkerror(ctx,

(*v->ob_type->tp_as_number->nb_divide)(v, w));

type_error(ctx, "bad operand type(s) for /");

return NULL;

}

static object *

rem(ctx, v, w)

context *ctx;

object *v, *w;

{

if (v->ob_type->tp_as_number != NULL)

return checkerror(ctx,

(*v->ob_type->tp_as_number->nb_remainder)(v, w));

type_error(ctx, "bad operand type(s) for %");

return NULL;

}

static object *

neg(ctx, v)

context *ctx;

object *v;

{

if (v->ob_type->tp_as_number != NULL)

return checkerror(ctx,

(*v->ob_type->tp_as_number->nb_negative)(v));

type_error(ctx, "bad operand type(s) for unary -");

return NULL;

}

static object *

pos(ctx, v)

context *ctx;

object *v;

{

if (v->ob_type->tp_as_number != NULL)

return checkerror(ctx,

(*v->ob_type->tp_as_number->nb_positive)(v));

type_error(ctx, "bad operand type(s) for unary +");

return NULL;

}

static object *

not(ctx, v)

context *ctx;

object *v;

{

int outcome = testbool(ctx, v);

if (ctx->ctx_exception)

return NULL;

return checkerror(ctx, newintobject((long) !outcome));

}

static object *

call_builtin(ctx, func, args)

context *ctx;

object *func;

object *args;

{

if (is_builtinobject(func)) {

function funcptr = getbuiltinfunction(func);

return (*funcptr)(ctx, args);

}

if (is_methodobject(func)) {

method meth = getmethod(func);

object *self = getself(func);

return checkerror(ctx, (*meth)(self, args));

}

if (is_classobject(func)) {

if (args != NULL) {

type_error(ctx, "classobject() allows no arguments");

return NULL;

}

return checkerror(ctx, newclassmemberobject(func));

}

type_error(ctx, "call of non-function");

return NULL;

}

static object *eval_compiled PROTO((context *, codeobject *, object *, int));

/* XXX Eventually, this should not call eval_compiled recursively

but create a new frame */

static object *

call_function(ctx, func, args)

context *ctx;

object *func;

object *args;

{

object *newargs = NULL;

object *savelocals, *newlocals, *saveglobals;

object *c, *v;

if (is_classmethodobject(func)) {

object *self = classmethodgetself(func);

func = classmethodgetfunc(func);

if (args == NULL) {

args = self;

}

else {

newargs = checkerror(ctx, newtupleobject(2));

if (newargs == NULL)

return NULL;

INCREF(self);

INCREF(args);

settupleitem(newargs, 0, self);

settupleitem(newargs, 1, args);

args = newargs;

}

}

else {

if (!is_funcobject(func)) {

type_error(ctx, "call of non-function");

return NULL;

}

}

c = checkerror(ctx, getfunccode(func));

if (c == NULL) {

XDECREF(newargs);

return NULL;

}

if (!is_codeobject(c)) {

printf("Bad code\n");

abort();

}

newlocals = checkerror(ctx, newdictobject());

if (newlocals == NULL) {

XDECREF(newargs);

return NULL;

}

savelocals = ctx->ctx_locals;

ctx->ctx_locals = newlocals;

saveglobals = ctx->ctx_globals;

ctx->ctx_globals = getfuncglobals(func);

v = eval_compiled(ctx, (codeobject *)c, args, 1);

DECREF(ctx->ctx_locals);

ctx->ctx_locals = savelocals;

ctx->ctx_globals = saveglobals;

XDECREF(newargs);

return v;

}

static object *

apply_subscript(ctx, v, w)

context *ctx;

object *v, *w;

{

typeobject *tp = v->ob_type;

if (tp->tp_as_sequence == NULL && tp->tp_as_mapping == NULL) {

type_error(ctx, "unsubscriptable object");

return NULL;

}

if (tp->tp_as_sequence != NULL) {

int i;

if (!is_intobject(w)) {

type_error(ctx, "sequence subscript not int");

return NULL;

}

i = getintvalue(w);

return checkerror(ctx, (*tp->tp_as_sequence->sq_item)(v, i));

}

return checkerror(ctx, (*tp->tp_as_mapping->mp_subscript)(v, w));

}

static object *

loop_subscript(ctx, v, w)

context *ctx;

object *v, *w;

{

sequence_methods *sq = v->ob_type->tp_as_sequence;

int i, n;

if (sq == NULL) {

type_error(ctx, "loop over non-sequence");

return NULL;

}

i = getintvalue(w);

n = (*sq->sq_length)(v);

if (i >= n)

return NULL; /* End of loop */

return checkerror(ctx, (*sq->sq_item)(v, i));

}

static int

slice_index(ctx, v, isize, pi)

context *ctx;

object *v;

int isize;

int *pi;

{

if (v != NULL) {

if (!is_intobject(v)) {

type_error(ctx, "slice index must be int");

return 0;

}

*pi = getintvalue(v);

if (*pi < 0)

*pi += isize;

}

return 1;

}

static object *

apply_slice(ctx, u, v, w) /* u[v:w] */

context *ctx;

object *u, *v, *w;

{

typeobject *tp = u->ob_type;

int ilow, ihigh, isize;

if (tp->tp_as_sequence == NULL) {

type_error(ctx, "only sequences can be sliced");

return NULL;

}

ilow = 0;

isize = ihigh = (*tp->tp_as_sequence->sq_length)(u);

if (!slice_index(ctx, v, isize, &ilow))

return NULL;

if (!slice_index(ctx, w, isize, &ihigh))

return NULL;

return checkerror(ctx, (*tp->tp_as_sequence->sq_slice)(u, ilow, ihigh));

}

static void

assign_subscript(ctx, w, key, v)

context *ctx;

object *w;

object *key;

object *v;

{

typeobject *tp = w->ob_type;

sequence_methods *sq;

mapping_methods *mp;

int (*func)();

int err;

if ((sq = tp->tp_as_sequence) != NULL &&

(func = sq->sq_ass_item) != NULL) {

if (!is_intobject(key)) {

type_error(ctx, "sequence subscript must be integer");

return;

}

err = (*func)(w, (int)getintvalue(key), v);

}

else if ((mp = tp->tp_as_mapping) != NULL &&

(func = mp->mp_ass_subscript) != NULL) {

err = (*func)(w, key, v);

}

else {

type_error(ctx, "can't assign to this subscripted object");

return;

}

if (err != 0)

puterrno(ctx);

}

static void

assign_slice(ctx, u, v, w, x) /* u[v:w] = x */

context *ctx;

object *u, *v, *w, *x;

{

typeobject *tp = u->ob_type;

int ilow, ihigh, isize;

if (tp->tp_as_sequence == NULL ||

tp->tp_as_sequence->sq_ass_slice == NULL) {

type_error(ctx, "unassignable slice");

return;

}

ilow = 0;

isize = ihigh = (*tp->tp_as_sequence->sq_length)(u);

if (!slice_index(ctx, v, isize, &ilow))

return;

if (!slice_index(ctx, w, isize, &ihigh))

return;

if ((*tp->tp_as_sequence->sq_ass_slice)(u, ilow, ihigh, x) != 0)

puterrno(ctx);

}

static int

cmp_exception(err, v)

object *err, *v;

{

if (is_tupleobject(v)) {

int i, n;

n = gettuplesize(v);

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

if (err == gettupleitem(v, i))

return 1;

}

return 0;

}

return err == v;

}

static object *

cmp_outcome(ctx, op, v, w)

register context *ctx;

enum cmp_op op;

register object *v;

register object *w;

{

register int cmp;

register int res = 0;

switch (op) {

case IN:

case NOT_IN:

cmp = cmp_member(ctx, v, w);

break;

case IS:

case IS_NOT:

cmp = (v == w);

break;

case EXC_MATCH:

cmp = cmp_exception(v, w);

break;

default:

cmp = cmp_values(ctx, v, w);

}

if (ctx->ctx_exception)

return NULL;

switch (op) {

case EXC_MATCH:

case IS:

case IN: res = cmp; break;

case IS_NOT:

case NOT_IN: res = !cmp; break;

case LT: res = cmp < 0; break;

case LE: res = cmp <= 0; break;

case EQ: res = cmp == 0; break;

case NE: res = cmp != 0; break;

case GT: res = cmp > 0; break;

case GE: res = cmp >= 0; break;

/* XXX no default? */

}

v = res ? True : False;

INCREF(v);

return v;

}

static void

import_from(ctx, v, name)

context *ctx;

object *v;

char *name;

{

object *w, *x;

w = getmoduledict(v);

if (name[0] == '*') {

int i;

int n = getdictsize(w);

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

name = getdictkey(w, i);

if (name == NULL || name[0] == '_')

continue;

x = dictlookup(w, name);

if (x == NULL) {

/* XXX can't happen? */

name_error(ctx, name);

break;

}

if (dictinsert(ctx->ctx_locals, name, x) != 0) {

puterrno(ctx);

break;

}

}

}

else {

x = dictlookup(w, name);

if (x == NULL)

name_error(ctx, name);

else if (dictinsert(ctx->ctx_locals, name, x) != 0)

puterrno(ctx);

}

}

static object *

build_class(ctx, v, w)

context *ctx;

object *v; /* None or tuple containing base classes */

object *w; /* dictionary */

{

if (is_tupleobject(v)) {

int i;

for (i = gettuplesize(v); --i >= 0; ) {

object *x = gettupleitem(v, i);

if (!is_classobject(x)) {

type_error(ctx, "base is not a class object");

return NULL;

}

}

}

else {

v = NULL;

}

if (!is_dictobject(w)) {

sys_error(ctx, "build_class with non-dictionary");

return NULL;

}

return checkerror(ctx, newclassobject(v, w));

}

static object *

eval_compiled(ctx, co, arg, needvalue)

context *ctx;

codeobject *co;

object *arg;

int needvalue;

{

frameobject *f;

register object *v;

register object *w;

register object *u;

register object *x;

char *name;

int i, op;

FILE *fp;

#ifndef NDEBUG

int trace = dictlookup(ctx->ctx_globals, "__trace") != NULL;

#endif

f = newframeobject(

(frameobject *)NULL, /*back*/

co, /*code*/

ctx->ctx_locals, /*locals*/

ctx->ctx_globals, /*globals*/

50, /*nvalues*/

20); /*nblocks*/

if (f == NULL) {

puterrno(ctx);

return NULL;

}

#define EMPTY() Empty(f)

#define FULL() Full(f)

#define GETCONST(i) Getconst(f, i)

#define GETNAME(i) Getname(f, i)

#define JUMPTO(x) Jumpto(f, x)

#define JUMPBY(x) Jumpby(f, x)

#ifdef NDEBUG

#define PUSH(v) Push(f, v)

#define TOP() Top(f)

#define POP() Pop(f)

#else

#define PUSH(v) if(trace) trace_push(f, v); else push(f, v)

#define TOP() (trace ? trace_top(f) : top(f))

#define POP() (trace ? trace_pop(f) : pop(f))

#endif

if (arg != NULL) {

INCREF(arg);

PUSH(arg);

}

while (f->f_nexti < getstringsize((object *)f->f_code->co_code) &&

!ctx->ctx_exception) {

#ifdef NDEBUG

op = Nextbyte(f);

#else

op = trace ? trace_nextop(f) : nextbyte(f);

#endif

if (op >= HAVE_ARGUMENT)

i = nextint(f);

switch (op) {

case DUP_TOP:

v = TOP();

INCREF(v);

PUSH(v);

break;

case POP_TOP:

v = POP();

DECREF(v);

break;

case ROT_TWO:

v = POP();

w = POP();

PUSH(v);

PUSH(w);

break;

case ROT_THREE:

v = POP();

w = POP();

x = POP();

PUSH(v);

PUSH(x);

PUSH(w);

break;

case UNARY_POSITIVE:

v = POP();

u = pos(ctx, v);

DECREF(v);

PUSH(u);

break;

case UNARY_NEGATIVE:

v = POP();

u = neg(ctx, v);

DECREF(v);

PUSH(u);

break;

case UNARY_NOT:

v = POP();

u = not(ctx, v);

DECREF(v);

PUSH(u);

break;

case UNARY_CONVERT:

v = POP();

u = checkerror(ctx, reprobject(v));

DECREF(v);

PUSH(u);

break;

case UNARY_CALL:

v = POP();

if (is_classmethodobject(v) || is_funcobject(v))

u = call_function(ctx, v, (object *)NULL);

else

u = call_builtin(ctx, v, (object *)NULL);

DECREF(v);

PUSH(u);

break;

case BINARY_MULTIPLY:

w = POP();

v = POP();

u = mul(ctx, v, w);

DECREF(v);

DECREF(w);

PUSH(u);

break;

case BINARY_DIVIDE:

w = POP();

v = POP();

u = div(ctx, v, w);

DECREF(v);

DECREF(w);

PUSH(u);

break;

case BINARY_MODULO:

w = POP();

v = POP();

u = rem(ctx, v, w);

DECREF(v);

DECREF(w);

PUSH(u);

break;

case BINARY_ADD:

w = POP();

v = POP();

u = add(ctx, v, w);

DECREF(v);

DECREF(w);

PUSH(u);

break;

case BINARY_SUBTRACT:

w = POP();

v = POP();

u = sub(ctx, v, w);

DECREF(v);

DECREF(w);

PUSH(u);

break;

case BINARY_SUBSCR:

w = POP();

v = POP();

u = apply_subscript(ctx, v, w);

DECREF(v);

DECREF(w);

PUSH(u);

break;

case BINARY_CALL:

w = POP();

v = POP();

if (is_classmethodobject(v) || is_funcobject(v))

u = call_function(ctx, v, w);

else

u = call_builtin(ctx, v, w);

DECREF(v);

DECREF(w);