#include "limbo.h"

char *storename[Dend]=
{
	/* Dtype */	"type",
	/* Dfn */	"function",
	/* Dglobal */	"global",
	/* Darg */	"argument",
	/* Dlocal */	"local",
	/* Dconst */	"con",
	/* Dfield */	"field",
	/* Dtag */	"pick tag",
	/* Dimport */	"import",
	/* Dunbound */	"unbound",
	/* Dundef */	"undefined",
	/* Dwundef */	"undefined",
};

char *storeart[Dend] =
{
	/* Dtype */	"a ",
	/* Dfn */	"a ",
	/* Dglobal */	"a ",
	/* Darg */	"an ",
	/* Dlocal */	"a ",
	/* Dconst */	"a ",
	/* Dfield */	"a ",
	/* Dtag */	"a",
	/* Dimport */	"an ",
	/* Dunbound */	"",
	/* Dundef */	"",
	/* Dwundef */	"",
};

int storespace[Dend] =
{
	/* Dtype */	0,
	/* Dfn */	0,
	/* Dglobal */	1,
	/* Darg */	1,
	/* Dlocal */	1,
	/* Dconst */	0,
	/* Dfield */	1,
	/* Dtag */	0,
	/* Dimport */	0,
	/* Dunbound */	0,
	/* Dundef */	0,
	/* Dwundef */	0,
};

static	Decl	*scopes[MaxScope];
static	Decl	*tails[MaxScope];
static	Node *scopenode[MaxScope];
static	uchar scopekind[MaxScope];

static	void	freeloc(Decl*);

void
popscopes(void)
{
	Decl *d;
	Dlist *id;

	/*
	 * clear out any decls left in syms
	 */
	while(scope >= ScopeBuiltin){
		for(d = scopes[scope--]; d != nil; d = d->next){
			if(d->sym != nil){
				d->sym->decl = d->old;
				d->old = nil;
			}
		}
	}

	for(id = impdecls; id != nil; id = id->next){
		for(d = id->d->ty->ids; d != nil; d = d->next){
			d->sym->decl = nil;
			d->old = nil;
		}
	}
	impdecls = nil;

	scope = ScopeBuiltin;
	scopes[ScopeBuiltin] = nil;
	tails[ScopeBuiltin] = nil;
}

void
declstart(void)
{
	Decl *d;

	iota = mkids(&nosrc, enter("iota", 0), tint, nil);
	iota->init = mkconst(&nosrc, 0);

	scope = ScopeNils;
	scopes[ScopeNils] = nil;
	tails[ScopeNils] = nil;

	nildecl = mkdecl(&nosrc, Dglobal, tany);
	nildecl->sym = enter("nil", 0);
	installids(Dglobal, nildecl);
	d = mkdecl(&nosrc, Dglobal, tstring);
	d->sym = enter("", 0);
	installids(Dglobal, d);

	scope = ScopeGlobal;
	scopes[ScopeGlobal] = nil;
	tails[ScopeGlobal] = nil;
}

void
redecl(Decl *d)
{
	Decl *old;

	old = d->sym->decl;
	if(old->store == Dwundef)
		return;
	error(d->src.start, "redeclaration of %K, previously declared as %k on line %L",
		d, old, old->src.start);
}

