#include <ctype.h>
#define	EXTERN
#include "a.h"
#include "y.tab.h"

void
main(int argc, char *argv[])
{
	char ofile[100], incfile[20], *p;
	int nout, nproc, status, i, c, of;

	thechar = '7';			/* of 9 */
	thestring = "alpha";
	memset(debug, 0, sizeof(debug));
	cinit();
	outfile = 0;
	include[ninclude++] = ".";
	ARGBEGIN {
	default:
		c = ARGC();
		if(c >= 0 || c < sizeof(debug))
			debug[c] = 1;
		break;

	case 'o':
		outfile = ARGF();
		break;

	case 'D':
		p = ARGF();
		if(p)
			Dlist[nDlist++] = p;
		break;

	case 'I':
		p = ARGF();
		if(p)
			include[ninclude++] = p;
		break;
	} ARGEND
	if(*argv == 0) {
		print("usage: %ca [-options] file.s\n", thechar);
		errorexit();
	}
	nproc = 3;
	if(p = getenv("NPROC"))
		nproc = atol(p);
	if(argc > 1) {
		c = 0;
		nout = 0;
		for(;;) {
			while(nout < nproc && argc > 0) {
				i = fork();
				if(i < 0) {
					i = mywait(&status);
					if(i < 0)
						errorexit();
					if(status)
						c++;
					nout--;
					continue;
				}
				if(i == 0) {
					print("%s:\n", *argv);
					goto child;
				}
				nout++;
				argc--;
				argv++;
			}
			i = mywait(&status);
			if(i < 0) {
				if(c)
					errorexit();
				exits(0);
			}
			if(status)
				c++;
			nout--;
		}
	}

child:
	strecpy(ofile, ofile + sizeof(ofile), *argv);
	if(p = strrchr(ofile, '/')) {
		include[0] = ofile;
		*p++ = 0;
	} else
		p = ofile;
	if(outfile == 0) {
		outfile = p;
		if(p = strrchr(outfile, '.'))
			if(p[1] == 's' && p[2] == 0)
				p[0] = 0;
		p = strrchr(outfile, 0);
		p[0] = '.';
		p[1] = thechar;
		p[2] = 0;
	}
	if(0) {
		strcpy(incfile, "/usr/%include");
		p = strrchr(incfile, '%');
		if(p)
			*p = thechar;
	} else {
		snprint(incfile, sizeof(incfile), "/%s/include", thestring);
	}
	include[ninclude++] = incfile;
	if(p = getenv("INCLUDE"))
		include[ninclude-1] = p;	/* */
	of = mycreat(outfile, 0664);
	if(of < 0) {
		yyerror("%ca: cannot create %s", thechar, outfile);
		errorexit();
	}
	Binit(&obuf, of, OWRITE);

	pass = 1;
	pinit(*argv);
	for(i=0; i<nDlist; i++)
		dodefine(Dlist[i]);
	yyparse();
	if(nerrors) {
		cclean();
		errorexit();
	}

	pass = 2;
	outhist();
	pinit(*argv);
	for(i=0; i<nDlist; i++)
		dodefine(Dlist[i]);
	yyparse();
	cclean();
	if(nerrors)
		errorexit();
	exits(0);
}

