#include "limbo.h"
#include "y.tab.h"

Node	**labstack;
int	labdep;
static Node* inexcept;
static Decl* fndec;

void checkraises(Node *n);

static void
increfs(Decl *id)
{
	for( ; id != nil; id = id->link)
		id->refs++;
}

static int
fninline(Decl *d)
{
	Node *n, *left, *right;

	left = right = nil;
	n = d->init;
	if(dontinline || d->caninline < 0 || d->locals != nil || ispoly(d) || n->ty->tof->kind == Tnone || nodes(n) >= 100)
		return 0;
	n = n->right;
	if(n->op == Oseq && n->right == nil)
		n = n->left;
	/* 
	  *	inline
	  *		(a) return e;
	  *		(b) if(c) return e1; else return e2;
	  *		(c) if(c) return e1; return e2;
	  */
	switch(n->op){
	case Oret:
		break;
	case Oif:
		right = n->right;
		if(right->right == nil || right->left->op != Oret || right->right->op != Oret || !tequal(right->left->left->ty, right->right->left->ty))
			return 0;
		break;
	case Oseq:
		left = n->left;
		right = n->right;
		if(left->op != Oif || left->right->right != nil || left->right->left->op != Oret || right->op != Oseq || right->right != nil || right->left->op != Oret || !tequal(left->right->left->left->ty, right->left->left->ty))
			return 0;
		break;
	default:
		return 0;
	}
	if(occurs(d, n) || hasasgns(n))
		return 0;
	if(n->op == Oseq){
		left->right->right = right->left;
		n = left;
		right = n->right;
		d->init->right->right = nil;
	}
	if(n->op == Oif){
		n->ty = right->ty = right->left->left->ty;
		right->left = right->left->left;
		right->right = right->right->left;
		d->init->right->left = mkunary(Oret, n);
	}
	return 1;
}

static int
isfnrefty(Type *t)
{
	return t->kind == Tref && t->tof->kind == Tfn;
}

static int
isfnref(Decl *d)
{
	switch(d->store){
	case Dglobal:
	case Darg:
	case Dlocal:
	case Dfield:
	case Dimport:
		return isfnrefty(d->ty);
	}
	return 0;
}

int
argncompat(Node *n, Decl *f, Node *a)
{
	for(; a != nil; a = a->right){
		if(f == nil){
			nerror(n, "%V: too many function arguments", n->left);
			return 0;
		}
		f = f->next;
	}
	if(f != nil){
		nerror(n, "%V: too few function arguments", n->left);
		return 0;
	}
	return 1;
}

static void
rewind(Node *n)
{
	Node *r, *nn;

	r = n;
	nn = n->left;
	for(n = n->right; n != nil; n = n->right){
		if(n->right == nil){
			r->left = nn;
			r->right = n->left;
		}
		else
			nn = mkbin(Oindex, nn, n->left);
	}
}

static void
ckmod(Node *n, Decl *id)
{
	Type *t;
	Decl *d, *idc;
	Node *mod;

	if(id == nil)
		fatal("can't find function: %n", n);
	idc = nil;
	mod = nil;
	if(n->op == Oname){
		idc = id;
		mod = id->eimport;
	}
	else if(n->op == Omdot)
		mod = n->left;
	else if(n->op == Odot){
		idc = id->dot;
		t = n->left->ty;
		if(t->kind == Tref)
			t = t->tof;
		if(t->kind == Tadtpick)
			t = t->decl->dot->ty;
		d = t->decl;
		while(d != nil && d->link != nil)
			d = d->link;
		if(d != nil && d->timport != nil)
			mod = d->timport->eimport;
		n->right->left = mod;
	}
	if(mod != nil && mod->ty->kind != Tmodule){
		nerror(n, "cannot use %V as a function reference", n);
		return;
	}
	if(mod != nil){
		if(valistype(mod)){
			nerror(n, "cannot use %V as a function reference because %V is a module interface", n, mod);
			return;
		}
	}else if(idc != nil && idc->dot != nil && !isimpmod(idc->dot->sym)){
		nerror(n, "cannot use %V without importing %s from a variable", n, idc->sym->name);
		return;
	}
	if(mod != nil)
		modrefable(n->ty);
}

static void
addref(Node *n)
{
	Node *nn;

	nn = mkn(0, nil, nil);
	*nn = *n;
	n->op = Oref;
	n->left = nn;
	n->right = nil;
	n->decl = nil;
	n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tref, nn->ty, nil));
}

static void
fnref(Node *n, Decl *id)
{
	id->caninline = -1;
	ckmod(n, id);
	addref(n);
	while(id->link != nil)
		id = id->link;
	if(ispoly(id) && encpolys(id) != nil)
		nerror(n, "cannot have a polymorphic adt function reference %s", id->sym->name);
}

Decl*
typecheck(int checkimp)
{
	Decl *entry, *m, *d;
	Sym *s;
	int i;

	if(errors)
		return nil;

	/*
	 * generate the set of all functions
	 * compile one function at a time
	 */
	gdecl(tree);
	gbind(tree);
	fns = allocmem(nfns * sizeof(Decl));
	i = gcheck(tree, fns, 0);
	if(i != nfns)
		fatal("wrong number of functions found in gcheck");

	maxlabdep = 0;
	for(i = 0; i < nfns; i++){
		d = fns[i];
		if(d != nil)
			fndec = d;
		if(d != nil)
			fncheck(d);
		fndec = nil;
	}

	if(errors)
		return nil;

	entry = nil;
	if(checkimp){
		Decl *im;
		Dlist *dm;

		if(impmods == nil){
			yyerror("no implementation module");
			return nil;
		}
		for(im = impmods; im != nil; im = im->next){
			for(dm = impdecls; dm != nil; dm = dm->next)
				if(dm->d->sym == im->sym)
					break;
			if(dm == nil || dm->d->ty == nil){
				yyerror("no definition for implementation module %s", im->sym->name);
				return nil;
			}
		}
	
		/*
		 * can't check the module spec until all types and imports are determined,
		 * which happens in scheck
		 */
		for(dm = impdecls; dm != nil; dm = dm->next){
			im = dm->d;
			im->refs++;
			im->ty = usetype(im->ty);
			if(im->store != Dtype || im->ty->kind != Tmodule){
				error(im->src.start, "cannot implement %K", im);
				return nil;
			}
		}
	
		/* now check any multiple implementations */
		impdecl = modimp(impdecls, impmods);

		s = enter("init", 0);
		entry = nil;
		for(dm = impdecls; dm != nil; dm = dm->next){
			im = dm->d;
			for(m = im->ty->ids; m != nil; m = m->next){
				m->ty = usetype(m->ty);
				m->refs++;
	
				if(m->sym == s && m->ty->kind == Tfn && entry == nil)
					entry = m;
	
				if(m->store == Dglobal || m->store == Dfn)
					modrefable(m->ty);
	
				if(m->store == Dtype && m->ty->kind == Tadt){
					for(d = m->ty->ids; d != nil; d = d->next){
						d->ty = usetype(d->ty);
						modrefable(d->ty);
						d->refs++;
					}
				}
			}
			checkrefs(im->ty->ids);
		}
	}

	if(errors)
		return nil;
	gsort(tree);
	tree = nil;
	return entry;
}
	
/*
 * introduce all global declarations
 * also adds all fields to adts and modules
 * note the complications due to nested Odas expressions
 */
void
gdecl(Node *n)
{
	for(;;){
		if(n == nil)
			return;
		if(n->op != Oseq)
			break;
		gdecl(n->left);
		n = n->right;
	}
	switch(n->op){
	case Oimport:
		importdecled(n);
		gdasdecl(n->right);
		break;
	case Oadtdecl:
		adtdecled(n);
		break;
	case Ocondecl:
		condecled(n);
		gdasdecl(n->right);
		break;
	case Oexdecl:
		exdecled(n);
		break;
	case Omoddecl:
		moddecled(n);
		break;
	case Otypedecl:
		typedecled(n);
		break;
	case Ovardecl:
		vardecled(n);
		break;
	case Ovardecli:
		vardecled(n->left);
		gdasdecl(n->right);
		break;
	case Ofunc:
		fndecled(n);
		break;
	case Oas:
	case Odas:
	case Onothing:
		gdasdecl(n);
		break;
	default:
		fatal("can't deal with %O in gdecl", n->op);
	}
}

/*
 * bind all global type ids,
 * including those nested inside modules
 * this needs to be done, since we may use such
 * a type later in a nested scope, so if we bound
 * the type ids then, the type could get bound
 * to a nested declaration
 */
void
gbind(Node *n)
{
	Decl *d, *ids;

	for(;;){
		if(n == nil)
			return;
		if(n->op != Oseq)
			break;
		gbind(n->left);
		n = n->right;
	}
	switch(n->op){
	case Oas:
	case Ocondecl:
	case Odas:
	case Oexdecl:
	case Ofunc:
	case Oimport:
	case Onothing:
	case Ovardecl:
	case Ovardecli:
		break;
	case Ofielddecl:
		bindtypes(n->decl->ty);
		break;
	case Otypedecl:
		bindtypes(n->decl->ty);
		if(n->left != nil)
			gbind(n->left);
		break;
	case Opickdecl:
		gbind(n->left);
		d = n->right->left->decl;
		bindtypes(d->ty);
		repushids(d->ty->ids);
		gbind(n->right->right);
		/* get new ids for undefined types; propagate outwards */
		ids = popids(d->ty->ids);
		if(ids != nil)
			installids(Dundef, ids);
		break;
	case Oadtdecl:
	case Omoddecl:
		bindtypes(n->ty);
		if(n->ty->polys != nil)
			repushids(n->ty->polys);
		repushids(n->ty->ids);
		gbind(n->left);
		/* get new ids for undefined types; propagate outwards */
		ids = popids(n->ty->ids);
		if(ids != nil)
			installids(Dundef, ids);
		if(n->ty->polys != nil)
			popids(n->ty->polys);
		break;
	default:
		fatal("can't deal with %O in gbind", n->op);
	}
}

/*
 * check all of the > declarations
 * bind all type ids referred to within types at the global level
 * record decls for defined functions
 */
int
gcheck(Node *n, Decl **fns, int nfns)
{
	Ok rok;
	Decl *d;

	for(;;){
		if(n == nil)
			return nfns;
		if(n->op != Oseq)
			break;
		nfns = gcheck(n->left, fns, nfns);
		n = n->right;
	}

	switch(n->op){
	case Ofielddecl:
		if(n->decl->ty->u.eraises)
			raisescheck(n->decl->ty);
		break;
	case Onothing:
	case Opickdecl:
		break;
	case Otypedecl:
		tcycle(n->ty);
		break;
	case Oadtdecl:
	case Omoddecl:
		if(n->ty->polys != nil)
			repushids(n->ty->polys);
		repushids(n->ty->ids);
		if(gcheck(n->left, nil, 0))
			fatal("gcheck fn decls nested in modules or adts");
		if(popids(n->ty->ids) != nil)
			fatal("gcheck installs new ids in a module or adt");
		if(n->ty->polys != nil)
			popids(n->ty->polys);
		break;
	case Ovardecl:
		varcheck(n, 1);
		break;
	case Ocondecl:
		concheck(n, 1);
		break;
	case Oexdecl:
		excheck(n, 1);
		break;
	case Oimport:
		importcheck(n, 1);
		break;
	case Ovardecli:
		varcheck(n->left, 1);
		rok = echeck(n->right, 0, 1, nil);
		if(rok.ok){
			if(rok.allok)
				n->right = fold(n->right);
			globalas(n->right->left, n->right->right, rok.allok);
		}
		break;
	case Oas:
	case Odas:
		rok = echeck(n, 0, 1, nil);
		if(rok.ok){
			if(rok.allok)
				n = fold(n);
			globalas(n->left, n->right, rok.allok);
		}
		break;
	case Ofunc:
		rok = echeck(n->left, 0, 1, n);
		if(rok.ok && n->ty->u.eraises)
			raisescheck(n->ty);
		d = nil;
		if(rok.ok)
			d = fnchk(n);
		fns[nfns++] = d;
		break;
	default:
		fatal("can't deal with %O in gcheck", n->op);
	}
	return nfns;
}