void
checkrefs(Decl *d)
{
	Decl *id, *m;
	long refs;

	for(; d != nil; d = d->next){
		if(d->das)
			d->refs--;
		switch(d->store){
		case Dtype:
			refs = d->refs;
			if(d->ty->kind == Tadt){
				for(id = d->ty->ids; id != nil; id = id->next){
					d->refs += id->refs;
					if(id->store != Dfn)
						continue;
					if(id->init == nil && id->link == nil && d->importid == nil)
						error(d->src.start, "function %s.%s not defined", d->sym->name, id->sym->name);
					if(superwarn && !id->refs && d->importid == nil)
						warn(d->src.start, "function %s.%s not referenced", d->sym->name, id->sym->name);
				}
			}
			if(d->ty->kind == Tmodule){
				for(id = d->ty->ids; id != nil; id = id->next){
					refs += id->refs;
					if(id->iface != nil)
						id->iface->refs += id->refs;
					if(id->store == Dtype){
						for(m = id->ty->ids; m != nil; m = m->next){
							refs += m->refs;
							if(m->iface != nil)
								m->iface->refs += m->refs;
						}
					}
				}
				d->refs = refs;
			}
			if(superwarn && !refs && d->importid == nil)
				warn(d->src.start, "%K not referenced", d);
			break;
		case Dglobal:
			if(!superwarn)
				break;
		case Dlocal:
		case Darg:
			if(!d->refs && d->sym != nil
			&& d->sym->name != nil && d->sym->name[0] != '.')
				warn(d->src.start, "%K not referenced", d);
			break;
		case Dconst:
			if(superwarn && !d->refs && d->sym != nil)
				warn(d->src.start, "%K not referenced", d);
			if(d->ty == tstring && d->init != nil)
				d->init->decl->refs += d->refs;
			break;
		case Dfn:
			if(d->init == nil && d->importid == nil)
				error(d->src.start, "%K not defined", d);
			if(superwarn && !d->refs)
				warn(d->src.start, "%K not referenced", d);
			break;
		case Dimport:
			if(superwarn && !d->refs)
				warn(d->src.start, "%K not referenced", d);
			break;
		}
		if(d->das)
			d->refs++;
	}
}

Node*
vardecl(Decl *ids, Type *t)
{
	Node *n;

	n = mkn(Ovardecl, mkn(Oseq, nil, nil), nil);
	n->decl = ids;
	n->ty = t;
	return n;
}

void
vardecled(Node *n)
{
	Decl *ids, *last;
	Type *t;
	int store;

	store = Dlocal;
	if(scope == ScopeGlobal)
		store = Dglobal;
	if(n->ty->kind == Texception && n->ty->cons){
		store = Dconst;
		fatal("Texception in vardecled");
	}
	ids = n->decl;
	installids(store, ids);
	t = n->ty;
	for(last = ids; ids != nil; ids = ids->next){
		ids->ty = t;
		last = ids;
	}
	n->left->decl = last;
}

Node*
condecl(Decl *ids, Node *init)
{
	Node *n;

	n = mkn(Ocondecl, mkn(Oseq, nil, nil), init);
	n->decl = ids;
	return n;
}

void
condecled(Node *n)
{
	Decl *ids, *last;

	ids = n->decl;
	installids(Dconst, ids);
	for(last = ids; ids != nil; ids = ids->next){
		ids->ty = tunknown;
		last = ids;
	}
	n->left->decl = last;
}

Node*
exdecl(Decl *ids, Decl *tids)
{
	Node *n;
	Type *t;

	t = mktype(&ids->src.start, &ids->src.stop, Texception, nil, tids);
	t->cons = 1;
	n = mkn(Oexdecl, mkn(Oseq, nil, nil), nil);
	n->decl = ids;
	n->ty = t;
	return n;
}

void
exdecled(Node *n)
{
	Decl *ids, *last;
	Type *t;

	ids = n->decl;
	installids(Dconst, ids);
	t = n->ty;
	for(last = ids; ids != nil; ids = ids->next){
		ids->ty = t;
		last = ids;
	}
	n->left->decl = last;
}

Node*
importdecl(Node *m, Decl *ids)
{
	Node *n;

	n = mkn(Oimport, mkn(Oseq, nil, nil), m);
	n->decl = ids;
	return n;
}

void
importdecled(Node *n)
{
	Decl *ids, *last;

	ids = n->decl;
	installids(Dimport, ids);
	for(last = ids; ids != nil; ids = ids->next){
		ids->ty = tunknown;
		last = ids;
	}
	n->left->decl = last;
}

Node*
mkscope(Node *body)
{
	Node *n;

	n = mkn(Oscope, nil, body);
	if(body != nil)
		n->src = body->src;
	return n;
}

Node*
fndecl(Node *n, Type *t, Node *body)
{
	n = mkbin(Ofunc, n, body);
	n->ty = t;
	return n;
}

