#define EXTERN

#include "cc.h"

/*
 *	locals, parameters, globals etc of the same name should work ok without having
 *	to duplicate Syms because the details are on the containing Nodes
 */

#define SZ_CHAR	1
#define SZ_SHORT	2
#define SZ_INT	4
#define SZ_LONG	4
#define SZ_FLOAT	4
#define SZ_IND	4
#define SZ_VLONG	8
#define SZ_DOUBLE	8

char buf[128], mbuf[128];
static Sym *sysop, *bioop, *libcop;
static int again;

#define	STAR	0x80
#define	RET		0x80

#define	LARR	(-1729)

static void swalk(void);
static int isdec(Node*);
static int isconst(Node*, vlong);
static int cktype(Node*, Node*, int, int);
static void addnode(int, Node*);
static int argpos(Node*, Node*);
static void setdec(Sym*, Type*);
static Type* tcp(Type*);
static int isadt(Type*);
static void aargs(Node*);
static int iteq(Type*, Type*);
static Node* arg(Node*, int);
static void etgen2(Sym*);
static Node* ckneg(Node*);
static Sym* suename(Type*);
static int isnil(Node*);
static void sliceasgn(Node*);
static Node* lastn(Node*);
static char* hasm(void);
static void prn(Node*, int);
static int isfn(Type*);

schar	ewidth[NTYPE] =
{
	-1,		/* [TXXX] */
	SZ_CHAR,	/* [TCHAR] */
	SZ_CHAR,	/* [TUCHAR] */
	SZ_SHORT,	/* [TSHORT] */
	SZ_SHORT,	/* [TUSHORT] */
	SZ_INT,		/* [TINT] */
	SZ_INT,		/* [TUINT] */
	SZ_LONG,	/* [TLONG] */
	SZ_LONG,	/* [TULONG] */
	SZ_VLONG,	/* [TVLONG] */
	SZ_VLONG,	/* [TUVLONG] */
	SZ_FLOAT,	/* [TFLOAT] */
	SZ_DOUBLE,	/* [TDOUBLE] */
	SZ_IND,		/* [TIND] */
	0,		/* [TFUNC] */
	-1,		/* [TARRAY] */
	0,		/* [TVOID] */
	-1,		/* [TSTRUCT] */
	-1,		/* [TUNION] */
	SZ_INT,		/* [TENUM] */
};

long	ncast[NTYPE] =
{
	0,				/* [TXXX] */
	BCHAR|BUCHAR,			/* [TCHAR] */
	BCHAR|BUCHAR,			/* [TUCHAR] */
	BSHORT|BUSHORT,			/* [TSHORT] */
	BSHORT|BUSHORT,			/* [TUSHORT] */
	BINT|BUINT|BLONG|BULONG|BIND,	/* [TINT] */
	BINT|BUINT|BLONG|BULONG|BIND,	/* [TUINT] */
	BINT|BUINT|BLONG|BULONG|BIND,	/* [TLONG] */
	BINT|BUINT|BLONG|BULONG|BIND,	/* [TULONG] */
	BVLONG|BUVLONG,			/* [TVLONG] */
	BVLONG|BUVLONG,			/* [TUVLONG] */
	BFLOAT,				/* [TFLOAT] */
	BDOUBLE,			/* [TDOUBLE] */
	BLONG|BULONG|BIND,		/* [TIND] */
	0,				/* [TFUNC] */
	0,				/* [TARRAY] */
	0,				/* [TVOID] */
	BSTRUCT,			/* [TSTRUCT] */
	BUNION,				/* [TUNION] */
	0,				/* [TENUM] */
};

enum{
	TCFD = 1,
	TCFC = 2,
	TCPC = 4,
	TCAR = 8,
	TCIN = 16,
	TCGEN = TCFD|TCFC|TCPC|TCAR,
	TCALL = TCFD|TCFC|TCPC|TCAR|TCIN,
};

enum{
	SGLOB,
	SPARM,
	SAUTO,
};

typedef struct Scope Scope;

struct Scope{
	Node *n;
	int	k;
	Scope *nxt;
};

static void
prtyp(Type *t, char *s, int nl)
{
	print("%s: ", s);
	if(t == T){
		print("nil");
		if(nl)
			print("\n");
		return;
	}
	while(t != T){
		print("%d(%d)[%x] ", t->etype, t->mark, (int)t);
		if(isadt(t))
			break;
		t = t->link;
	}
	if(nl)
		print("\n");
}

static Node*
func(Node *n)
{
	while(n != Z && n->op != OFUNC)
		n = n->left;
	return n;
}

static void
setmain(Node *n)
{
	inmain |= n->left->op == ONAME && strcmp(n->left->sym->name, "main") == 0;
}

static Node*
protoname(Node *n)
{
	do
		n = n->left;
	while(n != Z && n->op != ONAME && n->op != ODOTDOT);
	return n;
}

static Type*
prototype(Node *n, Type *t)
{
	for( ; n != Z ; n = n->left){
		switch(n->op){
		case OARRAY:
			t = typ(TARRAY, t);
			t->width = 0;
			break;
		case OIND:
			t = typ(TIND, t);
			break;
		case OFUNC:
			t = typ(TFUNC, t);
			t->down = fnproto(n);
			break;
		}
	}
	return t;
}

static Scope *scopes, *freescopes;

static void
pushdcl(Node *n, int c)
{
	Sym *s;

	if(passes){
		s = n->sym;
		push1(s);
		if(c != CAUTO || s->class != CSTATIC)
			s->class = c;
		s->type = n->type;
	}
}

static void
pushparams(Node *n)
{
	if(n == Z)
		return;
	if(passes){
		if(n->op == OLIST){
			pushparams(n->left);
			pushparams(n->right);
		}
		else if(n->op == OPROTO){
			n = protoname(n);
			if(n != Z && n->op == ONAME)
				pushdcl(n, CPARAM);
		}
		else if(n->op == ONAME){
			addnode(OPROTO, n);
			pushdcl(n, CPARAM);
		}
		else if(n->op != ODOTDOT)
			diag(Z, "bad op in pushparams");
	}
}

static void
pushscope(Node *n, int k)
{
	Scope *s;

	if(freescopes != nil){
		s = freescopes;
		freescopes = freescopes->nxt;
	}
	else
		s = (Scope*)malloc(sizeof(Scope));
	s->n = n;
	s->k = k;
	s->nxt = scopes;
	scopes = s;
	if(passes && (k == SPARM || k == SAUTO))
		markdcl();
	if(k == SPARM)
		pushparams(n->right);
}

static void
popscope(void)
{
	int k;
	Scope *s;

	s = scopes;
	k = s->k;
	scopes = scopes->nxt;
	s->nxt = freescopes;
	freescopes = s;
	if(passes && (k == SPARM || k == SAUTO))
		revertdcl();
}

static Node*
curfn(void)
{
	Scope *s;

	for(s = scopes; s != nil; s = s->nxt)
		if(s->k == SPARM)
			return s->n;
	return Z;
}

static void
marktype(Type *t, int tc)
{
	t->mark = tc;
}

static int
marked(Type *t)
{
	return t == T ? 0 :  t->mark;
}

static Sym*
decsym(Node *n)
{
	if(n == Z)
		return S;
	if(n->op == OFUNC){
		if(n->left->op == ONAME)
			return n->left->sym;
		return S;
	}
	if(n->op == ODAS)
		return n->left->sym;
	return n->sym;
}

static void
trep(Type *t1, Type *t)
{
	int l;
	Sym *s;
	Type *t2;

	if(t1 != T){
		l = t1->lineno;
		s = t1->sym;
		t2 = t1->down;
		*t1 = *t;
		t1->down = t2;
		t1->sym = s;
		t1->lineno = l;
	}
}

static void
tind(Node *n)
{
	if(n == Z)
		return;
	n = protoname(n);
	if(n != Z && n->type != T){
		n->type = tcp(n->type->link);
		marktype(n->type, TCIN);
	}
}

static void
tcon(Node *n, Type *t)
{
	Type *tt;

	if(n->garb)
		return;
	n->garb = 1;
	again = 1;
	switch(n->op){
		case OCONST:
			if(t->mark == TCFD && !isnil(n))
				addnode(OFILDES, n);
			n->type = t;
			break;
		case OCAST:
			tcon(n->left, t);
			*n = *n->left;
			n->type = t;
			break;
		case ONAME:
			n->sym->type = t;
			n->type = t;
			setdec(n->sym, t);
			break;
		case ODOT:
		case ODOTIND:
			trep(n->type, t);
			n->type = t;
			break;
		case OARRIND:
			tt = n->left->type;
			if(tt != T)
				tt->link = t;
			n->type = t;
			break;
		case OFUNC:
			n->left->type->link = t;
			if(n->left->op == ONAME)
				n->left->sym->type->link = t;
			n->type = t;
			break;
	}
}

static Node*
retval(Node *n)
{
	int i;
	Type *t;
	Node *a, *l, *cf;

	cf = curfn();
	t = cf->left->type->link;
	if(t->mark&(TCPC|TCFC) && (n == Z || !(n->type->mark&(TCPC|TCFC)))){
		if(n == Z)
			n = new1(ORETURN, Z, Z);
		l = n->left;
		for(i = 0; ; i++){
			a = arg(cf->right, i);
			if(a == Z)
				break;
			a = protoname(a);
			if(a == Z || a->op != ONAME)
				break;
			if(a->type->mark == TCIN){
				if(l == Z)
					l = ncopy(a);
				else
					l = new1(OTUPLE, l, ncopy(a));
			}
		}
		n->left = l;
		n->type = l->type = t;
	}
	return n;
}

static void
sube(Node *n)
{
	Node *l, *r, *nn;
	Type *tt;
	static Node *gn;
	int p;

	if(n == Z)
		return;
	l = n->left;
	r = n->right;
	switch(n->op){
		default:
			sube(l);
			sube(r);
			break;
		case OIND:
			if(l == Z)
				return;
			tt = l->type;
			sube(l);
			if(cktype(l, n, TCIN, 0) && iteq(tt, l->type))
				*n = *n->left;
			break;
		case OARRIND:
			tt = l->type;
			sube(l);
			sube(r);
			if(!isconst(r, 0))
				break;
			if(cktype(l, n, TCIN, 0) && iteq(tt, l->type))
				*n = *n->left;
			break;
		case ONAME:
			if(cktype(n, n, TCALL, 0))
				setdec(n->sym, n->type);
			break;
		case OCAST:
			sube(l);
			if(cktype(l, n, TCALL, 0))
				n->type = l->type;
			break;
		case OPROTO:
			sube(l);
			sube(r);
			nn = protoname(n);
			if(nn != Z && cktype(nn, n, TCALL, 0)){
				n->type = nn->type;
				p = argpos(n, gn->right);
				for(tt = gn->left->type->down; tt != T && p >= 0; tt = tt->down){
					if(p == 0){
						trep(tt, nn->type);
						break;
					}
					--p;
				}
			}
			break;
		case OFUNC:
			if(n->kind == KEXP)
				aargs(n);
			if(n->left->op == ONAME)
				gn = n;
			sube(l);
			sube(r);
			if(l != Z && cktype(n, n, TCGEN, 0))
				l->type->link = n->type;
			break;
		case OAS:
			sube(l);
			sube(r);
			if(r->op == ORETV){
				n->left = new1(OTUPLE, l, r->right);
				n->right = r->left;
				n->left->type = n->type;
				break;
			}
			if(cktype(r, n, TCGEN, 0)){
				tcon(l, r->type);
				n->type = r->type;
			}
			if(cktype(l, n, TCGEN, 1)){
				tcon(r, l->type);
				n->type = l->type;
			}
			break;
		case OLT:
		case OGE:
			sube(l);
			sube(r);
			if(cktype(l, n, TCFD, 0) && isconst(r, 0)){
				n->op = n->op == OLT ? OEQ : ONE;
				r->op = ONIL;
				r->type = l->type;
			}
			break;
		case OGT:
		case OLE:
			sube(l);
			sube(r);
			if(cktype(r, n, TCFD, 0) && isconst(l, 0)){
				n->op = n->op == OGT ? OEQ : ONE;
				l->op = ONIL;
				l->type = r->type;
			}
			break;
	}
}

static void
subs(Node *n, int blk, int aut)
{
	Node *l, *r;

	if(n == Z)
		return;
	if(blk)
		pushscope(n, SAUTO);
	nearln = n->lineno;
	l = n->left;
	r = n->right;
	switch(n->op){
		default:
			sube(n);
			break;
		case ONAME:
			if(aut && n->kind != KEXP)
				pushdcl(n, CAUTO);
			if(cktype(n, n, TCALL, 0))
				setdec(n->sym, n->type);
			break;
		case ODAS:
			if(aut)
				pushdcl(l, CAUTO);
			subs(l, 0, aut);
			if(cktype(l, n, TCALL, 0))
				tcon(r, l->type);
			break;
		case OSBREAK:
		case ONUL:
		case OLABEL:
		case OGOTO:
		case OCONTINUE:
		case OBREAK:
		case OSET:
		case OUSED:
			break;
		case OBLK:
			subs(l, 1, aut);
			break;
		case OCASE:
			subs(r, 1, aut);
			break;
		case OLIST:
			subs(l, 0, aut);
			subs(r, 0, aut);
			break;
		case ORETURN:
			sube(l);
			if(l != Z && cktype(l, n, TCGEN, 0)){
				n->type = l->type;
				tcon(curfn(), l->type);
			}
			retval(n);
			break;
		case OSWITCH:
		case OWHILE:
		case ODWHILE:
			sube(l);
			subs(r, 1, aut);
			break;
		case OIF:
			sube(l);
			subs(r->left, 1, aut);
			subs(r->right, 1, aut);
			break;
		case OFOR:
			sube(l->left);
			sube(l->right->left);
			sube(l->right->right);
			subs(r, 1, aut);
			break;
	}
	if(blk)
		popscope();
}

static Node*
finddec0(Sym *s, Node *n)
{
	Node *nn;

	if(n == Z)
		return ZZ;
	switch(n->op){
		case OLIST:
			nn = finddec0(s, n->left);
			if(nn != Z)
				return nn;
			return finddec0(s, n->right);
		case OFUNC:
			if(n->op != KEXP){
				if(s == decsym(n))
					return n;
				return finddec0(s, n->right);
			}
			else
				return ZZ;
		case OPROTO:
		case OIND:
		case OARRAY:
			return finddec0(s, n->left);
		case ODOTDOT:
			return ZZ;
		case ONOOP:
		case OPUSH:
		case OPOP:
		case OCODE:
		case ODECE:
		case ODECT:
			return finddec0(s, n->right);
		case ODECV:
		case ODECF:
			if(s == decsym(n->left) && !isfn(n->left->type))
				return n->left;
			return finddec0(s, n->right);
	}
	if(isdec(n)){
		if(s == decsym(n) && !isfn(n->type))
			return n;
		return Z;
	}
	return ZZ;
}

