scummvm/engines/private/code.cpp

#include "common/str.h"
#include "common/debug.h"
#include "common/hash-ptr.h"

#include "grammar.h"
#include "grammar.tab.h"
#include "private.h"

namespace Private {

Setting *setting;
SettingMap settingMap;

Datum	*stack       = NULL;	/* the stack */
Datum	*stackp      = NULL;	/* next free spot on stack */

Inst	*prog        = NULL;	/* the machine */
Inst	*progp       = NULL;	/* next free spot for code generation */
Inst	*pc          = NULL;	/* program counter during execution */


static struct InstDescr {
    const Inst func;
    const char *name;
} instDescr[] = {
    { 0,        "STOP",     },
    { constpush,"constpush" },
    { strpush,  "strpush",	},
    { varpush,  "varpush",	},
    { funcpush, "funcpush",	},
    { eval,	    "eval",     },
    { ifcode,   "ifcode",	},
    { add,      "add",      },
    { negate,	"negate",	},

    { 0, 0}
};

PtrToName _insts;

void initInsts() {
    for (InstDescr *fnc = instDescr; fnc->name; fnc++) {
        _insts[(void *)fnc->func] = new Common::String(fnc->name);
    }
}

/* initialize for code generation */
void initSetting() {
    setting = (Setting*) malloc(sizeof(Setting));
    memset((void *) setting, 0, sizeof(Setting));

    prog = (Inst *) &setting->prog;
    stack = (Datum *) &setting->stack;

    stackp = stack;
    progp = prog;
}

void saveSetting(char *name) {
    Common::String s(name);
    settingMap.setVal(s, setting);
}

void loadSetting(Common::String *name) {
    assert(settingMap.contains(*name));
    setting = settingMap.getVal(*name);

    debug("loading setting %s", name->c_str());

    prog = (Inst *) &setting->prog;
    stack = (Datum *) &setting->stack;

    stackp = stack;
    progp = prog;

    /*for (Inst *pc_ = progp; pc_-progp < 100; pc_++) {
        if (_functions.contains((void *) *pc_))
            debug("%p: %s", (void*) pc_, _functions.getVal((void*) *pc_)->c_str());
        else if ( (Inst *) *pc_ >= progp && (Inst *) *pc_ <= (progp + NPROG))
            debug("%p: %p", (void*) pc_, (void*) *pc_);
        else {
            debugN("%p:", (void*) pc_);
            showSymbol((Symbol *) *pc_);
        }
    }*/
}

/* push d onto stack */
int push(Datum d) {
    assert (!(stackp >= &stack[NSTACK]));
    *stackp++ = d;
    return 0;
}

/* pop and return top elem from stack */
Datum pop()	{
    assert (!(stackp <= stack));
    return *--stackp;
}

/* push constant onto stack */
int constpush()	{
    Datum d;
    Symbol *s = (Symbol *)*pc++;
    d.type = NUM;
    d.u.val = s->u.val;

    debug("pushing const %d with name %s", d.u.val, s->name->c_str());
    push(d);
    return 0;
}

int strpush()	/* push constant onto stack */
{
    Datum d;
    d.type = STRING;
    Symbol *s = (Symbol *)*pc++;
    d.u.str = s->u.str;
    debug("pushing const %s with name %s", d.u.str, s->name->c_str());
    push(d);
    return 0;
}


int varpush()	/* push variable onto stack */
{
    Datum d;
    d.type = NAME;
    d.u.sym = (Symbol *)(*pc++);
    debug("var pushing %s", d.u.sym->name->c_str());
    push(d);
    return 0;
}

int funcpush() //(char *name, int nargs)
{
    Datum s, n, arg;
    s = pop();
    n = pop();
    ArgArray args;

    //debug("executing %s with %d params", s.u.str, n.u.val);
    for (int i = 0; i < n.u.val; i++) {
        arg = pop();
        args.insert(args.begin(), arg) ;
    }

    call(s.u.str, args);
    return 0;
}

/* evaluate variable on stack */
int eval() {
    Datum d;
    d = pop();
    //debug("eval %s", d.u.sym->name->c_str());
    //if (d.sym->type == UNDEF)
    //	execerror("undefined variable", d.sym->name);
    if (d.u.sym->type == NUM) {
        d.type = NUM;
        d.u.val = d.u.sym->u.val;
    } else if (d.u.sym->type == STRING) {
        d.type = STRING;
        d.u.str = d.u.sym->u.str;
        debug("eval returned %s", d.u.str );
    } else if (d.u.sym->type == RECT) {
        d.type = RECT;
        d.u.rect = d.u.sym->u.rect;
    } else if (d.u.sym->type == NAME) {
        // No evaluation until is absolutely needed
    }
    else
        assert(0);

    push(d);
    return 0;
}

/* add top two elems on stack */
int add() {
    Datum d1, d2;
    d2 = pop();
    d1 = pop();
    if (d1.type == NAME) {
        d1.u.val = d1.u.sym->u.val;
        d1.type = NUM;
    }

    if (d2.type == NAME) {
        d2.u.val = d2.u.sym->u.val;
        d2.type = NUM;
    }

    assert(d1.type == NUM);
    assert(d2.type == NUM);

    //printf("adding %d %d\n",d1.val, d2.val);
    d1.u.val += d2.u.val;
    push(d1);
    return 0;
}

int negate() {
    Datum d;
    d = pop();
    int v;
    if (d.type == NAME) {
        //debug("negating %s", d.u.sym->name->c_str());
        v = d.u.sym->u.val;
        d.type = NUM;
    }
    else if (d.type == NUM) {
        v = d.u.val;
    }
    else
        assert(0);

    d.u.val = !v;
    push(d);
    return 0;
}

int gt() {
    Datum d1, d2;
    d2 = pop();
    d1 = pop();
    if (d1.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d1.u.val = d1.u.sym->u.val;
        d1.type = NUM;
    }

    if (d2.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d2.u.val = d2.u.sym->u.val;
        d2.type = NUM;
    }

    d1.u.val = (int)(d1.u.val > d2.u.val);
    push(d1);
    return 0;
}

int lt() {
    Datum d1, d2;
    d2 = pop();
    d1 = pop();
    if (d1.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d1.u.val = d1.u.sym->u.val;
        d1.type = NUM;
    }

    if (d2.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d2.u.val = d2.u.sym->u.val;
        d2.type = NUM;
    }


    d1.u.val = (int)(d1.u.val < d2.u.val);
    push(d1);
    return 0;
}

int ge() {
    Datum d1, d2;
    d2 = pop();
    d1 = pop();
    if (d1.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d1.u.val = d1.u.sym->u.val;
        d1.type = NUM;
    }

    if (d2.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d2.u.val = d2.u.sym->u.val;
        d2.type = NUM;
    }


    d1.u.val = (int)(d1.u.val >= d2.u.val);
    push(d1);
    return 0;
}

int le() {
    Datum d1, d2;
    d2 = pop();
    d1 = pop();
    if (d1.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d1.u.val = d1.u.sym->u.val;
        d1.type = NUM;
    }

    if (d2.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d2.u.val = d2.u.sym->u.val;
        d2.type = NUM;
    }


    d1.u.val = (int)(d1.u.val <= d2.u.val);
    push(d1);
    return 0;
}

int eq() {
    Datum d1, d2;
    d2 = pop();
    d1 = pop();
    if (d1.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d1.u.val = d1.u.sym->u.val;
        d1.type = NUM;
    }

    if (d2.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d2.u.val = d2.u.sym->u.val;
        d2.type = NUM;
    }


    d1.u.val = (int)(d1.u.val == d2.u.val);
    push(d1);
    return 0;
}

int ne() {
    Datum d1, d2;
    d2 = pop();
    d1 = pop();
    if (d1.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d1.u.val = d1.u.sym->u.val;
        d1.type = NUM;
    }

    if (d2.type == NAME) {
        //char *name =  d1.u.sym->name->c_str();
        //debug("eval %s to %d",
        d2.u.val = d2.u.sym->u.val;
        d2.type = NUM;
    }


    d1.u.val = (int)(d1.u.val != d2.u.val);
    push(d1);
    return 0;
}

/* install one instruction or operand */
Inst *code(Inst f) {
    //debug("pushing code at %d", progp);
    Inst *oprogp = progp;
    assert (!(progp >= &prog[NPROG]));
    *progp++ = f;
    return oprogp;
}

int ifcode() {
    Datum d;
    Inst *savepc = pc;	/* then part */
    debug("ifcode: evaluating condition");

    execute(savepc+3);	/* condition */
    d = pop();

    debug("ifcode: selecting branch");

    if (d.type == NAME) {
        debug("name %s", d.u.sym->name->c_str()); //, d.sym->u.val);
        d.u.val = d.u.sym->u.val;
    }

    if (d.u.val) {
        debug("ifcode: true branch");
        execute(*((Inst **)(savepc)));
    }
    else if (*((Inst **)(savepc+1))) { /* else part? */
        debug("ifcode: false branch");
        execute(*((Inst **)(savepc+1)));
    }
    debug("ifcode finished");
    pc = *((Inst **)(savepc+2));	 /* next stmt */
    return 0;
}

int randbool() {
    Datum d;
    d = pop();

    int v = g_private->getRandomBool(d.u.val);

    d.u.val = v;
    push(d);
    return 0;
}

int fail() {
    assert(0);
    return 0;
}

/* run the machine */
void execute(Inst *p) {
    for (pc = p; *pc != STOP; ) {
        (*(*pc++))();
    }
}

}