void
fndecled(Node *n)
{
	Decl *d;
	Node *left;

	left = n->left;
	if(left->op == Oname){
		d = left->decl->sym->decl;
		if(d == nil || d->store == Dimport){
			d = mkids(&left->src, left->decl->sym, n->ty, nil);
			installids(Dfn, d);
		}
		left->decl = d;
		d->refs++;
	}
	if(left->op == Odot)
		pushscope(nil, Sother);
	if(n->ty->polys != nil){
		pushscope(nil, Sother);
		installids(Dtype, n->ty->polys);
	}
	pushscope(nil, Sother);
	installids(Darg, n->ty->ids);
	n->ty->ids = popscope();
	if(n->ty->val != nil)
		mergepolydecs(n->ty);
	if(n->ty->polys != nil)
		n->ty->polys = popscope();
	if(left->op == Odot)
		popscope();
}

/*
 * check the function declaration only
 * the body will be type checked later by fncheck
 */
Decl *
fnchk(Node *n)
{
	int bad;
	Decl *d, *inadt, *adtp;
	Type *t;

	bad = 0;
	d = n->left->decl;
	if(n->left->op == Odot)
		d = n->left->right->decl;
	if(d == nil)
		fatal("decl() fnchk nil");
	n->left->decl = d;
	if(d->store == Dglobal || d->store == Dfield)
		d->store = Dfn;
	if(d->store != Dfn || d->init != nil){
		nerror(n, "redeclaration of function %D, previously declared as %k on line %L",
			d, d, d->src.start);
		if(d->store == Dfn && d->init != nil)
			bad = 1;
	}
	d->init = n;

	t = n->ty;
	inadt = d->dot;
	if(inadt != nil && (inadt->store != Dtype || inadt->ty->kind != Tadt))
		inadt = nil;
	if(n->left->op == Odot){
		pushscope(nil, Sother);
		adtp = outerpolys(n->left);
		if(adtp != nil)
			installids(Dtype, adtp);
		if(!polyequal(adtp, n->decl))
			nerror(n, "adt polymorphic type mismatch");
		n->decl = nil;
	}
	t = validtype(t, inadt);
	if(n->left->op == Odot)
		popscope();
	if(debug['d'])
		print("declare function %D ty %T newty %T\n", d, d->ty, t);
	t = usetype(t);

	if(!polyequal(d->ty->polys, t->polys))
		nerror(n, "function polymorphic type mismatch");
	if(!tcompat(d->ty, t, 0))
		nerror(n, "type mismatch: %D defined as %T declared as %T on line %L",
			d, t, d->ty, d->src.start);
	else if(!raisescompat(d->ty->u.eraises, t->u.eraises))
		nerror(n, "raises mismatch: %D", d);
	if(t->varargs != 0)
		nerror(n, "cannot define functions with a '*' argument, such as %D", d);

	t->u.eraises = d->ty->u.eraises;

	d->ty = t;
	d->offset = idoffsets(t->ids, MaxTemp, IBY2WD);
	d->src = n->src;

	d->locals = nil;

	n->ty = t;

	return bad ? nil: d;
}

Node*
globalas(Node *dst, Node *v, int valok)
{
	Node *tv;

	if(v == nil)
		return nil;
	if(v->op == Oas || v->op == Odas){
		v = globalas(v->left, v->right, valok);
		if(v == nil)
			return nil;
	}else if(valok && !initable(dst, v, 0))
		return nil;
	switch(dst->op){
	case Oname:
		if(dst->decl->init != nil)
			nerror(dst, "duplicate assignment to %V, previously assigned on line %L",
				dst, dst->decl->init->src.start);
		if(valok)
			dst->decl->init = v;
		return v;
	case Otuple:
		if(valok && v->op != Otuple)
			fatal("can't deal with %n in tuple case of globalas", v);
		tv = v->left;
		for(dst = dst->left; dst != nil; dst = dst->right){
			globalas(dst->left, tv->left, valok);
			if(valok)
				tv = tv->right;
		}
		return v;
	}
	fatal("can't deal with %n in globalas", dst);
	return nil;
}

int
needsstore(Decl *d)
{
	if(!d->refs)
		return 0;
	if(d->importid != nil)
		return 0;
	if(storespace[d->store])
		return 1;
	return 0;
}

/*
 * return the list of all referenced storage variables
 */