struct
{
	char	*name;
	ushort	type;
	ushort	value;
} itab[] =
{
	"SP",		LSP,	D_AUTO,
	"SB",		LSB,	D_EXTERN,
	"FP",		LFP,	D_PARAM,
	"PC",		LPC,	D_BRANCH,

	"R",		LR,	0,
	"R0",		LREG,	0,
	"R1",		LREG,	1,
	"R2",		LREG,	2,
	"R3",		LREG,	3,
	"R4",		LREG,	4,
	"R5",		LREG,	5,
	"R6",		LREG,	6,
	"R7",		LREG,	7,
	"R8",		LREG,	8,
	"R9",		LREG,	9,
	"R10",		LREG,	10,
	"R11",		LREG,	11,
	"R12",		LREG,	12,
	"R13",		LREG,	13,
	"R14",		LREG,	14,
	"R15",		LREG,	15,
	"R16",		LREG,	16,
	"R17",		LREG,	17,
	"R18",		LREG,	18,
	"R19",		LREG,	19,
	"R20",		LREG,	20,
	"R21",		LREG,	21,
	"R22",		LREG,	22,
	"R23",		LREG,	23,
	"R24",		LREG,	24,
	"R25",		LREG,	25,
	"R26",		LREG,	26,
	"R27",		LREG,	27,
	"R28",		LREG,	28,
	"R29",		LREG,	29,
	"R30",		LREG,	30,
	"R31",		LREG,	31,

	"P",		LP,	0,
	"I",		LP,	32,
	"A",		LP,	64,
	"IA",		LP,	96,
	"T",		LP,	128,
	"IT",		LP,	32+128,
	"AT",		LP,	64+128,
	"IAT",		LP,	96+128,
	"T0",		LPREG,	0+128,
	"T1",		LPREG,	1+128,
	"T2",		LPREG,	2+128,
	"T3",		LPREG,	3+128,
	"T4",		LPREG,	4+128,
	"T5",		LPREG,	5+128,
	"T6",		LPREG,	6+128,
	"T7",		LPREG,	7+128,
	"T8",		LPREG,	8+128,
	"T9",		LPREG,	9+128,
	"T10",		LPREG,	10+128,
	"T11",		LPREG,	11+128,
	"T12",		LPREG,	12+128,
	"T13",		LPREG,	13+128,
	"T14",		LPREG,	14+128,
	"T15",		LPREG,	15+128,
	"T16",		LPREG,	16+128,
	"T17",		LPREG,	17+128,
	"T18",		LPREG,	18+128,
	"T19",		LPREG,	19+128,
	"T20",		LPREG,	20+128,
	"T21",		LPREG,	21+128,
	"T22",		LPREG,	22+128,
	"T23",		LPREG,	23+128,
	"T24",		LPREG,	24+128,
	"T25",		LPREG,	25+128,
	"T26",		LPREG,	26+128,
	"T27",		LPREG,	27+128,
	"T28",		LPREG,	28+128,
	"T29",		LPREG,	29+128,
	"T30",		LPREG,	30+128,
	"T31",		LPREG,	31+128,

	"F",		LF,	0,

	"F0",		LFREG,	0,
	"F1",		LFREG,	1,
	"F2",		LFREG,	2,
	"F3",		LFREG,	3,
	"F4",		LFREG,	4,
	"F5",		LFREG,	5,
	"F6",		LFREG,	6,
	"F7",		LFREG,	7,
	"F8",		LFREG,	8,
	"F9",		LFREG,	9,
	"F10",		LFREG,	10,
	"F11",		LFREG,	11,
	"F12",		LFREG,	12,
	"F13",		LFREG,	13,
	"F14",		LFREG,	14,
	"F15",		LFREG,	15,
	"F16",		LFREG,	16,
	"F17",		LFREG,	17,
	"F18",		LFREG,	18,
	"F19",		LFREG,	19,
	"F20",		LFREG,	20,
	"F21",		LFREG,	21,
	"F22",		LFREG,	22,
	"F23",		LFREG,	23,
	"F24",		LFREG,	24,
	"F25",		LFREG,	25,
	"F26",		LFREG,	26,
	"F27",		LFREG,	27,
	"F28",		LFREG,	28,
	"F29",		LFREG,	29,
	"F30",		LFREG,	30,
	"F31",		LFREG,	31,

	"FPCR",		LFPCR,	0,
	"PCC",		LPCC,	0,

	/* 1: integer operates */
	"ADDQ",		LTYPE1, AADDQ,
	"ADDL",		LTYPE1, AADDL,
	"SUBL",		LTYPE1, ASUBL,
	"SUBQ",		LTYPE1, ASUBQ,
	"CMPEQ",	LTYPE1, ACMPEQ,
	"CMPGT",	LTYPE1, ACMPGT,
	"CMPGE",	LTYPE1, ACMPGE,
	"CMPUGT",	LTYPE1, ACMPUGT,
	"CMPUGE",	LTYPE1, ACMPUGE,
	"CMPBLE",	LTYPE1, ACMPBLE,

	"AND",		LTYPE1, AAND,
	"ANDNOT",	LTYPE1, AANDNOT,
	"OR",		LTYPE1, AOR,
	"ORNOT",	LTYPE1, AORNOT,
	"XOR",		LTYPE1, AXOR,
	"XORNOT",	LTYPE1, AXORNOT,

	"CMOVEQ",	LTYPE1, ACMOVEQ,
	"CMOVNE",	LTYPE1, ACMOVNE,
	"CMOVLT",	LTYPE1, ACMOVLT,
	"CMOVGE",	LTYPE1, ACMOVGE,
	"CMOVLE",	LTYPE1, ACMOVLE,
	"CMOVGT",	LTYPE1, ACMOVGT,
	"CMOVLBS",	LTYPE1, ACMOVLBS,
	"CMOVLBC",	LTYPE1, ACMOVLBC,

	"MULL",		LTYPE1, AMULL,
	"MULQ",		LTYPE1, AMULQ,
	"UMULH",	LTYPE1, AUMULH,
	"DIVQ",		LTYPE1, ADIVQ,
	"MODQ",		LTYPE1, AMODQ,
	"DIVQU",	LTYPE1, ADIVQU,
	"MODQU",	LTYPE1, AMODQU,
	"DIVL",		LTYPE1, ADIVL,
	"MODL",		LTYPE1, AMODL,
	"DIVLU",	LTYPE1, ADIVLU,
	"MODLU",	LTYPE1, AMODLU,

	"SLLQ",		LTYPE1, ASLLQ,
	"SRLQ",		LTYPE1, ASRLQ,
	"SRAQ",		LTYPE1, ASRAQ,

	"SLLL",		LTYPE1, ASLLL,
	"SRLL",		LTYPE1, ASRLL,
	"SRAL",		LTYPE1, ASRAL,

	"EXTBL",	LTYPE1, AEXTBL,
	"EXTWL",	LTYPE1, AEXTWL,
	"EXTLL",	LTYPE1, AEXTLL,
	"EXTQL",	LTYPE1, AEXTQL,
	"EXTWH",	LTYPE1, AEXTWH,
	"EXTLH",	LTYPE1, AEXTLH,
	"EXTQH",	LTYPE1, AEXTQH,

	"INSBL",	LTYPE1, AINSBL,
	"INSWL",	LTYPE1, AINSWL,
	"INSLL",	LTYPE1, AINSLL,
	"INSQL",	LTYPE1, AINSQL,
	"INSWH",	LTYPE1, AINSWH,
	"INSLH",	LTYPE1, AINSLH,
	"INSQH",	LTYPE1, AINSQH,

	"MSKBL",	LTYPE1, AMSKBL,
	"MSKWL",	LTYPE1, AMSKWL,
	"MSKLL",	LTYPE1, AMSKLL,
	"MSKQL",	LTYPE1, AMSKQL,
	"MSKWH",	LTYPE1, AMSKWH,
	"MSKLH",	LTYPE1, AMSKLH,
	"MSKQH",	LTYPE1, AMSKQH,

	"ZAP",		LTYPE1, AZAP,
	"ZAPNOT",	LTYPE1, AZAPNOT,

	/* 2: floating operates with 2 operands */
	"CVTQS",	LTYPE2, ACVTQS,
	"CVTQT",	LTYPE2, ACVTQT,
	"CVTTS",	LTYPE2, ACVTTS,
	"CVTTQ",	LTYPE2, ACVTTQ,
	"CVTLQ",	LTYPE2, ACVTLQ,
	"CVTQL",	LTYPE2, ACVTQL,

	/* 3: floating operates with 2 or 3 operands */
	"CPYS",		LTYPE3, ACPYS,
	"CPYSN",	LTYPE3, ACPYSN,
	"CPYSE",	LTYPE3, ACPYSE,
	"ADDS",		LTYPE3, AADDS,
	"ADDT",		LTYPE3, AADDT,
	"CMPTEQ",	LTYPE3, ACMPTEQ,
	"CMPTGT",	LTYPE3, ACMPTGT,
	"CMPTGE",	LTYPE3, ACMPTGE,
	"CMPTUN",	LTYPE3, ACMPTUN,
	"DIVS",		LTYPE3, ADIVS,
	"DIVT",		LTYPE3, ADIVT,
	"MULS",		LTYPE3, AMULS,
	"MULT",		LTYPE3, AMULT,
	"SUBS",		LTYPE3, ASUBS,
	"SUBT",		LTYPE3, ASUBT,
	"FCMOVEQ",	LTYPE3, AFCMOVEQ,
	"FCMOVNE",	LTYPE3, AFCMOVNE,
	"FCMOVLT",	LTYPE3, AFCMOVLT,
	"FCMOVGE",	LTYPE3, AFCMOVGE,
	"FCMOVLE",	LTYPE3, AFCMOVLE,
	"FCMOVGT",	LTYPE3, AFCMOVGT,

	/* 4: integer load/store and reg->reg (incl special regs) */
	"MOVQ",		LTYPE4, AMOVQ,

	/* 5: integer load/store and reg->reg */
	"MOVL",		LTYPE5, AMOVL,
	"MOVQU",	LTYPE5, AMOVQU,
	"MOVB",		LTYPE5, AMOVB,
	"MOVBU",	LTYPE5, AMOVBU,
	"MOVW",		LTYPE5, AMOVW,
	"MOVWU",	LTYPE5, AMOVWU,
	"MOVLP",	LTYPE5, AMOVLP,
	"MOVQP",	LTYPE5, AMOVQP,

	/* 6: integer load/store (only) */
	"MOVA", 	LTYPE6, AMOVA,
	"MOVAH",	LTYPE6, AMOVAH,
	"MOVLL",	LTYPE6, AMOVLL,
	"MOVQL",	LTYPE6, AMOVQL,
	"MOVLC",	LTYPEK, AMOVLC,
	"MOVQC",	LTYPEK, AMOVQC,

	/* 7: floating load/store and reg->reg */
	"MOVS",		LTYPE7, AMOVS,
	"MOVT",		LTYPE7, AMOVT,

	/* 8,9: jumps */
	"JMP",		LTYPE8, AJMP,
	"JSR",		LTYPE8, AJSR,
	"RET",		LTYPE9, ARET,

	/* A: integer conditional branches */
	"BEQ",		LTYPEA, ABEQ,
	"BNE",		LTYPEA, ABNE,
	"BLT",		LTYPEA, ABLT,
	"BGE",		LTYPEA, ABGE,
	"BLE",		LTYPEA, ABLE,
	"BGT",		LTYPEA, ABGT,
	"BLBC",		LTYPEA, ABLBC,
	"BLBS",		LTYPEA, ABLBS,

	/* B: floating conditional branches */
	"FBEQ",		LTYPEB, AFBEQ,
	"FBNE",		LTYPEB, AFBNE,
	"FBLT",		LTYPEB, AFBLT,
	"FBGE",		LTYPEB, AFBGE,
	"FBLE",		LTYPEB, AFBLE,
	"FBGT",		LTYPEB, AFBGT,

	/* C-J: miscellaneous */
	"TRAPB",	LTYPEC, ATRAPB,
	"MB",		LTYPEC, AMB,
	"REI",		LTYPEC, AREI,
	"END",		LTYPEC, AEND,
	"FETCH",	LTYPED, AFETCH,
	"FETCHM",	LTYPED, AFETCHM,
	"CALL_PAL",	LTYPEE, ACALL_PAL,
	"TEXT",		LTYPEF, ATEXT,
	"GLOBL",	LTYPEF, AGLOBL,
	"DATA",		LTYPEG, ADATA,
	"WORD",		LTYPEH, AWORD,
	"NOP",		LTYPEI, ANOP,
	0
};

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

	nullgen.sym = S;
	nullgen.offset = 0;
	nullgen.type = D_NONE;
	nullgen.name = D_NONE;
	nullgen.reg = NREG;
	if(FPCHIP)
		nullgen.dval = 0;
	for(i=0; i<sizeof(nullgen.sval); i++)
		nullgen.sval[i] = 0;

	nerrors = 0;
	iostack = I;
	iofree = I;
	peekc = IGN;
	nhunk = 0;
	for(i=0; i<NHASH; i++)
		hash[i] = S;
	for(i=0; itab[i].name; i++) {
		s = slookup(itab[i].name);
		s->type = itab[i].type;
		s->value = itab[i].value;
	}

	ALLOCN(pathname, 0, 100);
	if(getwd(pathname, 99) == 0) {
		ALLOCN(pathname, 100, 900);
		if(getwd(pathname, 999) == 0)
			strcpy(pathname, "/???");
	}
}