static Node*
finddec(Sym *s, int g)
{
	Node *n;
	Scope *sc;

	for(sc = scopes; sc != nil; sc = sc->nxt){
		if(!g || sc->k == SGLOB){
			n = finddec0(s, sc->n);
			if(n != Z && n != ZZ)
				return n;
		}
	}
	return Z;	
}

static void
setdec(Sym *s, Type *t)
{
	Node *n;

	if((n = finddec(s, 0)) != Z){
		n->type = t;
		if(n->op == ODAS){
			n = n->left;
			n->type = t;
		}
		n->sym->type = t;
	}
}
		
typedef struct Syml Syml;

struct Syml{
	Sym *sym;
	Syml *nxt;
};

typedef struct Symq Symq;

struct Symq{
	Syml *f;
	Syml *r;
};

typedef struct Modl Modl;

struct Modl{
	char *mod;
	int	ld;
	Modl *nxt;
};

static void
prn(Node *n, int i)
{
	int j;

	for(j = 0; j < i; j++)
		print("\t");
	if(n == Z){
		print("Z\n");
		return;
	}
	print("%s", onames[n->op]);
	if(n->blk)
		print("	block");
	if(n->type == T)
		print("	T");
	else
		print("	%s", tnames[n->type->etype]);
	if(n->op == OCONST)
		print("	%d", (int)n->vconst);
	else if(n->op == OSTRING)
		print("	%s", n->cstring);
	else if(n->op == ONAME)
		print("	%s", n->sym->name);
	print("\n");
	if(n->op != OLIST)
		i++;
	prn(n->left, i);
	prn(n->right, i);
}

static int
isbigv(vlong v)
{
	return v > 0xffffffff;
}

static int
islbigv(vlong v)
{
	return v > 0x7fffffff || v < -0x7fffffff;
}

static int
isuintv(vlong v)
{
	return !isbigv(v) && (v&0x80000000) != 0;
}

static int
isadt(Type *t)
{
	return t != T && (t->etype == TSTRUCT || t->etype == TUNION);
}

static int
isreal(Type *t)
{
	return t != T && (t->etype == TDOUBLE || t->etype == TFLOAT);
}

static int
isbyte(Type *t)
{
	return t != T && (t->etype == TCHAR || t->etype == TUCHAR);
}

static int
isshort(Type *t)
{
	return t != T && (t->etype == TSHORT || t->etype == TUSHORT);
}

static int
isint(Type *t)
{
	return t != T && (t->etype == TINT || t->etype == TUINT);
}

static int
islong(Type *t)
{
	return t != T && (t->etype == TLONG || t->etype == TULONG);
}

static int
isbig(Type *t)
{
	return t != T && (t->etype == TVLONG || t->etype == TUVLONG);
}

static int
isinteger(Type *t)
{
	return isbyte(t) || isshort(t) || isint(t) || islong(t) || isbig(t);
}

static int
isptr(Type *t)
{
	return t != T && (t->etype == TIND || t->etype == TARRAY || t->etype == TFUNC);
}

static int
isscalar(Type *t)
{
	return t != T && !isadt(t) && t->etype != TTUPLE;
}

static int
isvoid(Type *t)
{
	return t == T || t->etype == TVOID;
}

static int
isnum(Type *t)
{
	return t != T && isscalar(t) && !isptr(t) && !isvoid(t);
}

static int
isarray(Type *t)
{
	return t != T && (t->etype == TARRAY || (t->etype == TIND && !isadt(t->link)));
}

static int
isstr(Type *t)
{
	return t != T && (t->etype == TSTRING || isarray(t) && isbyte(t->link));
}

static int
isfn(Type *t)
{
	return t != T && t->etype == TFUNC;
}

static int
iscastable(Type *t, Type *tt)
{
	return t != T && (!isptr(t) || isarray(t) && isbyte(t->link) && isstr(tt));
}

static int
isname(Node *n)
{
	return n->op == ONAME;
}

static int
isstring(Node *n)
{
	return n->op == OSTRING || n->op == OLSTRING || n->op == ONAME && n->sym->tenum != T && n->sym->tenum->etype == TIND;
}

static int
isnil(Node *n)
{
	if(!isptr(n->type))
		return 0;
	while(n->op == OCAST)
		n = n->left;
	return n->op == OCONST && n->vconst == 0 || n->op == ONIL;
}

static int
isconst(Node *n, vlong v)
{
	while(n->op == OCAST)
		n = n->left;
	return n->op == OCONST && n->vconst == v;
}

static Node*
cknil(Node *n)
{
	if(isconst(n, 0))
		n->op = ONIL;
	return n;
}

static int
cktype(Node *n, Node *t, int mask, int lev)
{
	int g, m, m0;

	g = t->garb > lev;
	m = marked(n->type) & mask;
	if(n->op == ONAME){
		m0 = marked(n->sym->type) & mask;
		if(m && !m0){
			n->sym->type = n->type;
			if(!g)
				again = 1;
		}
		if(!m && m0){
			n->type = n->sym->type;
			if(!g)
				again = 1;
		}
		m |= m0;
	}
	if(m && t->garb < 2)
		t->garb++;
	return m && !g ? m : 0;
}

int
isconsym(Sym *s)
{
	switch(s->class){
		case CXXX:
		case CTYPEDEF:
			return 1;
		case CEXTERN:
		case	CGLOBL:
		case CSTATIC:
		case CLOCAL:
			return s->type != T && s->type->etype == TENUM;
	}
	return -1;
}

static void genstart(void);

static char*
mprolog[] =
{
	"%%: module",
	"{",
	"\tPATH: con \"%%%.dis\";",
	"",
	nil
};

static char*
mepilog[] =
{
	"};",
	nil
};

static char*
bprolog[] =
{
	"implement %%;",
	"",
	"include \"draw.m\";",
	"",
	"%%: module",
	"{",
	"	init: fn(nil: ref Draw->Context, argl: list of string);",
	"};",
	"",
	nil
};

static char*
bmprolog[] =
{
	"implement %%;",
	"",
	"include \"draw.m\";",
	"",
	nil
};

static char*
bepilog[] =
{
	nil
};

static void
pgen0(char **txt)
{
	int sub;
	char *b, *s, *t, **p;

	p = txt;
	for(;;){
		s = *p++;
		if(s == nil)
			break;
		sub = 0;
		for(t = s; *t != 0; t++){
			if(*t == '%' && *(t+1) == '%'){
				sub = 1;
				break;
			}
		}
		if(sub){
			strcpy(buf, s);
			b = buf;
			for(t = s; *t != 0; t++){
				if(*t == '%' && *(t+1) == '%'){
					if(*(t+2) == '%'){
						outmod(mbuf, 0);
						t++;
					}
					else
						outmod(mbuf, 1);
					strcpy(b, mbuf);
					b += strlen(mbuf);
					t++;
				}
				else
					*b++ = *t;
			}
			*b = 0;
			prline(buf);
		}
		else			
			prline(s);
	}
}

static char*
hasm()
{
	outmod(mbuf, 0);
	strcat(mbuf, ".m");
	if(exists(mbuf))
		return mbuf;
	else if(domod){
		outmod(buf, 0);
		strcat(buf, ".h");
		if(exists(buf))
			return mbuf;
	}
	return nil;
}

void
pgen(int b)
{
	char **p;

	if(!dolog())
		return;
	if(b)
		p = hasm() ? bmprolog : bprolog;
	else
		p = mprolog;
	pgen0(p);
	if(b && passes)
		genstart();
	if(!b)
		incind();
}

void
epgen(int b)
{
	char **p;

	/* output(0x7fffffff, 1); */	/* INFINITY */
	if(!dolog())
		return;
	if(b){
		if(!passes)
			genstart();
		p = bepilog;
	}
	else
		p = mepilog;
	if(!b)
		decind();
	pgen0(p);
}

static int lastsec = 0;

#define ASSOC		1
#define RASSOC	2
#define POSTOP	4

#define LEFT	1
#define RIGHT	2
#define PRE	4
#define POST	8

static int space[] = { 0, 0, 2, 0, 4, 5, 0, 0, 0, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0 };

static struct{
	char *name;
	int	prec;
	int	kind;
} ops[] = {
	"",		0,	0,	/* ONOOP */
	"",		16,	0,	/* OXXX, */
	"+",		12,	ASSOC,	/* OADD, */
	"&",		14,	RASSOC,	/* OADDR, */
	"&",		8,	ASSOC,	/* OAND, */
	"&&",	5,	ASSOC,	/* OANDAND, */
	"",		16,	0,	/* OARRAY, */
	"=",		2,	RASSOC,	/* OAS, */
	"=",		2,	RASSOC,	/* OASI, */
	"+=",		2,	RASSOC,	/* OASADD, */
	"&=",		2,	RASSOC,	/* OASAND, */
	"<<=",	2,	RASSOC,	/* OASASHL, */
	">>=",	2,	RASSOC,	/* OASASHR, */
	"/=",		2,	RASSOC,	/* OASDIV, */
	"<<",		11,	0,	/* OASHL, */
	">>",		11,	0,	/* OASHR, */
	"/=",		2,	RASSOC,	/* OASLDIV, */
	"%=",		2,	RASSOC,	/* OASLMOD, */
	"*=",		2,	RASSOC,	/* OASLMUL, */
	">>=",	2,	RASSOC,	/* OASLSHR, */
	"%=",		2,	RASSOC,	/* OASMOD, */
	"*=",		2,	RASSOC,	/* OASMUL, */
	"|=",		2,	RASSOC,	/* OASOR, */
	"-=",		2,	RASSOC,	/* OASSUB, */
	"^=",		2,	RASSOC,	/* OASXOR, */
	"",		-1,	0,	/* OBIT, */
	"",		-1,	0,	/* OBREAK, */
	"",		-1,	0,	/* OCASE, */
	"",		14,	RASSOC,	/* OCAST, */
	"",		1,	ASSOC,	/* OCOMMA, */
	"",		3,	RASSOC,	/* OCOND, */
	"",		16,	0,	/* OCONST, */
	"",		-1,	0,	/* OCONTINUE, */
	"/",		13,	0,	/* ODIV, */
	".",		15,	0,	/* ODOT, */
	"...",		16,	0,	/* ODOTDOT, */
	"",		-1,	0,	/* ODWHILE, */
	"",		-1,	0,	/* OENUM, */
	"==",		9,	0,	/* OEQ, */
	"",		-1,	0,	/* OFOR, */
	"",		15,	0,	/* OFUNC, */
	">=",		10,	0,	/* OGE, */
	"",		-1,	0,	/* OGOTO, */
	">",		10,	0,	/* OGT, */
	">",		10,	0,	/* OHI, */
	">=",		10,	0,	/* OHS, */
	"",		-1,	0,	/* OIF, */
	"*",		14,	RASSOC,	/* OIND, */
	"",		-1,	0,	/* OINDREG, */
	"",		16,	0,	/* OINIT, */
	"",		-1,	0,	/* OLABEL, */
	"/",		13,	0,	/* OLDIV, */
	"<=",		10,	0,	/* OLE, */
	"",		16,	0,	/* OLIST, */
	"%",		13,	0,	/* OLMOD, */
	"*",		13,	ASSOC,	/* OLMUL, */
	"<",		10,	0,	/* OLO, */
	"<=",		10,	0,	/* OLS, */
	">>",		11,	0,	/* OLSHR, */
	"<",		10,	0,	/* OLT, */
	"%",		13,	0,	/* OMOD, */
	"*",		13,	ASSOC,	/* OMUL, */
	"",		16,	0,	/* ONAME, */
	"!=",		9,	0,	/* ONE, */
	"!",		14,	RASSOC,	/* ONOT, */
	"|",		6,	ASSOC,	/* OOR, */
	"||",		4,	ASSOC,	/* OOROR, */
	"--",		14,	RASSOC|POSTOP,	/* OPOSTDEC, */
	"++",		14,	RASSOC|POSTOP,	/* OPOSTINC, */
	"--",		14,	RASSOC,	/* OPREDEC, */
	"++",		14,	RASSOC,	/* OPREINC, */
	"",		16,	0,	/* OPROTO, */
	"",		-1,	0,	/* OREGISTER, */
	"",		0,	0,	/* ORETURN, */
	"SET",	-1,	0,	/* OSET, */
	"signof",	14,	RASSOC,	/* OSIGN, */
	"sizeof",	14,	RASSOC,	/* OSIZE, */
	"",		16,	0,	/* OSTRING, */
	"",		16,	0,	/* OLSTRING, */
	"",		16,	0,	/* OSTRUCT, */
	"-",		12,	0,	/* OSUB, */
	"",		-1,	0,	/* OSWITCH, */
	"",		16,	0,	/* OUNION, */
	"USED",	-1,	0,	/* OUSED, */
	"",		-1,	0,	/* OWHILE, */
	"^",		7,	ASSOC,	/* OXOR, */
	"-",		14,	RASSOC,	/* ONEG, */
	"~",		14,	RASSOC,	/* OCOM, */
	"",		16,	0,	/* OELEM, */
	"",		-1,	0,	/* OTST, */
	"",		-1,	0,	/* OINDEX, */
	"",		-1,	0,	/* OFAS, */
	"",		-1,	0,	/* OBLK */
	"+",		14,	RASSOC,	/* OPOS */
	"",		-1,	0,	/* ONUL */
	".",		15,	0,	/* ODOTIND */
	"",		15,	0,	/* OARRIND */
	"",		-1,	0,	/* ODAS */
	":=",		2,	RASSOC,	/* OASD */
	"",		16,	0,	/* OIOTA */
	"",		14,	RASSOC,	/* OLEN */
	"",		17,	0,	/* OBRACKET */
	"",		14,	RASSOC,	/* OREF */
	"",		14,	RASSOC,	/* OARRAYOF */
	"",		15,	0,	/* OSLICE */
	"&",		14,	RASSOC,	/* OSADDR, */
	"",		16,	0,	/* ONIL */
	"",		16,	0,	/* OS2AB */
	"",		16,	0,	/* OAB2S */
	"",		16,	0,	/* OFILDES */
	".",		15,	0,	/* OFD */
	"",		16,	0,	/* OTUPLE */
	".",		15,	0,	/* OT0 */
	"",		15,	0,	/* ORETV */
	"+",		12,	ASSOC,	/* OCAT */
	"",		-1,	0,	/* OSBREAK, */
	".",		15,	0,	/* OLDOT */
	"->",		15,	0,	/* OMDOT */
	nil,		-1,	0,	/* OCODE */
	nil,		-1,	0,	/* ODECE */
	nil,		-1,	0,	/* ODECT */
	nil,		-1,	0,	/* ODECV */
	nil,		-1,	0,	/* ODECF */
	nil,		-1,	0,	/* OPUSH */
	nil,		-1,	0,	/* OPOP */
	"",		-1,	0,	/* OEND */
};