Decl*
vars(Decl *d)
{
	Decl *v, *n;

	while(d != nil && !needsstore(d))
		d = d->next;
	for(v = d; v != nil; v = v->next){
		while(v->next != nil){
			n = v->next;
			if(needsstore(n))
				break;
			v->next = n->next;
		}
	}
	return d;
}

/*
 * declare variables from the left side of a := statement
 */
static int
recdasdecl(Node *n, int store, int *nid)
{
	Decl *d, *old;
	int ok;

	switch(n->op){
	case Otuple:
		ok = 1;
		for(n = n->left; n != nil; n = n->right)
			ok &= recdasdecl(n->left, store, nid);
		return ok;
	case Oname:
		if(n->decl == nildecl){
			*nid = -1;
			return 1;
		}
		d = mkids(&n->src, n->decl->sym, nil, nil);
		installids(store, d);
		old = d->old;
		if(old != nil
		&& old->store != Dfn
		&& old->store != Dwundef
		&& old->store != Dundef)
			warn(d->src.start,  "redeclaration of %K, previously declared as %k on line %L",
				d, old, old->src.start);
		n->decl = d;
		d->refs++;
		d->das = 1;
		if(*nid >= 0)
			(*nid)++;
		return 1;
	}
	return 0;
}

static int
recmark(Node *n, int nid)
{
	switch(n->op){
	case Otuple:
		for(n = n->left; n != nil; n = n->right)
			nid = recmark(n->left, nid);
		break;
	case Oname:
		n->decl->nid = nid;
		nid = 0;
		break;
	}
	return nid;
}

int
dasdecl(Node *n)
{
	int store, ok, nid;

	nid = 0;
	if(scope == ScopeGlobal)
		store = Dglobal;
	else
		store = Dlocal;

	ok = recdasdecl(n, store, &nid);
	if(!ok)
		nerror(n, "illegal declaration expression %V", n);
	if(ok && store == Dlocal && nid > 1)
		recmark(n, nid);
	return ok;
}

/*
 * declare global variables in nested := expressions
 */
void
gdasdecl(Node *n)
{
	if(n == nil)
		return;

	if(n->op == Odas){
		gdasdecl(n->right);
		dasdecl(n->left);
	}else{
		gdasdecl(n->left);
		gdasdecl(n->right);
	}
}

Decl*
undefed(Src *src, Sym *s)
{
	Decl *d;

	d = mkids(src, s, tnone, nil);
	error(src->start, "%s is not declared", s->name);
	installids(Dwundef, d);
	return d;
}

/*
int
inloop()
{
	int i;

	for (i = scope; i > 0; i--)
		if (scopekind[i] == Sloop)
			return 1;
	return 0;
}
*/

int
nested()
{
	int i;

	for (i = scope; i > 0; i--)
		if (scopekind[i] == Sscope || scopekind[i] == Sloop)
			return 1;
	return 0;
}

void
decltozero(Node *n)
{
	Node *scp;

	if ((scp = scopenode[scope]) != nil) {
		/* can happen if we do
		 *	x[i] := ......
		 * which is an error
		 */
		if (n->right != nil && errors == 0)
			fatal("Ovardecl/Oname/Otuple has right field\n");
		n->right = scp->left;
		scp->left = n;
	}
}

void
pushscope(Node *scp, int kind)
{
	if(scope >= MaxScope)
		fatal("scope too deep");
	scope++;
	scopes[scope] = nil;
	tails[scope] = nil;
	scopenode[scope] = scp;
	scopekind[scope] = kind;
}

Decl*
curscope(void)
{
	return scopes[scope];
}

/*
 * revert to old declarations for each symbol in the currect scope.
 * remove the effects of any imported adt types
 * whenever the adt is imported from a module,
 * we record in the type's decl the module to use
 * when calling members.  the process is reversed here.
 */
Decl*
popscope(void)
{
	Decl *id;
	Type *t;

if (debug['X'])
	print("popscope\n");
	for(id = scopes[scope]; id != nil; id = id->next){
		if(id->sym != nil){
if (debug['X'])
	print("%s : %s %d\n", id->sym->name, kindname[id->ty->kind], id->init != nil ? id->init->op : 0);
			id->sym->decl = id->old;
			id->old = nil;
		}
		if(id->importid != nil)
			id->importid->refs += id->refs;
		t = id->ty;
		if(id->store == Dtype
		&& t->decl != nil
		&& t->decl->timport == id)
			t->decl->timport = id->timport;
		if(id->store == Dlocal)
			freeloc(id);
	}
	return scopes[scope--];
}

