#include <u.h>
#include <libc.h>
#include <bio.h>
#include "hoc.h"
#include "y.tab.h"

#define NSTACK  256

static Datum stack[NSTACK];     /* the stack */
static Datum *stackp;           /* next free spot on stack */

#define NPROG   2000
Inst    prog[NPROG];    /* the machine */
Inst    *progp;         /* next free spot for code generation */
Inst    *pc;            /* program counter during execution */
Inst    *progbase = prog; /* start of current subprogram */
int     returning;      /* 1 if return stmt seen */
int     indef;  /* 1 if parsing a func or proc */

typedef struct Frame {  /* proc/func call stack frame */
       Symbol  *sp;    /* symbol table entry */
       Inst    *retpc; /* where to resume after return */
       Datum   *argn;  /* n-th argument on stack */
       int     nargs;  /* number of arguments */
} Frame;
#define NFRAME  100
Frame   frame[NFRAME];
Frame   *fp;            /* frame pointer */

void
initcode(void)
{
       progp = progbase;
       stackp = stack;
       fp = frame;
       returning = 0;
       indef = 0;
}

void
push(Datum d)
{
       if (stackp >= &stack[NSTACK])
               execerror("stack too deep", 0);
       *stackp++ = d;
}

Datum
pop(void)
{
       if (stackp == stack)
               execerror("stack underflow", 0);
       return *--stackp;
}

void
xpop(void)      /* for when no value is wanted */
{
       if (stackp == stack)
               execerror("stack underflow", (char *)0);
       --stackp;
}

void
constpush(void)
{
       Datum d;
       d.val = ((Symbol *)*pc++)->u.val;
       push(d);
}

void
varpush(void)
{
       Datum d;
       d.sym = (Symbol *)(*pc++);
       push(d);
}

void
whilecode(void)
{
       Datum d;
       Inst *savepc = pc;

       execute(savepc+2);      /* condition */
       d = pop();
       while (d.val) {
               execute(*((Inst **)(savepc)));  /* body */
               if (returning)
                       break;
               execute(savepc+2);      /* condition */
               d = pop();
       }
       if (!returning)
               pc = *((Inst **)(savepc+1)); /* next stmt */
}

void
forcode(void)
{
       Datum d;
       Inst *savepc = pc;

       execute(savepc+4);              /* precharge */
       pop();
       execute(*((Inst **)(savepc)));  /* condition */
       d = pop();
       while (d.val) {
               execute(*((Inst **)(savepc+2)));        /* body */
               if (returning)
                       break;
               execute(*((Inst **)(savepc+1)));        /* post loop */
               pop();
               execute(*((Inst **)(savepc)));  /* condition */
               d = pop();
       }
       if (!returning)
               pc = *((Inst **)(savepc+3)); /* next stmt */
}

void
ifcode(void)
{
       Datum d;
       Inst *savepc = pc;      /* then part */

       execute(savepc+3);      /* condition */
       d = pop();
       if (d.val)
               execute(*((Inst **)(savepc)));
       else if (*((Inst **)(savepc+1))) /* else part? */
               execute(*((Inst **)(savepc+1)));
       if (!returning)
               pc = *((Inst **)(savepc+2)); /* next stmt */
}

void
define(Symbol* sp, Formal *f)   /* put func/proc in symbol table */
{
       Fndefn *fd;
       int n;

       fd = emalloc(sizeof(Fndefn));
       fd->code = progbase;    /* start of code */
       progbase = progp;       /* next code starts here */
       fd->formals = f;
       for(n=0; f; f=f->next)
               n++;
       fd->nargs = n;
       sp->u.defn = fd;
}

void
call(void)              /* call a function */
{
       Formal *f;
       Datum *arg;
       Saveval *s;
       int i;

       Symbol *sp = (Symbol *)pc[0]; /* symbol table entry */
                                     /* for function */
       if (fp >= &frame[NFRAME-1])
               execerror(sp->name, "call nested too deeply");
       fp++;
       fp->sp = sp;
       fp->nargs = (int)(uintptr)pc[1];
       fp->retpc = pc + 2;
       fp->argn = stackp - 1;  /* last argument */
       if(fp->nargs != sp->u.defn->nargs)
               execerror(sp->name, "called with wrong number of arguments");
       /* bind formals */
       f = sp->u.defn->formals;
       arg = stackp - fp->nargs;
       while(f){
               s = emalloc(sizeof(Saveval));
               s->val = f->sym->u;
               s->type = f->sym->type;
               s->next = f->save;
               f->save = s;
               f->sym->u.val = arg->val;
               f->sym->type = VAR;
               f = f->next;
               arg++;
       }
       for (i = 0; i < fp->nargs; i++)
               pop();  /* pop arguments; no longer needed */
       execute(sp->u.defn->code);
       returning = 0;
}