#define COMPLEX	32

#define NOBR	2
#define NOIN	4
#define YESBR	8
#define NONL	16
#define NOENL	32

enum{
	LNONE,
	LSTRLEN,
	LSTRCMP,
	LSTRCPY,
	LSTRCAT,
	LSTRNCMP,
	LSTRNCPY,
	LSTRNCAT,
	LSTRDUP,
	LMEMMOVE,
	LMALLOC,
	LFREE,
	LEXIT,
	LCLOSE,
	LATOI,
	LATOL,
	LATOF,
	LPRINT,
	LFPRINT,
	LSPRINT,
	LSELF,
};

static int tmp;

static void egen(Node*, int, int);
static Node* buildcases(Node*);
static void tdgen(Node *, int);
static Node* cfind(Node*);
static Node* cgen(Node*, Node*);
static void cgen0(Node*, Node*);
static int lteq(Type*, Type*);
static Type* ntype(Node*);
static int rewe(Node*, Type*, int);
static void rewlc(Node*, int, Type*);
static Node* con(vlong);
static void	clrbrk(Node*);
static int hasbrk(Node*);
static int isgen(char*);
static int simple(Node*);
static void pfmt(char*);
static void lpfmt(Rune*);
static int lline(Node*);
static void args(Node*);
static void addmodn(Sym*);
static void scomplex(Node*);
static void mset(Node*);

static Node *lastd;

static int
rev(int op)
{
	switch(op){
		case OLT:	return OGT;
		case OLE:	return OGE;
		case OGT:	return OLT;
		case OGE:	return OLE;
	}
	return op;
}

void
newsec(int l)
{
	if(l != 1 && lastd != Z){
		tdgen(lastd, 1);
		lastd = Z;
	}
	if(l != 2)
		etgen2(nil);
	if(lastsec && l != lastsec)
		newline();
	lastsec = l;
}

static Node*
defval(Type *t)
{
	Node *n;

	if(t == T)
		t = types[TINT];
	n = con(0);
	n->type = types[TINT];
	n->kind = KDEC;
	switch(t->etype){
		case TFLOAT:
		case TDOUBLE:
			n->type = types[TDOUBLE];
			n->fconst = 0.0;
			n->cstring = "0.0";
			return n;
		default:
			break;
		case TIND:
		case TFUNC:
		case TARRAY:
			n->type = typ1(TIND, types[TVOID]);
			return n;
		case TVOID:
		case TSTRUCT:
		case TUNION:
			free(n);
			return Z;
	}
	if(!lteq(n->type, t)){
		n = new1(OCAST, n, Z);
		n->type = t;
	}
	return n;
}

static int
teq(Type *t1, Type *t2)
{
	if(t1 == t2)
		return 1;
	return sametype(t1, t2);
/*
	if(t1->etype != t2->etype)
		return 0;
	switch(t1->etype){
		case TARRAY:
			if(t1->width != t2->width)
				return 0;
			break;
		case TFUNC:
			if(!teq(t1->down, t2->down))
				return 0;
			break;
		case TSTRUCT:
		case TUNION:
			return t1->link == t2->link;
		case TENUM:
			return 1;
	}
	return teq(t1->link, t2->link);
*/
}

static int
tequiv(Type *t1, Type *t2)
{
	if(!teq(t1, t2))
		return 0;
	if(t1->etype == TSTRUCT || t1->etype == TUNION)
		return suename(t1) == suename(t2);
	return 1;
}

static int
iteq(Type *t1, Type *t2)
{
	if(t1 == T || t2 == T)
		return 0;
	return t1->etype == TIND && (teq(t1->link, t2) || (t1->link->etype == TVOID && isnum(t2)));
}

static Type *
ltype(Type *t)
{
	switch(t->etype){
		case TUCHAR:
			return types[TCHAR];
		case TSHORT:
		case TUSHORT:
		case TUINT:
		case TLONG:
		case TULONG:
		case TENUM:
			return types[TINT];
		case TUVLONG:
			return types[TVLONG];
		case TFLOAT:
			return types[TDOUBLE];
		default:
			return t;
	}
}

static int
lteq(Type *t1, Type *t2)
{
	if(t1 == T || t2 == T)
		return 0;
	if(t1 == t2)
		return 1;
	if(t1->etype == TIND && t2->etype == TIND)
		return lteq(t1->link, t2->link);
	return sametype(ltype(t1), ltype(t2));
}

static Type*
tcp(Type *t)
{
	Type *nt;

	if(t == T)
		return T;
	nt = typ1(TXXX, T);
	*nt = *t;
	return nt;
}

static Type*
tuple(Type *t1, Type *t2)
{
	Type *t, **at, *l;

	if(t1 == T || t1->etype == TVOID)
		return tcp(t2);
	if(t2 == T || t2->etype == TVOID)
		return tcp(t1);
	if(t2->etype == TTUPLE)
		diag(Z, "bad tuple type");
	t = typ1(TTUPLE, T);
	at = &t->link;
	if(t1->etype == TTUPLE){
		for(l = t1->link; l != T; l = l->down){
			*at = tcp(l);
			at = &(*at)->down;
		}
	}
	else{
		*at = tcp(t1);
		at = &(*at)->down;
	}
	*at = tcp(t2);
	return t;
}

static Sym*
sue(Type *t)
{
	int h;
	Sym *s;

	if(t != T)
		for(h=0; h<nelem(hash); h++)
			for(s = hash[h]; s != S; s = s->link)
				if(s->suetag && s->suetag->link == t)
					return s;
	return S;
}

static void
pranon(int i)
{
	prid("anon_");
	prnum(i+1, KDEC, T);
}

static int
dotpath(Sym *s, Type *t, int pr)
{
	int i;
	Type *t1;

	if(t == T)
		return 0;
	for(t1 = t->link; t1 != T; t1 = t1->down){
		if(t1->sym == s){
			if(pr){
				prdelim(".");
				prsym(s, 0);
			}
			return 1;
		}
	}
	i = 0;
	for(t1 = t->link; t1 != T; t1 = t1->down){
		if(t1->sym == S){
			i++;
			if(typesu[t1->etype] && sametype(s->type, t1)){
				if(pr){
					prdelim(".");
					pranon(i-1);
				}
				return 1;
			}
		}
	}
	i = 0;
	for(t1 = t->link; t1 != T; t1 = t1->down){
		if(t1->sym == S){
			i++;
			if(typesu[t1->etype] && dotpath(s, t1, 0)){
				if(pr){
					prdelim(".");
					pranon(i-1);
					dotpath(s, t1, 1);
				}
				return 1;
			}
		}
	}
	return 0;
}

static Sym*
suename(Type *t)
{
	Sym *s;

	s = sue(t->link);
	if(s != S)
		return s;
	else if(t->tag != S)
		return t->tag;
	else if(t->sym != S)
		return t->sym;
	return S;
}

static int
cycle(Type *t, Type *base)
{
	int r;
	Type *l;

	if(t->vis){
		/* sametype() does structural comparison so have to check names */
		if(t == base || tequiv(t, base))
			return 1;
		return 0;
	}
	r = 0;
	t->vis = 1;
	switch(t->etype){
		case TIND:
		case TARRAY:
			r = cycle(t->link, base);
			break;
		case TSTRUCT:
		case TUNION:
		case TTUPLE:
			for(l = t->link; l != T; l = l->down)
				r |= cycle(l, base);
			break;
	}
	t->vis = 0;
	return r;
}

static void
addnode(int op, Node *n)
{
	Node *nn;

	nn = new1(OXXX, Z, Z);
	*nn = *n;
	n->op = op;
	n->left = nn;
	n->right = Z;
	n->type = nn->type;
}

static void
cast(Node *n, Type *t)
{
	addnode(OCAST, n);
	n->type = t;
}

static void
intcast(Node *n)
{
	if(isptr(n->type)){
		addnode(ONE, n);
		n->right = con(0);
		n->right->type = n->left->type;
		n->type = types[TINT];
	}
	else
		cast(n, types[TINT]);
}

static void
strcast(Node *n)
{
	cast(n, stringtype);
}

static void
bptr(Node *n)
{
	if(n == Z)
		return;
	switch(n->op){
		default:
			if(!lteq(n->type, types[TINT]))
				intcast(n);
			break;
		case ONOT:
			if(!lteq(n->left->type, types[TINT])){
				intcast(n->left);
				if(n->left->op == ONE){
					n->left->op = OEQ;
					*n = *n->left;
				}
			}
			break;
		case OANDAND:
		case OOROR:
			bptr(n->left);
			bptr(n->right);
			break;
		case OCOND:
			bptr(n->right->left);
			bptr(n->right->right);
			break;
	}
}

static void
bcomplex(Node *n)
{
	if(n == Z)
		return;
	if(!passes)
		complex(n);
	bptr(n);
}

static void
ecomplex(Node *n)
{
	if(!passes)
		complex(n);
	rewe(n, T, 0);
}

static void
becomplex(Node *n)
{
	bcomplex(n);
	rewe(n, T, 0);
}

static void
tgen(Type *t, int dec, int arinit)
{
	Type *l;

	if(t == T)
		return;
	switch(t->etype){
		case TXXX:
			prid("int");
			break;
		case TCHAR: 
		case TUCHAR:
			prid("byte");
			break;
		case TSHORT:
		case TUSHORT:
		case TINT:
		case TUINT:
		case TLONG:
		case TULONG:
		case TENUM:
			prid("int");
			break;
		case TVLONG:
		case TUVLONG:
			prid("big");
			break;
		case TFLOAT:
		case TDOUBLE:
			prid("real");
			break;
		case TIND:
			if(strings == 2 && t->link && t->link->etype == TCHAR){
				prid("string");
				break;
			}
			if(isadt(t->link) || t->link->etype == TFUNC)
				prid("ref ");
			else
				prid("array of ");
			if(t->link && t->link->etype == TVOID){
				prid("byte");
				prcom("was void*", Z);
			}
			else
				tgen(t->link, 1, 0);
			break;
		case TFUNC:
			if(0){
				prid("int");
				prcom("was function", Z);
				break;
			}
			prid("fn");
			prdelim("(");
			for(l = t->down; l != T; l = l->down){
				if(l->etype == TVOID && l->down == T)
					break;
				if(l->etype == TDOT){
					prcom("was ...", Z);
					break;
				}
				if(l->sym != S)
					prsym(l->sym, 0);
				else
					prid("nil");
				prdelim(": ");
				tgen(l, 1, 0);
				if(l->down != T && l->down->etype != TDOT)
					prdelim(", ");
			}
			/* tgen(t->down, dec, 0, 0); */
			prdelim(")");
			if(!isvoid(t->link)){
				prdelim(": ");
				tgen(t->link, dec, 0);
			}
			break;
		case TARRAY:
			prid("array");
			if(t->width == LARR)
				t->width = LARR;
			else if(dec){
				if(t->nwidth != Z)
					prcom("array index was ", t->nwidth);
				else if(t->width != 0){
					sprint(buf, "array index was %ld", t->width/t->link->width);
					prcom(buf, Z);
				}
			}
			else{
				prdelim("[");
				if(t->nwidth != Z)
					egen(t->nwidth, ONOOP, PRE);
				else if(t->width != 0)
					prnum(t->width/t->link->width, KDEC, T);
				prdelim("]");
			}
			prdelim(" of ");
			if(!arinit)
				tgen(t->link, 1, 0);
			break;
		case TVOID:
			/* prid("void"); */
			prid("byte");
			prcom("was void", Z);
			break;
		case TSTRUCT:
		case TUNION:
			if(t->link != T && t->link->etype == TFD){
				prid("Sys->FD");
				usemod(sysop, 0);
			}
			else
				prsym(suename(t), 1);
			break;
		case TTUPLE:
			prdelim("(");
			for(l = t->link; l != T; l = l->down){
				tgen(l, dec, 0);
				if(l->down != T)
					prdelim(", ");
			}
			prdelim(")");
			break;
		case TDOT:
			prdelim("...");
			break;
		case TSTRING:
			prid("string");
			break;
		case TFD:
			prid("fd");
			break;
		default:
			diag(Z, "unknown type");
			break;
	}
}

static Type*
typn(Type *t, int i)
{
	Type *l;

	for(l = t->down; l != T && --i >= 0; l = l->down)
		;
	return l;
}

void
ttgen2(Type *t)
{
	Type *l;
	Sym *s;
	int anon = 0;

	switch(t->etype){
		case TSTRUCT:
		case TUNION:
			newsec(0);
			output(t->lineno, 1);
			s = suename(t);
			if(isgen(s->name))
				addmodn(s);
			setmod(s);
			prsym(s, 0);
			prdelim(": ");
			prid("adt");
			prdelim("{");
			if(t->etype == TUNION)
				prcom("was union", Z);
			newline();
			incind();
			t->vis = 1;
			for(l = t->link; l != T; l = l->down){
				output(l->lineno, 1);
				if(l->nbits)
					prcom("was bit field", Z);
				if(l->sym != S)
					prsym(l->sym, 0);
				else
					pranon(anon++);
				prdelim(": ");
				if(cycle(l, t))
					prid("cyclic ");
				tgen(l, 1, 0);
				prdelim(";");
				newline();
			}
			t->vis = 0;
			decind();
			prdelim("};");
			newline();
			newline();
			break;
		default:
			break;
	}
}

static int
canjoin(Node *n, Node *nn)
{
	return teq(n->type, nn->type) && isname(n) && isname(nn) && n->type->etype != TARRAY;
}