/*
 * make a new scope,
 * preinstalled with some previously installed identifiers
 * don't add the identifiers to the scope chain,
 * so they remain separate from any newly installed ids
 *
 * these routines assume no ids are imports
 */
void
repushids(Decl *ids)
{
	Sym *s;

	if(scope >= MaxScope)
		fatal("scope too deep");
	scope++;
	scopes[scope] = nil;
	tails[scope] = nil;
	scopenode[scope] = nil;
	scopekind[scope] = Sother;

	for(; ids != nil; ids = ids->next){
		if(ids->scope != scope
		&& (ids->dot == nil || !isimpmod(ids->dot->sym)
			|| ids->scope != ScopeGlobal || scope != ScopeGlobal + 1))
			fatal("repushids scope mismatch");
		s = ids->sym;
		if(s != nil && ids->store != Dtag){
			if(s->decl != nil && s->decl->scope >= scope)
				ids->old = s->decl->old;
			else
				ids->old = s->decl;
			s->decl = ids;
		}
	}
}

/*
 * pop a scope which was started with repushids
 * return any newly installed ids
 */
Decl*
popids(Decl *ids)
{
	for(; ids != nil; ids = ids->next){
		if(ids->sym != nil && ids->store != Dtag){
			ids->sym->decl = ids->old;
			ids->old = nil;
		}
	}
	return popscope();
}

void
installids(int store, Decl *ids)
{
	Decl *d, *last;
	Sym *s;

	last = nil;
	for(d = ids; d != nil; d = d->next){
		d->scope = scope;
		if(d->store == Dundef)
			d->store = store;
		s = d->sym;
		if(s != nil){
			if(s->decl != nil && s->decl->scope >= scope){
				redecl(d);
				d->old = s->decl->old;
			}else
				d->old = s->decl;
			s->decl = d;
		}
		last = d;
	}
	if(ids != nil){
		d = tails[scope];
		if(d == nil)
			scopes[scope] = ids;
		else
			d->next = ids;
		tails[scope] = last;
	}
}

Decl*
lookup(Sym *sym)
{
	int s;
	Decl *d;

	for(s = scope; s >= ScopeBuiltin; s--){
		for(d = scopes[s]; d != nil; d = d->next){
			if(d->sym == sym)
				return d;
		}
	}
	return nil;
}

Decl*
mkids(Src *src, Sym *s, Type *t, Decl *next)
{
	Decl *d;

	d = mkdecl(src, Dundef, t);
	d->next = next;
	d->sym = s;
	return d;
}

Decl*
mkdecl(Src *src, int store, Type *t)
{
	Decl *d;
	static Decl z;

	d = allocmem(sizeof *d);
	*d = z;
	d->src = *src;
	d->store = store;
	d->ty = t;
	d->nid = 1;
	return d;
}

Decl*
dupdecl(Decl *old)
{
	Decl *d;

	d = allocmem(sizeof *d);
	*d = *old;
	d->next = nil;
	return d;
}

Decl*
dupdecls(Decl *old)
{
	Decl *d, *nd, *first, *last;

	first = last = nil;
	for(d = old; d != nil; d = d->next){
		nd = dupdecl(d);
		if(first == nil)
			first = nd;
		else
			last->next = nd;
		last = nd;
	}
	return first;
}
		
Decl*
appdecls(Decl *d, Decl *dd)
{
	Decl *t;

	if(d == nil)
		return dd;
	for(t = d; t->next != nil; t = t->next)
		;
	t->next = dd;
	return d;
}

Decl*
revids(Decl *id)
{
	Decl *d, *next;

	d = nil;
	for(; id != nil; id = next){
		next = id->next;
		id->next = d;
		d = id;
	}
	return d;
}