/*
 * check for unused expression results
 * make sure the any calculated expression has
 * a destination
 */
Node*
checkused(Node *n)
{
	Type *t;
	Node *nn;

	/*
	 * only nil; and nil = nil; should have type tany
	 */
	if(n->ty == tany){
		if(n->op == Oname)
			return n;
		if(n->op == Oas)
			return checkused(n->right);
		fatal("line %L checkused %n", n->src.start, n);
	}

	if(n->op == Ocall && n->left->ty->kind == Tfn && n->left->ty->tof != tnone){
		n = mkunary(Oused, n);
		n->ty = n->left->ty;
		return n;
	}
	if(n->op == Ocall && isfnrefty(n->left->ty)){
		if(n->left->ty->tof->tof != tnone){
			n = mkunary(Oused, n);
			n->ty = n->left->ty;
		}
		return n;
	}
	if(isused[n->op] && (n->op != Ocall || n->left->ty->kind == Tfn))
		return n;
	t = n->ty;
	if(t->kind == Tfn)
		nerror(n, "function %V not called", n);
	else if(t->kind == Tadt && t->tags != nil || t->kind == Tadtpick)
		nerror(n, "expressions cannot have type %T", t);
	else if(n->op == Otuple){
		for(nn = n->left; nn != nil; nn = nn->right)
			checkused(nn->left);
	}
	else
		nwarn(n, "result of expression %V not used", n);
	n = mkunary(Oused, n);
	n->ty = n->left->ty;
	return n;
}

void
fncheck(Decl *d)
{
	Node *n;
	Decl *adtp;

	n = d->init;
	if(debug['t'])
		print("typecheck tree: %n\n", n);

	fndecls = nil;
	adtp = outerpolys(n->left);
	if(n->left->op == Odot)
		repushids(adtp);
	if(d->ty->polys != nil)
		repushids(d->ty->polys);
	repushids(d->ty->ids);

	labdep = 0;
	labstack = allocmem(maxlabdep * sizeof *labstack);
	n->right = scheck(n->right, d->ty->tof, Sother);
	if(labdep != 0)
		fatal("unbalanced label stack in fncheck");
	free(labstack);

	d->locals = appdecls(popids(d->ty->ids), fndecls);
	if(d->ty->polys != nil)
		popids(d->ty->polys);
	if(n->left->op == Odot)
		popids(adtp);
	fndecls = nil;

	checkrefs(d->ty->ids);
	checkrefs(d->ty->polys);
	checkrefs(d->locals);

	checkraises(n);

	d->caninline = fninline(d);
}

Node*
scheck(Node *n, Type *ret, int kind)
{
	Node *left, *right, *last, *top;
	Decl *d;
	Sym *s;
	Ok rok;
	int i;

	top = n;
	last = nil;
	for(; n != nil; n = n->right){
		left = n->left;
		right = n->right;
		switch(n->op){
		case Ovardecl:
			vardecled(n);
			varcheck(n, 0);
			if (nested() && tmustzero(n->decl->ty))
				decltozero(n);
/*
			else if (inloop() && tmustzero(n->decl->ty))
				decltozero(n);
*/
			return top;
		case Ovardecli:
			vardecled(left);
			varcheck(left, 0);
			echeck(right, 0, 0, nil);
			if (nested() && tmustzero(left->decl->ty))
				decltozero(left);
			return top;
		case Otypedecl:
			typedecled(n);
			bindtypes(n->ty);
			tcycle(n->ty);
			return top;
		case Ocondecl:
			condecled(n);
			concheck(n, 0);
			return top;
		case Oexdecl:
			exdecled(n);
			excheck(n, 0);
			return top;
		case Oimport:
			importdecled(n);
			importcheck(n, 0);
			return top;
		case Ofunc:
			fatal("scheck func");
		case Oscope:
			pushscope(n, kind == Sother ? Sscope : kind);
			if (left != nil)
				fatal("Oscope has left field");
			echeck(left, 0, 0, nil);
			n->right = scheck(right, ret, Sother);
			d = popscope();
			fndecls = appdecls(fndecls, d);
			return top;
		case Olabel:
			echeck(left, 0, 0, nil);
			n->right = scheck(right, ret, Sother);
			return top;
		case Oseq:
			n->left = scheck(left, ret, Sother);
			/* next time will check n->right */
			break;
		case Oif:
			rok = echeck(left, 0, 0, nil);
			if(rok.ok && left->op != Onothing && left->ty != tint)
				nerror(n, "if conditional must be an int, not %Q", left);
			right->left = scheck(right->left, ret, Sother);
			/* next time will check n->right->right */
			n = right;
			break;
		case Ofor:
			rok = echeck(left, 0, 0, nil);
			if(rok.ok && left->op != Onothing && left->ty != tint)
				nerror(n, "for conditional must be an int, not %Q", left);
			/*
			 * do the continue clause before the body
			 * this reflects the ordering of declarations
			 */
			pushlabel(n);
			right->right = scheck(right->right, ret, Sother);
			right->left = scheck(right->left, ret, Sloop);
			labdep--;
			if(n->decl != nil && !n->decl->refs)
				nwarn(n, "label %s never referenced", n->decl->sym->name);
			return top;
		case Odo:
			rok = echeck(left, 0, 0, nil);
			if(rok.ok && left->op != Onothing && left->ty != tint)
				nerror(n, "do conditional must be an int, not %Q", left);
			pushlabel(n);
			n->right = scheck(n->right, ret, Sloop);
			labdep--;
			if(n->decl != nil && !n->decl->refs)
				nwarn(n, "label %s never referenced", n->decl->sym->name);
			return top;
		case Oalt:
		case Ocase:
		case Opick:
		case Oexcept:
			pushlabel(n);
			switch(n->op){
			case Oalt:
				altcheck(n, ret);
				break;
			case Ocase:
				casecheck(n, ret);
				break;
			case Opick:
				pickcheck(n, ret);
				break;
			case Oexcept:
				exccheck(n, ret);
				break;
			}
			labdep--;
			if(n->decl != nil && !n->decl->refs)
				nwarn(n, "label %s never referenced", n->decl->sym->name);
			return top;
		case Oret:
			rok = echeck(left, 0, 0, nil);
			if(!rok.ok)
				return top;
			if(left == nil){
				if(ret != tnone)
					nerror(n, "return of nothing from a fn of %T", ret);
			}else if(ret == tnone){
				if(left->ty != tnone)
					nerror(n, "return %Q from a fn with no return type", left);
			}else if(!tcompat(ret, left->ty, 0))
				nerror(n, "return %Q from a fn of %T", left, ret);
			return top;
		case Obreak:
		case Ocont:
			s = nil;
			if(n->decl != nil)
				s = n->decl->sym;
			for(i = 0; i < labdep; i++){
				if(s == nil || labstack[i]->decl != nil && labstack[i]->decl->sym == s){
					if(n->op == Ocont
					&& labstack[i]->op != Ofor && labstack[i]->op != Odo)
						continue;
					if(s != nil)
						labstack[i]->decl->refs++;
					return top;
				}
			}
			nerror(n, "no appropriate target for %V", n);
			return top;
		case Oexit:
		case Onothing:
			return top;
		case Oexstmt:
			fndec->handler = 1;
			n->left = scheck(left, ret, Sother);
			n->right = scheck(right, ret, Sother);
			return top;
		default:
			rok = echeck(n, 0, 0, nil);
			if(rok.allok)
				n = checkused(n);
			if(last == nil)
				return n;
			last->right = n;
			return top;
		}
		last = n;
	}
	return top;
}

void
pushlabel(Node *n)
{
	Sym *s;
	int i;

	if(labdep >= maxlabdep){
		maxlabdep += MaxScope;
		labstack = reallocmem(labstack, maxlabdep * sizeof *labstack);
	}
	if(n->decl != nil){
		s = n->decl->sym;
		n->decl->refs = 0;
		for(i = 0; i < labdep; i++)
			if(labstack[i]->decl != nil && labstack[i]->decl->sym == s)
				nerror(n, "label %s duplicated on line %L", s->name, labstack[i]->decl->src.start);
	}
	labstack[labdep++] = n;
}

void
varcheck(Node *n, int isglobal)
{
	Type *t;
	Decl *ids, *last;

	t = validtype(n->ty, nil);
	t = topvartype(t, n->decl, isglobal, 0);
	last = n->left->decl;
	for(ids = n->decl; ids != last->next; ids = ids->next){
		ids->ty = t;
		shareloc(ids);
	}
	if(t->u.eraises)
		raisescheck(t);
}

void
concheck(Node *n, int isglobal)
{
	Decl *ids, *last;
	Type *t;
	Node *init;
	Ok rok;
	int i;

	pushscope(nil, Sother);
	installids(Dconst, iota);
	rok = echeck(n->right, 0, isglobal, nil);
	popscope();

	init = n->right;
	if(!rok.ok){
		t = terror;
	}else{
		t = init->ty;
		if(!tattr[t->kind].conable){
			nerror(init, "cannot have a %T constant", t);
			rok.allok = 0;
		}
	}

	last = n->left->decl;
	for(ids = n->decl; ids != last->next; ids = ids->next)
		ids->ty = t;

	if(!rok.allok)
		return;

	i = 0;
	for(ids = n->decl; ids != last->next; ids = ids->next){
		if(rok.ok){
			iota->init->val = i;
			ids->init = dupn(0, &nosrc, init);
			if(!varcom(ids))
				rok.ok = 0;
		}
		i++;
	}
}

static char*
exname(Decl *d)
{
	int n;
	Sym *m;
	char *s;
	char buf[16];

	n = 0;
	sprint(buf, "%d", scope-ScopeGlobal);
	m = nil;
	if(d->dot)
		m = d->dot->sym;
	else if(impmods)
		m = impmods->sym;
	if(m)
		n += strlen(m->name)+1;
	if(fndec)
		n += strlen(fndec->sym->name)+1;
	n += strlen(buf)+1+strlen(d->sym->name)+1;
	s = malloc(n);
	strcpy(s, "");
	if(m){
		strcat(s, m->name);
		strcat(s, ".");
	}
	if(fndec){
		strcat(s, fndec->sym->name);
		strcat(s, ".");
	}
	strcat(s, buf);
	strcat(s, ".");
	strcat(s, d->sym->name);
	return s;
}

void
excheck(Node *n, int isglobal)
{
	char *nm;
	Type *t;
	Decl *ids, *last;

	t = validtype(n->ty, nil);
	t = topvartype(t, n->decl, isglobal, 0);
	last = n->left->decl;
	for(ids = n->decl; ids != last->next; ids = ids->next){
		ids->ty = t;
		nm = exname(ids);
		ids->init = mksconst(&n->src, enterstring(nm, strlen(nm)));
		/* ids->init = mksconst(&n->src, enterstring(strdup(ids->sym->name), strlen(ids->sym->name))); */
	}
}