void
vtgen2(Node *n)
{
	int  t, c, comma = 0;
	Node *nn;
	Sym *s;

	nn = n;
	if(n->op == ODAS)
		nn = n->left;
	if(nn->type == T || nn->sym == S)
		return;
	t = nn->type->etype;
	c = nn->sym->class;
	if(0 && c == CTYPEDEF){
		/* egen(nn, ONOOP, PRE); */
		/* tdgen(n, 1, 0); */
		if(isadt(n->type)){
			s = suename(n->type);
			if(isgen(s->name)){
				s->lname = nn->sym->name;
				ttgen2(n->type);
			}
		}
	}
	if(c != CGLOBL && c != CSTATIC && c != CLOCAL && c != CEXREG)
		return;
	newsec(1);
	if(lastd != Z){
		if(t != TFUNC && canjoin(lastd, n))
			comma = 1;
		else
			tdgen(lastd, 1);
	}
	output(nn->lineno, 1);
	if(t == TFUNC){
		if(ism()){
			setmod(nn->sym);
			egen(nn, ONOOP, PRE);
			tdgen(n, 1);
		}
		lastd = Z;
		return;
	}
	if(comma)
		prdelim(", ");
	if(nn->op != ONAME)
		diag(nn, "internal: not name in vtgen");
	setmod(nn->sym);
	prsym(nn->sym, 0);
	/* egen(nn, ONOOP, PRE); */
	/* tdgen(n, 1, 0); */
	lastd = n;
	if(n->op == ODAS)
		rewe(n->right, T, 1);
}

static void minseq(Syml*);

static Node*
con(vlong v)
{
	int neg = 0;
	Node *n;

	if(v < 0){
		neg = 1;
		v = -v;
	}
	n = new1(OCONST, Z, Z);
	n->vconst = v;
	n->kind = KDEC;
	n->type = types[TINT];
	if(neg)
		n = new1(ONEG, n, Z);
	return n;
}

/*
static Node*
fcon(double v)
{
	int neg = 0;
	Node *n;

	if(v < 0){
		neg = 1;
		v = -v;
	}
	n = new1(OCONST, Z, Z);
	n->fconst = v;
	n->kind = KDEC;
	n->type = types[TDOUBLE];
	if(neg)
		n = new1(ONEG, n, Z);
	return n;
}
*/

static Node*
add(vlong v, Node *n)
{
	if(v == 0)
		return n;
	return new1(OADD, con(v), n);
}

static Node*
addn(Node *n1, Node *n2)
{
	if(n1 == Z || n2 == Z)
		return Z;
	if(isconst(n1, 0))
		return n2;
	if(isconst(n2, 0))
		return n1;
	return new1(OADD, n1, n2);
}

static Node*
mul(vlong v, Node *n)
{
	if(v == 0)
		return con(0);
	else if(v == 1)
		return n;
	else if(v == -1)
		return new1(ONEG, n, Z);
	return new1(OMUL, con(v), n);
}

static Node*
mydiv(Node *n, vlong w)
{
	Node *nn;

	if(w == 0)
		return Z;
	if(w == 1)
		return n;
	else if(w == -1)
		return new1(ONEG, n, Z);
	switch(n->op){
		case OCONST:
			if(n->vconst % w == 0){
				n->vconst /= w;
				if(n->left != Z && mydiv(n->left, w) == Z){
					n->vconst *= w;
					break;
				}
				return n;
			}
			break;
		case OCAST:
			return mydiv(n->left, w);
		case OMUL:
			nn = mydiv(n->right, w);
			if(nn != Z){
				if(isconst(nn, 1))
					*n = *n->left;
				return n;
			}
			nn = mydiv(n->left, w);
			if(nn != Z){
				if(isconst(nn, 1))
					*n = *n->right;
				return n;
			}
			break;
		default:
			break;
	}
	return Z;			
}

static Node*
iota(void)
{
	return new1(OIOTA, Z, Z);
}

static Node*
symcon(Sym *s)
{
	Node *n;

	if(s->nconst != Z)
		return s->nconst;
	n = con(s->vconst);
	n->kind = s->kind;
	return n;
}

#define ARITH	1
#define GEOM	2

static Syml*
newsyml(Sym *s, Syml **frees)
{
	Syml *sl, *f;

	if((f = *frees) != nil){
		sl = f;
		*frees = f->nxt;
	}
	else
		sl = (Syml*)malloc(sizeof(Syml));
	sl->sym = s;
	sl->nxt = nil;
	return sl;
}

static Syml*
etseq(Syml *syml)
{
	int e, pio, io, comma;
	vlong d, dd, v0, v1, v, t, tt;
	Node *expr;
	Sym *s;
	Syml *sl, *lsl;

	lsl = nil;
	pio = io = ARITH|GEOM;
	e = 0;
	dd = 0;
	d = 0;
	for(sl = syml; sl != nil; sl = sl->nxt){
		s = sl->sym;
		if(isreal(s->tenum) || s->tenum->etype == TIND)
			break;
		if(e == 0)
			v0 = s->vconst;
		if(e == 1){
			v1 = s->vconst;
			d = v1-v0;
		}
		if(e > 0 && (v <= 0 || s->vconst != 2*v))
			io &= ~GEOM;
		if(0 && e > 1 && s->vconst-v != d)
			io &= ~ARITH;
		if(e > 1){
			t = s->vconst-v;
			tt = t-d;
			if(e > 2 && tt != dd)
				io &= ~ARITH;
			else{
				d = t;
				dd = tt;
			}
		}
		if(io == 0)
			break;
		v = s->vconst;
		lsl = sl;
		pio = io;
		e++;
	}
	if(e < 2)
		pio = 0;
	if(pio&GEOM){
		if(e < 3)
			pio = 0;
	}
	else if(pio&ARITH){
		int n;

		if(d == 0 && dd == 0)
			n = 2;
		else if(dd == 0)
			n = 3;
		else
			n = 4;
		if(e < n || (dd&1) != 0)
			pio = 0;
	}
	if(lsl == nil || pio == 0)
		lsl = syml;
	comma = 0;
	for(sl = syml; sl != nil; sl = sl->nxt){
		s = sl->sym;
		nearln = s->lineno;
		output(s->lineno, 1);
		if(pio){
			if(comma)
				prdelim(", ");
			setmod(s);
			prsym(s, 0);
			comma = 1;
		}
		else{
			setmod(s);
			prsym(s, 0);
			prdelim(": ");
			prid("con ");
			if(isbyte(s->tenum) || isbig(s->tenum) && !islbigv(s->vconst) || !isbig(s->tenum) && isuintv(s->vconst)){
				tgen(s->tenum, 1, 0);
				prdelim(" ");
			}
			if(s->nconst != Z)
				egen(s->nconst, ONOOP, PRE);
			else if(s->kind == KCHR)
				prchar(s->vconst);
			else if(isreal(s->tenum))
				prreal(s->fconst, s->cstring, s->kind);
			else
				prnum(s->vconst, s->kind, s->tenum);
			prdelim(";");
			newline();
		}
		if(sl == lsl)
			break;
	}
	if(pio){
		s = syml->sym;
		prdelim(": ");
		prid("con ");
		if(isbyte(s->tenum) || isbig(s->tenum)){
			tgen(s->tenum, 1, 0);
			prdelim(" ");
		}
		if(pio&GEOM){
			if(v0 == 0 || v0 == 1 || v0 == -1)
				expr = mul(v0, new1(OASHL, con(1), iota()));
			else
				expr = new1(OMUL, symcon(s), new1(OASHL, con(1), iota()));
		}
		else if(d == 0 && dd == 0)
			expr = symcon(s);
		else if(dd == 0)
			expr = add(v0, mul(d, iota()));
		else
			expr = add(v0, new1(OADD, mul(v1-dd/2-v0, iota()), mul(dd/2, new1(OMUL, iota(), iota()))));
		complex(expr);
		expr = ckneg(expr);
		egen(expr, ONOOP, PRE);
		prdelim(";");
		newline();
	}
	return lsl->nxt;
}

static void
adde(Syml *sl, Symq *q)
{
	if(q->f == nil)
		q->f = sl;
	else
		q->r->nxt = sl;
	q->r = sl;
}

static void
freeq(Symq *q, Syml **frees)
{
	if(q->f){
		q->r->nxt = *frees;
		*frees = q->f;
		q->f = q->r = nil;
	}
}

static void
etgen2(Sym *s)
{
	Syml *sl;
	static Syml *frees;
	static Symq symq, symq1;

	if(s != nil){
		newsec(2);
		sl = newsyml(s, &frees);
		adde(sl, &symq);
		if(isinteger(s->tenum) && isbigv(s->vconst) && !isbig(s->tenum))
			s->tenum = types[TVLONG];
		return;
	}
	/* end of enums */
	if(symq.f && symq.f == symq.r){	/* try to merge with other singletons */
		adde(symq.f, &symq1);
		symq.f = symq.r = nil;
		return;
	}
	if(symq1.f){
		for(sl = symq1.f; sl != nil; sl = etseq(sl))
			;
		freeq(&symq1, &frees);
	}
	if(symq.f){
		for(sl = symq.f; sl != nil; sl = etseq(sl))
			;
		freeq(&symq, &frees);
	}
}

static void
lgen(Node *n, int br, int first)
{
	if(br)
		prdelim("(");
	if(n == Z){
		if(br)
			prdelim(")");
		return;
	}
	if(n->op == OLIST || n->op == OTUPLE){
		lgen(n->left, 0, first);
		lgen(n->right, 0, 0);
	}
	else if(n->op != ODOTDOT){
		if(!first)
			prdelim(", ");
		egen(n, ONOOP, PRE);
	}
	else
		prcom("was ...", Z);
	if(br)
		prdelim(")");
}

static void
preced(int op1, int op2, int s, int c)
{
	int p1, p2, k1, k2, br;
	char buf[2];

	br = 0;
	p1 = ops[op1].prec;
	p2 = ops[op2].prec;
	if(p1 < 0 || p2 < 0)
		diag(Z, "-ve precedence");
	if(p1 > p2)
		br = 1;
	else if(p1 == p2){
		k1 = ops[op1].kind;
		k2 = ops[op2].kind;
		if(op1 == op2){
			if(k1&RASSOC)
				br = s == LEFT;
			else
				br = s == RIGHT && !(k1&ASSOC);
		}
		else{
			if(k1&RASSOC)
				br = s == LEFT;
			else
				br = s == RIGHT && op1 != OADD;

			if(k1&POSTOP && !(k2&POSTOP))
				br = 1;

			/* funny case */
			if(op2 == OMDOT && s == LEFT && (op1 == ODOT || op1 == ODOTIND))
				br = 1;
		}
	}
	if(br){
		buf[0] = c;
		buf[1] = '\0';
		prdelim(buf);
	}
}

static void
egen(Node *n, int op0, int side)
{
	int op, p;
	Type *t;
	Node *nn;

	if(n == Z){
		if(op0 == OBRACKET)
			prdelim("()");
		return;
	}
	if(n->op == OCONST && n->left != Z){	/* actual node in source */
		n->left->type = n->type;
		n = n->left;
	}
	if((n->op == OSTRING || n->op == OLSTRING) && n->left != Z)	/* actual node in source */
		n = n->left;
	if(n->op == OCAST && (lteq(n->type, n->left->type) || isnil(n) || !iscastable(n->type, n->left->type))){
		if(isnil(n))
			prid("nil");
		else
			egen(n->left, op0, side);
		return;
	}
	if(n->op == ONAME && arrow(n->sym))
		n->op = OMDOT;
	if(n->op != OLIST)
		output(n->lineno, 0);
	op = n->op;
	preced(op0, op, side, '(');
	switch(op){
		case OLIST:
		case OTUPLE:
			lgen(n, 1, 1);
			break;
		case OIOTA:
			prid("iota");
			break;
		case OMDOT:
		case ONAME:
		case OXXX:
			prsym(n->sym, 1);
			break;
		case OCONST:
			if(n->kind == KCHR)
				prchar(n->vconst);
			else if(isreal(n->type))
				prreal(n->fconst, n->cstring, n->kind);
			else if(isnil(n))
				prid("nil");
			else
				prnum(n->vconst, n->kind, n->type);
			if(n->right != Z)
				prcom("was ", n->right);
			break;
		case OSTRING:
			prstr(n->cstring);
			break;
		case OLSTRING:
			prlstr(n->rstring);
			break;
		case OCOND:
			egen(n->left, op, POST);
			prdelim(" ? ");
			egen(n->right->left, op, PRE|POST);
			prdelim(" : ");
			egen(n->right->right, op, PRE);
			prcom("?", Z);
			break;
		case OCOMMA:
			if(op0 != OCOMMA)
				prdelim("(");
			egen(n->left, op, LEFT);
			prdelim(", ");
			egen(n->right, op, RIGHT);
			if(op0 != OCOMMA)
				prdelim(")");
			break;
		case OLDOT:
			egen(n->left, OMOD, LEFT);	/* any precedence 13 operator */
			prdelim(".");
			egen(n->right, op, RIGHT);
			break;
		default:
			p = ops[op].prec;
			egen(n->left, op, LEFT);
			if(space[p])
				prdelim(" ");
			prdelim(ops[op].name);
			if(space[p])
				prdelim(" ");
			egen(n->right, op, RIGHT);
			break;
		case OIND: case OADDR: case OSADDR:
		case OPOS: case ONEG:
		case ONOT: case OCOM:
		case OPREINC: case OPREDEC:
			if(op == OADDR){
				n->op = OSADDR;
				if(!isfn(n->left->type))
					prcom("was ", n);
			}
			else
				prdelim(ops[op].name);
			egen(n->left, op, PRE);
			break;
		case OPOSTINC: case OPOSTDEC:
			egen(n->left, op, POST);
			prdelim(ops[op].name);
			break;
		case ODOT:
			egen(n->left, op, LEFT);
			dotpath(n->sym, n->left->type, 1);
			/* prdelim(ops[op].name); */
			/* prsym(n->sym, 0); */
			break;
		case ODOTIND:
			egen(n->left, op, LEFT);
			if(isadt(n->left->type))
				dotpath(n->sym, n->left->type, 1);	/* type may be demoted arg */
			else
				dotpath(n->sym, n->left->type->link, 1);
			/* prdelim(ops[op].name); */
			/* prsym(n->sym, 0); */
			break;
		case OARRIND:
			egen(n->left, op, LEFT);
			prdelim("[");
			egen(n->right, ONOOP, RIGHT);
			prdelim("]");
			if(n->right->op == OCONST && n->right->vconst < 0)
				prcom("negative array index", Z);
			break;
		case OLEN:
			prid("len ");
			egen(n->right, op, PRE);
			break;
		case OREF:
			prid("ref ");
			tgen(n->type->link, 0, 0);
			break;
		case OARRAYOF:
			prid("array");
			prdelim("[");
			egen(n->left, ONOOP, LEFT);
			prdelim("]");
			prid(" of ");
			tgen(n->type->link, 0, 0);
			break;
		case OSLICE:
			egen(n->left, op, LEFT);
			prdelim("[");
			egen(n->right->left, ONOOP, RIGHT);
			prdelim(": ");
			egen(n->right->right, ONOOP, RIGHT);
			prdelim("]");
			break;
		case OFUNC:
			if(n->kind == KEXP)
				egen(n->left, op, LEFT);
			else
				prsym(n->left->sym, 0);
			lgen(n->right, 1, 1);
			if(n->kind != KEXP && !isvoid(n->left->type->link)){
				prdelim(": ");
				tgen(n->left->type->link, 0, 0);
			}
			break;
		case	ONIL:
			prid("nil");
			break;
		case OCAST:
			if(isnil(n))
				prid("nil");
			else if(iscastable(n->type, n->left->type)){
				tgen(n->type, 0, 0);
				prdelim(" ");
				egen(n->left, op, RIGHT);
			}
			else
				egen(n->left, op0, RIGHT);
			break;
		case OARRAY:
			tgen(n->type, 0, 0);
			egen(n->left, op, LEFT);
			prdelim("[");
			egen(n->right, ONOOP, RIGHT);
			prdelim("]");
			break;
		case OSTRUCT:
		case OUNION:
			tgen(n->type, 0, 0);
			lgen(n->left, 1, 1);
			break;
		case OELEM:
			prdelim(".");
			/* tgen(n->type, 0, 0, 0); */
			prsym(n->sym, 0);
			break;
		case OSIZE:
		case OSIGN:
			prid(ops[op].name);
			if(n->left != Z)
				egen(n->left, OBRACKET, RIGHT);
			else{
				prdelim(" ");
				prid(tnames[n->type->etype]);
				if(typesu[n->type->etype] && n->type->tag){
					prdelim(" ");
					prid(n->type->tag->name);
				}
			}
			break;
		case OPROTO:
			nn = n;
			t = n->type;
			n = protoname(n);
			if(n != Z)
				t = n->type;
			else
				t = prototype(nn->left, t);
			if(!isvoid(t) || n != Z){
				if(n == Z)
					prid("nil");
				else if(n->op == ODOTDOT){
					prcom("was ...", Z);
					break;
				}
				else
					prsym(n->sym, 0);
				/* egen(n, ONOOP, PRE); */
				prdelim(": ");
				tgen(t, 1, 0);
			}
			break;
		case ODOTDOT:
			prid("...");
			break;
		case OINIT:
			egen(n->left, ONOOP, PRE);
			break;
		case OS2AB:
			prid("libc0->s2ab");
			prdelim("(");
			egen(n->left, ONOOP, PRE);
			prdelim(")");
			usemod(libcop, 1);
			break;
		case OAB2S:
			prid("libc0->ab2s");
			prdelim("(");
			egen(n->left, ONOOP, PRE);
			prdelim(")");
			usemod(libcop, 1);
			break;
		case OFILDES:
			prid("sys->fildes");
			prdelim("(");
			egen(n->left, ONOOP, PRE);
			prdelim(")");
			usemod(sysop, 1);
			break;
		case OFD:
			egen(n->left, op, LEFT);
			prdelim(ops[op].name);
			prid("fd");
			break;
		case OT0:
			egen(n->left, op, LEFT);
			prdelim(ops[op].name);
			prid("t0");
			break;
		case ORETV:
			n->op = OAS;
			nn = n->left;
			p = isvoid(n->type) || n->type->etype != TTUPLE || n->type->mark == TCPC;
			if(p)
				n->left = n->right;
			else
				n->left = new1(OTUPLE, new1(ONIL, Z, Z), n->right);
			n->right = nn;
			n->left->type = n->type;
			if(!p && op0 != ONOOP)
				addnode(OT0, n);
			egen(n, op0, side);
			break;
		case OCAT:
			egen(n->left, op, LEFT);
			prdelim(" + ");
			egen(n->right, op, RIGHT);
			break;
	}
	preced(op0, op, side, ')');
}

