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);
}