void
importcheck(Node *n, int isglobal)
{
	Node *m;
	Decl *id, *last, *v;
	Type *t;
	Ok rok;

	rok = echeck(n->right, 1, isglobal, nil);
	if(!rok.ok)
		return;

	m = n->right;
	if(m->ty->kind != Tmodule || m->op != Oname){
		nerror(n, "cannot import from %Q", m);
		return;
	}

	last = n->left->decl;
	for(id = n->decl; id != last->next; id = id->next){
		v = namedot(m->ty->ids, id->sym);
		if(v == nil){
			error(id->src.start, "%s is not a member of %V", id->sym->name, m);
			id->store = Dwundef;
			continue;
		}
		id->store = v->store;
		v->ty = validtype(v->ty, nil);
		id->ty = t = v->ty;
		if(id->store == Dtype && t->decl != nil){
			id->timport = t->decl->timport;
			t->decl->timport = id;
		}
		id->init = v->init;
		id->importid = v;
		id->eimport = m;
	}
}

static Decl*
rewcall(Node *n, Decl *d)
{
	/* put original function back now we're type checked */
	while(d->link != nil)
		d = d->link;
	if(n->op == Odot)
		n->right->decl = d;
	else if(n->op == Omdot){
		n->right->right->decl = d;
		n->right->right->ty = d->ty;
	}
	else
		fatal("bad op in Ocall rewcall");
	n->ty = n->right->ty = d->ty;
	d->refs++;
	usetype(d->ty);
	return d;
}

/*
 * annotate the expression with types
 */