long
idoffsets(Decl *id, long offset, int al)
{
	int a, algn;
	Decl *d;

	algn = 1;
	for(; id != nil; id = id->next){
		if(storespace[id->store]){
usedty(id->ty);
			if(id->store == Dlocal && id->link != nil){
				/* id->nid always 1 */
				id->offset = id->link->offset;
				continue;
			}
			a = id->ty->align;
			if(id->nid > 1){
				for(d = id->next; d != nil && d->nid == 0; d = d->next)
					if(d->ty->align > a)
						a = d->ty->align;
				algn = a;
			}
			offset = align(offset, a);
			id->offset = offset;
			offset += id->ty->size;
			if(id->nid == 0 && (id->next == nil || id->next->nid != 0))
				offset = align(offset, algn);
		}
	}
	return align(offset, al);
}

long
idindices(Decl *id)
{
	int i;

	i = 0;
	for(; id != nil; id = id->next){
		if(storespace[id->store]){
			usedty(id->ty);
			id->offset = i++;
		}
	}
	return i;
}

int
declconv(Fmt *f)
{
	Decl *d;
	char buf[4096], *s;

	d = va_arg(f->args, Decl*);
	if(d->sym == nil)
		s = "<nil>";
	else
		s = d->sym->name;
	seprint(buf, buf+sizeof(buf), "%s %s", storename[d->store], s);
	return fmtstrcpy(f, buf);
}

int
storeconv(Fmt *f)
{
	Decl *d;
	char buf[4096];

	d = va_arg(f->args, Decl*);
	seprint(buf, buf+sizeof(buf), "%s%s", storeart[d->store], storename[d->store]);
	return fmtstrcpy(f, buf);
}

int
dotconv(Fmt *f)
{
	Decl *d;
	char buf[4096], *p, *s;

	d = va_arg(f->args, Decl*);
	buf[0] = 0;
	p = buf;
	if(d->dot != nil && !isimpmod(d->dot->sym)){
		s = ".";
		if(d->dot->ty != nil && d->dot->ty->kind == Tmodule)
			s = "->";
		p = seprint(buf, buf+sizeof(buf), "%D%s", d->dot, s);
	}
	seprint(p, buf+sizeof(buf), "%s", d->sym->name);
	return fmtstrcpy(f, buf);
}

/*
 * merge together two sorted lists, yielding a sorted list
 */
static Decl*
namemerge(Decl *e, Decl *f)
{
	Decl rock, *d;

	d = &rock;
	while(e != nil && f != nil){
		if(strcmp(e->sym->name, f->sym->name) <= 0){
			d->next = e;
			e = e->next;
		}else{
			d->next = f;
			f = f->next;
		}
		d = d->next;
	}
	if(e != nil)
		d->next = e;
	else
		d->next = f;
	return rock.next;
}

/*
 * recursively split lists and remerge them after they are sorted
 */
static Decl*
recnamesort(Decl *d, int n)
{
	Decl *r, *dd;
	int i, m;

	if(n <= 1)
		return d;
	m = n / 2 - 1;
	dd = d;
	for(i = 0; i < m; i++)
		dd = dd->next;
	r = dd->next;
	dd->next = nil;
	return namemerge(recnamesort(d, n / 2),
			recnamesort(r, (n + 1) / 2));
}

/*
 * sort the ids by name
 */
Decl*
namesort(Decl *d)
{
	Decl *dd;
	int n;

	n = 0;
	for(dd = d; dd != nil; dd = dd->next)
		n++;
	return recnamesort(d, n);
}

void
printdecls(Decl *d)
{
	for(; d != nil; d = d->next)
		print("%ld: %K %T ref %d\n", d->offset, d, d->ty, d->refs);
}

void
mergepolydecs(Type *t)
{
	Node *n, *nn;
	Decl *id, *ids, *ids1;

	for(n = t->val; n != nil; n = n->right){
		nn = n->left;
		for(ids = nn->decl; ids != nil; ids = ids->next){
			id = ids->sym->decl;
			if(id == nil){
				undefed(&ids->src, ids->sym);
				break;
			}
			if(id->store != Dtype){
				error(ids->src.start, "%K is not a type", id);
				break;
			}
			if(id->ty->kind != Tpoly){
				error(ids->src.start, "%K is not a polymorphic type", id);
				break;
			}
			if(id->ty->ids != nil)
				error(ids->src.start, "%K redefined", id);
			pushscope(nil, Sother);
			fielddecled(nn->left);
			id->ty->ids = popscope();
			for(ids1 = id->ty->ids; ids1 != nil; ids1 = ids1->next){
				ids1->dot = id;
				bindtypes(ids1->ty);
				if(ids1->ty->kind != Tfn){
					error(ids1->src.start, "only function types expected");
					id->ty->ids = nil;
				}
			}
		}
	}
	t->val = nil;
}

