ref: 7a29422cfefaf76315eafa82ca606f9ded9517b3
dir: /appl/lib/ecmascript/exec.b/
exec(ex: ref Exec, code: ref Code): Completion
{
ssp := ex.sp;
r := estmt(ex, code, 0, code.npc);
if(r.kind == CThrow)
ex.sp = ssp;
if(ssp != ex.sp)
runtime(ex, InternalError, "internal error: exec stack not balanced");
if(r.lab != nil)
runtime(ex, InternalError, "internal error: label out of stack");
return r;
}
estmt(ex: ref Exec, code: ref Code, pc, epc: int): Completion
{
e: ref Ref;
ev: ref Val;
k, apc, pc2, apc2, pc3, apc3, c: int;
lab: string;
labs: list of string;
osp := ex.sp;
{
v : ref Val = nil;
k1 := CNormal;
while(pc < epc){
v1 : ref Val = nil;
labs = nil;
op := int code.ops[pc++];
while(op == Llabel){
(pc, c) = getconst(code.ops, pc);
labs = code.strs[c] :: labs;
op = int code.ops[pc++];
}
if(debug['e'] > 1)
print("estmt(pc %d, sp %d) %s\n", pc-1, ex.sp, tokname(op));
case op {
Lbreak =>
return (CBreak, v, nil);
Lcontinue =>
return (CContinue, v, nil);
Lbreaklab =>
(pc, c) = getconst(code.ops, pc);
return (CBreak, v, code.strs[c]);
Lcontinuelab =>
(pc, c) = getconst(code.ops, pc);
return (CContinue, v, code.strs[c]);
Lreturn =>
(pc, v) = eexpval(ex, code, pc, code.npc);
return (CReturn, v, nil);
'{' =>
(pc, apc) = getjmp(code.ops, pc);
(k1, v1, lab) = estmt(ex, code, pc, apc);
pc = apc;
Lif =>
(pc, apc) = getjmp(code.ops, pc);
(pc, ev) = eexpval(ex, code, pc, apc);
(pc, apc) = getjmp(code.ops, pc);
(pc2, apc2) = getjmp(code.ops, apc);
if(toBoolean(ex, ev) != false)
(k1, v1, lab) = estmt(ex, code, pc, apc);
else if(pc2 != apc2)
(k1, v1, lab) = estmt(ex, code, pc2, apc2);
pc = apc2;
Lwhile =>
(pc, apc) = getjmp(code.ops, pc);
(pc2, apc2) = getjmp(code.ops, apc);
for(;;){
(nil, ev) = eexpval(ex, code, pc, apc);
if(toBoolean(ex, ev) == false)
break;
(k, v1, lab) = estmt(ex, code, pc2, apc2);
if(v1 != nil)
v = v1;
if(k == CBreak || k == CContinue){
if(initlabs(lab, labs)){
if(k == CBreak)
break;
else
continue;
}
else
return (k, v1, lab);
}
if(k == CReturn || k == CThrow)
return (k, v1, nil);
}
pc = apc2;
Ldo =>
(pc, apc) = getjmp(code.ops, pc);
(pc2, apc2) = getjmp(code.ops, apc);
for(;;){
(k, v1, lab) = estmt(ex, code, pc, apc);
if(v1 != nil)
v = v1;
if(k == CBreak || k == CContinue){
if(initlabs(lab, labs)){
if(k == CBreak)
break;
else
continue;
}
else
return (k, v1, lab);
}
if(k == CReturn || k == CThrow)
return (k, v1, nil);
(nil, ev) = eexpval(ex, code, pc2, apc2);
if(toBoolean(ex, ev) == false)
break;
}
pc = apc2;
Lfor or
Lforvar =>
(pc, apc) = getjmp(code.ops, pc);
(pc, nil) = eexpval(ex, code, pc, apc);
(pc, apc) = getjmp(code.ops, pc);
(pc2, apc2) = getjmp(code.ops, apc);
(pc3, apc3) = getjmp(code.ops, apc2);
for(;;){
(nil, e) = eexp(ex, code, pc, apc);
if(e != nil && toBoolean(ex, getValue(ex, e)) == false)
break;
(k, v1, lab) = estmt(ex, code, pc3, apc3);
if(v1 != nil)
v = v1;
if(k == CBreak || k == CContinue){
if(initlabs(lab, labs)){
if(k == CBreak)
break;
else
continue;
}
else
return (k, v1, lab);
}
if(k == CReturn || k == CThrow)
return (k, v1, nil);
eexpval(ex, code, pc2, apc2);
}
pc = apc3;
Lforin or
Lforvarin =>
(pc, apc) = getjmp(code.ops, pc);
(pc2, apc2) = getjmp(code.ops, apc);
(pc3, apc3) = getjmp(code.ops, apc2);
if(op == Lforvarin){
(nil, nil) = eexp(ex, code, pc, apc);
# during for only evaluate the id, not the initializer
apc = pc + 1;
}
(nil, ev) = eexpval(ex, code, pc2, apc2);
bo := toObject(ex, ev);
#
# note this won't enumerate host properties
#
enum:
for(o := bo; o != nil; o = o.prototype){
if(o.host != nil && o.host != me)
continue;
for(i := 0; i < len o.props; i++){
if(o.props[i] == nil
|| (o.props[i].attr & DontEnum)
|| propshadowed(bo, o, o.props[i].name))
continue;
(nil, e) = eexp(ex, code, pc, apc);
putValue(ex, e, strval(o.props[i].name));
(k, v1, lab) = estmt(ex, code, pc3, apc3);
if(v1 != nil)
v = v1;
if(k == CBreak || k == CContinue){
if(initlabs(lab, labs)){
if(k == CBreak)
break enum;
else
continue enum;
}
else
return (k, v1, lab);
}
if(k == CReturn || k == CThrow)
return (k, v1, nil);
}
}
pc = apc3;
Lwith =>
(pc, apc) = getjmp(code.ops, pc);
(pc, ev) = eexpval(ex, code, pc, apc);
pushscope(ex, toObject(ex, ev));
(pc, apc) = getjmp(code.ops, pc);
(k1, v1, lab) = estmt(ex, code, pc, apc);
popscope(ex);
pc = apc;
';' =>
;
Lvar =>
(pc, apc) = getjmp(code.ops, pc);
(pc, nil) = eexp(ex, code, pc, apc);
Lswitch =>
(pc, apc) = getjmp(code.ops, pc);
(pc, ev) = eexpval(ex, code, pc, apc);
(pc, apc) = getjmp(code.ops, pc);
(k1, v1, lab) = ecaseblk(ex, code, ev, pc, apc, labs);
pc = apc;
Lthrow =>
(pc, v) = eexpval(ex, code, pc, code.npc);
ex.error = toString(ex, v);
return (CThrow, v, nil);
Lprint =>
(pc, v1) = eexpval(ex, code, pc, code.npc);
print("%s\n", toString(ex, v1));
Ltry =>
(pc, apc) = getjmp(code.ops, pc);
(k1, v1, lab) = estmt(ex, code, pc, apc);
(kc, vc) := (k1, v1);
(pc, apc) = getjmp(code.ops, apc);
if(pc != apc){
(pc, c) = getconst(code.ops, ++pc);
if(k1 == CThrow){
o := mkobj(ex.objproto, "Object");
valinstant(o, DontDelete, code.strs[c], v1);
pushscope(ex, o);
(k1, v1, lab) = estmt(ex, code, pc, apc);
popscope(ex);
if(k1 != CNormal)
(kc, vc) = (k1, v1);
}
}
(pc, apc) = getjmp(code.ops, apc);
if(pc != apc){
(k, v, lab) = estmt(ex, code, pc, apc);
if(k == CNormal)
(k1, v1) = (kc, vc);
else
(k1, v1) = (k, v);
}
pc = apc;
* =>
(pc, e) = eexp(ex, code, pc-1, code.npc);
if(e != nil)
v1 = getValue(ex, e);
if(debug['v'])
print("%s\n", toString(ex, v1));
}
if(v1 != nil)
v = v1;
if(k1 == CBreak && lab != nil && inlabs(lab, labs))
(k1, lab) = (CNormal, nil);
if(k1 != CNormal)
return (k1, v, lab);
}
return (CNormal, v, nil);
}
exception{
"throw" =>
ex.sp = osp;
return (CThrow, ex.errval, nil);
}
}
ecaseblk(ex : ref Exec, code : ref Code, sv : ref Val, pc, epc : int, labs: list of string) : Completion
{ defpc, nextpc, clausepc, apc : int;
ev : ref Val;
lab: string;
k := CNormal;
v := undefined;
matched := 0;
(pc, defpc) = getjmp(code.ops, pc);
clausepc = pc;
(pc, nextpc) = getjmp(code.ops, pc);
for (; pc <= epc; (clausepc, (pc, nextpc)) = (nextpc, getjmp(code.ops, nextpc))) {
if (nextpc == epc) {
if (matched || defpc == epc)
break;
# do the default
matched = 1;
nextpc = defpc;
continue;
}
if (!matched && clausepc == defpc)
# skip default case - still scanning guards
continue;
if (clausepc != defpc) {
# only case clauses have guard exprs
(pc, apc) = getjmp(code.ops, pc);
if (matched)
pc = apc;
else {
(pc, ev) = eexpval(ex, code, pc, apc);
if (identical(sv, ev))
matched = 1;
else
continue;
}
}
(k, v, lab) = estmt(ex, code, pc, nextpc);
if(k == CBreak && initlabs(lab, labs))
return (CNormal, v, nil);
if(k == CBreak || k == CContinue || k == CReturn || k == CThrow)
return (k, v, lab);
}
return (k, v, lab);
}
identical(v1, v2 : ref Val) : int
{
if (v1.ty != v2.ty)
return 0;
ret := 0;
case v1.ty{
TUndef or
TNull =>
ret = 1;
TNum =>
if(v1.num == v2.num)
ret = 1;
TBool =>
if(v1 == v2)
ret = 1;
TStr =>
if(v1.str == v2.str)
ret = 1;
TObj =>
if(v1.obj == v2.obj)
ret = 1;
TRegExp =>
if(v1.rev == v2.rev)
ret = 1;
}
return ret;
}
eexpval(ex: ref Exec, code: ref Code, pc, epc: int): (int, ref Val)
{
e: ref Ref;
(pc, e) = eexp(ex, code, pc, epc);
if(e == nil)
v := undefined;
else
v = getValue(ex, e);
return (pc, v);
}
eexp(ex: ref Exec, code: ref Code, pc, epc: int): (int, ref Ref)
{
o, th: ref Obj;
a1: ref Ref;
v, v1, v2: ref Val;
s: string;
r1, r2: real;
c, apc, i1, i2: int;
savesp := ex.sp;
out: while(pc < epc){
op := int code.ops[pc++];
if(debug['e'] > 1){
case op{
Lid or
Lstr or
Lregexp =>
(nil, c) = getconst(code.ops, pc);
print("eexp(pc %d, sp %d) %s '%s'\n", pc-1, ex.sp, tokname(op), code.strs[c]);
Lnum =>
(nil, c) = getconst(code.ops, pc);
print("eexp(pc %d, sp %d) %s '%g'\n", pc-1, ex.sp, tokname(op), code.nums[c]);
* =>
print("eexp(pc %d, sp %d) %s\n", pc-1, ex.sp, tokname(op));
}
}
case op{
Lthis =>
v1 = objval(ex.this);
Lnum =>
(pc, c) = getconst(code.ops, pc);
v1 = numval(code.nums[c]);
Lstr =>
(pc, c) = getconst(code.ops, pc);
v1 = strval(code.strs[c]);
Lregexp =>
(pc, c) = getconst(code.ops, pc);
(p, f) := rsplit(code.strs[c]);
o = nregexp(ex, nil, array[] of { strval(p), strval(f) });
v1 = objval(o);
# v1 = regexpval(p, f, 0);
Lid =>
(pc, c) = getconst(code.ops, pc);
epush(ex, esprimid(ex, code.strs[c]));
continue;
Lnoval =>
v1 = undefined;
'.' =>
a1 = epop(ex);
v1 = epopval(ex);
epush(ex, ref Ref(1, nil, toObject(ex, v1), a1.name));
continue;
'[' =>
v2 = epopval(ex);
v1 = epopval(ex);
epush(ex, ref Ref(1, nil, toObject(ex, v1), toString(ex, v2)));
continue;
Lpostinc or
Lpostdec =>
a1 = epop(ex);
r1 = toNumber(ex, getValue(ex, a1));
v1 = numval(r1);
if(op == Lpostinc)
r1++;
else
r1--;
putValue(ex, a1, numval(r1));
Linc or
Ldec or
Lpreadd or
Lpresub =>
a1 = epop(ex);
r1 = toNumber(ex, getValue(ex, a1));
case op{
Linc =>
r1++;
Ldec =>
r1--;
Lpresub =>
r1 = -r1;
}
v1 = numval(r1);
if(op == Linc || op == Ldec)
putValue(ex, a1, v1);
'~' =>
v = epopval(ex);
i1 = toInt32(ex, v);
i1 = ~i1;
v1 = numval(real i1);
'!' =>
v = epopval(ex);
v1 = toBoolean(ex, v);
if(v1 == true)
v1 = false;
else
v1 = true;
Ltypeof =>
a1 = epop(ex);
if(a1.isref && getBase(ex, a1) == nil)
s = "undefined";
else case (v1 = getValue(ex, a1)).ty{
TUndef =>
s = "undefined";
TNull =>
s = "object";
TBool =>
s = "boolean";
TNum =>
s = "number";
TStr =>
s = "string";
TObj =>
if(v1.obj.call != nil)
s = "function";
else
s = "object";
TRegExp =>
s = "regexp";
}
v1 = strval(s);
Ldelete =>
a1 = epop(ex);
o = getBase(ex, a1);
s = getPropertyName(ex, a1);
if(o != nil)
esdelete(ex, o, s, 0);
v1 = undefined;
Lvoid =>
epopval(ex);
v = undefined;
'*' or
'/' or
'%' or
'-' =>
v2 = epopval(ex);
a1 = epop(ex);
r1 = toNumber(ex, getValue(ex, a1));
r2 = toNumber(ex, v2);
case op{
'*' =>
r1 = r1 * r2;
'/' =>
r1 = r1 / r2;
'%' =>
r1 = fmod(r1, r2);
'-' =>
r1 = r1 - r2;
}
v1 = numval(r1);
'+' =>
v2 = epopval(ex);
a1 = epop(ex);
v1 = toPrimitive(ex, getValue(ex, a1), NoHint);
v2 = toPrimitive(ex, v2, NoHint);
if(v1.ty == TStr || v2.ty == TStr)
v1 = strval(toString(ex, v1)+toString(ex, v2));
else
v1 = numval(toNumber(ex, v1)+toNumber(ex, v2));
Llsh or
Lrsh or
Lrshu or
'&' or
'^' or
'|' =>
v2 = epopval(ex);
a1 = epop(ex);
i1 = toInt32(ex, getValue(ex, a1));
i2 = toInt32(ex, v2);
case op{
Llsh =>
i1 <<= i2 & 16r1f;
Lrsh =>
i1 >>= i2 & 16r1f;
Lrshu =>
i1 = int (((big i1) & 16rffffffff) >> (i2 & 16r1f));
'&' =>
i1 &= i2;
'|' =>
i1 |= i2;
'^' =>
i1 ^= i2;
}
v1 = numval(real i1);
'=' or
Las =>
v1 = epopval(ex);
a1 = epop(ex);
putValue(ex, a1, v1);
'<' or
'>' or
Lleq or
Lgeq =>
v2 = epopval(ex);
v1 = epopval(ex);
if(op == '>' || op == Lleq){
v = v1;
v1 = v2;
v2 = v;
}
v1 = toPrimitive(ex, v1, TNum);
v2 = toPrimitive(ex, v2, TNum);
if(v1.ty == TStr && v2.ty == TStr){
if(v1.str < v2.str)
v1 = true;
else
v1 = false;
}else{
r1 = toNumber(ex, v1);
r2 = toNumber(ex, v2);
if(isnan(r1) || isnan(r2))
v1 = undefined;
else if(r1 < r2)
v1 = true;
else
v1 = false;
}
if(op == Lgeq || op == Lleq){
if(v1 == false)
v1 = true;
else
v1 = false;
}
Lin =>
v2 = epopval(ex);
v1 = epopval(ex);
if(v2.ty != TObj)
runtime(ex, TypeError, "rhs of 'in' not an object");
s = toString(ex, v1);
v1 = eshasproperty(ex, v2.obj, s, 0);
Linstanceof =>
v2 = epopval(ex);
v1 = epopval(ex);
if(v2.ty != TObj)
runtime(ex, TypeError, "rhs of 'instanceof' not an object");
if(!isfuncobj(v2.obj))
runtime(ex, TypeError, "rhs of 'instanceof' not a function");
if(v1.ty != TObj)
v1 = false;
else{
v2 = esget(ex, v2.obj, "prototype", 0);
if(v2.ty != TObj)
runtime(ex, TypeError, "prototype value not an object");
o = v2.obj;
for(p := v1.obj.prototype; p != nil; p = p.prototype){
if(p == o){
v1 = true;
break;
}
}
if(p == nil)
v1 = false;
}
Leq or
Lneq or
Lseq or
Lsne =>
strict := op == Lseq || op == Lsne;
v2 = epopval(ex);
v1 = epopval(ex);
v = false;
while(v1.ty != v2.ty){
if(strict)
break;
if(isnull(v1) && v2 == undefined
|| v1 == undefined && isnull(v2))
v1 = v2;
else if(v1.ty == TNum && v2.ty == TStr)
v2 = numval(toNumber(ex, v2));
else if(v1.ty == TStr && v2.ty == TNum)
v1 = numval(toNumber(ex, v1));
else if(v1.ty == TBool)
v1 = numval(toNumber(ex, v1));
else if(v2.ty == TBool)
v2 = numval(toNumber(ex, v2));
else if(v2.ty == TObj && (v1.ty == TStr || v1.ty == TNum))
v2 = toPrimitive(ex, v2, NoHint);
else if(v1.ty == TObj && (v2.ty == TStr || v2.ty == TNum))
v1 = toPrimitive(ex, v1, NoHint);
else{
v1 = true;
v2 = false;
}
}
if(v1.ty != v2.ty)
v = false;
else{
case v1.ty{
TUndef or
TNull =>
v = true;
TNum =>
if(v1.num == v2.num)
v = true;
TBool =>
if(v1 == v2)
v = true;
TStr =>
if(v1.str == v2.str)
v = true;
TObj =>
if(v1.obj == v2.obj)
v = true;
TRegExp =>
if(v1.rev.p == v2.rev.p && v1.rev.f == v2.rev.f)
v = true;
}
}
if(op == Lneq || op == Lsne){
if(v == false)
v = true;
else
v = false;
}
v1 = v;
Landand =>
v1 = epopval(ex);
(pc, apc) = getjmp(code.ops, pc);
if(toBoolean(ex, v1) != false){
(pc, a1) = eexp(ex, code, pc, apc);
v1 = getValue(ex, a1);
}
pc = apc;
Loror =>
v1 = epopval(ex);
(pc, apc) = getjmp(code.ops, pc);
if(toBoolean(ex, v1) != true){
(pc, a1) = eexp(ex, code, pc, apc);
v1 = getValue(ex, a1);
}
pc = apc;
'?' =>
v1 = epopval(ex);
(pc, apc) = getjmp(code.ops, pc);
v1 = toBoolean(ex, v1);
if(v1 == true)
(pc, a1) = eexp(ex, code, pc, apc);
pc = apc;
(pc, apc) = getjmp(code.ops, pc);
if(v1 != true)
(pc, a1) = eexp(ex, code, pc, apc);
pc = apc;
v1 = getValue(ex, a1);
Lasop =>
a1 = epop(ex);
epush(ex, a1);
v1 = getValue(ex, a1);
Lgetval =>
v1 = epopval(ex);
',' =>
v1 = epopval(ex);
epop(ex);
# a1's value already gotten by Lgetval
'(' or
')' =>
continue;
Larrinit =>
o = narray(ex, nil, nil);
(pc, c) = getconst(code.ops, pc);
esput(ex, o, "length", numval(real c), 0);
c = ex.sp-c;
for(sp := c; sp < ex.sp; sp++){
v = getValue(ex, ex.stack[sp]);
if(v != undefined)
esput(ex, o, string (sp-c), v, 0);
}
ex.sp = c;
v1 = objval(o);
Lobjinit =>
o = nobj(ex, nil, nil);
(pc, c) = getconst(code.ops, pc);
c = ex.sp-2*c;
for(sp := c; sp < ex.sp; sp += 2){
v = getValue(ex, ex.stack[sp]);
if(isnum(v) || isstr(v))
p := toString(ex, v);
else
p = ex.stack[sp].name;
v = getValue(ex, ex.stack[sp+1]);
esput(ex, o, p, v, 0);
}
ex.sp = c;
v1 = objval(o);
Lcall or
Lnewcall =>
(pc, c) = getconst(code.ops, pc);
args := array[c] of ref Val;
c = ex.sp - c;
for(sp := c; sp < ex.sp; sp++)
args[sp-c] = getValue(ex, ex.stack[sp]);
ex.sp = c;
a1 = epop(ex);
v = getValue(ex, a1);
o = getobj(v);
if(op == Lcall){
if(o == nil || o.call == nil)
runtime(ex, TypeError, "can only call function objects ("+a1.name+")");
th = nil;
if(a1.isref){
th = getBase(ex, a1);
if(th != nil && isactobj(th))
th = nil;
}
# have to execute functions in the same context as they
# were defined, but need to use current stack.
if (o.call.ex == nil)
a1 = escall(ex, v.obj, th, args, 0);
else {
fnex := ref *o.call.ex;
fnex.stack = ex.stack;
fnex.sp = ex.sp;
fnex.scopechain = fnex.global :: nil;
# drop ref to stack to avoid array duplication should stack grow
ex.stack = nil;
osp := ex.sp;
# can get an exception here that corrupts ex etc.
#aardvark:=99;
#test:=99;
# zebra:=99;
{
a1 = escall(fnex, v.obj, th, args, 0);
}
exception e{
"throw" =>
# copy up error so as it gets reported properly
ex.error = fnex.error;
ex.errval = fnex.errval;
ex.stack = fnex.stack;
ex.sp = osp;
# raise e;
raise "throw";
}
# restore stack, sp is OK as escall() ensures that stack is balanced
ex.stack = fnex.stack;
}
}else{
if(o == nil || o.construct == nil)
runtime(ex, TypeError, "new must be given a constructor object");
a1 = valref(objval(esconstruct(ex, o, args)));
}
epush(ex, a1);
args = nil;
continue;
Lnew =>
v = epopval(ex);
o = getobj(v);
if(o == nil || o.construct == nil)
runtime(ex, TypeError, "new must be given a constructor object");
v1 = objval(esconstruct(ex, o, nil));
Lfunction =>
(pc, c) = getconst(code.ops, pc);
v1 = objval(code.fexps[c]);
';' =>
break out;
* =>
fatal(ex, sprint("eexp: unknown op %s\n", tokname(op)));
}
epushval(ex, v1);
}
if(savesp == ex.sp)
return (pc, nil);
if(savesp != ex.sp-1)
print("unbalanced stack in eexp: %d %d\n", savesp, ex.sp);
return (pc, epop(ex));
}
epushval(ex: ref Exec, v: ref Val)
{
epush(ex, valref(v));
}
epush(ex: ref Exec, r: ref Ref)
{
if(ex.sp >= len ex.stack){
st := array[2 * len ex.stack] of ref Ref;
st[:] = ex.stack;
ex.stack = st;
}
ex.stack[ex.sp++] = r;
}
epop(ex: ref Exec): ref Ref
{
if(ex.sp == 0)
fatal(ex, "popping too far off the estack\n");
return ex.stack[--ex.sp];
}
epopval(ex: ref Exec): ref Val
{
if(ex.sp == 0)
fatal(ex, "popping too far off the estack\n");
return getValue(ex, ex.stack[--ex.sp]);
}
inlabs(lab: string, labs: list of string): int
{
for(l := labs; l != nil; l = tl l)
if(hd l == lab)
return 1;
return 0;
}
initlabs(lab: string, labs: list of string): int
{
return lab == nil || inlabs(lab, labs);
}