Ok
echeck(Node *n, int typeok, int isglobal, Node *par)
{
	Type *t, *tt;
	Node *left, *right, *mod, *nn;
	Decl *tg, *id, *callee;
	Sym *s;
	int max, nocheck;
	Ok ok, rok, kidsok;
	static int tagopt;

	ok.ok = ok.allok = 1;
	if(n == nil)
		return ok;
	
	/* avoid deep recursions */
	if(n->op == Oseq){
		for( ; n != nil && n->op == Oseq; n = n->right){
			rok = echeck(n->left, typeok == 2, isglobal, n);
			ok.ok &= rok.ok;
			ok.allok &= rok.allok;
			n->ty = tnone;
		}
		if(n == nil)
			return ok;
	}

	left = n->left;
	right = n->right;

	nocheck = 0;
	if(n->op == Odot || n->op == Omdot || n->op == Ocall || n->op == Oref || n->op == Otagof || n->op == Oindex)
		nocheck = 1;
	if(n->op != Odas		/* special case */
	&& n->op != Oload)		/* can have better error recovery */
		ok = echeck(left, nocheck, isglobal, n);
	if(n->op != Odas		/* special case */
	&& n->op != Odot		/* special check */
	&& n->op != Omdot		/* special check */
	&& n->op != Ocall		/* can have better error recovery */
	&& n->op != Oindex){
		rok = echeck(right, 0, isglobal, n);
		ok.ok &= rok.ok;
		ok.allok &= rok.allok;
	}
	if(!ok.ok){
		n->ty = terror;
		ok.allok = 0;
		return ok;
	}

	switch(n->op){
	case Odas:
		kidsok = echeck(right, 0, isglobal, n);
		if(!kidsok.ok)
			right->ty = terror;
		if(!isglobal && !dasdecl(left)){
			kidsok.ok = 0;
		}else if(!specific(right->ty) || !declasinfer(left, right->ty)){
			nerror(n, "cannot declare %V from %Q", left, right);
			declaserr(left);
			kidsok.ok = 0;
		}
		if(right->ty->kind == Texception)
			left->ty = n->ty = mkextuptype(right->ty);
		else{
			left->ty = n->ty = right->ty;
			usedty(n->ty);
		}
		kidsok.allok &= kidsok.ok;
		if (nested() && tmustzero(left->ty))
			decltozero(left);
		return kidsok;
	case Oseq:
	case Onothing:
		n->ty = tnone;
		break;
	case Owild:
		n->ty = tint;
		break;
	case Ocast:
		t = usetype(n->ty);
		n->ty = t;
		tt = left->ty;
		if(tcompat(t, tt, 0)){
			left->ty = t;
			break;
		}
		if(tt->kind == Tarray){
			if(tt->tof == tbyte && t == tstring)
				break;
		}else if(t->kind == Tarray){
			if(t->tof == tbyte && tt == tstring)
				break;
		}else if(casttab[tt->kind][t->kind]){
			break;
		}
		nerror(n, "cannot make a %T from %Q", n->ty, left);
		ok.ok = ok.allok = 0;
		return ok;
	case Ochan:
		n->ty = usetype(n->ty);
		if(left && left->ty->kind != Tint){
			nerror(n, "channel size %Q is not an int", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		break;
	case Oload:
		n->ty = usetype(n->ty);
		kidsok = echeck(left, 0, isglobal, n);
		if(n->ty->kind != Tmodule){
			nerror(n, "cannot load a %T, ", n->ty);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(!kidsok.allok){
			ok.allok = 0;
			break;
		}
		if(left->ty != tstring){
			nerror(n, "cannot load a module from %Q", left);
			ok.allok = 0;
			break;
		}
if(n->ty->tof->decl->refs != 0)
n->ty->tof->decl->refs++;
n->ty->decl->refs++;
		usetype(n->ty->tof);
		break;
	case Oref:
		t = left->ty;
		if(t->kind != Tadt && t->kind != Tadtpick && t->kind != Tfn && t->kind != Ttuple){
			nerror(n, "cannot make a ref from %Q", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(!tagopt && t->kind == Tadt && t->tags != nil && valistype(left)){
			nerror(n, "instances of ref %V must be qualified with a pick tag", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(t->kind == Tadtpick)
			t->tof = usetype(t->tof);
		n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tref, t, nil));
		break;
	case Oarray:
		max = 0;
		if(right != nil){
			max = assignindices(n);
			if(max < 0){
				ok.ok = ok.allok = 0;
				return ok;
			}
			if(!specific(right->left->ty)){
				nerror(n, "type for array not specific");
				ok.ok = ok.allok = 0;
				return ok;
			}
			n->ty = mktype(&n->src.start, &n->src.stop, Tarray, right->left->ty, nil);
		}
		n->ty = usetype(n->ty);

		if(left->op == Onothing)
			n->left = left = mkconst(&n->left->src, max);

		if(left->ty->kind != Tint){
			nerror(n, "array size %Q is not an int", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		break;
	case Oelem:
		n->ty = right->ty;
		break;
	case Orange:
		if(left->ty != right->ty
		|| left->ty != tint && left->ty != tstring){
			nerror(left, "range %Q to %Q is not an int or string range", left, right);
			ok.ok = ok.allok = 0;
			return ok;
		}
		n->ty = left->ty;
		break;
	case Oname:
		id = n->decl;
		if(id == nil){
			nerror(n, "name with no declaration");
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(id->store == Dunbound){
			s = id->sym;
			id = s->decl;
			if(id == nil)
				id = undefed(&n->src, s);
			/* save a little space */
			s->unbound = nil;
			n->decl = id;
			id->refs++;
		}
		n->ty = id->ty = usetype(id->ty);
		switch(id->store){
		case Dfn:
		case Dglobal:
		case Darg:
		case Dlocal:
		case Dimport:
		case Dfield:
		case Dtag:
			break;
		case Dundef:
			nerror(n, "%s is not declared", id->sym->name);
			id->store = Dwundef;
			ok.ok = ok.allok = 0;
			return ok;
		case Dwundef:
			ok.ok = ok.allok = 0;
			return ok;
		case Dconst:
			if(id->init == nil){
				nerror(n, "%s's value cannot be determined", id->sym->name);
				id->store = Dwundef;
				ok.ok = ok.allok = 0;
				return ok;
			}
			break;
		case Dtype:
			if(typeok)
				break;
			nerror(n, "%K is not a variable", id);
			ok.ok = ok.allok = 0;
			return ok;
		default:
			fatal("echeck: unknown symbol storage");
		}
		
		if(n->ty == nil){
			nerror(n, "%K's type is not fully defined", id);
			id->store = Dwundef;
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(id->importid != nil && valistype(id->eimport)
		&& id->store != Dconst && id->store != Dtype && id->store != Dfn){
			nerror(n, "cannot use %V because %V is a module interface", n, id->eimport);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(n->ty->kind == Texception && !n->ty->cons && par != nil && par->op != Oraise && par->op != Odot){
			nn = mkn(0, nil, nil);
			*nn = *n;
			n->op = Ocast;
			n->left = nn;
			n->decl = nil;
			n->ty = usetype(mkextuptype(n->ty));
		}
		/* function name as function reference */
		if(id->store == Dfn && (par == nil || (par->op != Odot && par->op != Omdot && par->op != Ocall && par->op != Ofunc)))
			fnref(n, id);
		break;
	case Oconst:
		if(n->ty == nil){
			nerror(n, "no type in %V", n);
			ok.ok = ok.allok = 0;
			return ok;
		}
		break;
	case Oas:
		t = right->ty;
		if(t->kind == Texception)
			t = mkextuptype(t);
		if(!tcompat(left->ty, t, 1)){
			nerror(n, "type clash in %Q = %Q", left, right);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(t == tany)
			t = left->ty;
		n->ty = t;
		left->ty = t;
		if(t->kind == Tadt && t->tags != nil || t->kind == Tadtpick)
		if(left->ty->kind != Tadtpick || right->ty->kind != Tadtpick)
			nerror(n, "expressions cannot have type %T", t);
		if(left->ty->kind == Texception){
			nerror(n, "cannot assign to an exception");
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(islval(left))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Osnd:
		if(left->ty->kind != Tchan){
			nerror(n, "cannot send on %Q", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(!tcompat(left->ty->tof, right->ty, 0)){
			nerror(n, "type clash in %Q <-= %Q", left, right);
			ok.ok = ok.allok = 0;
			return ok;
		}
		t = right->ty;
		if(t == tany)
			t = left->ty->tof;
		n->ty = t;
		break;
	case Orcv:
		t = left->ty;
		if(t->kind == Tarray)
			t = t->tof;
		if(t->kind != Tchan){
			nerror(n, "cannot receive on %Q", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(left->ty->kind == Tarray)
			n->ty = usetype(mktype(&n->src.start, &n->src.stop, Ttuple, nil,
					mkids(&n->src, nil, tint, mkids(&n->src, nil, t->tof, nil))));
		else
			n->ty = t->tof;
		break;
	case Ocons:
		if(right->ty->kind != Tlist && right->ty != tany){
			nerror(n, "cannot :: to %Q", right);
			ok.ok = ok.allok = 0;
			return ok;
		}
		n->ty = right->ty;
		if(right->ty == tany)
			n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tlist, left->ty, nil));
		else if(!tcompat(right->ty->tof, left->ty, 0)){
			t = tparent(right->ty->tof, left->ty);
			if(!tcompat(t, left->ty, 0)){
				nerror(n, "type clash in %Q :: %Q", left, right);
				ok.ok = ok.allok = 0;
				return ok;
			}
			else
				n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tlist, t, nil));
		}
		break;
	case Ohd:
	case Otl:
		if(left->ty->kind != Tlist || left->ty->tof == nil){
			nerror(n, "cannot %O %Q", n->op, left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(n->op == Ohd)
			n->ty = left->ty->tof;
		else
			n->ty = left->ty;
		break;
	case Otuple:
		n->ty = usetype(mktype(&n->src.start, &n->src.stop, Ttuple, nil, tuplefields(left)));
		break;
	case Ospawn:
		if(left->op != Ocall || left->left->ty->kind != Tfn && !isfnrefty(left->left->ty)){
			nerror(left, "cannot spawn %V", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(left->ty != tnone){
			nerror(left, "cannot spawn functions which return values, such as %Q", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		break;
	case Oraise:
		if(left->op == Onothing){
			if(inexcept == nil){
				nerror(n, "%V: empty raise not in exception handler", n);
				ok.ok = ok.allok = 0;
				return ok;
			}
			n->left = dupn(1, &n->src, inexcept);
			break;
		}
		if(left->ty != tstring && left->ty->kind != Texception){
			nerror(n, "%V: raise argument %Q is not a string or exception", n, left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if((left->op != Ocall || left->left->ty->kind == Tfn) && left->ty->ids != nil && left->ty->cons){
			nerror(n, "too few exception arguments");
			ok.ok = ok.allok = 0;
			return ok;
		}
		break;
	case Ocall:{
		int pure;

		kidsok = echeck(right, 0, isglobal, nil);
		t = left->ty;
		usedty(t);
		pure = 1;
		if(t->kind == Tref){
			pure = 0;
			t = t->tof;
		}
		if(t->kind != Tfn)
			return callcast(n, kidsok.allok, ok.allok);
		n->ty = t->tof;
		if(!kidsok.allok){
			ok.allok = 0;
			break;
		}

		/*
		 * get the name to call and any associated module
		 */
		mod = nil;
		callee = nil;
		id = nil;
		tt = nil;
		if(left->op == Odot){
			Decl *dd;
			Type *ttt;

			callee = left->right->decl;
			id = callee->dot;
			right = passimplicit(left, right);
			n->right = right;
			tt = left->left->ty;
			if(tt->kind == Tref)
				tt = tt->tof;
			ttt = tt;
			if(tt->kind == Tadtpick)
				ttt = tt->decl->dot->ty;
			dd = ttt->decl;
			while(dd != nil && dd->link != nil)
				dd = dd->link;
			if(dd != nil && dd->timport != nil)
				mod = dd->timport->eimport;
			/*
			 * stash the import module under a rock,
			 * because we won't be able to get it later
			 * after scopes are popped
			 */
			left->right->left = mod;
		}else if(left->op == Omdot){
			if(left->right->op == Odot){
				callee = left->right->right->decl;
				right = passimplicit(left->right, right);
				n->right = right;
				tt = left->right->left->ty;
				if(tt->kind == Tref)
					tt = tt->tof;
			}else
				callee = left->right->decl;
			mod = left->left;
		}else if(left->op == Oname){
			callee = left->decl;
			id = callee;
			mod = id->eimport;
		}else if(pure){
			nerror(left, "%V is not a function name", left);
			ok.allok = 0;
			break;
		}
		if(pure && callee == nil)
			fatal("can't find called function: %n", left);
		if(callee != nil && callee->store != Dfn && !isfnref(callee)){
			nerror(left, "%V is not a function or function reference", left);
			ok.allok = 0;
			break;
		}
		if(mod != nil && mod->ty->kind != Tmodule){
			nerror(left, "cannot call %V", left);
			ok.allok = 0;
			break;
		}
		if(mod != nil){
			if(valistype(mod)){
				nerror(left, "cannot call %V because %V is a module interface", left, mod);
				ok.allok = 0;
				break;
			}
		}else if(id != nil && id->dot != nil && !isimpmod(id->dot->sym)){
			nerror(left, "cannot call %V without importing %s from a variable", left, id->sym->name);
			ok.allok = 0;
			break;
		}
		if(mod != nil)
			modrefable(left->ty);
		if(callee != nil && callee->store != Dfn)
			callee = nil;
		if(t->varargs != 0){
			t = mkvarargs(left, right);
			if(left->ty->kind == Tref)
				left->ty = usetype(mktype(&t->src.start, &t->src.stop, Tref, t, nil));
			else
				left->ty = t;
		}
		else if(ispoly(callee) || isfnrefty(left->ty) && left->ty->tof->polys != nil){
			Tpair *tp;

			unifysrc = n->src;
			if(!argncompat(n, t->ids, right))
				ok.allok = 0;
			else if(!tunify(left->ty, calltype(left->ty, right, n->ty), &tp)){
				nerror(n, "function call type mismatch");
				ok.allok = 0;
			}
			else{
				n->ty = usetype(expandtype(n->ty, nil, nil, &tp));
				if(ispoly(callee) && tt != nil && (tt->kind == Tadt || tt->kind == Tadtpick) && (tt->flags&INST))
					callee = rewcall(left, callee);
				n->right = passfns(&n->src, callee, left, right, tt, tp);
			}
		}
		else if(!argcompat(n, t->ids, right))
			ok.allok = 0;
		break;
	}
	case Odot:
		t = left->ty;
		if(t->kind == Tref)
			t = t->tof;
		switch(t->kind){
		case Tadt:
		case Tadtpick:
		case Ttuple:
		case Texception:
		case Tpoly:
			id = namedot(t->ids, right->decl->sym);
			if(id == nil){
				id = namedot(t->tags, right->decl->sym);
				if(id != nil && !valistype(left)){
					nerror(n, "%V is not a type", left);
					ok.ok = ok.allok = 0;
					return ok;
				}
			}
			if(id == nil){
				id = namedot(t->polys, right->decl->sym);
				if(id != nil && !valistype(left)){
					nerror(n, "%V is not a type", left);
					ok.ok = ok.allok = 0;
					return ok;
				}
			}
			if(id == nil && t->kind == Tadtpick)
				id = namedot(t->decl->dot->ty->ids, right->decl->sym);
			if(id == nil){
				for(tg = t->tags; tg != nil; tg = tg->next){
					id = namedot(tg->ty->ids, right->decl->sym);
					if(id != nil)
						break;
				}
				if(id != nil){
					nerror(n, "cannot yet index field %s of %Q", right->decl->sym->name, left);
					ok.ok = ok.allok = 0;
					return ok;
				}
			}
			if(id == nil)
				break;
			if(id->store == Dfield && valistype(left)){
				nerror(n, "%V is not a value", left);
				ok.ok = ok.allok = 0;
				return ok;
			}
			id->ty = validtype(id->ty, t->decl);
			id->ty = usetype(id->ty);
			break;
		default:
			nerror(left, "%Q cannot be qualified with .", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(id == nil){
			nerror(n, "%V is not a member of %Q", right, left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(id->ty == tunknown){
			nerror(n, "illegal forward reference to %V", n);
			ok.ok = ok.allok = 0;
			return ok;
		}

		increfs(id);
		right->decl = id;
		n->ty = id->ty;
		if((id->store == Dconst || id->store == Dtag) && hasside(left, 1))
			nwarn(left, "result of expression %Q ignored", left);
		/* function name as function reference */
		if(id->store == Dfn && (par == nil || (par->op != Omdot && par->op != Ocall && par->op != Ofunc)))
			fnref(n, id);
		break;
	case Omdot:
		t = left->ty;
		if(t->kind != Tmodule){
			nerror(left, "%Q cannot be qualified with ->", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		id = nil;
		if(right->op == Oname){
			id = namedot(t->ids, right->decl->sym);
		}else if(right->op == Odot){
			kidsok = echeck(right, 0, isglobal, n);
			ok.ok = kidsok.ok;
			ok.allok &= kidsok.allok;
			if(!ok.ok){
				ok.allok = 0;
				return ok;
			}
			tt = right->left->ty;
			if(tt->kind == Tref)
				tt = tt->tof;
			if(right->ty->kind == Tfn
			&& tt->kind == Tadt
			&& tt->decl->dot == t->decl)
				id = right->right->decl;
		}
		if(id == nil){
			nerror(n, "%V is not a member of %Q", right, left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(id->store != Dconst && id->store != Dtype && id->store != Dtag){
			if(valistype(left)){
				nerror(n, "%V is not a value", left);
				ok.ok = ok.allok = 0;
				return ok;
			}
		}else if(hasside(left, 1))
			nwarn(left, "result of expression %Q ignored", left);
		if(!typeok && id->store == Dtype){
			nerror(n, "%V is a type, not a value", n);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(id->ty == tunknown){
			nerror(n, "illegal forward reference to %V", n);
			ok.ok = ok.allok = 0;
			return ok;
		}
		id->refs++;
		right->decl = id;
		n->ty = id->ty = usetype(id->ty);
		if(id->store == Dglobal)
			modrefable(id->ty);
		/* function name as function reference */
		if(id->store == Dfn && (par == nil || (par->op != Ocall && par->op != Ofunc)))
			fnref(n, id);
		break;
	case Otagof:
		n->ty = tint;
		t = left->ty;
		if(t->kind == Tref)
			t = t->tof;
		id = nil;
		switch(left->op){
		case Oname:
			id = left->decl;
			break;
		case Odot:
			id = left->right->decl;
			break;
		case Omdot:
			if(left->right->op == Odot)
				id = left->right->right->decl;
			break;
		}
		if(id != nil && id->store == Dtag
		|| id != nil && id->store == Dtype && t->kind == Tadt && t->tags != nil)
			n->decl = id;
		else if(t->kind == Tadt && t->tags != nil || t->kind == Tadtpick)
			n->decl = nil;
		else{
			nerror(n, "cannot get the tag value for %Q", left);
			ok.ok = 1;
			ok.allok = 0;
			return ok;
		}
		break;
	case Oind:
		t = left->ty;
		if(t->kind != Tref || (t->tof->kind != Tadt && t->tof->kind != Tadtpick && t->tof->kind != Ttuple)){
			nerror(n, "cannot * %Q", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		n->ty = t->tof;
		for(tg = t->tof->tags; tg != nil; tg = tg->next)
			tg->ty->tof = usetype(tg->ty->tof);
		break;
	case Oindex:
		if(valistype(left)){
			tagopt = 1;
			kidsok = echeck(right, 2, isglobal, n);
			tagopt = 0;
			if(!kidsok.allok){
				ok.ok = ok.allok = 0;
				return ok;
			}
			if((t = exptotype(n)) == nil){
				nerror(n, "%V is not a type list", right);
				ok.ok = ok.allok = 0;
				return ok;
			}
			if(!typeok){
				nerror(n, "%Q is not a variable", left);
				ok.ok = ok.allok = 0;
				return ok;
			}
			*n = *(n->left);
			n->ty = usetype(t);
			break;
		}
		if(0 && right->op == Oseq){	/* a[e1, e2, ...] */
			/* array creation to do before we allow this */
			rewind(n);
			return echeck(n, typeok, isglobal, par);
		}
		t = left->ty;
		kidsok = echeck(right, 0, isglobal, n);
		if(t->kind != Tarray && t != tstring){
			nerror(n, "cannot index %Q", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(t == tstring){
			n->op = Oinds;
			n->ty = tint;
		}else{
			n->ty = t->tof;
		}
		if(!kidsok.allok){
			ok.allok = 0;
			break;
		}
		if(right->ty != tint){
			nerror(n, "cannot index %Q with %Q", left, right);
			ok.allok = 0;
			break;
		}
		break;
	case Oslice:
		t = n->ty = left->ty;
		if(t->kind != Tarray && t != tstring){
			nerror(n, "cannot slice %Q with '%v:%v'", left, right->left, right->right);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(right->left->ty != tint && right->left->op != Onothing
		|| right->right->ty != tint && right->right->op != Onothing){
			nerror(n, "cannot slice %Q with '%v:%v'", left, right->left, right->right);
			ok.allok = 0;
			return ok;
		}
		break;
	case Olen:
		t = left->ty;
		n->ty = tint;
		if(t->kind != Tarray && t->kind != Tlist && t != tstring){
			nerror(n, "len requires an array, string or list in %Q", left);
			ok.allok = 0;
			return ok;
		}
		break;
	case Ocomp:
	case Onot:
	case Oneg:
		n->ty = left->ty;
		usedty(n->ty);
		switch(left->ty->kind){
		case Tint:
			return ok;
		case Treal:
		case Tfix:
			if(n->op == Oneg)
				return ok;
			break;
		case Tbig:
		case Tbyte:
			if(n->op == Oneg || n->op == Ocomp)
				return ok;
			break;
		}
		nerror(n, "cannot apply %O to %Q", n->op, left);
		ok.ok = ok.allok = 0;
		return ok;
	case Oinc:
	case Odec:
	case Opreinc:
	case Opredec:
		n->ty = left->ty;
		switch(left->ty->kind){
		case Tint:
		case Tbig:
		case Tbyte:
		case Treal:
			break;
		default:
			nerror(n, "cannot apply %O to %Q", n->op, left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(islval(left))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Oadd:
	case Odiv:
	case Omul:
	case Osub:
		if(mathchk(n, 1))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Oexp:
	case Oexpas:
		n->ty = left->ty;
		if(n->ty != tint && n->ty != tbig && n->ty != treal){
			nerror(n, "exponend %Q is not int, big or real", left);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(right->ty != tint){
			nerror(n, "exponent %Q is not int", right);
			ok.ok = ok.allok = 0;
			return ok;
		}
		if(n->op == Oexpas && !islval(left)){
			ok.ok = ok.allok = 0;
			return ok;
		}
		break;
	case Olsh:
	case Orsh:
		if(shiftchk(n))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Oandand:
	case Ooror:
		if(left->ty != tint){
			nerror(n, "%O's left operand is not an int: %Q", n->op, left);
			ok.allok = 0;
		}
		if(right->ty != tint){
			nerror(n, "%O's right operand is not an int: %Q", n->op, right);
			ok.allok = 0;
		}
		n->ty = tint;
		break;
	case Oand:
	case Omod:
	case Oor:
	case Oxor:
		if(mathchk(n, 0))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Oaddas:
	case Odivas:
	case Omulas:
	case Osubas:
		if(mathchk(n, 1) && islval(left))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Olshas:
	case Orshas:
		if(shiftchk(n) && islval(left))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Oandas:
	case Omodas:
	case Oxoras:
	case Ooras:
		if(mathchk(n, 0) && islval(left))
			break;
		ok.ok = ok.allok = 0;
		return ok;
	case Olt:
	case Oleq:
	case Ogt:
	case Ogeq:
		if(!mathchk(n, 1)){
			ok.ok = ok.allok = 0;
			return ok;
		}
		n->ty = tint;
		break;
	case Oeq:
	case Oneq:
		switch(left->ty->kind){
		case Tint:
		case Tbig:
		case Tbyte:
		case Treal:
		case Tstring:
		case Tref:
		case Tlist:
		case Tarray:
		case Tchan:
		case Tany:
		case Tmodule:
		case Tfix:
		case Tpoly:
			if(!tcompat(left->ty, right->ty, 0) && !tcompat(right->ty, left->ty, 0))
				break;
			t = left->ty;
			if(t == tany)
				t = right->ty;
			if(t == tany)
				t = tint;
			if(left->ty == tany)
				left->ty = t;
			if(right->ty == tany)
				right->ty = t;
			n->ty = tint;
			return ok;
		}
		nerror(n, "cannot compare %Q to %Q", left, right);
		usedty(n->ty);
		ok.ok = ok.allok = 0;
		return ok;
	case Otype:
		if(!typeok){
			nerror(n, "%Q is not a variable", n);
			ok.ok = ok.allok = 0;
			return ok;
		}
		n->ty = usetype(n->ty);
		break;
	default:
		fatal("unknown op in typecheck: %O", n->op);
	}
	usedty(n->ty);
	return ok;
}

/*
 * n is syntactically a call, but n->left is not a fn
 * check if it's the contructor for an adt
 */
Ok
callcast(Node *n, int kidsok, int allok)
{
	Node *left, *right;
	Decl *id;
	Type *t, *tt;
	Ok ok;

	left = n->left;
	right = n->right;
	id = nil;
	switch(left->op){
	case Oname:
		id = left->decl;
		break;
	case Omdot:
		if(left->right->op == Odot)
			id = left->right->right->decl;
		else
			id = left->right->decl;
		break;
	case Odot:
		id = left->right->decl;
		break;
	}
/*
	(chan of int)(nil) looks awkward since both sets of brackets needed
	if(id == nil && right != nil && right->right == nil && (t = exptotype(left)) != nil){
		n->op = Ocast;
		n->left = right->left;
		n->right = nil;
		n->ty = t;
		return echeck(n, 0, 0, nil);
	}
*/
	if(id == nil || (id->store != Dtype && id->store != Dtag && id->ty->kind != Texception)){
		nerror(left, "%V is not a function or type name", left);
		ok.ok = ok.allok = 0;
		return ok;
	}
	if(id->store == Dtag)
		return tagcast(n, left, right, id, kidsok, allok);
	t = left->ty;
	n->ty = t;
	if(!kidsok){
		ok.ok = 1;
		ok.allok = 0;
		return ok;
	}

	if(t->kind == Tref)
		t = t->tof;
	tt = mktype(&n->src.start, &n->src.stop, Ttuple, nil, tuplefields(right));
	if(t->kind == Tadt && tcompat(t, tt, 1)){
		if(right == nil)
			*n = *n->left;
		ok.ok = 1;
		ok.allok = allok;
		return ok;
	}

	/* try an exception with args */
	tt = mktype(&n->src.start, &n->src.stop, Texception, nil, tuplefields(right));
	tt->cons = 1;
	if(t->kind == Texception && t->cons && tcompat(t, tt, 1)){
		if(right == nil)
			*n = *n->left;
		ok.ok = 1;
		ok.allok = allok;
		return ok;
	}

	/* try a cast */
	if(t->kind != Texception && right != nil && right->right == nil){	/* Oseq but single expression */
		right = right->left;
		n->op = Ocast;
		n->left = right;
		n->right = nil;
		n->ty = mkidtype(&n->src, id->sym);
		return echeck(n, 0, 0, nil);
	}

	nerror(left, "cannot make a %V from '(%v)'", left, right);
	ok.ok = ok.allok = 0;
	return ok;
}

Ok
tagcast(Node *n, Node *left, Node *right, Decl *id, int kidsok, int allok)
{
	Type *tt;
	Ok ok;

	left->ty = id->ty;
	if(left->op == Omdot)
		left->right->ty = id->ty;
	n->ty = id->ty;
	if(!kidsok){
		ok.ok = 1;
		ok.allok = 0;
		return ok;
	}
	id->ty->tof = usetype(id->ty->tof);
	if(right != nil)
		right->ty = id->ty->tof;
	tt = mktype(&n->src.start, &n->src.stop, Ttuple, nil, mkids(&nosrc, nil, tint, tuplefields(right)));
	tt->ids->store = Dfield;
	if(tcompat(id->ty->tof, tt, 1)){
		ok.ok = 1;
		ok.allok = allok;
		return ok;
	}

	nerror(left, "cannot make a %V from '(%v)'", left, right);
	ok.ok = ok.allok = 0;
	return ok;
}

int
valistype(Node *n)
{
	switch(n->op){
	case Oname:
		if(n->decl->store == Dtype)
			return 1;
		break;
	case Omdot:
		return valistype(n->right);
	}
	return 0;
}

int
islval(Node *n)
{
	int s;

	s = marklval(n);
	if(s == 1)
		return 1;
	if(s == 0)
		nerror(n, "cannot assign to %V", n);
	else
		circlval(n, n);
	return 0;
}

/*
 * check to see if n is an lval
 * mark the lval name as set
 */
int
marklval(Node *n)
{
	Decl *id;
	Node *nn;
	int s;

	if(n == nil)
		return 0;
	switch(n->op){
	case Oname:
		return storespace[n->decl->store] && n->ty->kind != Texception; /*ZZZZ && n->decl->tagged == nil;*/
	case Odot:
		if(n->right->decl->store != Dfield)
			return 0;
		if(n->right->decl->cycle && !n->right->decl->cyc)
			return -1;
		if(n->left->ty->kind != Tref && marklval(n->left) == 0)
			nwarn(n, "assignment to %Q ignored", n);
		return 1;
	case Omdot:
		if(n->right->decl->store == Dglobal)
			return 1;
		return 0;
	case Oind:
		for(id = n->ty->ids; id != nil; id = id->next)
			if(id->cycle && !id->cyc)
				return -1;
		return 1;
	case Oslice:
		if(n->right->right->op != Onothing || n->ty == tstring)
			return 0;
		return 1;
	case Oinds:
		/*
		 * make sure we don't change a string constant
		 */
		switch(n->left->op){
		case Oconst:
			return 0;
		case Oname:
			return storespace[n->left->decl->store];
		case Odot:
		case Omdot:
			if(n->left->right->decl != nil)
				return storespace[n->left->right->decl->store];
			break;
		}
		return 1;
	case Oindex:
	case Oindx:
		return 1;
	case Otuple:
		for(nn = n->left; nn != nil; nn = nn->right){
			s = marklval(nn->left);
			if(s != 1)
				return s;
		}
		return 1;
	default:
		return 0;
	}
}

/*
 * n has a circular field assignment.
 * find it and print an error message.
 */
int
circlval(Node *n, Node *lval)
{
	Decl *id;
	Node *nn;
	int s;

	if(n == nil)
		return 0;
	switch(n->op){
	case Oname:
		break;
	case Odot:
		if(oldcycles && n->right->decl->cycle && !n->right->decl->cyc){
			nerror(lval, "cannot assign to %V because field '%s' of %V could complete a cycle to %V",
				lval, n->right->decl->sym->name, n->left, n->left);
			return -1;
		}
		return 1;
	case Oind:
		if(!oldcycles)
			return 1;
		for(id = n->ty->ids; id != nil; id = id->next){
			if(id->cycle && !id->cyc){
				nerror(lval, "cannot assign to %V because field '%s' of %V could complete a cycle to %V",
					lval, id->sym->name, n, n);
				return -1;
			}
		}
		return 1;
	case Oslice:
		if(n->right->right->op != Onothing || n->ty == tstring)
			return 0;
		return 1;
	case Oindex:
	case Oinds:
	case Oindx:
		return 1;
	case Otuple:
		for(nn = n->left; nn != nil; nn = nn->right){
			s = circlval(nn->left, lval);
			if(s != 1)
				return s;
		}
		return 1;
	default:
		return 0;
	}
	return 0;
}

int
mathchk(Node *n, int realok)
{
	Type *tr, *tl;

	tl = n->left->ty;
	tr = n->right->ty;
	if(tr != tl && !tequal(tl, tr)){
		nerror(n, "type clash in %Q %O %Q", n->left, n->op, n->right);
		return 0;
	}
	n->ty = tr;
	switch(tr->kind){
	case Tint:
	case Tbig:
	case Tbyte:
		return 1;
	case Tstring:
		switch(n->op){
		case Oadd:
		case Oaddas:
		case Ogt:
		case Ogeq:
		case Olt:
		case Oleq:
			return 1;
		}
		break;
	case Treal:
	case Tfix:
		if(realok)
			return 1;
		break;
	}
	nerror(n, "cannot %O %Q and %Q", n->op, n->left, n->right);
	return 0;
}

int
shiftchk(Node *n)
{
	Node *left, *right;

	right = n->right;
	left = n->left;
	n->ty = left->ty;
	switch(n->ty->kind){
	case Tint:
	case Tbyte:
	case Tbig:
		if(right->ty->kind != Tint){
			nerror(n, "shift %Q is not an int", right);
			return 0;
		}
		return 1;
	}
	nerror(n, "cannot %Q %O %Q", left, n->op, right);
	return 0;
}

/*
 * check for any tany's in t
 */
int
specific(Type *t)
{
	Decl *d;

	if(t == nil)
		return 0;
	switch(t->kind){
	case Terror:
	case Tnone:
	case Tint:
	case Tbig:
	case Tstring:
	case Tbyte:
	case Treal:
	case Tfn:
	case Tadt:
	case Tadtpick:
	case Tmodule:
	case Tfix:
		return 1;
	case Tany:
		return 0;
	case Tpoly:
		return 1;
	case Tref:
	case Tlist:
	case Tarray:
	case Tchan:
		return specific(t->tof);
	case Ttuple:
	case Texception:
		for(d = t->ids; d != nil; d = d->next)
			if(!specific(d->ty))
				return 0;
		return 1;
	}
	fatal("unknown type %T in specific", t);
	return 0;
}

/*
 * infer the type of all variable in n from t
 * n is the left-hand exp of a := exp
 */
int
declasinfer(Node *n, Type *t)
{
	Decl *ids;
	int ok;

	if(t->kind == Texception){
		if(t->cons)
			return 0;
		t = mkextuptype(t);
	}
	switch(n->op){
	case Otuple:
		if(t->kind != Ttuple && t->kind != Tadt && t->kind != Tadtpick)
			return 0;
		ok = 1;
		n->ty = t;
		n = n->left;
		ids = t->ids;
		if(t->kind == Tadtpick)
			ids = t->tof->ids->next;
		for(; n != nil && ids != nil; ids = ids->next){
			if(ids->store != Dfield)
				continue;
			ok &= declasinfer(n->left, ids->ty);
			n = n->right;
		}
		for(; ids != nil; ids = ids->next)
			if(ids->store == Dfield)
				break;
		if(n != nil || ids != nil)
			return 0;
		return ok;
	case Oname:
		topvartype(t, n->decl, 0, 0);
		if(n->decl == nildecl)
			return 1;
		n->decl->ty = t;
		n->ty = t;
		shareloc(n->decl);
		return 1;
	}
	fatal("unknown op %n in declasinfer", n);
	return 0;
}

/*
 * an error occured in declaring n;
 * set all decl identifiers to Dwundef
 * so further errors are squashed.
 */
void
declaserr(Node *n)
{
	switch(n->op){
	case Otuple:
		for(n = n->left; n != nil; n = n->right)
			declaserr(n->left);
		return;
	case Oname:
		if(n->decl != nildecl)
			n->decl->store = Dwundef;
		return;
	}
	fatal("unknown op %n in declaserr", n);
}

int
argcompat(Node *n, Decl *f, Node *a)
{
	for(; a != nil; a = a->right){
		if(f == nil){
			nerror(n, "%V: too many function arguments", n->left);
			return 0;
		}
		if(!tcompat(f->ty, a->left->ty, 0)){
			nerror(n, "%V: argument type mismatch: expected %T saw %Q",
				n->left, f->ty, a->left);
			return 0;
		}
		if(a->left->ty == tany)
			a->left->ty = f->ty;
		f = f->next;
	}
	if(f != nil){
		nerror(n, "%V: too few function arguments", n->left);
		return 0;
	}
	return 1;
}

/*
 * fn is Odot(adt, methid)
 * pass adt implicitly if needed
 * if not, any side effect of adt will be ignored
 */
Node*
passimplicit(Node *fn, Node *args)
{
	Node *n;
	Type *t;

	t = fn->ty;
	n = fn->left;
	if(t->ids == nil || !t->ids->implicit){
		if(!isfnrefty(t) && hasside(n, 1))
			nwarn(fn, "result of expression %V ignored", n);
		return args;
	}
	if(n->op == Oname && n->decl->store == Dtype){
		nerror(n, "%V is a type and cannot be a self argument", n);
		n = mkn(Onothing, nil, nil);
		n->src = fn->src;
		n->ty = t->ids->ty;
	}
	args = mkn(Oseq, n, args);
	args->src = n->src;
	return args;
}

static int
mem(Type *t, Decl *d)
{
	for( ; d != nil; d = d->next)
		if(d->ty == t)	/* was if(d->ty == t || tequal(d->ty, t)) */
			return 1;
	return 0;
}

static int
memp(Type *t, Decl *f)
{
	return mem(t, f->ty->polys) || mem(t, encpolys(f));
}

static void
passfns0(Src *src, Decl *fn, Node *args0, Node **args, Node **a, Tpair *tp, Decl *polys)
{
	Decl *id, *idt, *idf, *dot;
	Type *tt;
	Sym *sym;
	Node *n, *na, *mod;
	Tpair *p;

if(debug['w']){
	print("polys: ");
	for(id=polys; id!=nil; id=id->next) print("%s ", id->sym->name);
	print("\nmap: ");
	for(p=tp; p!=nil; p=p->nxt) print("%T -> %T ", p->t1, p->t2);
	print("\n");
}
	for(idt = polys; idt != nil; idt = idt->next){
		tt = valtmap(idt->ty, tp);
		if(tt->kind == Tpoly && fndec != nil && !memp(tt, fndec))
			error(src->start, "cannot determine the instantiated type of %T", tt);
		for(idf = idt->ty->ids; idf != nil; idf = idf->next){
			sym = idf->sym;
			id = fnlookup(sym, tt, &mod);
			while(id != nil && id->link != nil)
				id = id->link;
if(debug['v']) print("fnlookup: %p\n", id);
			if(id == nil)	/* error flagged already */
				continue;
			id->refs++;
			id->caninline = -1;
			if(tt->kind == Tmodule){	/* mod an actual parameter */
				for(;;){
					if(args0 != nil && tequal(tt, args0->left->ty)){
						mod = args0->left;
						break;
					}
					if(args0 == nil)
						break;
					args0 = args0->right;
				}
			}
			if(mod == nil && (dot = module(id)) != nil && !isimpmod(dot->sym))
				error(src->start, "cannot use %s without importing %s from a variable", id->sym->name, id->dot->sym->name);

if(debug['U']) print("fp: %s %s %s\n", fn->sym->name, mod ? mod->decl->sym->name : "nil", id->sym->name);
			n = mkn(Ofnptr, mod, mkdeclname(src, id));
			n->src = *src;
			n->decl = fn;
			if(tt->kind == Tpoly)
				n->flags = FNPTRA;
			else
				n->flags = 0;
			na = mkn(Oseq, n, nil);
			if(*a == nil)
				*args = na;
			else
				(*a)->right = na;
			
			n = mkn(Ofnptr, mod, mkdeclname(src, id));
			n->src = *src;
			n->decl = fn;
			if(tt->kind == Tpoly)
				n->flags = FNPTRA|FNPTR2;
			else
				n->flags = FNPTR2;
			*a = na->right = mkn(Oseq, n, nil);
		}
		if(args0 != nil)
			args0 = args0->right;
	}
}

Node*
passfns(Src *src, Decl *fn, Node *left, Node *args, Type *adt, Tpair *tp)
{
	Node *a, *args0;

	a = nil;
	args0 = args;
	if(args != nil)
		for(a = args; a->right != nil; a = a->right)
			;
	passfns0(src, fn, args0, &args, &a, tp, ispoly(fn) ? fn->ty->polys : left->ty->tof->polys);
	if(adt != nil)
		passfns0(src, fn, args0, &args, &a, adt->u.tmap, ispoly(fn) ? encpolys(fn) : nil);
	return args;	
}

/*
 * check the types for a function with a variable number of arguments
 * last typed argument must be a constant string, and must use the
 * print format for describing arguments.
 */
Type*
mkvarargs(Node *n, Node *args)
{
	Node *s, *a;
	Decl *f, *last, *va;
	Type *nt;

	nt = copytypeids(n->ty);
	n->ty = nt;
	f = n->ty->ids;
	last = nil;
	if(f == nil){
		nerror(n, "%V's type is illegal", n);
		return nt;
	}
	s = args;
	for(a = args; a != nil; a = a->right){
		if(f == nil)
			break;
		if(!tcompat(f->ty, a->left->ty, 0)){
			nerror(n, "%V: argument type mismatch: expected %T saw %Q",
				n, f->ty, a->left);
			return nt;
		}
		if(a->left->ty == tany)
			a->left->ty = f->ty;
		last = f;
		f = f->next;
		s = a;
	}
	if(f != nil){
		nerror(n, "%V: too few function arguments", n);
		return nt;
	}

	s->left = fold(s->left);
	s = s->left;
	if(s->ty != tstring || s->op != Oconst){
		nerror(args, "%V: format argument %Q is not a string constant", n, s);
		return nt;
	}
	fmtcheck(n, s, a);
	va = tuplefields(a);
	if(last == nil)
		nt->ids = va;
	else
		last->next = va;
	return nt;
}

/*
 * check that a print style format string matches its arguments
 */
void
fmtcheck(Node *f, Node *fmtarg, Node *va)
{
	Sym *fmt;
	Rune r;
	char *s, flags[10];
	int i, c, n1, n2, dot, verb, flag, ns, lens, fmtstart;
	Type *ty;

	fmt = fmtarg->decl->sym;
	s = fmt->name;
	lens = fmt->len;
	ns = 0;
	while(ns < lens){
		c = s[ns++];
		if(c != '%')
			continue;

		verb = -1;
		n1 = 0;
		n2 = 0;
		dot = 0;
		flag = 0;
		fmtstart = ns - 1;
		while(ns < lens && verb < 0){
			c = s[ns++];
			switch(c){
			default:
				chartorune(&r, &s[ns-1]);
				nerror(f, "%V: invalid character %C in format '%.*s'", f, r, ns-fmtstart, &s[fmtstart]);
				return;
			case '.':
				if(dot){
					nerror(f, "%V: invalid format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
					return;
				}
				n1 = 1;
				dot = 1;
				continue;
			case '*':
				if(!n1)
					n1 = 1;
				else if(!n2 && dot)
					n2 = 1;
				else{
					nerror(f, "%V: invalid format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
					return;
				}
				if(va == nil){
					nerror(f, "%V: too few arguments for format '%.*s'",
						f, ns-fmtstart, &s[fmtstart]);
					return;
				}
				if(va->left->ty->kind != Tint){
					nerror(f, "%V: format '%.*s' incompatible with argument %Q",
						f, ns-fmtstart, &s[fmtstart], va->left);
					return;
				}
				va = va->right;
				break;
			case '0': case '1': case '2': case '3': case '4':
			case '5': case '6': case '7': case '8': case '9':
				while(ns < lens && s[ns] >= '0' && s[ns] <= '9')
					ns++;
				if(!n1)
					n1 = 1;
				else if(!n2 && dot)
					n2 = 1;
				else{
					nerror(f, "%V: invalid format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
					return;
				}
				break;
			case '+':
			case '-':
			case '#':
			case ',':
			case 'b':
			case 'u':
				for(i = 0; i < flag; i++){
					if(flags[i] == c){
						nerror(f, "%V: duplicate flag %c in format '%.*s'",
							f, c, ns-fmtstart, &s[fmtstart]);
						return;
					}
				}
				flags[flag++] = c;
				if(flag >= sizeof flags){
					nerror(f, "too many flags in format '%.*s'", ns-fmtstart, &s[fmtstart]);
					return;
				}
				break;
			case '%':
			case 'r':
				verb = Tnone;
				break;
			case 'H':
				verb = Tany;
				break;
			case 'c':
				verb = Tint;
				break;
			case 'd':
			case 'o':
			case 'x':
			case 'X':
				verb = Tint;
				for(i = 0; i < flag; i++){
					if(flags[i] == 'b'){
						verb = Tbig;
						break;
					}
				}
				break;
			case 'e':
			case 'f':
			case 'g':
			case 'E':
			case 'G':
				verb = Treal;
				break;
			case 's':
			case 'q':
				verb = Tstring;
				break;
			}
		}
		if(verb != Tnone){
			if(verb < 0){
				nerror(f, "%V: incomplete format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
				return;
			}
			if(va == nil){
				nerror(f, "%V: too few arguments for format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
				return;
			}
			ty = va->left->ty;
			if(ty->kind == Texception)
				ty = mkextuptype(ty);
			switch(verb){
			case Tint:
				switch(ty->kind){
				case Tstring:
				case Tarray:
				case Tref:
				case Tchan:
				case Tlist:
				case Tmodule:
					if(c == 'x' || c == 'X')
						verb = ty->kind;
					break;
				}
				break;
			case Tany:
				if(tattr[ty->kind].isptr)
					verb = ty->kind;
				break;
			}
			if(verb != ty->kind){
				nerror(f, "%V: format '%.*s' incompatible with argument %Q", f, ns-fmtstart, &s[fmtstart], va->left);
				return;
			}
			va = va->right;
		}
	}
	if(va != nil)
		nerror(f, "%V: more arguments than formats", f);
}

Decl*
tuplefields(Node *n)
{
	Decl *d, *h, **last;

	h = nil;
	last = &h;
	for(; n != nil; n = n->right){
		d = mkdecl(&n->left->src, Dfield, n->left->ty);
		*last = d;
		last = &d->next;
	}
	return h;
}

/*
 * make explicit indices for every element in an array initializer
 * return the maximum index
 * sort the indices and check for duplicates
 */
int
assignindices(Node *ar)
{
	Node *wild, *off, *size, *inits, *n, *q;
	Type *t;
	Case *c;
	int amax, max, last, nlab, ok;

	amax = 0x7fffffff;
	size = dupn(0, &nosrc, ar->left);
	if(size->ty == tint){
		size = fold(size);
		if(size->op == Oconst)
			amax = size->val;
	}

	inits = ar->right;
	max = -1;
	last = -1;
	t = inits->left->ty;
	wild = nil;
	nlab = 0;
	ok = 1;
	for(n = inits; n != nil; n = n->right){
		if(!tcompat(t,  n->left->ty, 0)){
			t = tparent(t, n->left->ty);
			if(!tcompat(t, n->left->ty, 0)){
				nerror(n->left, "inconsistent types %T and %T and in array initializer", t, n->left->ty);
				return -1;
			}
			else
				inits->left->ty = t;
		}
		if(t == tany)
			t = n->left->ty;

		/*
		 * make up an index if there isn't one
		 */
		if(n->left->left == nil)
			n->left->left = mkn(Oseq, mkconst(&n->left->right->src, last + 1), nil);

		for(q = n->left->left; q != nil; q = q->right){
			off = q->left;
			if(off->ty != tint){
				nerror(off, "array index %Q is not an int", off);
				ok = 0;
				continue;
			}
			off = fold(off);
			switch(off->op){
			case Owild:
				if(wild != nil)
					nerror(off, "array index * duplicated on line %L", wild->src.start);
				wild = off;
				continue;
			case Orange:
				if(off->left->op != Oconst || off->right->op != Oconst){
					nerror(off, "range %V is not constant", off);
					off = nil;
				}else if(off->left->val < 0 || off->right->val >= amax){
					nerror(off, "array index %V out of bounds", off);
					off = nil;
				}else
					last = off->right->val;
				break;
			case Oconst:
				last = off->val;
				if(off->val < 0 || off->val >= amax){
					nerror(off, "array index %V out of bounds", off);
					off = nil;
				}
				break;
			case Onothing:
				/* get here from a syntax error */
				off = nil;
				break;
			default:
				nerror(off, "array index %V is not constant", off);
				off = nil;
				break;
			}

			nlab++;
			if(off == nil){
				off = mkconst(&n->left->right->src, last);
				ok = 0;
			}
			if(last > max)
				max = last;
			q->left = off;
		}
	}

	/*
	 * fix up types of nil elements
	 */
	for(n = inits; n != nil; n = n->right)
		if(n->left->ty == tany)
			n->left->ty = t;

	if(!ok)
		return -1;


	c = checklabels(inits, tint, nlab, "array index");
	t = mktype(&inits->src.start, &inits->src.stop, Tainit, nil, nil);
	inits->ty = t;
	t->cse = c;

	return max + 1;
}

/*
 * check the labels of a case statment
 */
void
casecheck(Node *cn, Type *ret)
{
	Node *n, *q, *wild, *left, *arg;
	Type *t;
	Case *c;
	Ok rok;
	int nlab, ok, op;

	rok = echeck(cn->left, 0, 0, nil);
	cn->right = scheck(cn->right, ret, Sother);
	if(!rok.ok)
		return;
	arg = cn->left;

	t = arg->ty;
	if(t != tint && t != tbig && t != tstring){
		nerror(cn, "case argument %Q is not an int or big or string", arg);
		return;
	}

	wild = nil;
	nlab= 0;
	ok = 1;
	for(n = cn->right; n != nil; n = n->right){
		q = n->left->left;
		if(n->left->right->right == nil)
			nwarn(q, "no body for case qualifier %V", q);
		for(; q != nil; q = q->right){
			left = fold(q->left);
			q->left = left;
			switch(left->op){
			case Owild:
				if(wild != nil)
					nerror(left, "case qualifier * duplicated on line %L", wild->src.start);
				wild = left;
				break;
			case Orange:
				if(left->ty != t)
					nerror(left, "case qualifier %Q clashes with %Q", left, arg);
				else if(left->left->op != Oconst || left->right->op != Oconst){
					nerror(left, "case range %V is not constant", left);
					ok = 0;
				}
				nlab++;
				break;
			default:
				if(left->ty != t){
					nerror(left, "case qualifier %Q clashes with %Q", left, arg);
					ok = 0;
				}else if(left->op != Oconst){
					nerror(left, "case qualifier %V is not constant", left);
					ok = 0;
				}
				nlab++;
				break;
			}
		}
	}

	if(!ok)
		return;

	c = checklabels(cn->right, t, nlab, "case qualifier");
	op = Tcase;
	if(t == tbig)
		op = Tcasel;
	else if(t == tstring)
		op = Tcasec;
	t = mktype(&cn->src.start, &cn->src.stop, op, nil, nil);
	cn->ty = t;
	t->cse = c;
}

/*
 * check the labels and bodies of a pick statment
 */
void
pickcheck(Node *n, Type *ret)
{
	Node *w, *arg, *qs, *q, *qt, *left, **tags;
	Decl *id, *d;
	Type *t, *argty;
	Case *c;
	Ok rok;
	int ok, nlab;

	arg = n->left->right;
	rok = echeck(arg, 0, 0, nil);
	if(!rok.allok)
		return;
	t = arg->ty;
	if(t->kind == Tref)
		t = t->tof;
	if(arg->ty->kind != Tref || t->kind != Tadt || t->tags == nil){
		nerror(arg, "pick argument %Q is not a ref adt with pick tags", arg);
		return;
	}
	argty = usetype(mktype(&arg->ty->src.start, &arg->ty->src.stop, Tref, t, nil));

	arg = n->left->left;
	pushscope(nil, Sother);
	dasdecl(arg);
	arg->decl->ty = argty;
	arg->ty = argty;

	tags = allocmem(t->decl->tag * sizeof *tags);
	memset(tags, 0, t->decl->tag * sizeof *tags);
	w = nil;
	ok = 1;
	nlab = 0;
	for(qs = n->right; qs != nil; qs = qs->right){
		qt = nil;
		for(q = qs->left->left; q != nil; q = q->right){
			left = q->left;
			switch(left->op){
			case Owild:
				/* left->ty = tnone; */
				left->ty = t;
				if(w != nil)
					nerror(left, "pick qualifier * duplicated on line %L", w->src.start);
				w = left;
				break;
			case Oname:
				id = namedot(t->tags, left->decl->sym);
				if(id == nil){
					nerror(left, "pick qualifier %V is not a member of %Q", left, arg);
					ok = 0;
					continue;
				}

				left->decl = id;
				left->ty = id->ty;

				if(tags[id->tag] != nil){
					nerror(left, "pick qualifier %V duplicated on line %L",
						left, tags[id->tag]->src.start);
					ok = 0;
				}
				tags[id->tag] = left;
				nlab++;
				break;
			default:
				fatal("pickcheck can't handle %n", q);
				break;
			}

			if(qt == nil)
				qt = left;
			else if(!tequal(qt->ty, left->ty))
				nerror(left, "type clash in pick qualifiers %Q and %Q", qt, left);
		}

		argty->tof = t;
		if(qt != nil)
			argty->tof = qt->ty;
		qs->left->right = scheck(qs->left->right, ret, Sother);
		if(qs->left->right == nil)
			nwarn(qs->left->left, "no body for pick qualifier %V", qs->left->left);
	}
	argty->tof = t;
	for(qs = n->right; qs != nil; qs = qs->right)
		for(q = qs->left->left; q != nil; q = q->right)
			q->left = fold(q->left);

	d = popscope();
	d->refs++;
	if(d->next != nil)
		fatal("pickcheck: installing more than one id");
	fndecls = appdecls(fndecls, d);

	if(!ok)
		return;

	c = checklabels(n->right, tint, nlab, "pick qualifier");
	t = mktype(&n->src.start, &n->src.stop, Tcase, nil, nil);
	n->ty = t;
	t->cse = c;
}

void
exccheck(Node *en, Type *ret)
{
	Decl *ed;
	Node *n, *q, *wild, *left, *oinexcept;
	Type *t, *qt;
	Case *c;
	int nlab, ok;
	Ok rok;
	char buf[32];
	static int nexc;

	pushscope(nil, Sother);
	if(en->left == nil){
		seprint(buf, buf+sizeof(buf), ".ex%d", nexc++);
		en->left = mkdeclname(&en->src, mkids(&en->src, enter(buf, 0), texception, nil));
	}
	oinexcept = inexcept;
	inexcept = en->left;
	dasdecl(en->left);
	en->left->ty = en->left->decl->ty = texception;
	ed = en->left->decl;
	/* en->right = scheck(en->right, ret, Sother); */
	t = tstring;
	wild = nil;
	nlab = 0;
	ok = 1;
	for(n = en->right; n != nil; n = n->right){
		qt = nil;
		for(q = n->left->left; q != nil; q = q->right){
			left = q->left;
			switch(left->op){
			case Owild:
				left->ty = texception;
				if(wild != nil)
					nerror(left, "exception qualifier * duplicated on line %L", wild->src.start);
				wild = left;
				break;
			case Orange:
				left->ty = tnone;
				nerror(left, "exception qualifier %V is illegal", left);
				ok = 0;
				break;
			default:
				rok = echeck(left, 0, 0, nil);
				if(!rok.ok){
					ok = 0;
					break;
				}
				left = q->left = fold(left);
				if(left->ty != t && left->ty->kind != Texception){
					nerror(left, "exception qualifier %Q is not a string or exception", left);
					ok = 0;
				}else if(left->op != Oconst){
					nerror(left, "exception qualifier %V is not constant", left);
					ok = 0;
				}
				else if(left->ty != t)
					left->ty = mkextype(left->ty);
				nlab++;
				break;
			}

			if(qt == nil)
				qt = left->ty;
			else if(!tequal(qt, left->ty))
				qt = texception;
		}

		if(qt != nil)
			ed->ty = qt;
		n->left->right = scheck(n->left->right, ret, Sother);
		if(n->left->right->right == nil)
			nwarn(n->left->left, "no body for exception qualifier %V", n->left->left);
	}
	ed->ty = texception;
	inexcept = oinexcept;
	if(!ok)
		return;
	c = checklabels(en->right, texception, nlab, "exception qualifier");
	t = mktype(&en->src.start, &en->src.stop, Texcept, nil, nil);
	en->ty = t;
	t->cse = c;
	ed = popscope();
	fndecls = appdecls(fndecls, ed);
}

/*
 * check array and case labels for validity
 */
Case *
checklabels(Node *inits, Type *ctype, int nlab, char *title)
{
	Node *n, *p, *q, *wild;
	Label *labs, *aux;
	Case *c;
	char buf[256], buf1[256];
	int i, e;

	labs = allocmem(nlab * sizeof *labs);
	i = 0;
	wild = nil;
	for(n = inits; n != nil; n = n->right){
		for(q = n->left->left; q != nil; q = q->right){
			switch(q->left->op){
			case Oconst:
				labs[i].start = q->left;
				labs[i].stop = q->left;
				labs[i++].node = n->left;
				break;
			case Orange:
				labs[i].start = q->left->left;
				labs[i].stop = q->left->right;
				labs[i++].node = n->left;
				break;
			case Owild:
				wild = n->left;
				break;
			default:
				fatal("bogus index in checklabels");
				break;
			}
		}
	}

	if(i != nlab)
		fatal("bad label count: %d then %d", nlab, i);

	aux = allocmem(nlab * sizeof *aux);
	casesort(ctype, aux, labs, 0, nlab);
	for(i = 0; i < nlab; i++){
		p = labs[i].stop;
		if(casecmp(ctype, labs[i].start, p) > 0)
			nerror(labs[i].start, "unmatchable %s %V", title, labs[i].node);
		for(e = i + 1; e < nlab; e++){
			if(casecmp(ctype, labs[e].start, p) <= 0){
				eprintlist(buf, buf+sizeof(buf), labs[e].node->left, " or ");
				eprintlist(buf1, buf1+sizeof(buf1), labs[e-1].node->left, " or ");
				nerror(labs[e].start,"%s '%s' overlaps with '%s' on line %L",
					title, buf, buf1, p->src.start);
			}

			/*
			 * check for merging case labels
			 */
			if(ctype != tint
			|| labs[e].start->val != p->val+1
			|| labs[e].node != labs[i].node)
				break;
			p = labs[e].stop;
		}
		if(e != i + 1){
			labs[i].stop = p;
			memmove(&labs[i+1], &labs[e], (nlab-e) * sizeof *labs);
			nlab -= e - (i + 1);
		}
	}
	free(aux);

	c = allocmem(sizeof *c);
	c->nlab = nlab;
	c->nsnd = 0;
	c->labs = labs;
	c->wild = wild;

	return c;
}

static int
matchcmp(Node *na, Node *nb)
{
	Sym *a, *b;
	int sa, sb;

	a = na->decl->sym;
	b = nb->decl->sym;
	sa = a->len > 0 && a->name[a->len-1] == '*';
	sb = b->len > 0 && b->name[b->len-1] == '*';
	if(sa){
		if(sb){
			if(a->len == b->len)
				return symcmp(a, b);
			return b->len-a->len;
		}
		else
			return 1;
	}
	else{
		if(sb)
			return -1;
		else{
			if(na->ty == tstring){
				if(nb->ty == tstring)
					return symcmp(a, b);
				else
					return 1;
			}
			else{
				if(nb->ty == tstring)
					return -1;
				else
					return symcmp(a, b);
			}
		}
	}
}

int
casecmp(Type *ty, Node *a, Node *b)
{
	if(ty == tint || ty == tbig){
		if(a->val < b->val)
			return -1;
		if(a->val > b->val)
			return 1;
		return 0;
	}
	if(ty == texception)
		return matchcmp(a, b);
	return symcmp(a->decl->sym, b->decl->sym);
}

void
casesort(Type *t, Label *aux, Label *labs, int start, int stop)
{
	int n, top, mid, base;

	n = stop - start;
	if(n <= 1)
		return;
	top = mid = start + n / 2;

	casesort(t, aux, labs, start, top);
	casesort(t, aux, labs, mid, stop);

	/*
	 * merge together two sorted label arrays, yielding a sorted array
	 */
	n = 0;
	base = start;
	while(base < top && mid < stop){
		if(casecmp(t, labs[base].start, labs[mid].start) <= 0)
			aux[n++] = labs[base++];
		else
			aux[n++] = labs[mid++];
	}
	if(base < top)
		memmove(&aux[n], &labs[base], (top-base) * sizeof *aux);
	else if(mid < stop)
		memmove(&aux[n], &labs[mid], (stop-mid) * sizeof *aux);
	memmove(&labs[start], &aux[0], (stop-start) * sizeof *labs);
}

/*
 * binary search for the label corresponding to a given value
 */
int
findlab(Type *ty, Node *v, Label *labs, int nlab)
{
	int l, r, m;

	if(nlab <= 1)
		return 0;
	l = 1;
	r = nlab - 1;
	while(l <= r){
		m = (r + l) / 2;
		if(casecmp(ty, labs[m].start, v) <= 0)
			l = m + 1;
		else
			r = m - 1;
	}
	m = l - 1;
	if(casecmp(ty, labs[m].start, v) > 0
	|| casecmp(ty, labs[m].stop, v) < 0)
		fatal("findlab out of range");
	return m;
}

void
altcheck(Node *an, Type *ret)
{
	Node *n, *q, *left, *op, *wild;
	Case *c;
	int ok, nsnd, nrcv;

	an->left = scheck(an->left, ret, Sother);

	ok = 1;
	nsnd = 0;
	nrcv = 0;
	wild = nil;
	for(n = an->left; n != nil; n = n->right){
		q = n->left->right->left;
		if(n->left->right->right == nil)
			nwarn(q, "no body for alt guard %V", q);
		for(; q != nil; q = q->right){
			left = q->left;
			switch(left->op){
			case Owild:
				if(wild != nil)
					nerror(left, "alt guard * duplicated on line %L", wild->src.start);
				wild = left;
				break;
			case Orange:
				nerror(left, "alt guard %V is illegal", left);
				ok = 0;
				break;
			default:
				op = hascomm(left);
				if(op == nil){
					nerror(left, "alt guard %V has no communication", left);
					ok = 0;
					break;
				}
				if(op->op == Osnd)
					nsnd++;
				else
					nrcv++;
				break;
			}
		}
	}

	if(!ok)
		return;

	c = allocmem(sizeof *c);
	c->nlab = nsnd + nrcv;
	c->nsnd = nsnd;
	c->wild = wild;

	an->ty = mktalt(c);
}

Node*
hascomm(Node *n)
{
	Node *r;

	if(n == nil)
		return nil;
	if(n->op == Osnd || n->op == Orcv)
		return n;
	r = hascomm(n->left);
	if(r != nil)
		return r;
	return hascomm(n->right);
}

void
raisescheck(Type *t)
{
	Node *n, *nn;
	Ok ok;

	if(t->kind != Tfn)
		return;
	n = t->u.eraises;
	for(nn = n->left; nn != nil; nn = nn->right){
		ok = echeck(nn->left, 0, 0, nil);
		if(ok.ok && nn->left->ty->kind != Texception)
			nerror(n, "%V: illegal raises expression", nn->left);
	}
}

typedef struct Elist Elist;

struct Elist{
	Decl *d;
	Elist *nxt;
};

static Elist*
emerge(Elist *el1, Elist *el2)
{
	int f;
	Elist *el, *nxt;

	for( ; el1 != nil; el1 = nxt){
		f = 0;
		for(el = el2; el != nil; el = el->nxt){
			if(el1->d == el->d){
				f = 1;
				break;
			}
		}
		nxt = el1->nxt;
		if(!f){
			el1->nxt = el2;
			el2 = el1;
		}
	}
	return el2;
}

static Elist*
equals(Node *n)
{
	Node *q, *nn;
	Elist *e, *el;

	el = nil;
	for(q = n->left->left; q != nil; q = q->right){
		nn = q->left;
		if(nn->op == Owild)
			return nil;
		if(nn->ty->kind != Texception)
			continue;
		e = (Elist*)malloc(sizeof(Elist));
		e->d = nn->decl;
		e->nxt = el;
		el = e;
	}
	return el;
}

static int
caught(Decl *d, Node *n)
{
	Node *q, *nn;

	for(n = n->right; n != nil; n = n->right){
		for(q = n->left->left; q != nil; q = q->right){
			nn = q->left;
			if(nn->op == Owild)
				return 1;
			if(nn->ty->kind != Texception)
				continue;
			if(d == nn->decl)
				return 1;
		}
	}
	return 0;
}

static Elist*
raisecheck(Node *n, Elist *ql)
{
	int exc;
	Node *e;
	Elist *el, *nel, *nxt;

	if(n == nil)
		return nil;
	el = nil;
	for(; n != nil; n = n->right){
		switch(n->op){
		case Oscope:
			return raisecheck(n->right, ql);
		case Olabel:
		case Odo:
			return raisecheck(n->right, ql);
		case Oif:
		case Ofor:
			return emerge(raisecheck(n->right->left, ql),
					        raisecheck(n->right->right, ql));
		case Oalt:
		case Ocase:
		case Opick:
		case Oexcept:
			exc = n->op == Oexcept;
			for(n = n->right; n != nil; n = n->right){
				ql = nil;
				if(exc)
					ql = equals(n);
				el = emerge(raisecheck(n->left->right, ql), el);
			}
			return el;
		case Oseq:
			el = emerge(raisecheck(n->left, ql), el);
			break;
		case Oexstmt:
			el = raisecheck(n->left, ql);
			nel = nil;
			for( ; el != nil; el = nxt){
				nxt = el->nxt;
				if(!caught(el->d, n->right)){
					el->nxt = nel;
					nel = el;
				}
			}		
			return emerge(nel, raisecheck(n->right, ql));
		case Oraise:
			e = n->left;
			if(e->ty && e->ty->kind == Texception){
				if(!e->ty->cons)
					return ql;
				if(e->op == Ocall)
					e = e->left;
				if(e->op == Omdot)
					e = e->right;
				if(e->op != Oname)
					fatal("exception %n not a name", e);
				el = (Elist*)malloc(sizeof(Elist));
				el->d = e->decl;
				el->nxt = nil;
				return el;
			}
			return nil;
		default:
			return nil;
		}
	}
	return el;
}

void
checkraises(Node *n)
{
	int f;
	Decl *d;
	Elist *e, *el;
	Node *es, *nn;

	el = raisecheck(n->right, nil);
	es = n->ty->u.eraises;
	if(es != nil){
		for(nn = es->left; nn != nil; nn = nn->right){
			d = nn->left->decl;
			f = 0;
			for(e = el; e != nil; e = e->nxt){
				if(d == e->d){
					f = 1;
					e->d = nil;
					break;
				}
			}
			if(!f)
				nwarn(n, "function %V does not raise %s but declared", n->left, d->sym->name);
		}
	}
	for(e = el; e != nil; e = e->nxt)
		if(e->d != nil)
			nwarn(n, "function %V raises %s but not declared", n->left, e->d->sym->name);
}

/* sort all globals in modules now that we've finished with 'last' pointers
 * and before any code generation
 */
void
gsort(Node *n)
{
	for(;;){
		if(n == nil)
			return;
		if(n->op != Oseq)
			break;
		gsort(n->left);
		n = n->right;
	}
	if(n->op == Omoddecl && n->ty->ok & OKverify){
		n->ty->ids = namesort(n->ty->ids);
		sizeids(n->ty->ids, 0);
	}
}