static void
adjfnptrs(Decl *d, Decl *polys1, Decl *polys2)
{
	int n;
	Decl *id, *idt, *idf, *arg;

	if(debug['U'])
		print("adjnptrs %s\n", d->sym->name);
	n = 0;
	for(id = d->ty->ids; id != nil; id = id->next)
		n++;
	for(idt = polys1; idt != nil; idt = idt->next)
		for(idf = idt->ty->ids; idf != nil; idf = idf->next)
			n -= 2;
	for(idt = polys2; idt != nil; idt = idt->next)
		for(idf = idt->ty->ids; idf != nil; idf = idf->next)
			n -= 2;
	for(arg = d->ty->ids; --n >= 0; arg = arg->next)
		;
	for(idt = polys1; idt != nil; idt = idt->next){
		for(idf = idt->ty->ids; idf != nil; idf = idf->next){
			idf->link = arg;
			arg = arg->next->next;
		}
	}
	for(idt = polys2; idt != nil; idt = idt->next){
		for(idf = idt->ty->ids; idf != nil; idf = idf->next){
			idf->link = arg;
			arg = arg->next->next;
		}
	}
}

static void
addptrs(Decl *polys, Decl** fps, Decl **last, int link, Src *src)
{
	Decl *idt, *idf, *fp;

	if(debug['U'])
		print("addptrs\n");
	for(idt = polys; idt != nil; idt = idt->next){
		for(idf = idt->ty->ids; idf != nil; idf = idf->next){
			fp = mkdecl(src, Darg, tany);
			fp->sym = idf->sym;
			if(link)
				idf->link = fp;
			if(*fps == nil)
				*fps = fp;
			else
				(*last)->next = fp;
			*last = fp;
			fp = mkdecl(src, Darg, tint);
			fp->sym = idf->sym;
			(*last)->next = fp;
			*last = fp;
		}
	}
}

void
addfnptrs(Decl *d, int link)
{
	Decl *fps, *last, *polys;

	if(debug['U'])
		print("addfnptrs %s %d\n", d->sym->name, link);
	polys = encpolys(d);
	if(d->ty->flags&FULLARGS){
		if(link)
			adjfnptrs(d, d->ty->polys, polys);
		if(0 && debug['U']){
			for(d = d->ty->ids; d != nil; d = d->next)
				print("%s=%ld(%d) ", d->sym->name, d->offset, tattr[d->ty->kind].isptr);
			print("\n");
		}
		return;
	}
	d->ty->flags |= FULLARGS;
	fps = last = nil;
	addptrs(d->ty->polys, &fps, &last, link, &d->src);
	addptrs(polys, &fps, &last, link, &d->src);
	for(last = d->ty->ids; last != nil && last->next != nil; last = last->next)
		;
	if(last != nil)
		last->next = fps;
	else
		d->ty->ids = fps;
	d->offset = idoffsets(d->ty->ids, MaxTemp, IBY2WD);
	if(0 && debug['U']){
		for(d = d->ty->ids; d != nil; d = d->next)
			print("%s=%ld(%d) ", d->sym->name, d->offset, tattr[d->ty->kind].isptr);
		print("\n");
	}
}

void
rmfnptrs(Decl *d)
{
	int n;
	Decl *id, *idt, *idf;

	if(debug['U'])
		print("rmfnptrs %s\n", d->sym->name);
	if(!(d->ty->flags&FULLARGS))
		return;
	d->ty->flags &= ~FULLARGS;
	n = 0;
	for(id = d->ty->ids; id != nil; id = id->next)
		n++;
	for(idt = d->ty->polys; idt != nil; idt = idt->next)
		for(idf = idt->ty->ids; idf != nil; idf = idf->next)
			n -= 2;
	for(idt = encpolys(d); idt != nil; idt = idt->next)
		for(idf = idt->ty->ids; idf != nil; idf = idf->next)
			n -= 2;
	if(n == 0){
		d->ty->ids = nil;
		return;
	}
	for(id = d->ty->ids; --n > 0; id = id->next)
		;
	id->next = nil;
	d->offset = idoffsets(d->ty->ids, MaxTemp, IBY2WD);
}