void
restore(Symbol *sp)     /* restore formals associated with symbol */
{
       Formal *f;
       Saveval *s;

       f = sp->u.defn->formals;
       while(f){
               s = f->save;
               if(s == 0)      /* more actuals than formals */
                       break;
               f->sym->u = s->val;
               f->sym->type = s->type;
               f->save = s->next;
               free(s);
               f = f->next;
       }
}

void
restoreall(void)        /* restore all variables in case of error */
{
       while(fp>=frame && fp->sp){
               restore(fp->sp);
               --fp;
       }
       fp = frame;
}

static void
ret(void)               /* common return from func or proc */
{
       /* restore formals */
       restore(fp->sp);
       pc = (Inst *)fp->retpc;
       --fp;
       returning = 1;
}

void
funcret(void)   /* return from a function */
{
       Datum d;
       if (fp->sp->type == PROCEDURE)
               execerror(fp->sp->name, "(proc) returns value");
       d = pop();      /* preserve function return value */
       ret();
       push(d);
}

void
procret(void)   /* return from a procedure */
{
       if (fp->sp->type == FUNCTION)
               execerror(fp->sp->name,
                       "(func) returns no value");
       ret();
}

void
bltin(void)
{

       Datum d;
       d = pop();
       d.val = (*(double (*)(double))*pc++)(d.val);
       push(d);
}

void
add(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val += d2.val;
       push(d1);
}

void
sub(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val -= d2.val;
       push(d1);
}

void
mul(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val *= d2.val;
       push(d1);
}

void
div(void)
{
       Datum d1, d2;
       d2 = pop();
       if (d2.val == 0.0)
               execerror("division by zero", (char *)0);
       d1 = pop();
       d1.val /= d2.val;
       push(d1);
}

void
mod(void)
{
       Datum d1, d2;
       d2 = pop();
       if (d2.val == 0.0)
               execerror("division by zero", (char *)0);
       d1 = pop();
       /* d1.val %= d2.val; */
       d1.val = fmod(d1.val, d2.val);
       push(d1);
}

void
negate(void)
{
       Datum d;
       d = pop();
       d.val = -d.val;
       push(d);
}

void
verify(Symbol* s)
{
       if (s->type != VAR && s->type != UNDEF)
               execerror("attempt to evaluate non-variable", s->name);
       if (s->type == UNDEF)
               execerror("undefined variable", s->name);
}

void
eval(void)              /* evaluate variable on stack */
{
       Datum d;
       d = pop();
       verify(d.sym);
       d.val = d.sym->u.val;
       push(d);
}

void
preinc(void)
{
       Datum d;
       d.sym = (Symbol *)(*pc++);
       verify(d.sym);
       d.val = d.sym->u.val += 1.0;
       push(d);
}

void
predec(void)
{
       Datum d;
       d.sym = (Symbol *)(*pc++);
       verify(d.sym);
       d.val = d.sym->u.val -= 1.0;
       push(d);
}

void
postinc(void)
{
       Datum d;
       double v;
       d.sym = (Symbol *)(*pc++);
       verify(d.sym);
       v = d.sym->u.val;
       d.sym->u.val += 1.0;
       d.val = v;
       push(d);
}

void
postdec(void)
{
       Datum d;
       double v;
       d.sym = (Symbol *)(*pc++);
       verify(d.sym);
       v = d.sym->u.val;
       d.sym->u.val -= 1.0;
       d.val = v;
       push(d);
}

void
gt(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val > d2.val);
       push(d1);
}

void
lt(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val < d2.val);
       push(d1);
}

void
ge(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val >= d2.val);
       push(d1);
}

void
le(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val <= d2.val);
       push(d1);
}

void
eq(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val == d2.val);
       push(d1);
}

void
ne(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val != d2.val);
       push(d1);
}

