20060303a

1 files changed, 1402 insertions, 0 deletions

diff --git a/appl/cmd/limbo/nodes.b b/appl/cmd/limbo/nodes.b
new file mode 100644
index 00000000..61e97dc0
--- /dev/null
+++ b/appl/cmd/limbo/nodes.b
@@ -0,0 +1,1402 @@
+include "opname.m";
+
+znode:	Node;
+
+isused = array[Oend] of
+{
+	Oas =>		1,
+	Odas =>		1,
+	Oaddas =>	1,
+	Osubas =>	1,
+	Omulas =>	1,
+	Odivas =>	1,
+	Omodas =>	1,
+	Oexpas =>	1,
+	Oandas =>	1,
+	Ooras =>	1,
+	Oxoras =>	1,
+	Olshas =>	1,
+	Onothing =>	1,
+	Orshas =>	1,
+	Oinc =>		1,
+	Odec =>		1,
+	Opreinc =>	1,
+	Opredec =>	1,
+	Ocall =>	1,
+	Oraise =>	1,
+	Ospawn =>	1,
+	Osnd =>		1,
+	Orcv =>		1,
+
+	* =>		0
+};
+
+sideeffect := array[Oend] of
+{
+	Oas =>		1,
+	Odas =>		1,
+	Oaddas =>	1,
+	Osubas =>	1,
+	Omulas =>	1,
+	Odivas =>	1,
+	Omodas =>	1,
+	Oexpas =>	1,
+	Oandas =>	1,
+	Ooras =>	1,
+	Oxoras =>	1,
+	Olshas =>	1,
+	Orshas =>	1,
+	Oinc =>		1,
+	Odec =>		1,
+	Opreinc =>	1,
+	Opredec =>	1,
+	Ocall =>	1,
+	Oraise =>	1,
+	Ospawn =>	1,
+	Osnd =>		1,
+	Orcv =>		1,
+
+	Oadr =>		1,
+	Oarray =>	1,
+	Ocast =>	1,
+	Ochan =>	1,
+	Ocons =>	1,
+	Odiv =>		1,
+	Odot =>		1,
+	Oind =>		1,
+	Oindex =>	1,
+	Oinds =>	1,
+	Oindx =>	1,
+	Olen =>		1,
+	Oload =>	1,
+	Omod =>		1,
+	Oref =>		1,
+
+	* =>		0
+};
+
+opcommute = array[Oend] of
+{
+	Oeq =>		Oeq,
+	Oneq =>		Oneq,
+	Olt =>		Ogt,
+	Ogt =>		Olt,
+	Ogeq =>		Oleq,
+	Oleq =>		Ogeq,
+	Oadd =>		Oadd,
+	Omul =>		Omul,
+	Oxor =>		Oxor,
+	Oor =>		Oor,
+	Oand =>		Oand,
+
+	* =>		0
+};
+
+oprelinvert = array[Oend] of
+{
+
+	Oeq =>		Oneq,
+	Oneq =>		Oeq,
+	Olt =>		Ogeq,
+	Ogt =>		Oleq,
+	Ogeq =>		Olt,
+	Oleq =>		Ogt,
+
+	* =>		0
+};
+
+isrelop := array[Oend] of
+{
+
+	Oeq =>		1,
+	Oneq =>		1,
+	Olt =>		1,
+	Oleq =>		1,
+	Ogt =>		1,
+	Ogeq =>		1,
+	Oandand =>	1,
+	Ooror =>	1,
+	Onot =>		1,
+
+	* =>		0
+};
+
+ipow(x: big, n: int): big
+{
+	inv: int;
+	r: big;
+
+	inv = 0;
+	if(n < 0){
+		n = -n;
+		inv = 1;
+	}
+	r = big 1;
+	for(;;){
+		if(n&1)
+			r *= x;
+		if((n >>= 1) == 0)
+			break;
+		x *= x;
+	}
+	if(inv)
+		r = big 1/r;
+	return r;
+}
+
+rpow(x: real, n: int): real
+{
+	inv: int;
+	r: real;
+
+	inv = 0;
+	if(n < 0){
+		n = -n;
+		inv = 1;
+	}
+	r = 1.0;
+	for(;;){
+		if(n&1)
+			r *= x;
+		if((n >>= 1) == 0)
+			break;
+		x *= x;
+	}
+	if(inv)
+		r = 1.0/r;
+	return r;
+}
+
+real2fix(v: real, t: ref Type): big
+{
+	return big(v/scale(t));
+}
+
+fix2fix(v: big, f: ref Type, t: ref Type): big
+{
+	return big(real v * (scale(f)/scale(t)));
+}
+
+fix2real(v: big, f: ref Type): real
+{
+	return real v * scale(f);
+}
+
+istuple(n: ref Node): int
+{
+	d: ref Decl;
+
+	case(n.op){
+	Otuple =>
+		return 1;
+	Oname =>
+		d = n.decl;
+		if(d.importid != nil)
+			d = d.importid;
+		return d.store == Dconst && (n.ty.kind == Ttuple || n.ty.kind == Tadt);
+	Odot =>
+		return 0;	# istuple(n.left);
+	}
+	return 0;
+}
+
+tuplemem(n: ref Node, d: ref Decl): ref Node
+{
+	ty: ref Type;
+	ids: ref Decl;
+
+	ty = n.ty;
+	n = n.left;
+	for(ids = ty.ids; ids != nil; ids = ids.next){
+		if(ids.sym == d.sym)
+			break;
+		else
+			n = n.right;
+	}
+	if(n == nil)
+		fatal("tuplemem cannot cope !\n");
+	return n.left;
+}
+
+varcom(v: ref Decl): int
+{
+	n := v.init;
+	n = fold(n);
+	v.init = n;
+	if(debug['v'])
+		print("variable '%s' val %s\n", v.sym.name, expconv(n));
+	if(n == nil)
+		return 1;
+
+	tn := ref znode;
+	tn.op = Oname;
+	tn.decl = v;
+	tn.src = v.src;
+	tn.ty = v.ty;
+	return initable(tn, n, 0);
+}
+
+initable(v, n: ref Node, allocdep: int): int
+{
+	case n.ty.kind{
+	Tiface or
+	Tgoto or
+	Tcase or
+	Tcasel or
+	Tcasec or
+	Talt or
+	Texcept =>
+		return 1;
+	Tint or
+	Tbig or
+	Tbyte or
+	Treal or
+	Tstring or
+	Tfix =>
+		if(n.op != Oconst)
+			break;
+		return 1;
+	Tadt or
+	Tadtpick or
+	Ttuple =>
+		if(n.op == Otuple)
+			n = n.left;
+		else if(n.op == Ocall)
+			n = n.right;
+		else
+			break;
+		for(; n != nil; n = n.right)
+			if(!initable(v, n.left, allocdep))
+				return 0;
+		return 1;
+	Tarray =>
+		if(n.op != Oarray)
+			break;
+		if(allocdep >= DADEPTH){
+			nerror(v, expconv(v)+"s initializer has arrays nested more than "+string allocdep+" deep");
+			return 0;
+		}
+		allocdep++;
+		usedesc(mktdesc(n.ty.tof));
+		if(n.left.op != Oconst){
+			nerror(v, expconv(v)+"s size is not a constant");
+			return 0;
+		}
+		for(e := n.right; e != nil; e = e.right)
+			if(!initable(v, e.left.right, allocdep))
+				return 0;
+		return 1;
+	Tany =>
+		return 1;
+	Tref or
+	Tlist or
+	Tpoly or
+	* =>
+		nerror(v, "can't initialize "+etconv(v));
+		return 0;
+	}
+	nerror(v, expconv(v)+"s initializer, "+expconv(n)+", is not a constant expression");
+	return 0;
+}
+
+#
+# merge together two sorted lists, yielding a sorted list
+#
+elemmerge(e, f: ref Node): ref Node
+{
+	r := rock := ref Node;
+	while(e != nil && f != nil){
+		if(e.left.left.c.val <= f.left.left.c.val){
+			r.right = e;
+			e = e.right;
+		}else{
+			r.right = f;
+			f = f.right;
+		}
+		r = r.right;
+	}
+	if(e != nil)
+		r.right = e;
+	else
+		r.right = f;
+	return rock.right;
+}
+
+#
+# recursively split lists and remerge them after they are sorted
+#
+recelemsort(e: ref Node, n: int): ref Node
+{
+	if(n <= 1)
+		return e;
+	m := n / 2 - 1;
+	ee := e;
+	for(i := 0; i < m; i++)
+		ee = ee.right;
+	r := ee.right;
+	ee.right = nil;
+	return elemmerge(recelemsort(e, n / 2),
+			recelemsort(r, (n + 1) / 2));
+}
+
+#
+# sort the elems by index; wild card is first
+#
+elemsort(e: ref Node): ref Node
+{
+	n := 0;
+	for(ee := e; ee != nil; ee = ee.right){
+		if(ee.left.left.op == Owild)
+			ee.left.left.c = ref Const(big -1, 0.);
+		n++;
+	}
+	return recelemsort(e, n);
+}
+
+sametree(n1: ref Node, n2: ref Node): int
+{
+	if(n1 == n2)
+		return 1;
+	if(n1 == nil || n2 == nil)
+		return 0;
+	if(n1.op != n2.op || n1.ty != n2.ty)
+		return 0;
+	if(n1.op == Oconst){
+		case(n1.ty.kind){
+		Tbig or
+		Tbyte or
+		Tint =>
+			return n1.c.val == n2.c.val;
+		Treal =>
+			return n1.c.rval == n2.c.rval;
+		Tfix =>
+			return n1.c.val == n2.c.val && tequal(n1.ty, n2.ty);
+		Tstring =>
+			return n1.decl.sym == n2.decl.sym;
+		}
+		return 0;
+	}
+	return n1.decl == n2.decl && sametree(n1.left, n2.left) && sametree(n1.right, n2.right);
+}
+
+occurs(d: ref Decl, n: ref Node): int
+{
+	if(n == nil)
+		return 0;
+	if(n.op == Oname){
+		if(d == n.decl)
+			return 1;
+		return 0;
+	}
+	return occurs(d, n.left) + occurs(d, n.right);
+}
+
+#
+# left and right subtrees the same
+#
+folds(n: ref Node): ref Node
+{
+	if(hasside(n, 1))
+		return n;
+	case(n.op){
+	Oeq or
+	Oleq or
+	Ogeq =>
+		n.c = ref Const(big 1, 0.0);
+	Osub =>
+		n.c = ref Const(big 0, 0.0);
+	Oxor or
+	Oneq or
+	Olt or
+	Ogt =>
+		n.c = ref Const(big 0, 0.0);
+	Oand or
+	Oor or
+	Oandand or
+	Ooror =>
+		return n.left;
+	* =>
+		return n;
+	}
+	n.op = Oconst;
+	n.left = n.right = nil;
+	n.decl = nil;
+	return n;
+}
+
+#
+# constant folding for typechecked expressions
+#
+fold(n: ref Node): ref Node
+{
+	if(n == nil)
+		return nil;
+	if(debug['F'])
+		print("fold %s\n", nodeconv(n));
+	n = efold(n);
+	if(debug['F'])
+		print("folded %s\n", nodeconv(n));
+	return n;
+}
+
+efold(n: ref Node): ref Node
+{
+	d: ref Decl;
+
+	if(n == nil)
+		return nil;
+
+	left := n.left;
+	right := n.right;
+	case n.op{
+	Oname =>
+		d = n.decl;
+		if(d.importid != nil)
+			d = d.importid;
+		if(d.store != Dconst){
+			if(d.store == Dtag){
+				n.op = Oconst;
+				n.ty = tint;
+				n.c = ref Const(big d.tag, 0.);
+			}
+			break;
+		}
+		case n.ty.kind{
+		Tbig =>
+			n.op = Oconst;
+			n.c = ref Const(d.init.c.val, 0.);
+		Tbyte =>
+			n.op = Oconst;
+			n.c = ref Const(big byte d.init.c.val, 0.);
+		Tint or
+		Tfix =>
+			n.op = Oconst;
+			n.c = ref Const(big int d.init.c.val, 0.);
+		Treal =>
+			n.op = Oconst;
+			n.c = ref Const(big 0, d.init.c.rval);
+		Tstring =>
+			n.op = Oconst;
+			n.decl = d.init.decl;
+		Ttuple =>
+			*n = *d.init;
+		Tadt =>
+			*n = *d.init;
+			n = rewrite(n);	# was call
+		Texception =>
+			if(n.ty.cons == byte 0)
+				fatal("non-const exception type in efold");
+			n.op = Oconst;
+		* =>
+			fatal("unknown const type "+typeconv(n.ty)+" in efold");
+		}
+	Oadd =>
+		left = efold(left);
+		right = efold(right);
+		n.left = left;
+		n.right = right;
+		if(n.ty == tstring && right.op == Oconst){
+			if(left.op == Oconst)
+				n = mksconst(n.src, stringcat(left.decl.sym, right.decl.sym));
+			else if(left.op == Oadd && left.ty == tstring && left.right.op == Oconst){
+				left.right = mksconst(n.src, stringcat(left.right.decl.sym, right.decl.sym));
+				n = left;
+			}
+		}
+	Olen =>
+		left = efold(left);
+		n.left = left;
+		if(left.ty == tstring && left.op == Oconst)
+			n = mkconst(n.src, big len left.decl.sym.name);
+	Oslice =>
+		if(right.left.op == Onothing)
+			right.left = mkconst(right.left.src, big 0);
+		n.left = efold(left);
+		n.right = efold(right);
+	Oinds =>
+		n.left = left = efold(left);
+		n.right = right = efold(right);
+		if(right.op == Oconst && left.op == Oconst){
+			;
+		}
+	Ocast =>
+		n.op = Ocast;
+		left = efold(left);
+		n.left = left;
+		if(n.ty == left.ty || n.ty.kind == Tfix && tequal(n.ty, left.ty))
+			return left;
+		if(left.op == Oconst)
+			return foldcast(n, left);
+	Odot or
+	Omdot =>
+		#
+		# what about side effects from left?
+		#
+		d = right.decl;
+		case d.store{
+		Dconst or
+		Dtag or
+		Dtype =>
+			#
+			# set it up as a name and let that case do the hard work
+			#
+			n.op = Oname;
+			n.decl = d;
+			n.left = nil;
+			n.right = nil;
+			return efold(n);
+		}
+		n.left = efold(left);
+		if(n.left.op == Otuple)
+			n = tuplemem(n.left, d);
+		else
+			n.right = efold(right);
+	Otagof =>
+		if(n.decl != nil){
+			n.op = Oconst;
+			n.left = nil;
+			n.right = nil;
+			n.c = ref Const(big n.decl.tag, 0.);			
+			return efold(n);
+		}
+		n.left = efold(left);
+	Oif =>
+		n.left = left = efold(left);
+		n.right = right = efold(right);
+		if(left.op == Oconst){
+			if(left.c.val != big 0)
+				return right.left;
+			else
+				return right.right;
+		}
+	* =>
+		n.left = efold(left);
+		n.right = efold(right);
+	}
+
+	left = n.left;
+	right = n.right;
+	if(left == nil)
+		return n;
+
+	if(right == nil){
+		if(left.op == Oconst){
+			if(left.ty == tint || left.ty == tbyte || left.ty == tbig)
+				return foldc(n);
+			if(left.ty == treal)
+				return foldr(n);
+		}
+		return n;
+	}
+
+	if(left.op == Oconst){
+		case n.op{
+		Olsh or
+		Orsh =>
+			if(left.c.val == big 0 && !hasside(right, 1))
+				return left;
+		Ooror =>
+			if(left.ty == tint || left.ty == tbyte || left.ty == tbig){
+				if(left.c.val == big 0){
+					n = mkbin(Oneq, right, mkconst(right.src, big 0));
+					n.ty = right.ty;
+					n.left.ty = right.ty;
+					return efold(n);
+				}
+				left.c.val = big 1;
+				return left;
+			}
+		Oandand =>
+			if(left.ty == tint || left.ty == tbyte || left.ty == tbig){
+				if(left.c.val == big 0)
+					return left;
+				n = mkbin(Oneq, right, mkconst(right.src, big 0));
+				n.ty = right.ty;
+				n.left.ty = right.ty;
+				return efold(n);
+			}
+		}
+	}
+	if(left.op == Oconst && right.op != Oconst
+	&& opcommute[n.op]
+	&& n.ty != tstring){
+		n.op = opcommute[n.op];
+		n.left = right;
+		n.right = left;
+		left = right;
+		right = n.right;
+	}
+	if(right.op == Oconst && left.op == n.op && left.right.op == Oconst
+	&& (n.op == Oadd || n.op == Omul || n.op == Oor || n.op == Oxor || n.op == Oand)
+	&& n.ty != tstring){
+		n.left = left.left;
+		left.left = right;
+		right = efold(left);
+		n.right = right;
+		left = n.left;
+	}
+	if(right.op == Oconst){
+		if(n.op == Oexp && left.ty == treal){
+			if(left.op == Oconst)
+				return foldr(n);
+			return n;
+		}
+		if(right.ty == tint || right.ty == tbyte || left.ty == tbig){
+			if(left.op == Oconst)
+				return foldc(n);
+			return foldvc(n);
+		}
+		if(right.ty == treal && left.op == Oconst)
+			return foldr(n);
+	}
+	if(sametree(left, right))
+		return folds(n);
+	return n;
+}
+
+#
+# does evaluating the node have any side effects?
+#
+hasside(n: ref Node, strict: int): int
+{
+	for(; n != nil; n = n.right){
+		if(sideeffect[n.op] && (strict || n.op != Oadr && n.op != Oind))
+			return 1;
+		if(hasside(n.left, strict))
+			return 1;
+	}
+	return 0;
+}
+
+hascall(n: ref Node): int
+{
+	for(; n != nil; n = n.right){
+		if(n.op == Ocall || n.op == Ospawn)
+			return 1;
+		if(hascall(n.left))
+			return 1;
+	}
+	return 0;
+}
+
+hasasgns(n: ref Node): int
+{
+	if(n == nil)
+		return 0;
+	if(n.op != Ocall && isused[n.op] && n.op != Onothing)
+		return 1;
+	return hasasgns(n.left) || hasasgns(n.right);
+}
+
+nodes(n: ref Node): int
+{
+	if(n == nil)
+		return 0;
+	return 1+nodes(n.left)+nodes(n.right);
+}
+	
+foldcast(n, left: ref Node): ref Node
+{
+	case left.ty.kind{
+	Tint =>
+		left.c.val = big int left.c.val;
+		return foldcasti(n, left);
+	Tbyte =>
+		left.c.val = big byte left.c.val;
+		return foldcasti(n, left);
+	Tbig =>
+		return foldcasti(n, left);
+	Treal =>
+		case n.ty.kind{
+		Tint or
+		Tbyte or
+		Tbig =>
+			left.c.val = big left.c.rval;
+		Tfix =>
+			left.c.val = real2fix(left.c.rval, n.ty);
+		Tstring =>
+			return mksconst(n.src, enterstring(string left.c.rval));
+		* =>
+			return n;
+		}
+	Tfix =>
+		case n.ty.kind{
+		Tint or
+		Tbyte or
+		Tbig =>
+			left.c.val = big fix2real(left.c.val, left.ty);
+		Treal =>
+			left.c.rval = fix2real(left.c.val, left.ty);
+		Tfix =>
+			if(tequal(left.ty, n.ty))
+				return left;
+			left.c.val = fix2fix(left.c.val, left.ty, n.ty);
+		Tstring =>
+			return mksconst(n.src, enterstring(string fix2real(left.c.val, left.ty)));
+		* =>
+			return n;
+		}
+		break;
+	Tstring =>
+		case n.ty.kind{
+		Tint or
+		Tbyte or
+		Tbig =>
+			left.c = ref Const(big left.decl.sym.name, 0.);
+		Treal =>
+			left.c = ref Const(big 0, real left.decl.sym.name);
+		Tfix =>
+			left.c = ref Const(real2fix(real left.decl.sym.name, n.ty), 0.);
+		* =>
+			return n;
+		}
+	* =>
+		return n;
+	}
+	left.ty = n.ty;
+	left.src = n.src;
+	return left;
+}
+
+#
+# left is some kind of int type
+#
+foldcasti(n, left: ref Node): ref Node
+{
+	case n.ty.kind{
+	Tint =>
+		left.c.val = big int left.c.val;
+	Tbyte =>
+		left.c.val = big byte left.c.val;
+	Tbig =>
+		;
+	Treal =>
+		left.c.rval = real left.c.val;
+	Tfix =>
+		left.c.val = real2fix(real left.c.val, n.ty);
+	Tstring =>
+		return mksconst(n.src, enterstring(string left.c.val));
+	* =>
+		return n;
+	}
+	left.ty = n.ty;
+	left.src = n.src;
+	return left;
+}
+
+#
+# right is a const int
+#
+foldvc(n: ref Node): ref Node
+{
+	left := n.left;
+	right := n.right;
+	case n.op{
+	Oadd or
+	Osub or
+	Oor or
+	Oxor or
+	Olsh or
+	Orsh or
+	Ooror =>
+		if(right.c.val == big 0)
+			return left;
+		if(n.op == Ooror && !hasside(left, 1))
+			return right;
+	Oand =>
+		if(right.c.val == big 0 && !hasside(left, 1))
+			return right;
+	Omul =>
+		if(right.c.val == big 1)
+			return left;
+		if(right.c.val == big 0 && !hasside(left, 1))
+			return right;
+	Odiv =>
+		if(right.c.val == big 1)
+			return left;
+	Omod =>
+		if(right.c.val == big 1 && !hasside(left, 1)){
+			right.c.val = big 0;
+			return right;
+		}
+	Oexp =>
+		if(right.c.val == big 0){
+			right.c.val = big 1;
+			return right;
+		}
+		if(right.c.val == big 1)
+			return left;
+	Oandand =>
+		if(right.c.val != big 0)
+			return left;
+		if(!hasside(left, 1))
+			return right;
+	Oneq =>
+		if(!isrelop[left.op])
+			return n;
+		if(right.c.val == big 0)
+			return left;
+		n.op = Onot;
+		n.right = nil;
+	Oeq =>
+		if(!isrelop[left.op])
+			return n;
+		if(right.c.val != big 0)
+			return left;
+		n.op = Onot;
+		n.right = nil;
+	}
+	return n;
+}
+
+#
+# left and right are const ints
+#
+foldc(n: ref Node): ref Node
+{
+	v: big;
+	rv, nb: int;
+
+	left := n.left;
+	right := n.right;
+	case n.op{
+	Oadd =>
+		v = left.c.val + right.c.val;
+	Osub =>
+		v = left.c.val - right.c.val;
+	Omul =>
+		v = left.c.val * right.c.val;
+	Odiv =>
+		if(right.c.val == big 0){
+			nerror(n, "divide by 0 in constant expression");
+			return n;
+		}
+		v = left.c.val / right.c.val;
+	Omod =>
+		if(right.c.val == big 0){
+			nerror(n, "mod by 0 in constant expression");
+			return n;
+		}
+		v = left.c.val % right.c.val;
+	Oexp =>
+		if(left.c.val == big 0 && right.c.val < big 0){
+			nerror(n, "0 to negative power in constant expression");
+			return n;
+		}
+		v = ipow(left.c.val, int right.c.val);
+	Oand =>
+		v = left.c.val & right.c.val;
+	Oor =>
+		v = left.c.val | right.c.val;
+	Oxor =>
+		v = left.c.val ^ right.c.val;
+	Olsh =>
+		v = left.c.val;
+		rv = int right.c.val;
+		if(rv < 0 || rv >= n.ty.size * 8){
+			nwarn(n, "shift amount "+string rv+" out of range");
+			rv = 0;
+		}
+		if(rv == 0)
+			break;
+		v <<= rv;
+	Orsh =>
+		v = left.c.val;
+		rv = int right.c.val;
+		nb = n.ty.size * 8;
+		if(rv < 0 || rv >= nb){
+			nwarn(n, "shift amount "+string rv+" out of range");
+			rv = 0;
+		}
+		if(rv == 0)
+			break;
+		v >>= rv;
+	Oneg =>
+		v = -left.c.val;
+	Ocomp =>
+		v = ~left.c.val;
+	Oeq =>
+		v = big(left.c.val == right.c.val);
+	Oneq =>
+		v = big(left.c.val != right.c.val);
+	Ogt =>
+		v = big(left.c.val > right.c.val);
+	Ogeq =>
+		v = big(left.c.val >= right.c.val);
+	Olt =>
+		v = big(left.c.val < right.c.val);
+	Oleq =>
+		v = big(left.c.val <= right.c.val);
+	Oandand =>
+		v = big(int left.c.val && int right.c.val);
+	Ooror =>
+		v = big(int left.c.val || int right.c.val);
+	Onot =>
+		v = big(left.c.val == big 0);
+	* =>
+		return n;
+	}
+	if(n.ty == tint)
+		v = big int v;
+	else if(n.ty == tbyte)
+		v = big byte v;
+	n.left = nil;
+	n.right = nil;
+	n.decl = nil;
+	n.op = Oconst;
+	n.c = ref Const(v, 0.);
+	return n;
+}
+
+#
+# left and right are const reals
+#
+foldr(n: ref Node): ref Node
+{
+	rv := 0.;
+	v := big 0;
+
+	left := n.left;
+	right := n.right;
+	case n.op{
+	Ocast =>
+		return n;
+	Oadd =>
+		rv = left.c.rval + right.c.rval;
+	Osub =>
+		rv = left.c.rval - right.c.rval;
+	Omul =>
+		rv = left.c.rval * right.c.rval;
+	Odiv =>
+		rv = left.c.rval / right.c.rval;
+	Oexp =>
+		rv = rpow(left.c.rval, int right.c.val);
+	Oneg =>
+		rv = -left.c.rval;
+	Oinv =>
+		if(left.c.rval == 0.0){
+			error(n.src.start, "divide by 0 in fixed point type");
+			return n;
+		}
+		rv = 1.0/left.c.rval;
+	Oeq =>
+		v = big(left.c.rval == right.c.rval);
+	Oneq =>
+		v = big(left.c.rval != right.c.rval);
+	Ogt =>
+		v = big(left.c.rval > right.c.rval);
+	Ogeq =>
+		v = big(left.c.rval >= right.c.rval);
+	Olt =>
+		v = big(left.c.rval < right.c.rval);
+	Oleq =>
+		v = big(left.c.rval <= right.c.rval);
+	* =>
+		return n;
+	}
+	n.left = nil;
+	n.right = nil;
+	n.op = Oconst;
+
+	if(isnan(rv))
+		rv = canonnan;
+
+	n.c = ref Const(v, rv);
+	return n;
+}
+
+varinit(d: ref Decl, e: ref Node): ref Node
+{
+	n := mkdeclname(e.src, d);
+	if(d.next == nil)
+		return mkbin(Oas, n, e);
+	return mkbin(Oas, n, varinit(d.next, e));
+}
+
+#
+# given: an Oseq list with left == next or the last child
+# make a list with the right == next
+# ie: Oseq(Oseq(a, b),c) ==> Oseq(a, Oseq(b, Oseq(c, nil))))
+#
+rotater(e: ref Node): ref Node
+{
+	if(e == nil)
+		return e;
+	if(e.op != Oseq)
+		return mkunary(Oseq, e);
+	e.right = mkunary(Oseq, e.right);
+	while(e.left.op == Oseq){
+		left := e.left;
+		e.left = left.right;
+		left.right = e;
+		e = left;
+	}
+	return e;
+}
+
+#
+# reverse the case labels list
+#
+caselist(s, nr: ref Node): ref Node
+{
+	r := s.right;
+	s.right = nr;
+	if(r == nil)
+		return s;
+	return caselist(r, s);
+}
+
+#
+# e is a seq of expressions; make into cons's to build a list
+#
+etolist(e: ref Node): ref Node
+{
+	if(e == nil)
+		return nil;
+	n := mknil(e.src);
+	n.src.start = n.src.stop;
+	if(e.op != Oseq)
+		return mkbin(Ocons, e, n);
+	e.right = mkbin(Ocons, e.right, n);
+	while(e.left.op == Oseq){
+		e.op = Ocons;
+		left := e.left;
+		e.left = left.right;
+		left.right = e;
+		e = left;
+	}
+	e.op = Ocons;
+	return e;
+}
+
+dupn(resrc: int, src: Src, n: ref Node): ref Node
+{
+	nn := ref *n;
+	if(resrc)
+		nn.src = src;
+	if(nn.left != nil)
+		nn.left = dupn(resrc, src, nn.left);
+	if(nn.right != nil)
+		nn.right = dupn(resrc, src, nn.right);
+	return nn;
+}
+
+mkn(op: int, left, right: ref Node): ref Node
+{
+	n := ref Node;
+	n.op = op;
+	n.flags = byte 0;
+	n.left = left;
+	n.right = right;
+	return n;
+}
+
+mkunary(op: int, left: ref Node): ref Node
+{
+	n := ref Node;
+	n.src = left.src;
+	n.op = op;
+	n.flags = byte 0;
+	n.left = left;
+	return n;
+}
+
+mkbin(op: int, left, right: ref Node): ref Node
+{
+	n := ref Node;
+	n.src.start = left.src.start;
+	n.src.stop = right.src.stop;
+	n.op = op;
+	n.flags = byte 0;
+	n.left = left;
+	n.right = right;
+	return n;
+}
+
+mkdeclname(src: Src, d: ref Decl): ref Node
+{
+	n := ref Node;
+	n.src = src;
+	n.op = Oname;
+	n.flags = byte 0;
+	n.decl = d;
+	n.ty = d.ty;
+	d.refs++;
+	return n;
+}
+
+mknil(src: Src): ref Node
+{
+	return mkdeclname(src, nildecl);
+}
+
+mkname(src: Src, s: ref Sym): ref Node
+{
+	n := ref Node;
+	n.src = src;
+	n.op = Oname;
+	n.flags = byte 0;
+	if(s.unbound == nil){
+		s.unbound = mkdecl(src, Dunbound, nil);
+		s.unbound.sym = s;
+	}
+	n.decl = s.unbound;
+	return n;
+}
+
+mkconst(src: Src, v: big): ref Node
+{
+	n := ref Node;
+	n.src = src;
+	n.op = Oconst;
+	n.flags = byte 0;
+	n.ty = tint;
+	n.c = ref Const(v, 0.);
+	return n;
+}
+
+mkrconst(src: Src, v: real): ref Node
+{
+	n := ref Node;
+	n.src = src;
+	n.op = Oconst;
+	n.flags = byte 0;
+	n.ty = treal;
+	n.c = ref Const(big 0, v);
+	return n;
+}
+
+mksconst(src: Src, s: ref Sym): ref Node
+{
+	n := ref Node;
+	n.src = src;
+	n.op = Oconst;
+	n.flags = byte 0;
+	n.ty = tstring;
+	n.decl = mkdecl(src, Dconst, tstring);
+	n.decl.sym = s;
+	return n;
+}
+
+opconv(op: int): string
+{
+	if(op < 0 || op > Oend)
+		return "op "+string op;
+	return opname[op];
+}
+
+etconv(n: ref Node): string
+{
+	s := expconv(n);
+	if(n.ty == tany || n.ty == tnone || n.ty == terror)
+		return s;
+	s += " of type ";
+	s += typeconv(n.ty);
+	return s;
+}
+
+expconv(n: ref Node): string
+{
+	return "'" + subexpconv(n) + "'";
+}
+
+subexpconv(n: ref Node): string
+{
+	if(n == nil)
+		return "";
+	s := "";
+	if(int n.flags & PARENS)
+		s[len s] = '(';
+	case n.op{
+	Obreak or
+	Ocont =>
+		s += opname[n.op];
+		if(n.decl != nil)
+			s += " "+n.decl.sym.name;
+	Oexit or
+	Owild =>
+		s += opname[n.op];
+	Onothing =>
+		;
+	Oadr or
+	Oused =>
+		s += subexpconv(n.left);
+	Oseq =>
+		s += eprintlist(n, ", ");
+	Oname =>
+		if(n.decl == nil)
+			s += "<nil>";
+		else
+			s += n.decl.sym.name;
+	Oconst =>
+		if(n.ty.kind == Tstring){
+			s += stringpr(n.decl.sym);
+			break;
+		}
+		if(n.decl != nil && n.decl.sym != nil){
+			s += n.decl.sym.name;
+			break;
+		}
+		case n.ty.kind{
+		Tbig or
+		Tint or
+		Tbyte =>
+			s += string n.c.val;
+		Treal =>
+			s += string n.c.rval;
+		Tfix =>
+			s += string n.c.val + "(" + string n.ty.val.c.rval + ")";
+		* =>
+			s += opname[n.op];
+		}
+	Ocast =>
+		s += typeconv(n.ty);
+		s[len s] = ' ';
+		s += subexpconv(n.left);
+	Otuple =>
+		if(n.ty != nil && n.ty.kind == Tadt)
+			s += n.ty.decl.sym.name;
+		s[len s] = '(';
+		s += eprintlist(n.left, ", ");
+		s[len s] = ')';
+	Ochan =>
+		if(n.left != nil){
+			s += "chan [";
+			s += subexpconv(n.left);
+			s += "] of ";
+			s += typeconv(n.ty.tof);
+		}
+		else
+			s += "chan of "+typeconv(n.ty.tof);
+	Oarray =>
+		s += "array [";
+		if(n.left != nil)
+			s += subexpconv(n.left);
+		s += "] of ";
+		if(n.right != nil){
+			s += "{";
+			s += eprintlist(n.right, ", ");
+			s += "}";
+		}else{
+			s += typeconv(n.ty.tof);
+		}
+	Oelem or
+	Olabel =>
+		if(n.left != nil){
+			s += eprintlist(n.left, " or ");
+			s += " =>";
+		}
+		s += subexpconv(n.right);
+	Orange =>
+		s += subexpconv(n.left);
+		s += " to ";
+		s += subexpconv(n.right);
+	Ospawn =>
+		s += "spawn ";
+		s += subexpconv(n.left);
+	Oraise =>
+		s += "raise ";
+		s += subexpconv(n.left);
+	Ocall =>
+		s += subexpconv(n.left);
+		s += "(";
+		s += eprintlist(n.right, ", ");
+		s += ")";
+	Oinc or
+	Odec =>
+		s += subexpconv(n.left);
+		s += opname[n.op];
+	Oindex or
+	Oindx or
+	Oinds =>
+		s += subexpconv(n.left);
+		s += "[";
+		s += subexpconv(n.right);
+		s += "]";
+	Oslice =>
+		s += subexpconv(n.left);
+		s += "[";
+		s += subexpconv(n.right.left);
+		s += ":";
+		s += subexpconv(n.right.right);
+		s += "]";
+	Oload =>
+		s += "load ";
+		s += typeconv(n.ty);
+		s += " ";
+		s += subexpconv(n.left);
+	Oref or
+	Olen or
+	Ohd or
+	Otl or
+	Otagof =>
+		s += opname[n.op];
+		s[len s] = ' ';
+		s += subexpconv(n.left);
+	* =>
+		if(n.right == nil){
+			s += opname[n.op];
+			s += subexpconv(n.left);
+		}else{
+			s += subexpconv(n.left);
+			s += opname[n.op];
+			s += subexpconv(n.right);
+		}
+	}
+	if(int n.flags & PARENS)
+		s[len s] = ')';
+	return s;
+}
+
+eprintlist(elist: ref Node, sep: string): string
+{
+	if(elist == nil)
+		return "";
+	s := "";
+	for(; elist.right != nil; elist = elist.right){
+		if(elist.op == Onothing)
+			continue;
+		if(elist.left.op == Ofnptr)
+			return s;
+		s += subexpconv(elist.left);
+		if(elist.right.left.op != Ofnptr)
+			s += sep;
+	}
+	s += subexpconv(elist.left);
+	return s;
+}
+
+nodeconv(n: ref Node): string
+{
+	return nprint(n, 0);
+}
+
+nprint(n: ref Node, indent: int): string
+{
+	if(n == nil)
+		return "";
+	s := "\n";
+	for(i := 0; i < indent; i++)
+		s[len s] = ' ';
+	case n.op{
+	Oname =>
+		if(n.decl == nil)
+			s += "<nil>";
+		else
+			s += n.decl.sym.name;
+	Oconst =>
+		if(n.decl != nil && n.decl.sym != nil)
+			s += n.decl.sym.name;
+		else
+			s += opconv(n.op);
+		if(n.ty == tint || n.ty == tbyte || n.ty == tbig)
+			s += " (" + string n.c.val + ")";
+	* =>
+		s += opconv(n.op);
+	}
+	s += " " + typeconv(n.ty) + " " + string n.addable + " " + string n.temps;
+	indent += 2;
+	s += nprint(n.left, indent);
+	s += nprint(n.right, indent);
+	return s;
+}