int
local(Decl *d)
{
	for(d = d->dot; d != nil; d = d->dot)
		if(d->store == Dtype && d->ty->kind == Tmodule)
			return 0;
	return 1;
}

Decl*
module(Decl *d)
{
	for(d = d->dot; d != nil; d = d->dot)
		if(d->store == Dtype && d->ty->kind == Tmodule)
			return d;
	return nil;
}

Decl*
outerpolys(Node *n)
{
	Decl *d;

	if(n->op == Odot){
		d = n->right->decl;
		if(d == nil)
			fatal("decl() outeradt nil");
		d = d->dot;
		if(d != nil && d->store == Dtype && d->ty->kind == Tadt)
			return d->ty->polys;
	}
	return nil;
}

Decl*
encpolys(Decl *d)
{
	if((d = d->dot) == nil)
		return nil;
	return d->ty->polys;
}

Decl*
fnlookup(Sym *s, Type *t, Node **m)
{
	Decl *id;
	Node *mod;

	id = nil;
	mod = nil;
	if(t->kind == Tpoly || t->kind == Tmodule)
		id = namedot(t->ids, s);
	else if(t->kind == Tref){
		t = t->tof;
		if(t->kind == Tadt){
			id = namedot(t->ids, s);
			if(t->decl != nil && t->decl->timport != nil)
				mod = t->decl->timport->eimport;
		}
		else if(t->kind == Tadtpick){
			id = namedot(t->ids, s);
			if(t->decl != nil && t->decl->timport != nil)
				mod = t->decl->timport->eimport;
			t = t->decl->dot->ty;
			if(id == nil)
				id = namedot(t->ids, s);
			if(t->decl != nil && t->decl->timport != nil)
				mod = t->decl->timport->eimport;	
		}
	}
	if(id == nil){
		id = lookup(s);
		if(id != nil)
			mod = id->eimport;
	}
	if(m != nil)
		*m = mod;
	return id;
}

int
isimpmod(Sym *s)
{
	Decl *d;

	for(d = impmods; d != nil; d = d->next)
		if(d->sym == s)
			return 1;
	return 0;
}

int
dequal(Decl *d1, Decl *d2, int full)
{
	return	d1->sym == d2->sym &&
			d1->store == d2->store &&
			d1->implicit == d2->implicit &&
			d1->cyc == d2->cyc &&
			(!full || tequal(d1->ty, d2->ty)) &&
			(!full || d1->store == Dfn || sametree(d1->init, d2->init));
}

static int
tzero(Type *t)
{
	return t->kind == Texception || tmustzero(t);
}

static int
isptr(Type *t)
{
	return t->kind == Texception || tattr[t->kind].isptr;
}

/* can d share the same stack location as another local ? */
void
shareloc(Decl *d)
{
	int z;
	Type *t, *tt;
	Decl *dd, *res;

	if(d->store != Dlocal || d->nid != 1)
		return;
	t = d->ty;
	res = nil;
	for(dd = fndecls; dd != nil; dd = dd->next){
		if(d == dd)
			fatal("d==dd in shareloc");
		if(dd->store != Dlocal || dd->nid != 1 || dd->link != nil || dd->tref != 0)
			continue;
		tt = dd->ty;
		if(t->size != tt->size || t->align != tt->align)
			continue;
		z = tzero(t)+tzero(tt);
		if(z > 0)
			continue;	/* for now */
		if(t == tt || tequal(t, tt))
			res = dd;
		else{
			if(z == 1)
				continue;
			if(z == 0 || isptr(t) || isptr(tt) || mktdesc(t) == mktdesc(tt))
				res = dd;
		}
		if(res != nil){
			/* print("%L %K share %L %K\n", d->src.start, d, res->src.start, res); */
			d->link = res;
			res->tref = 1;
			return;
		}
	}
	return;
}

static void
freeloc(Decl *d)
{
	if(d->link != nil)
		d->link->tref = 0;
}