void
and(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val != 0.0 && d2.val != 0.0);
       push(d1);
}

void
or(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = (double)(d1.val != 0.0 || d2.val != 0.0);
       push(d1);
}

void
not(void)
{
       Datum d;
       d = pop();
       d.val = (double)(d.val == 0.0);
       push(d);
}

void
power(void)
{
       Datum d1, d2;
       d2 = pop();
       d1 = pop();
       d1.val = Pow(d1.val, d2.val);
       push(d1);
}

void
assign(void)
{
       Datum d1, d2;
       d1 = pop();
       d2 = pop();
       if (d1.sym->type != VAR && d1.sym->type != UNDEF)
               execerror("assignment to non-variable",
                       d1.sym->name);
       d1.sym->u.val = d2.val;
       d1.sym->type = VAR;
       push(d2);
}

void
addeq(void)
{
       Datum d1, d2;
       d1 = pop();
       d2 = pop();
       if (d1.sym->type != VAR && d1.sym->type != UNDEF)
               execerror("assignment to non-variable",
                       d1.sym->name);
       d2.val = d1.sym->u.val += d2.val;
       d1.sym->type = VAR;
       push(d2);
}

void
subeq(void)
{
       Datum d1, d2;
       d1 = pop();
       d2 = pop();
       if (d1.sym->type != VAR && d1.sym->type != UNDEF)
               execerror("assignment to non-variable",
                       d1.sym->name);
       d2.val = d1.sym->u.val -= d2.val;
       d1.sym->type = VAR;
       push(d2);
}

void
muleq(void)
{
       Datum d1, d2;
       d1 = pop();
       d2 = pop();
       if (d1.sym->type != VAR && d1.sym->type != UNDEF)
               execerror("assignment to non-variable",
                       d1.sym->name);
       d2.val = d1.sym->u.val *= d2.val;
       d1.sym->type = VAR;
       push(d2);
}

void
diveq(void)
{
       Datum d1, d2;
       d1 = pop();
       d2 = pop();
       if (d1.sym->type != VAR && d1.sym->type != UNDEF)
               execerror("assignment to non-variable",
                       d1.sym->name);
       d2.val = d1.sym->u.val /= d2.val;
       d1.sym->type = VAR;
       push(d2);
}

void
modeq(void)
{
       Datum d1, d2;
       long x;
       d1 = pop();
       d2 = pop();
       if (d1.sym->type != VAR && d1.sym->type != UNDEF)
               execerror("assignment to non-variable",
                       d1.sym->name);
       /* d2.val = d1.sym->u.val %= d2.val; */
       x = d1.sym->u.val;
       x %= (long) d2.val;
       d2.val = d1.sym->u.val = x;
       d1.sym->type = VAR;
       push(d2);
}

void
printtop(void)  /* pop top value from stack, print it */
{
       Datum d;
       static Symbol *s;       /* last value computed */
       if (s == 0)
               s = install("_", VAR, 0.0);
       d = pop();
       print("%.12g\n", d.val);
       s->u.val = d.val;
}

void
prexpr(void)    /* print numeric value */
{
       Datum d;
       d = pop();
       print("%.12g ", d.val);
}

void
prstr(void)             /* print string value */
{
       print("%s", (char *) *pc++);
}

void
varread(void)   /* read into variable */
{
       Datum d;
       extern Biobuf *bin;
       Symbol *var = (Symbol *) *pc++;
       int c;

 Again:
       do
               c = Bgetc(bin);
       while(c==' ' || c=='\t' || c=='\n');
       if(c == Beof){
 Iseof:
               if(moreinput())
                       goto Again;
               d.val = var->u.val = 0.0;
               goto Return;
       }

       if(strchr("+-.0123456789", c) == 0)
               execerror("non-number read into", var->name);
       Bungetc(bin);
       if(Bgetd(bin, &var->u.val) == Beof)
               goto Iseof;
       else
               d.val = 1.0;
 Return:
       var->type = VAR;
       push(d);
}

Inst*
code(Inst f)    /* install one instruction or operand */
{
       Inst *oprogp = progp;
       if (progp >= &prog[NPROG])
               execerror("program too big", (char *)0);
       *progp++ = f;
       return oprogp;
}

void
execute(Inst* p)
{
       for (pc = p; *pc != STOP && !returning; )
               (*((++pc)[-1]))();
}