static int
isexpr(Node *n, Type *t)
{
	if(n == Z)
		return 0;
	if(n->op == OLIST || n->op == OINIT || n->op == OSTRUCT)
		return 0;
	if(teq(t, n->type))
		return 1;
	return 0;
}

static Node *
nxtval(Node *n, Node **nn)
{
	if(n == Z){
		*nn = Z;
		return Z;
	}
	if(n->op == OLIST){
		*nn = n->right;
		return n->left;
	}
	*nn = Z;
	return n;
}

static Node*
eagen(Node *n, Type *t, int ar, int *nz, int depth)
{
	int i, w, nw, down;
	Type *t1;
	Node *nn, *tn;

	if(n != Z){
		if(n->type == T && t == T){
			egen(n, ONOOP, PRE);
			if(ar){
				prdelim(",");
				newline();
			}
			return Z;
		}
		if(ar && n->op == OLIST && n->left->op == OARRAY){
			egen(n->left->left, ONOOP, PRE);
			prdelim(" => ");
			n = n->right;
		}
		if(n->op == OLIST && n->left->op == OELEM){
			prcom("cannot do ", n->left);
			n = n->right;
		}
		if(n->op == OUSED || n->op == ODOTDOT)
			n = n->left;
		if(t == T)
			t = n->type;
	}
	switch(t->etype){
		case TSTRUCT:
		case TUNION:
			if(isexpr(n, t))
				goto Default;
			down = 0;
			tn = nxtval(n, &nn);
			if(tn != Z && (tn->op == OINIT || tn->op == OSTRUCT)){
				down = 1;
				n = tn->left;
			}
			if(depth > 0){
				tgen(t, 0, 0);
				prdelim(" ");
			}
			prdelim("(");
			for(t1 = t->link; t1 != T; t1 = t1->down){
				if(n == Z)
					n = defval(t1);
				n = eagen(n, t1, 0, nil, depth+1);
				if(t1->down != T){
					prdelim(",");
					if(ar)
						prdelim("\t");
					else
						prdelim(" ");
				}
			}
			prdelim(")");
			if(down)
				n = nn;
			break;
		case TARRAY:
			if(isexpr(n, t))
				goto Default;
			if(depth > 0){
				tgen(t, 0, 1);
				prdelim(" ");
			}
			prdelim("{");
			newline();
			incind();
			w = t->width/t->link->width;
			nw = 0;
			for(i = 0; i < w; i++){
				down = 0;
				tn = nxtval(n, &nn);
				if(tn != Z && (tn->op == OINIT || tn->op == OSTRUCT)){
					down = 1;
					n = tn->left;
				}
				n = eagen(n, t->link, 1, &nw, depth+1);
				if(down)
					n = nn;
			}
			if(nw > 0){
				if(nw > 1)
					prdelim("* => ");
				egen(defval(t->link), ONOOP, PRE);
				newline();
			}
			decind();
			prdelim("}");
			break;
		default:
Default:
			if(n == Z){
				if(ar)
					(*nz)++;
				else
					egen(defval(t), ONOOP, PRE);
				return Z;
			}
			n = nxtval(n, &nn);
			if(ar && isnil(n) && iscastable(t, types[TINT])){
				tgen(t, 0, 0);
				prdelim(" ");
			}
			egen(n, ONOOP, PRE);
			n = nn;
			break;
	}
	if(ar){
		prdelim(",");
		newline();
	}
	return n;
}

/* better is
 *	array of byte "abcde\0"
 * but limbo compiler does not accept this as a constant expression
 */
static void
stob(Node *n)
{
	int m;
	char *s = nil, buf[UTFmax];
	Rune *u = nil;

	while(n->op == ONAME)
		n = n->sym->nconst;
	if(n->op == OSTRING)
		s = n->cstring;
	else
		u = n->rstring;
	prdelim("{ ");
	if(s){
		while(*s){
			prid("byte ");
			prchar(*s++);
			prdelim(", ");
		}
	}
	else{
		while(*u){
			m = runetochar(buf, u++);
			s = buf;
			while(--m >= 0){
				prid("byte ");
				prchar(*s++);
				prdelim(", ");
			}
		}
	}
	prid("byte ");
	prchar('\0');
	prdelim(" }");
}

static Type *arrayofchar;

static void
sdgen(Node *n, int glob)
{
	int sop = 0;

	prdelim(" := ");
	if(glob && n->right->op == OS2AB && isstring(n->right->left)){
		if(arrayofchar == T){
			arrayofchar = typ1(TARRAY, types[TCHAR]);
			arrayofchar->width = 0;
		}
		n->type = n->right->type = arrayofchar;
		sop = 1;
	}
	else
		n->type = n->right->type = T;
	tgen(n->type, 0, 1);
	if(sop)
		stob(n->right->left);
	else
		eagen(n->right, n->type, 0, nil, 0);
	prdelim(";");
	newline();
}

static void
tdgen(Node *n, int glob)
{
	int ar, arinit;

	if(ism()){
		prdelim(": ");
		tgen(n->type, 1, 0);
		if(n->op == ODAS)
			prcom("initial value was ", n->right);
		prdelim(";");
		newline();
		return;
	}
	if(n->op == ODAS && (isstring(n->right) || n->right->op == OS2AB)){
		sdgen(n, glob);
		return;
	}
	ar = n->type->etype == TARRAY && n->type->width != LARR;
	arinit = ar && n->op == ODAS;
	if(ar)
		prdelim(" := ");
	else
		prdelim(": ");
	tgen(n->type, 0, arinit);
	if(n->op == ODAS){
		if(!arinit)
			prdelim(" = ");
		eagen(n->right, n->type, 0, nil, 0);
	}
	prdelim(";");
	newline();
}

static int
isdec(Node *n)
{
	return isname(n) && n->kind != KEXP || n->op == ODAS;
}

static void
sgen(Node *n, int blk, Node **ln)
{
	int comma = 0;
	Node *nn;

	if(n == Z)
		return;
	if(blk){
		pushscope(n, SAUTO);
		if(n->op == OLIST && !(blk&NOBR) || (blk&YESBR)){
			prdelim("{");
			newline();
		}
		else if(!(blk&NONL))
			newline();
		if(!(blk&NOIN))
			incind();
	}
	if((nn = *ln) != Z && isdec(nn)){
		if(isdec(n)){
			if(canjoin(nn, n))
				comma = 1;
			else
				tdgen(nn, 0);
		}
		else if(n->op != OLIST){
			tdgen(nn, 0);
			newline();
		}
	}
	if(n->op != OLIST){
		*ln = n;
		output(n->lineno, 1);
	}
	switch(n->op){
		default:
			egen(n, ONOOP, PRE);
			prdelim(";");
			newline();
			break;
		case ODAS:
			pushdcl(n->left, CAUTO);
			egen(n->left, ONOOP, PRE);
			break;
		case ONAME:
			if(n->kind == KEXP){
				egen(n, ONOOP, PRE);
				prdelim(";");
				newline();
			}
			else{
				pushdcl(n, CAUTO);
				if(comma)
					prdelim(", ");
				if(n->op != ONAME)
					diag(n, "internal: not name in sgen");
				prsym(n->sym, 0);
				/* egen(n, ONOOP, PRE); */
/*
				prdelim(": ");
				tgen(n->type, 0, 0, 0);
				prdelim(";");
				newline();
*/
			}
			break;
		case OSBREAK:
			break;
		case ONUL:
			prdelim(";");
			newline();
			break;
		case OBLK:
			sgen(n->left, 1|YESBR, ln);
			break;
		case OLIST:
			sgen(n->left, 0, ln);
			sgen(n->right, 0, ln);
			break;
		case ORETURN:
			prkeywd("return");
			if(n->left != Z)
				prdelim(" ");
			egen(n->left, ONOOP, PRE);
			prdelim(";");
			newline();
			break;
		case OLABEL:
			prcom("was label ", n->left);
			/* i = zeroind(); */
			/* egen(n->left, ONOOP, PRE); */
			/* prdelim(":"); */
			newline();
			/* restoreind(i); */
			break;
		case OGOTO:
			prcom("was goto ", n->left);
			/* prkeywd("goto "); */
			/* egen(n->left, ONOOP, PRE); */
			prdelim(";");
			newline();
			break;
		case OCASE:
			for(nn = n->left; nn != Z; nn = nn->right){
				if(nn != n->left)
					prkeywd(" or ");
				if(nn->left != Z)
					egen(nn->left, ONOOP, PRE);
				else
					prkeywd("*");
			}
			prdelim(" =>");
			clrbrk(n->right);
			sgen(n->right, 1|NOBR, ln);
			if(n->kind != KLAST && !hasbrk(n->right)){
				prcom("fall through", Z);
				newline();
			}
			break;
		case OSWITCH:
			prkeywd("case");
			egen(n->left, OBRACKET, PRE);
			sgen(n->right, 1|NOIN|YESBR, ln);
			break;
		case OWHILE:
			prkeywd("while");
			egen(n->left, OBRACKET, PRE);
			sgen(n->right, 1, ln);
			break;
		case ODWHILE:
			prkeywd("do");
			sgen(n->right, 1|NOENL, ln);
			prkeywd("while");
			egen(n->left, OBRACKET, PRE);
			prdelim(";");
			newline();
			break;
		case OFOR:
			prkeywd("for");
			prdelim("(");
			egen(n->left->right->left, ONOOP, PRE);
			prdelim(";");
			if(n->left->left != Z)
				prdelim(" ");
			egen(n->left->left, ONOOP, PRE);
			prdelim(";");
			if(n->left->right->right != Z)
				prdelim(" ");
			egen(n->left->right->right, ONOOP, PRE);
			prdelim(")");
			sgen(n->right, 1, ln);
			break;
		case OCONTINUE:
			prkeywd("continue");
			prdelim(";");
			newline();
			break;
		case OBREAK:
			prkeywd("break");
			prdelim(";");
			newline();
			break;
		case OIF:
			prkeywd("if");
			egen(n->left, OBRACKET, PRE);
			if(n->right->left->op == OIF && n->right->left->right->right == Z && n->right->right != Z)		/* avoid dangling else */
				sgen(n->right->left, 1|YESBR, ln);
			else
				sgen(n->right->left, 1, ln);
			if(n->right->right != Z){
				prdelim("else");
				if(n->right->right->op == OIF){	/* merge else and if */
					prdelim(" ");
					sgen(n->right->right, 1|NONL|NOIN, ln);
				}
				else
					sgen(n->right->right, 1, ln);
			}
			break;
		case OSET:
		case OUSED:
			prkeywd(ops[n->op].name);
			lgen(n->left, 1, 1);
			prdelim(";");
			newline();
			break;
	}
	if(blk){
		if(!(blk&NOIN))
			decind();
		if(n->op == OLIST&& !(blk&NOBR) || (blk&YESBR)){
			prdelim("}");
			if(!(blk&NOENL))
				newline();
		}
		popscope();
	}
}