void
syminit(Sym *s)
{

	s->type = LNAME;
	s->value = 0;
}

int
isreg(Gen *g)
{

	USED(g);
	return 1;
}

void
cclean(void)
{

	outcode(AEND, &nullgen, NREG, &nullgen);
	Bflush(&obuf);
}

void
zname(char *n, int t, int s)
{

	Bputc(&obuf, ANAME);
	Bputc(&obuf, t);	/* type */
	Bputc(&obuf, s);	/* sym */
	while(*n) {
		Bputc(&obuf, *n);
		n++;
	}
	Bputc(&obuf, 0);
}

void
zaddr(Gen *a, int s)
{
	vlong l;
	int i;
	char *n;
	Ieee e;

	Bputc(&obuf, a->type);
	Bputc(&obuf, a->reg);
	Bputc(&obuf, s);
	Bputc(&obuf, a->name);
	switch(a->type) {
	default:
		print("unknown type %d\n", a->type);
		exits("arg");

	case D_NONE:
	case D_REG:
	case D_FREG:
	case D_PREG:
	case D_FCREG:
	case D_PCC:
		break;

	case D_OREG:
	case D_CONST:
	case D_BRANCH:
		l = a->offset;
		Bputc(&obuf, l);
		Bputc(&obuf, l>>8);
		Bputc(&obuf, l>>16);
		Bputc(&obuf, l>>24);
		Bputc(&obuf, l>>32);
		Bputc(&obuf, l>>40);
		Bputc(&obuf, l>>48);
		Bputc(&obuf, l>>56);
		break;

	case D_SCONST:
		n = a->sval;
		for(i=0; i<NSNAME; i++) {
			Bputc(&obuf, *n);
			n++;
		}
		break;

	case D_FCONST:
		ieeedtod(&e, a->dval);
		Bputc(&obuf, e.l);
		Bputc(&obuf, e.l>>8);
		Bputc(&obuf, e.l>>16);
		Bputc(&obuf, e.l>>24);
		Bputc(&obuf, e.h);
		Bputc(&obuf, e.h>>8);
		Bputc(&obuf, e.h>>16);
		Bputc(&obuf, e.h>>24);
		break;
	}
}

