summaryrefslogtreecommitdiff
path: root/appl/lib/ecmascript/exec.b
diff options
context:
space:
mode:
Diffstat (limited to 'appl/lib/ecmascript/exec.b')
-rw-r--r--appl/lib/ecmascript/exec.b863
1 files changed, 863 insertions, 0 deletions
diff --git a/appl/lib/ecmascript/exec.b b/appl/lib/ecmascript/exec.b
new file mode 100644
index 00000000..d182df82
--- /dev/null
+++ b/appl/lib/ecmascript/exec.b
@@ -0,0 +1,863 @@
+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);
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 15:37:45 +0000