static void rew(Node*, int);

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

	if((nn = cfind(n)) != Z){
		cgen0(nn, n);
		if(r->op == ORETURN){
			n->right->left = new1(ORETURN, n->right->left, Z);
			n->right->right = new1(ORETURN, n->right->right, Z);
			n->right->left->type = n->right->left->left->type;
			n->right->right->type = n->right->right->left->type;
			*r = *n;
		}
	}
}

static void
rewc1(Node *n)
{
	Node *c, *nc;

	if(n == Z || n->op != OCOND || side(n) || !simple(n))
		return;
	c = n->left;
	nc = new1(ONOT, ncopy(c), Z);
	n->op = OOROR;
	n->left = new1(OANDAND, c, n->right->left);
	n->right = new1(OANDAND, nc, n->right->right);
}

static void
rewc(Node *n, Node *r)
{
	Node *nn, *rr, *i;

	if((nn = cfind(n)) != Z){
		i = cgen(nn, n);
		rr = new1(OXXX, Z, Z);
		if(n == r && nn == n)
			*rr = *nn;
		else
			*rr = *r;
		r->op = OLIST;
		r->left = i;
		r->right = rr;
	}
}

static int
rewe(Node *n, Type *t, int lev)
{
	int op, k, k1, k2;
	int v;
	Node *nn;

	if(n == Z)
		return -1;
	switch(n->op){
		case OCONST:
			break;
		case ONAME:
			if(strings || !isstring(n))
				break;
		case OSTRING:
		case OLSTRING:
			if(!strings)
				addnode(OS2AB, n);
			break;
		case OCOND:
			bptr(n->left);
			rewe(n->left, T, 1);
			rewe(n->right, T, 1);
			break;
		case OIND:
			if(isfn(n->type)){
				*n = *n->left;
				rewe(n, T, 1);
				break;
			}
			if(!isadt(n->type)){
				n->op = OARRIND;
				n->right = con(0);
				rewe(n, T, 1);
				break;
			}
			rewe(n->left, T, 1);
			break;
		case OADDR:
			if(n->left->op == OARRIND){
				n->right = n->left;
				n->left = n->right->left;
				n->right->left = n->right->right;
				n->right->right = Z;
				n->right->op = OLIST;
				n->op = OSLICE;
				rewe(n, T, 1);
				break;
			}
			rewe(n->left, T, 1);
			break;
		case OSLICE:
			rewe(n->left, T, 1);
			rewe(n->right, T, 1);
			if(n->left->op == OSLICE){
				n->right->left = addn(n->left->right->left, n->right->left);
				n->right->right = addn(n->left->right->left, n->right->right);
				n->left = n->left->left;
				rewe(n, T, 1);
				break;
			}
			break;
		case OCOMMA:
			rewe(n->left, T, 1);
			rewe(n->right, T, 1);
			if(n->left->op == OAS && n->right->op == OAS){
				n->op = OAS;
				n->left->op = n->right->op = OLIST;
				nn = n->left->right;
				n->left->right = n->right->left;
				n->right->left = nn;
				rewe(n, T, 1);
				break;
			}
			break;
		case OFUNC:
			if(n->left->op == ONAME){
				if((k = n->left->sym->kind) != LNONE){
					rewlc(n, k, t);
					rewe(n->left, T, 1);
					rewe(n->right, T, 1);
					args(n);
					return k;
				}
			}
			else
				rewe(n->left, T, 1);
			rewe(n->right, T, 1);
			args(n);
			break;
		case OCAST:
			rewe(n->left, n->type, 1);
			break;
		case OAS:
		case OASI:
		case OASD:
			rewe(n->left, T, 1);
			rewe(n->right, n->type, 1);
			break;
		case ONOT:
		case OANDAND:
		case OOROR:
			bptr(n);
			rewe(n->left, T, 1);
			rewe(n->right, T, 1);
			break;
		case OPREINC:
		case OPOSTINC:
		case OASADD:
			if(n->op != OPOSTINC || lev == 0){
				sliceasgn(n);
				if(n->op == OAS){
					rewe(n, T, 1);
					break;
				}
			}
			rewe(n->left, T, 1);
			rewe(n->right, T, 1);
			break;
		case OEQ:
		case ONE:
		case OLT:
		case OLE:
		case OGT:
		case OGE:
			k1 = rewe(n->left, T, 1);
			k2 = rewe(n->right, T, 1);
			if(k1 == LSTRCMP && n->right->op == OCONST){
				op = -1;
				v = n->right->vconst;
				switch(v){
					case -1:
						if(n->op == OEQ)
							op = OLT;
						else if(n->op == ONE)
							op = OGE;
						break;
					case 0:
						op = n->op;
						break;
					case 1:
						if(n->op == OEQ)
							op = OGT;
						else if(n->op == ONE)
							op = OLE;
						break;
				}
				if(op != -1){
					*n = *n->left;
					n->op = op;
				}
			}
			if(k2 == LSTRCMP && n->left->op == OCONST){
				op = -1;
				v = n->left->vconst;
				switch(v){
					case -1:
						if(n->op == OEQ)
							op = OLT;
						else if(n->op == ONE)
							op = OGE;
						break;
					case 0:
						op = rev(n->op);
						break;
					case 1:
						if(n->op == OEQ)
							op = OGT;
						else if(n->op == ONE)
							op = OLE;
						break;
				}
				if(op != -1){
					*n = *n->right;
					n->op = op;
				}
			}
			break;
		default:
			rewe(n->left, T, 1);
			rewe(n->right, T, 1);
			break;
	}
	return -1;	
}

/*
static void
rewf(Node *n)
{
	if(n == Z)
		return;
	switch(n->op){
		case OFUNC:
			if(n->left->op == ONAME)
				fdargs(n);
			break;
		default:
			rewf(n->left);
			rewf(n->right);
			break;
	}
}
*/

static void
rew(Node *n, int blk)
{
	int i;
	Node *a, *nn;

	if(n == Z)
		return;
	if(blk)
		pushscope(n, SAUTO);
	nearln = n->lineno;
	if(n->blk){
		n->blk = 0;
		addnode(OBLK, n);
	}
	switch(n->op){
		default:
			if(simple(n))
				rewc0(n, n);
			else
				rewc(n, n);
			if(n->op == OLIST || n->op == OIF){
				rew(n, 0);
				break;
			}
			ecomplex(n);
			break;
		case ODAS:
			pushdcl(n->left, CAUTO);
			rewe(n->right, T, 1);
			break;
		case OSBREAK:
		case ONUL:
			break;
		case ONAME:
			if(n->kind == KEXP)
				ecomplex(n);
			else
				pushdcl(n, CAUTO);
			break;
		case OBLK:
			rew(n->left, 1);
			break;
		case OLIST:
			rew(n->left, 0);
			rew(n->right, 0);
			break;
		case ORETURN:
			if(simple(n->left))
				rewc0(n->left, n);
			else	
				rewc(n->left, n);
			if(n->op != ORETURN){
				rew(n, 0);
				break;
			}
			ecomplex(n);
			break;
		case OLABEL:
		case OGOTO:
			break;
		case OCASE:
			for(nn = n->left; nn != Z; nn = nn->right)
				if(nn->left != Z)
					ecomplex(nn->left);
			rew(n->right, 1);
			break;
		case OSWITCH:
			rewc(n->left, n);
			if(n->op == OLIST){
				rew(n, 0);
				break;
			}
			ecomplex(n->left);
			if(!lteq(n->left->type, types[TINT]))
				intcast(n->left);
			n->right = buildcases(n->right);
			rew(n->right, 1);
			break;
		case OWHILE:
		case ODWHILE:
			rewc1(n->left);
			becomplex(n->left);
			rew(n->right, 1);
			break;
		case OFOR:
			rewc1(n->left->left);
			rewc(n->left->right->left, n);
			if(n->op == OLIST){
				rew(n, 0);
				break;
			}
			becomplex(n->left->left);
			ecomplex(n->left->right->left);
			ecomplex(n->left->right->right);
			rew(n->right, 1);
			break;
		case OCONTINUE:
			break;
		case OBREAK:
			break;
		case OIF:
			rewc1(n->left);
			rewc(n->left, n);
			if(n->op == OLIST){
				rew(n, 0);
				break;
			}
			becomplex(n->left);
			rew(n->right->left, 1);
			rew(n->right->right, 1);
			break;
		case OSET:
			if(n->left == Z){
				n->op = ONUL;
				n->left = n->right = Z;
				break;
			}
			if(n->left->op != OLIST){
				n->op = OAS;
				n->right = defval(n->left->type);
				rew(n, 0);
				break;
			}
			i = 0;
			nn = Z;
			for(;;){
				a = arg(n->left, i);
				if(a == Z)
					break;
				a = new1(OAS, a, defval(a->type));
				if(i == 0)
					nn = a;
				else
					nn = new1(OLIST, nn, a);
				i++;
			}
			*n = *nn;
			rew(n, 0);
			break;
		case OUSED:
			if(n->left == Z){
				n->op = ONUL;
				n->left = n->right = Z;
				break;
			}
			i = 0;
			nn = Z;
			for(;;){
				a = arg(n->left, i);
				if(a == Z)
					break;
				if(i == 0)
					nn = a;
				else
					nn = new1(OOROR, nn, a);
				i++;
			}
			n->op = OIF;
			n->left = nn;
			n->right = new1(OLIST, Z, Z);
			n->right->left = new1(ONUL, Z, Z);
			rew(n, 0);
			break;
	}
	if(blk)
		popscope();
}

void
codgen2(Node *n, Node *nn, int lastlno, int rw)
{
	Node *ln = Z;

	newsec(0);
	output(nn->lineno, 1);
	tmp = 0;
	/* t = types[TVOID]; */
	nn = func(nn);
	pushscope(nn, SPARM);
	if(rw)
		rew(n, 1);
	egen(nn, ONOOP, PRE);
	newline();
	prdelim("{");
	newline();
	incind();
	/* rewf(n); */
	pushscope(n, SAUTO);
	sgen(n, 0, &ln);
	if(ln != Z && isdec(ln))
		tdgen(ln, 0);
	popscope();
	popscope();
	if(n != Z)
		output(lline(n), 1);
	output(lastlno, 1);
	decind();
	prdelim("}");
	newline();
	newline();
	setmain(nn);
}

void
rewall(Node *n, Node *nn, int lastlno)
{
	USED(lastlno);
	tmp = 0;
	nn = func(nn);
	pushscope(nn, SPARM);
	rew(n, 1);
	popscope();
	setmain(nn);
}

void
suball(Node *n, Node *nn)
{
	Node *rn;

	nn = func(nn);
	pushscope(nn, SPARM);
	subs(nn, 0, 0);
	subs(n, 1, 1);
	nn = lastn(n);
	if(nn != Z && nn->op != ORETURN){
		rn = retval(Z);
		if(rn != Z){
			addnode(OLIST, nn);
			nn->right = rn;
		}
	}
	popscope();
}

void
ginit(void)
{
	thechar = 'o';
	thestring = "386";
	tfield = types[TLONG];
}

long
align(long i, Type *t, int op)
{
	long o;
	Type *v;
	int w;

	o = i;
	w = 1;
	switch(op) {
	default:
		diag(Z, "unknown align opcode %d", op);
		break;

	case Asu2:	/* padding at end of a struct */
		w = SZ_LONG;
		break;

	case Ael1:	/* initial allign of struct element */
		for(v=t; v->etype==TARRAY; v=v->link)
			;
		w = ewidth[v->etype];
		if(w <= 0 || w >= SZ_LONG)
			w = SZ_LONG;
		break;

	case Ael2:	/* width of a struct element */
		o += t->width;
		break;

	case Aarg0:	/* initial passbyptr argument in arg list */
		if(typesuv[t->etype]) {
			o = align(o, types[TIND], Aarg1);
			o = align(o, types[TIND], Aarg2);
		}
		break;

	case Aarg1:	/* initial allign of parameter */
		w = ewidth[t->etype];
		if(w <= 0 || w >= SZ_LONG) {
			w = SZ_LONG;
			break;
		}
		w = 1;		/* little endian no adjustment */
		break;

	case Aarg2:	/* width of a parameter */
		o += t->width;
		w = SZ_LONG;
		break;

	case Aaut3:	/* total allign of automatic */
		o = align(o, t, Ael2);
		o = align(o, t, Ael1);
		w = SZ_LONG;	/* because of a pun in cc/dcl.c:contig() */
		break;
	}
	o = round(o, w);
	if(0)
		print("align %s %ld %T = %ld\n", bnames[op], i, t, o);
	return o;
}

long
maxround(long max, long v)
{
	v = round(v, SZ_LONG);
	if(v > max)
		return v;
	return max;
}

static int
nlen(Node *n)
{
	if(n == Z)
		return 0;
	if(n->op == OLIST)
		return nlen(n->left)+nlen(n->right);
	return 1;
}

static void
flatten(Node *n, Node **a, int *i)
{
	if(n == Z)
		return;
	if(n->op == OLIST){
		flatten(n->left, a, i);
		flatten(n->right, a, i);
		free(n);
		return;
	}
	a[(*i)++] = n;
}

static Node*
addcase(Node *n, Node **e, Node **s, int k)
{
	Node *nn;

	if(*e != Z){
		nn = new1(OCASE, *e, *s);
		nn->right->blk = 0;
		nn->kind = k;
	}
	else
		nn = *s;
	*e = *s = Z;
	if(n == Z)
		return nn;
	return new1(OLIST, n, nn);
}

/* collect case code together */		
static Node*
buildcases(Node *n)
{
	int i, m, m0, c;
	Node *e, *s, *nn, **a, **ep;

	m = nlen(n);
	a = (Node **)malloc(m*sizeof(Node*));
	m0 = 0;
	flatten(n, a, &m0);
	if(m != m0)
		diag(Z, "internal: bad buildcases()");
	c = 1;
	e = s = nn = Z;
	ep = &e;
	for(i = 0; i < m; i++){
		n = a[i];
		if(n->op == OCASE){
			if(!c){
				nn = addcase(nn, &e, &s, KNIL);
				ep = &e;
			}
			*ep = new1(OLIST, n->left, Z);
			if(n->left == Z)
				(*ep)->lineno = n->lineno;
			ep = &(*ep)->right;
			c = 1;
		}
		else{
			if(s == Z)
				s = n;
			else
				s = new1(OLIST, s, n);
			c = 0;
		}
	}
	nn = addcase(nn, &e, &s, KLAST);
	free(a);
	return nn;
}

