mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-17 07:07:10 +00:00
458 lines
9.3 KiB
C++
458 lines
9.3 KiB
C++
#include "common/str.h"
|
|
#include "common/debug.h"
|
|
#include "common/hash-ptr.h"
|
|
|
|
#include "grammar.h"
|
|
#include "grammar.tab.h"
|
|
|
|
namespace Private {
|
|
|
|
Setting *psetting;
|
|
SettingMap settingcode;
|
|
|
|
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 FuncDescr {
|
|
const Inst func;
|
|
const char *name;
|
|
const char *args;
|
|
} funcDescr[] = {
|
|
{ 0, "STOP", "" },
|
|
{ constpush, "constpush", "" },
|
|
{ strpush, "strpush", "" },
|
|
{ varpush, "varpush", "" },
|
|
{ funcpush, "funcpush", "" },
|
|
{ eval, "eval", "" },
|
|
{ ifcode, "ifcode", "" },
|
|
{ add, "add", "" },
|
|
{ negate, "negate", "" },
|
|
|
|
{ 0, 0, 0 }
|
|
};
|
|
|
|
FuncHash _functions;
|
|
|
|
void initFuncs() {
|
|
for (FuncDescr *fnc = funcDescr; fnc->name; fnc++) {
|
|
_functions[(void *)fnc->func] = new Common::String(fnc->name);
|
|
}
|
|
}
|
|
|
|
|
|
void initSetting() /* initialize for code generation */
|
|
{
|
|
psetting = (Setting*) malloc(sizeof(Setting));
|
|
memset((void *) psetting, 0, sizeof(Setting));
|
|
|
|
prog = (Inst *) &psetting->prog;
|
|
stack = (Datum *) &psetting->stack;
|
|
|
|
stackp = stack;
|
|
progp = prog;
|
|
}
|
|
|
|
void saveSetting(char *name)
|
|
{
|
|
Common::String s(name);
|
|
settingcode.setVal(s, psetting);
|
|
//debug("setting %s", name);
|
|
}
|
|
|
|
void loadSetting(Common::String *name)
|
|
{
|
|
assert(settingcode.contains(*name));
|
|
psetting = settingcode.getVal(*name);
|
|
|
|
debug("loading setting %s", name->c_str());
|
|
|
|
prog = (Inst *) &psetting->prog;
|
|
stack = (Datum *) &psetting->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_);
|
|
}
|
|
}*/
|
|
}
|
|
|
|
|
|
int push(Datum d) /* push d onto stack */
|
|
{
|
|
assert (!(stackp >= &stack[NSTACK]));
|
|
*stackp++ = d;
|
|
return 0;
|
|
}
|
|
|
|
Datum pop() /* pop and return top elem from stack */
|
|
{
|
|
assert (!(stackp <= stack));
|
|
return *--stackp;
|
|
}
|
|
|
|
int constpush() /* push constant onto stack */
|
|
{
|
|
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();
|
|
//debug("%d", arg.val);
|
|
args.insert(args.begin(), arg) ;
|
|
}
|
|
|
|
execFunction(s.u.str, args);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int eval() /* evaluate variable on stack */
|
|
{
|
|
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;
|
|
} 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) {
|
|
//debug("NAME %s", d.sym->name->c_str());
|
|
//d.sym = d.sym;
|
|
}
|
|
else
|
|
assert(0);
|
|
|
|
|
|
push(d);
|
|
return 0;
|
|
}
|
|
|
|
int add() /* add top two elems on stack */
|
|
{
|
|
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;
|
|
}
|
|
|
|
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 assign() /* assign top value to next value */
|
|
{
|
|
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.u.sym->u.val = d2.u.val;
|
|
d1.u.sym->type = NAME;
|
|
push(d2);
|
|
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;
|
|
}
|
|
|
|
Inst *code(Inst f) /* install one instruction or operand */
|
|
{
|
|
//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;
|
|
}
|
|
//debug("ptr: %x", *((Inst **)(savepc+1)));
|
|
//debug("ptr: %x", *((Inst **)(savepc+2)));
|
|
//debug("ptr: %x", *((Inst **)(savepc+3)));
|
|
|
|
//assert(0);
|
|
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 fail()
|
|
{
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
void execute(Inst *p) /* run the machine */
|
|
{
|
|
for (pc = p; *pc != STOP; ) {
|
|
(*(*pc++))();
|
|
}
|
|
}
|
|
|
|
}
|