void
outcode(int a, Gen *g1, int reg, Gen *g2)
{
	int sf, st, t;
	Sym *s;

	if(pass == 1)
		goto out;
jackpot:
	sf = 0;
	s = g1->sym;
	while(s != S) {
		sf = s->sym;
		if(sf < 0 || sf >= NSYM)
			sf = 0;
		t = g1->name;
		if(h[sf].type == t)
		if(h[sf].sym == s)
			break;
		zname(s->name, t, sym);
		s->sym = sym;
		h[sym].sym = s;
		h[sym].type = t;
		sf = sym;
		sym++;
		if(sym >= NSYM)
			sym = 1;
		break;
	}
	st = 0;
	s = g2->sym;
	while(s != S) {
		st = s->sym;
		if(st < 0 || st >= NSYM)
			st = 0;
		t = g2->name;
		if(h[st].type == t)
		if(h[st].sym == s)
			break;
		zname(s->name, t, sym);
		s->sym = sym;
		h[sym].sym = s;
		h[sym].type = t;
		st = sym;
		sym++;
		if(sym >= NSYM)
			sym = 1;
		if(st == sf)
			goto jackpot;
		break;
	}
	Bputc(&obuf, a);
	Bputc(&obuf, reg);
	Bputc(&obuf, lineno);
	Bputc(&obuf, lineno>>8);
	Bputc(&obuf, lineno>>16);
	Bputc(&obuf, lineno>>24);
	zaddr(g1, sf);
	zaddr(g2, st);

out:
	if(a != AGLOBL && a != ADATA)
		pc++;
}