static Sym *
tmpgen(Type *t)
{
	Sym *s;

	sprint(buf, "tmp_%d", ++tmp);
	s = slookup(buf);
	s->type = t;
	s->class = CAUTO;
	if(t->etype == TENUM)
		s->type = types[TINT];
	return s;
}

static Node*
cfind(Node *n)
{
	Node *nn;

	if(n == Z)
		return Z;
	if(n->op == OCOND)
		return n;
	nn = cfind(n->left);
	if(nn != Z)
		return nn;
	return cfind(n->right);
}

Node*
ncopy(Node *n)
{
	Node *nn;

	if(n == Z)
		return Z;
	nn = new1(n->op, Z, Z);
	*nn = *n;
	nn->left = ncopy(n->left);
	nn->right = ncopy(n->right);
	return nn;
}

static int
complexity(Node *n, int *cond)
{
	int c;

	if(n == Z)
		return 0;
	c = complexity(n->left, cond)+1+complexity(n->right, cond);
	if(n->op == OCOND)
		(*cond)++;
	return c;
}

static int
simple(Node *n)
{
	int c;

	c = 0;
	return complexity(n, &c) < COMPLEX && c <= 1;
}

static Type*
intype(Node *n)
{
	Type *t;

	t = ntype(n);
	if(t == T)
		return T;
	return t->link;
}

static Type*
ntype(Node *n)
{
	Type *t;

	if(n == Z)
		return T;
	t = n->type;
	if(t != T){
		if(t->etype == TENUM)
			return n->sym->tenum;
		return t;
	}
	switch(n->op){
		case OEQ:
		case ONE:
		case OLT:
		case OGE:
		case OGT:
		case OLE:
		case ONOT:
		case OANDAND:
		case OOROR:
		case OIOTA:
			return types[TINT];
		case OCOMMA:
			return ntype(n->right);
		case OCOND:
			return maxtype(ntype(n->right->left), ntype(n->right->right));
		case OFUNC:
			return intype(n->left);
		case ODOT:
			tcomd(n, ntype(n->left));
			t = n->type;
			n->type = T;
			return t;
		case ODOTIND:
			tcomd(n, intype(n->left));
			t = n->type;
			n->type = T;
			return t;
		case OARRIND:
			return intype(n->left);
		case OADDR:
			return typ1(TIND, ntype(n->left));
		case OIND:
			return intype(n->left);
		case OSTRUCT:
			return T;
	}
	return maxtype(ntype(n->left), ntype(n->right));
}

static Type*
gettype(Node *n1, Node *n2)
{
	Type *t;

	t = maxtype(n1->type, n2->type);
	if(t != T)
		return t;
	return maxtype(ntype(n1), ntype(n2));
}

static void
cgen0(Node *n, Node *e)
{
	Node *c, *nn, *ed, *ee;

	if(n == e){
		n->op = OIF;
		return;
	}
	c = n->left;
	ed = new1(OXXX, Z, Z);
	*ed = *e;
	ee = ncopy(e);
	nn = cfind(ee);
	*n = *n->right->left;
	*nn = *nn->right->right;
	e->op = OIF;
	e->left = c;
	e->right = new1(OLIST, ed, ee);
}

static Node*
cgen(Node *n, Node *e)
{
	Type *t;
	Node *tn, *i;

	USED(e);
	tn = new1(ONAME, Z, Z);
	t = gettype(n->right->left, n->right->right);
	tn->sym = tmpgen(t);
	tn->type = tn->sym->type;
/*
	if(n == e){
		n->op = OIF;
		n->right->left = new1(OASD, tn, n->right->left);
		n->right->right = new1(OAS, tn, n->right->right);
		return n;
	}
*/
	i = new1(OIF, n->left, new1(OLIST, new1(OASD, tn, n->right->left), new1(OAS, tn, n->right->right)));
	*n = *tn;
	return i;
}

static struct{
	char *name;
	int	args;
	int	fd;
	char *lname;
} sysops[] = {
	"create",	1,	RET,	nil,
	"dirstat",	1,	0,	"stat",
	"dirfstat",	0,	1,	"fstat",
	"dirwstat",	1,	0,	"wstat",
	"dirfwstat",	0,	1,	"fwstat",
	"dirread",	0,	1,	nil,
	"dup",	0,	0,	nil,
	"fprint",	2|STAR,	1,	nil,
	"fprintf",	2|STAR,	1,	"fprint",
	"open",	1,	RET,	nil,
	"print",	1|STAR,	0,	nil,
	"printf",	1|STAR,	0,	"print",
	"read",	0,	1,	nil,
	"remove",	1,	0,	nil,
	"seek",	0,	1,	nil,
	"sleep",	0,	0,	nil,
	"sprint",	1|STAR,	0,	nil,
	"sprintf",	1|STAR,	0,	"sprint",
	"write",	0,	1,	nil,
	0
};

/* dummy entry for module */
#define BIOTMP	"__bio__"

static struct{
	char	*name;
	char	*lname;
} bioops[] = {
	"Bflush",	"flush",
	"Bgetc",	"getc",
	"Bprint",	"puts",
	"Bputc",	"putc",
	"Bread",	"read",
	"Bseek",	"seek",
	"Bungetc",	"ungetc",
	"Bwrite",	"write",
	BIOTMP,	nil,
	0
};

char *libcops[] = {
	"isalnum",
	"isalpha",
	"isascii",
	"iscntrl",
	"isdigit",
	"isgraph",
	"islower",
	"isprint",
	"ispunct",
	"isspace",
	"isupper",
	"isxdigit",
	"strchr",
	"strrchr",
	"toascii",
	"tolower",
	"toupper",
	"abs",
	"min",
	"max",
	0,
};

static struct{
	char *name;
	int	type;
	int	string;
} xops[] = {
	"strlen",	LSTRLEN,	1,
	"strcmp",	LSTRCMP,	1,
	"strcpy",	LSTRCPY,	1,
	"strcat",	LSTRCAT,	1,
	"strncmp",	LSTRNCMP,	1,
	"strncpy",	LSTRNCPY,	1,
	"strncat",	LSTRNCAT,	1,
	"strdup",	LSTRDUP,	1,
	"memcpy",	LMEMMOVE,	0,
	"memmove",	LMEMMOVE,	0,
	"malloc",	LMALLOC,	0,
	"free",	LFREE,	0,
	"exit",	LEXIT,	0,
	"exits",	LEXIT,	0,
	"close",	LCLOSE,	0,
	"atoi",	LATOI,	0,
	"atol",	LATOI,	0,
	"atoll",	LATOL,	0,
	"atof",	LATOF,	0,
	"atod",	LATOF,	0,
	"print",	LPRINT,	0,
	"printf",	LPRINT,	0,
	"fprint",	LFPRINT,	0,
	"fprintf",	LFPRINT,	0,
	"sprint",	LSPRINT,	0,
	"sprintf",	LSPRINT,	0,
	0
};

char *mathsops[] = {
	"sin",
	"cos",
	"tan",
	"sinh",
	"cosh",
	"tanh",
	"asin",
	"acos",
	"atan",
	"asinh",
	"acosh",
	"atanh",
	"atan2",
	"sqrt",
	"cbrt",
	"pow",
	"pow10",
	"exp",
	"log",
	"log10",
	0
};

Node *glob, *globe;

void
sysinit(void)
{
	int i;
	Sym *s;

	glob = globe = new1(ONOOP, Z, Z);
	for(i = 0; sysops[i].name; i++){
		s = slookup(sysops[i].name);
		s->class = CEXTERN;
		s->args = sysops[i].args;
		s->fd = sysops[i].fd;
		s->mod = "sys";
		s->lname = sysops[i].lname;
		s->limbo = 1;
		sysop = s;
	}
	for(i = 0; bioops[i].name; i++){
		s = slookup(bioops[i].name);
		s->class = CEXTERN;
		if(strcmp(bioops[i].name, BIOTMP) == 0){
			s->mod = "bufio";
			bioop = s;
		}
		s->lname = bioops[i].lname;
		s->kind = LSELF;
		s->limbo = 1;
	}
	for(i = 0; mathsops[i]; i++){
		s = slookup(mathsops[i]);
		s->class = CEXTERN;
		s->mod = "math";
		s->limbo = 1;
	}
	for(i = 0; libcops[i]; i++){
		s = slookup(libcops[i]);
		s->class = CEXTERN;
		s->mod = strings ? "libc" : "libc0";
		s->limbo = 1;
		libcop = s;
	}
	for(i = 0; xops[i].name; i++){
		s = slookup(xops[i].name);
		s->class = CEXTERN;
		if(strings || !xops[i].string)
			s->kind = xops[i].type;
		else
			s->mod = "libc0";
		if(s->kind == LEXIT)
			s->lname = "exit";
		s->limbo = 1;
	}
	usemod(sysop, 1);
	if(!strings)
		usemod(libcop, 1);
}

void
clbegin(void)
{
	pushscope(glob, SGLOB);
}

void
clend(void)
{
	if(passes)
		swalk();
	popscope();
}

static Modl *mods;

void
usemod(Sym *s, int ld)
{
	Modl *ml;

	for(ml = mods; ml != nil; ml = ml->nxt)
		if(strcmp(ml->mod, s->mod) == 0){
			ml->ld |= ld;
			return;
		}
	ml = (Modl *)malloc(sizeof(Modl));
	ml->mod = s->mod;
	ml->ld = ld;
	ml->nxt = mods;
	mods = ml;
}

static void
ginc(Modl *ml)
{
	int c;
	char *s;

	if(ml == nil)
		return;
	if(ml->nxt != nil)
		ginc(ml->nxt);
	s = ml->mod;
	c = toupper(s[0]);
	sprint(buf, "include \"%s.m\";", s);
	prline(buf);
	if(ml->ld){
		sprint(buf, "	%s: %c%s;", s, c, s+1);
		prline(buf);
	}
}

static void
gload(Modl *ml)
{
	int c;
	char *s;

	if(ml == nil)
		return;
	if(ml->nxt != nil)
		gload(ml->nxt);
	if(ml->ld){
		s = ml->mod;
		c = toupper(s[0]);
		sprint(buf, "	%s = load %c%s %c%s->PATH;", s, c, s+1, c, s+1);
		prline(buf);
	}
}

static void
callmain(void)
{
	if(inmain){
		if(strings)
			prline("	main(len argl, argl);");
		else
			prline("	main(len argl, libc0->ls2aab(argl));");
	}
}

static void
genstart(void)
{
	char *s;

	if(!strings && inmain)
		usemod(libcop, 1);
	ginc(mods);
	s = hasm();
	if(s){
		sprint(buf, "include \"%s\";", s);
		prline(buf);
	}
	prline("");
	prline("init(nil: ref Draw->Context, argl: list of string)");
	prline("{");
	gload(mods);
	callmain();
	prline("}");
	prline("");
}

static int
argpos0(Node *nn, Node *n, int *p)
{
	int pp;

	if(n == Z)
		return -1;
	if(n->op == OLIST){
		pp = argpos0(nn, n->left, p);
		if(pp >= 0)
			return pp;
		return argpos0(nn, n->right, p);
	}
	if(n == nn)
		return *p;
	(*p)++;
	return -1;
}

static int
argpos(Node *nn, Node *n)
{
	int p = 0;

	p = argpos0(nn, n, &p);
	if(p < 0)
		diag(Z, "-ve argpos");
	return p;
}

static Node*
arg0(Node *n, int a, int *i)
{
	Node *nn;

	if(n == Z)
		return Z;
	if(n->op == OLIST){
		nn = arg0(n->left, a, i);
		if(nn != Z)
			return nn;
		return arg0(n->right, a, i);
	}
	if(a == (*i)++)
		return n;
	return Z;
}

static Node*
arg(Node *n, int a)
{
	int i = 0;

	return arg0(n, a, &i);
}

static Node*
list(Node *l, Node *r)
{
	if(r == Z)
		return l;
	if(l == Z)
		return r;
	return new1(OLIST, l, r);
}

static Node*
droparg(Node *n, int a, int *i)
{
	if(n == Z)
		return Z;
	if(n->op == OLIST)
		return list(droparg(n->left, a, i), droparg(n->right, a, i));
	if(a == (*i)++)
		return Z;
	return n;
}

static void
sargs(Node *n)
{
	int s, f, i, j;
	Node *a;

	if(strings || (f = n->left->sym->args) == 0)
		return;
	s = 0;
	for(i = 1, j = 0; i < STAR || s; i *= 2, j++){
		if(f&i || s){
			a = arg(n->right, j);
			if(a == Z)
				break;
			if(s && !isstr(a->type))
				continue;
			if(f&STAR)
				s++;
			if(a->op == OS2AB){
				*a = *a->left;
				continue;
			}
			addnode(OAB2S, a);
		}
	}
}

static void
fdargs(Node *n)
{
	int f, i, j;
	Node *a;

	if((f = n->left->sym->fd) == 0)
		return;
	marktype(pfdtype, TCFD);
	if(f&RET)
		tcon(n, pfdtype);
	for(i = 1, j = 0; i < RET; i *= 2, j++){
		if(f&i){
			a = arg(n->right, j);
			if(a == Z)
				break;
			tcon(a, pfdtype);
		}
	}
}

static void
aargs(Node *n)
{
	int i;
	Node *a, *nn, *fn;
	Type *t, *t0, *ft, *at, *st;

	if(!doaddr)
		return;
	if(n->op != OFUNC || n->left->op != ONAME)
		return;
	/* ft = n->left->type; */
	ft = n->left->sym->type;
	t = t0 = ft->link;
	nn = Z;
	for(i = 0; ; i++){
		a = arg(n->right, i);
		if(a == Z)
			break;
		at = typn(ft, i);
		if(at != T && at->etype != TDOT && (a->op == OADDR || iteq(a->type, at) || iteq(at, a->type))){
			if(iteq(at, a->type))
				st = at->link;
			else
				st = a->type->link;
			if(doalladdr || isscalar(st)){
				if(a->op == OADDR)
					*a = *a->left;
				else if(iteq(a->type, at))
					a->type = at;
				if(t->mark == 0){
					t = tuple(t, a->type);
					trep(at, at->link);
					fn = finddec(n->left->sym, 1);
					if(fn != Z && fn->op == OFUNC)
						tind(arg(fn->right, i));
				}
				if(nn == Z)
					nn = cknil(ncopy(a));
				else{
					nn = new1(OTUPLE, nn, cknil(ncopy(a)));
					nn->type = t;
				}
			}
		}
	}
	if(nn != Z){
		if(isvoid(t0) || t->mark == TCPC)
			marktype(t, TCPC);
		else
			marktype(t, TCFC);
		tcon(n, t);
		addnode(ORETV, n);
		n->right = nn;
	}
}