void
outhist(void)
{
	Gen g;
	Hist *h;
	char *p, *q, *op;
	int n;

	g = nullgen;
	for(h = hist; h != H; h = h->link) {
		p = h->name;
		op = 0;
		if(p && p[0] != '/' && h->offset == 0 && pathname && pathname[0] == '/') {
			op = p;
			p = pathname;
		}
		while(p) {
			q = strchr(p, '/');
			if(q) {
				n = q-p;
				if(n == 0)
					n = 1;	/* leading "/" */
				q++;
			} else {
				n = strlen(p);
				q = 0;
			}
			if(n) {
				Bputc(&obuf, ANAME);
				Bputc(&obuf, D_FILE);	/* type */
				Bputc(&obuf, 1);	/* sym */
				Bputc(&obuf, '<');
				Bwrite(&obuf, p, n);
				Bputc(&obuf, 0);
			}
			p = q;
			if(p == 0 && op) {
				p = op;
				op = 0;
			}
		}
		g.offset = h->offset;

		Bputc(&obuf, AHISTORY);
		Bputc(&obuf, 0);
		Bputc(&obuf, h->line);
		Bputc(&obuf, h->line>>8);
		Bputc(&obuf, h->line>>16);
		Bputc(&obuf, h->line>>24);
		zaddr(&nullgen, 0);
		zaddr(&g, 0);
	}
}

#include "../cc/lexbody"
#include "../cc/macbody"
#include "../cc/compat"