static void
args(Node *n)
{
	if(n->op != OFUNC || n->left->op != ONAME)
		return;
	sargs(n);
	if(passes){
		fdargs(n);
		aargs(n);
	}
}

static Node*
indir(Node *n)
{
	if(n->op == OADDR)
		return n->left;
	return new1(OIND, n, Z);
}

static void
rewlc(Node *n, int k, Type *t)
{
	int i;
	Type *tt;
	Node *a0, *a1, *a2, *nn;

	if(t == T)
		t = n->type;
	a0 = arg(n->right, 0);
	a1 = arg(n->right, 1);
	switch(k){
		case LSTRLEN:
			n->op = OLEN;
			break;
		case LSTRCMP:
			n->op = ONE;
			n->left = a0;
			n->right = a1;
			break;
		case LSTRCPY:
			n->op = OAS;
			n->left = a0;
			n->right = a1;
			n->type = n->left->type;
			break;
		case LSTRCAT:
			n->op = OASADD;
			n->left = a0;
			n->right = a1;
			n->type = n->left->type;
			break;
		case LSTRDUP:
			*n = *a0;
			break;
		case LMEMMOVE:
			if(!teq(a0->type, a1->type))
				break;
			if(a0->type->etype == TIND){
				tt = a0->type->link;
				a2 = arg(n->right, 2);
				if(isadt(tt) && isconst(a2, tt->width)){
					n->op = OAS;
					n->left = indir(a0);
					n->right = indir(a1);
					n->type = n->left->type = n->right->type = tt;
					break;
				}
				if(mydiv(a2, tt->width) != Z){
					n->op = OAS;
					n->left = new1(OSLICE, a0, new1(OLIST, con(0), Z));
					n->right = new1(OSLICE, a1, new1(OLIST, con(0), a2));
					n->type = n->left->type = n->right->type = a0->type;
				}
			}
			break;
		case LMALLOC:
			if(t->etype == TIND){
				tt = t->link;
				if(isadt(tt) && isconst(a0, tt->width)){
					n->op = OREF;
					n->left = Z;
					n->right = Z;
					n->type = t;
					break;
				}
				if(mydiv(a0, tt->width) != Z){
					n->op = OARRAYOF;
					n->left = a0;
					n->right = Z;
					n->type = t;
					if(isadt(tt)){
						n->type = typ1(TARRAY, tt);
						n->type->width = LARR;	/* limbo array without bounds */
						marktype(n->type, TCAR);
					}
				}
			}
			break;
		case LFREE:
			n->op = OAS;
			n->left = a0;
			n->right = con(0);
			n->type = n->left->type;
			n->right->type = n->type;
			break;
		case LEXIT:
			i = n->kind;
			*n = *n->left;
			n->kind = i;
			break;
		case LCLOSE:
			n->op = OAS;
			n->left = a0;
			n->right = con(0);
			n->left->type = typ1(TIND, n->left->type);
			n->type = n->left->type;
			n->right->type = n->type;
			break;
		case LATOI:
			if(!strings)
				strcast(a0);
			n->op = OCAST;
			n->left = a0;
			n->right = Z;
			n->type = types[TINT];
			break;
		case LATOL:
			if(!strings)
				strcast(a0);
			n->op = OCAST;
			n->left = a0;
			n->right = Z;
			n->type = types[TVLONG];
			break;
		case LATOF:
			if(!strings)
				strcast(a0);
			n->op = OCAST;
			n->left = a0;
			n->right = Z;
			n->type = types[TDOUBLE];
			break;
		case LPRINT:
			if(a0->op == OSTRING)
				pfmt(a0->cstring);
			else if(a0->op == OLSTRING)
				lpfmt(a0->rstring);
			break;
		case LFPRINT:
			if(a1->op == OSTRING)
				pfmt(a1->cstring);
			else if(a1->op == OLSTRING)
				lpfmt(a1->rstring);
			break;
		case LSPRINT:
			if(n->right->kind != KDROP){
				if(a1->op == OSTRING)
					pfmt(a1->cstring);
				else if(a1->op == OLSTRING)
					lpfmt(a1->rstring);
				nn = new1(OXXX, Z, Z);
				*nn = *n;
				i = 0;
				nn->right = droparg(nn->right, 0, &i);
				nn->right->kind = KDROP;
				n->op = OAS;
				n->left = a0;
				n->right = nn;
				n->type = nn->type;
			}
			break;
		case LSELF:
			if(n->right != Z && n->right->kind != KDROP){
				i = 0;
				n->right = droparg(n->right, 0, &i);
				if(n->right != Z)
					n->right->kind = KDROP;
				addnode(OLDOT, n->left);
				n->left->right = n->left->left;
				n->left->left = a0;
				usemod(bioop, 1);
			}
			break;
	}
}

void
expgen(Node *n)
{
	egen(n, ONOOP, PRE);
}

static void
clrbrk(Node *n)
{
	if(n == Z)
		return;
	switch(n->op){
		case OLIST:
			clrbrk(n->right);
			break;
		case OBREAK:
			n->op = OSBREAK;
			n->left = n->right = Z;
			break;
	}
}

static int
hasbrk(Node *n)
{
	if(n == Z)
		return 0;
	switch(n->op){
		case OLIST:
		case OWHILE:
		case ODWHILE:
		case OFOR:
			return hasbrk(n->right);
		case OIF:
			if(n->right->right == Z)
				return 0;
			return hasbrk(n->right->left) && hasbrk(n->right->right);
		case ORETURN:
		case OGOTO:
		case OCONTINUE:
		case OBREAK:
		case OSBREAK:
			return 1;
		default:
			return 0;
	}
}

static int
isgen(char *s)
{
	char *s1, *s2;

	s1 = strchr(s, '_');
	s2 = strrchr(s, '_');
	if(s1 == nil || s2-s1 != 4)
		return 0;
	return s1[1] == 'a' && s1[2] == 'd' && s1[3] == 't';
}

static void
addmodn(Sym *s)
{
	char buf[128], *ns;

	if(s->name[0] == '_'){
		outmod(buf, -1);
		ns = malloc(strlen(buf)+strlen(s->name)+1);
		strcpy(ns, buf);
		strcat(ns, s->name);
		s->name = ns;
	}
}
		
static void
pfmt(char *s)
{
	char *t = s;

	while(*s != '\0'){
		if(*s == '%'){
			*t++ = *s++;
			if(*s == 'l'){
				s++;
				if(*s == 'l')
					*t++ = 'b';
				else
					*t++ = *s;
				s++;
			}
			else if(*s == 'p'){
				*t++ = 'x';
				s++;
			}
			else
				*t++ = *s++;
		}
		else
			*t++ = *s++;
	}
	*t = '\0';
}

static void
lpfmt(Rune *s)
{
	 Rune*t = s;

	while(*s != '\0'){
		if(*s == '%'){
			*t++ = *s++;
			if(*s == 'l'){
				s++;
				if(*s == 'l')
					*t++ = 'b';
				else
					*t++ = *s;
				s++;
			}
			else if(*s == 'p'){
				*t++ = 'x';
				s++;
			}
			else
				*t++ = *s++;
		}
		else
			*t++ = *s++;
	}
	*t = '\0';
}

int
line(Node *n)
{
	if(n == Z)
		return 0;
	if(n->op == OLIST)
		return line(n->left);
	return n->lineno;
}

static int
lline(Node *n)
{
	if(n == Z)
		return 0;
	if(n->op == OLIST)
		return lline(n->right);
	return n->lineno+1;
}

static Node*
lastn(Node *n)
{
	while(n != Z && n->op == OLIST)
		n = n->right;
	return n;
}

static Node*
newnode(int op, Node *l)
{
	Node *n;

	n = new1(op, l, Z);
	globe->right = n;
	globe = n;
	return n;
}

void
codgen1(Node *n, Node *nn, int lastlno)
{
	Node *nnn;

	scomplex(n);
	nnn = newnode(OCODE, new1(OLIST, n, nn));
	nnn->lineno = lastlno;
	mset(n);
	mset(nn);
	nn = func(nn);
	newnode(ODECF, nn);
	setmain(nn);
}

void
vtgen1(Node *n)
{
	int c;
	Node *nn = n;

	if(n->op == ODAS)
		nn = n->left;
	if(nn->type == T || nn->sym == S)
		return;
	c = nn->sym->class;
	if(c == CGLOBL || c == CSTATIC || c == CLOCAL || c == CEXREG){
		newnode(ODECV, n);
		if(nn->type->etype != TFUNC || ism())
			setmod(nn->sym);
	}
	mset(n);
}

void
etgen1(Sym *s)
{
	Node *n;

	n = newnode(ODECE, Z);
	n->sym = s;
	if(s != S)
		setmod(s);
}

void
ttgen1(Type *t)
{
	Node *n;

	n = newnode(ODECT, Z);
	n->type = t;
	if(isadt(t))
		setmod(suename(t));
}

void
outpush1(char *s)
{
	Node *n;
	char *t;

	n = newnode(OPUSH, Z);
	if(s == nil)
		t = nil;
	else{
		t = malloc(strlen(s)+1);
		strcpy(t, s);
	}
	n->cstring = t;
	outpush0(s, n);
}

void
outpop1(int lno)
{
	Node *n;

	n = newnode(OPOP, Z);
	n->lineno = lno;
	outpop0(lno);
}

void
codgen(Node *n, Node *nn, int lastlno)
{
	if(passes)
		codgen1(n, nn, lastlno);
	else
		codgen2(n, nn, lastlno, 1);
}

void
vtgen(Node *n)
{
	if(passes)
		vtgen1(n);
	else
		vtgen2(n);
}

void
etgen(Sym *s)
{
	if(passes)
		etgen1(s);
	else
		etgen2(s);
}

void
ttgen(Type *t)
{
	if(passes)
		ttgen1(t);
	else
		ttgen2(t);
}

void
outpush(char *s)
{
	if(passes)
		outpush1(s);
	else
		outpush2(s, Z);
}

void
outpop(int lno)
{
	if(passes)
		outpop1(lno);
	else
		outpop2(lno);
}

static void
swalk(void)
{
	Node *n, *l;

	for(n = glob; n != Z; n = n->right){
		l = n->left;
		switch(n->op){
			case OCODE:
				rewall(l->left, l->right, n->lineno);
				break;
			default:
				break;
		}
	}
	while(again){
		again = 0;
		for(n = glob; n != Z; n = n->right){
			l = n->left;
			switch(n->op){
				case OCODE:
					suball(l->left, l->right);
					break;
				case ODECV:
					subs(l, 0, 0);
					break;
				case ODECE:
				case ODECT:
				case ODECF:
					break;
				default:
					break;
			}
		}
	}
	for(n = glob; n != Z; n = n->right){
		l = n->left;
		switch(n->op){
			case ONOOP:
				break;
			case OPUSH:
				outpush2(n->cstring, n);
				break;
			case OPOP:
				outpop2(n->lineno);
				break;
			case OCODE:
				codgen2(l->left, l->right, n->lineno, 0);
				break;
			case ODECV:
				vtgen2(l);
				break;
			case ODECE:
				etgen2(n->sym);
				break;
			case ODECT:
				ttgen2(n->type);
				break;
			case ODECF:
				break;
		}
	}
}

static void
scomplex(Node *n)
{
	if(n == Z)
		return;
	switch(n->op){
		default:
			complex(n);
			break;
		case ODAS:
		case OSBREAK:
		case ONUL:
		case OLABEL:
		case OGOTO:
		case OCONTINUE:
		case OBREAK:
			break;
		case ONAME:
			if(n->kind == KEXP)
				complex(n);
			break;
		case OBLK:
		case OSET:
		case OUSED:
			scomplex(n->left);
			break;
		case OLIST:
			scomplex(n->left);
			scomplex(n->right);
			break;
		case ORETURN:
			complex(n);
			break;
		case OCASE:
			complex(n->left);
			break;
		case OSWITCH:
		case OWHILE:
		case ODWHILE:
			complex(n->left);
			scomplex(n->right);
			break;
		case OFOR:
			complex(n->left->left);
			complex(n->left->right->left);
			complex(n->left->right->right);
			scomplex(n->right);
			break;
		case OIF:
			complex(n->left);
			scomplex(n->right->left);
			scomplex(n->right->right);
			break;
	}
}

static void
mtset(Type *t)
{
	if(t == T)
		return;
	switch(t->etype){
		case TIND:
		case TARRAY:
			mtset(t->link);
			break;
		case TSTRUCT:
		case TUNION:
			prsym0(suename(t));
			/*
			for(l = t->link; l != T; l = l->down)
				mtset(l);
			*/
			break;
	}
}

static void
mset(Node *n)
{
	if(n == Z)
		return;
	n->garb = 0;
	if(n->op == ONAME)
		prsym0(n->sym);
	mtset(n->type);
	mset(n->left);
	mset(n->right);
}

static int
sign(Node *n)
{
	int s;

	if(n == Z)
		return 1;
	switch(n->op){
		case OCONST:
			sign(n->left);
			if(n->vconst < 0){
				n->vconst = -n->vconst;
				return -1;
			}
			break;
		case OPOS:
			s = sign(n->left);
			*n = *n->left;
			return s;
		case ONEG:
			s = sign(n->left);
			*n = *n->left;
			return -s;
		case OADD:
			if(sign(n->right) < 0)
				n->op = OSUB;
			break;
		case OSUB:
			if(sign(n->right) < 0)
				n->op = OADD;
			break;
		case OMUL:
		case ODIV:
			return sign(n->left)*sign(n->right);
		default:
			break;
	}
	return 1;
}

static Node*
ckneg(Node *n)
{
	if(sign(n) < 0)
		return new1(ONEG, n, Z);
	return n;
}

static void
sliceasgn(Node *n)
{
	Type *t;
	Node *nn;

	if(side(n->left) || (n->right != Z && side(n->right)))
		return;
	t = n->type;
	if(isarray(t) && (!strings || t->link->etype != TCHAR)){
		if(n->op == OASADD)
			nn = n->right;
		else
			nn = con(1);
		n->op = OAS;
		n->right = new1(OSLICE, ncopy(n->left), new1(OLIST, nn, Z));
	}
}