#

/* uAssembler: initially for the uengine for the SD card handler for the QSIC.
 * It now reads a description of the umachine from a configuration file, and and
 * should be useful for a wide variety of umachines.
 *
 * The syntax, etc for the configuration file is documented in the initial
 * configuration file (for the QSIC SD uengine).
 *
 * The syntax for the ucode itself is a collection of lines, one per
 * micro-instruction. The syntax for individual lines ('{}' indicates an
 * optional item, and ... indicates an arbitrary number of them) is:
 *
 * {<label>:} <operator>{, <operator>}... {<literal>}
 *
 * <operator> can be either: <value> (symbolic) or <field>=<fvalue> (where
 * fvalue can be symbolic or numeric). <literal> is <data>{|<data>}... where
 * <data> is symbolic (a label, or a value - although only values defined as
 * being for the literal field are allowed) or numeric. All symbols are
 * lower-case only; forward references to labels are supported.
 *
 * Numeric items (everywhere) are either octal (leading "0"), decimal or
 * hexadecimal (with a leading "0x"; uppercase A-F only). Whitespace (either
 * space(s) or tab(s)) can be used in most places, with the exception of i)
 * between a label and the ':', ii) between an operator and any ',', and iii)
 * between a data and any '|'. Comments start with a ';' or '/', and the rest of
 * the line is ignored.
 *
 * The -d flag prints debugging info. More of them produce more info.
 * The -u flag is similar, but only affects the uassembler phase.
 * The -f flag produces a list of all the built-in fields; the -v flag,
 * with an argument of a field name, produces a list of values for that
 * field; if the field name is "all", all values are shown.
 *
 * JNC 19-Mar-2017
 */

#include	"stdio.h"
#include	<stdlib.h>
#include	<string.h>
#include	<stdarg.h>


/* Generic stuff. C doesn't have a '^' operator, do it with a table.
 */

#define	BSIZ	8				/* sizeof() -> bits */

#define	uns	unsigned			/* Keyword too long! */

#define MAXPOW	16				/* Size of ^2 table */

int	pow2tbl[MAXPOW] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,
			2048, 4096, 8192, 16384, 32768 };


/* Configuration parameters; read in from the umachine description file.
 *
 * The microcode length can be at most 2^(<literal> width); the startup
 * checks this, and prints a warning message if the literal field isn't
 * large enough to address the whole ucode.
 */

uns	uwidth;					/* uinst size */
uns	usize;					/* Max no of uinst words */

char	*addrp;					/* Address format */
char	*uinstp;				/* uinst format */
char	*litp;					/* Literal format */


/* ucode stuff.
 *
 * The ucode is held in an array of ucode structures while it is being
 * assembled - that is so that we can go back and fix up forward references
 * to labels which have not yet been seen (i.e. a 'miniature' second pass,
 * one that doesn't actually require re-parsing the source).
 */

#define	uinst	long				/* Storage for uinst */

#define	uwrd	struct	uword

struct	uword	{	uinst	u_val;
			uns	u_line;		/* Source code line number */
			char	*u_lab;		/* Label */
			char	*u_ref;		/* Unknown label */
		};

uwrd	*uwords;				/* Pointer to ucode array */
uwrd	*cuword;				/* Current uword */
uwrd	*ulast;					/* End of table */


/* Configuration structures; field and value names. The first entries are
 * specified in the umachine configuration file; the rest are calculated
 * from those values.
 *
 * Both values and fields have ancillary data, used only in producing ucode
 * listings (done by dis-assembly - this provides a useful cross-check on the
 * correct operation of the assembly). They say whether fields are bit-coded, or
 * ordinals; and whether they use the literal field, and if so, what form their
 * use is (i.e. how to decode it). Some some fields, only particular individual
 * values use the literal fields); for those, the individual value indicate if
 * they use it.
 */

#define	vals	struct	value			/* Have to be together, since */
#define	flds	struct	field			/* usage is recursive */


struct	value	{	char	*v_nm;		/* Value name, and field */
			char	*v_field;	/* it is associated with */
			uns	v_val;
			char	v_lit;		/* Value which uses literal */
			/* From here down calculated at startup */
			vals	*v_link;	/* Next entry */
			flds	*v_fp;		/* Associated field */
			uinst	v_ubits;
		};

#define	V_LIT	1				/* Uses literal as data */


struct	field	{	char	*f_nm;
			char	*f_def;		/* In string form (easy to enter) */
			char	f_lobit;	/* Low bit number */
			char	f_nbits;	/* Field width */
			char	f_type;		/* Ordinal, bit, etc */
			char	f_lit;		/* Literal use */
			/* From here down calculated at startup */
			flds	*f_link;	/* Next entry */
			vals	*f_dp;		/* Default value */
			uns	f_max;		/* Maximum value */
			uinst	f_mask;		/* Mask to get field data */
		};

#define	F_MAXTYP	4			/* Maximum field type */

#define	F_ORD	1				/* Field type */
#define	F_BIT	2
#define	F_LIT	3

char	*ftypes[F_MAXTYP] =	{ "none", "ord", "bit", "lit" };

#define	F_MAXLIT	4			/* Maximum literal type */

#define	L_LBL	1				/* Label literal */
#define	L_IMM	2				/* Immediate literal */
#define	L_BITS	3				/* Bit vector literal */
#define	L_VAL	010				/* Only some values, though */
#define	L_ERR	020				/* Error found */

char	*ltypes[F_MAXLIT] =	{ "none", "lbl", "imm", "bits" };


/* Field and value databases; read in from config file.
 */

int	nval;
struct	value	*vlst, *vlast;

int	nfield;
struct	field	*flst, *flast;

struct	field	*flit = NULL;	/* Literal field - set up at init */


/* Save strings here - too much of a PITA to allocate from the heap, limited
 * max, just do static allocations.
 */

#define	STRHPSZ	2048		/* Heap for labels */

char	labels[STRHPSZ];
char	*lblhp = &labels[0];


/* Command stuff */

int	dflg;				/* Debugging */
int	uflg;				/* uassembler debugging */
int	fflg;				/* Show fields */
int	vflg;				/* Show values */

char	*vsel;				/* Value set to print */

char	*cfnm, *ifnm, *ofnm, *lfnm;

char	*fnm;				/* Current input file */
int	cline;				/* and line number */


/* Data */

#define	MAXLIN	256

char	ibuf[MAXLIN];			/* Input buffer */

FILE	*cfile, *ifile, *ofile, *lfile;


/* Routine declarations so compiler doesn't barf */

extern	flds	*findf();
extern	vals	*findv();
extern	uwrd	*findlbl();
extern	char	*getcline(), *discws();
extern	char	*gettok(), *getnum();
extern	char	*savestring();

/* Effing anal modern compilers */

void	rdconf();
void	rdusrc();
void	fixrefs();
void	wtucode();
void	prlist();
void	initucode();
void	initflddb();
void	initvaldb();
void	setdefvals();
void	errex();
void	nferr(const char *c, ...);
void	ferr(const char *c, ...);
void	rdflddbline(flds *fp);
void	rdvaldbline(vals *vp);
void	checklit(int inum, char ntype, char *ltype);
void	showlbl(int lval, int iloc);
void	showbits(flds *lp, int lval);
void	prlittyp(int type);
void	parselit(uwrd *up, char *sp);
void	getlbl(uwrd *up, char *sp);
void	dumpfields(void);
void	dumpvalues(char *vnm);
void	help(char *errstr);
int	getiline(FILE *fp, char *fnm);
int	ntoi(char *cp);
int	htoi(char *cp);


/* Parse command line, call action routines.
 */

int	main(argc, argv)
int	argc;
char	**argv;

{	char	*arg;


	argv++;
	for (argc--; (argc > 0); argc--) {
		arg = *argv;
		if (*arg++ != '-')
			break;

		argv++;
		switch (*arg) {

		  case '?':	help("Help");

		  case 'f':	fflg++;
				break;

		  case 'v':	if (argc-- <= 1)
					nferr("No field specified");

				vflg++;
				vsel = *argv++;
				break;

		  case 'd':	dflg++;
				break;

		  case 'u':	uflg++;
				break;

		  default:	nferr("Bad flag: %c", *arg);
		  }
		}


	if (dflg > 1)
		printf("Flags done, %d args left\n", argc);

	if (argc < 3)
		help("Not enough arguments");
	if (argc > 4)
		help("Too many arguments");


	cfnm = *argv++;
	cfile = fopen(cfnm, "r");
	if (cfile == NULL)
		nferr("Error opening configuration file: '%s'", cfnm);

	rdconf();


	if (fflg) {
		dumpfields();
		exit(0);
		}

	if (vflg) {
		dumpvalues(vsel);
		exit(0);
		}


	dflg += uflg;

	ifnm = *argv++;
	ifile = fopen(ifnm, "r");
	if (ifile == NULL)
		nferr("Error opening input file: '%s'", ifnm);

	rdusrc();
	fixrefs();


	ofnm = *argv++;
	ofile = fopen(ofnm, "w");
	if (ofile == NULL)
		nferr("Error opening output file: '%s'", ofnm);

	wtucode();


	if (argc < 4)
		exit(0);


	lfnm = *argv++;
	lfile = fopen(lfnm, "w");
	if (lfile == NULL)
		nferr("Error opening listing file: '%s'", lfnm);

	prlist();


	exit(0);
}



/* Read configuration file, set up databases.
 *
 * Can't easily fold calls to discws() and gettok() into a single
 * call since we need two return values, and C isn't too good with that.
 *
 * The reason for setting cline to 0 at the start here, instead of 1, is
 * that there are a ton of calls to getcline(), so we can't increment the
 * current line after each one; so, instead of post-incrementing, we
 * pre-increment, hence the starting value.
 */

void	rdconf()

{	char	*cp, *ap, c;


	if (dflg > 1)
		printf("Rd conf file '%s'\n", cfnm);


	fnm = cfnm;
	cline = 0;

	initucode();


	cp = getcline();

	cp = discws(cp);
	ap = gettok(cp, '%');
	*ap++ = 0;
	addrp = savestring(cp);

	cp = discws(ap);
	ap = gettok(cp, '%');
	*ap++ = 0;
	uinstp = savestring(cp);

	cp = discws(ap);
	ap = gettok(cp, '%');
	*ap++ = 0;
	litp = savestring(cp);

	if (dflg)
		printf("Formats: '%s' '%s' '%s'\n", addrp, uinstp, litp);


	initflddb();
	initvaldb();
	setdefvals();
}


/* Get and check ucode params, set up ucode array.
 *
 * Ditto previous comment about can't easily fold calls to discws(),
 * getnum() and ntoi() into a single routine.
 *
 * The allocation of a 'spare' word of ucode is because of the way
 * the main parser loop handles maximum-length uprograms, with trailing
 * blank/comment lines - see comments on rdusrc().
 */

void	initucode()

{	char	*cp, *ap, c;
	uns	umax;


	if (dflg > 1)
		printf("initucode\n");


	cp = getcline();

	cp = discws(cp);
	ap = getnum(cp);
	*ap++ = 0;
	uwidth = ntoi(cp);

	cp = discws(ap);
	ap = getnum(cp);
	*ap++ = 0;
	usize = ntoi(cp);


	umax = (sizeof(uinst) * BSIZ);

	if (dflg)
		printf("Width: 0%o  max: 0%o  nwrds: 0%o\n",
			uwidth, umax, usize);

	if (uwidth > umax)
		ferr("Width: 0%o too large, maximum: 0%o",
			uwidth, umax);

	uwords = ((uwrd *) malloc((usize + 1) * sizeof(uwrd)));

	if (uwords == NULL)
		nferr("Could not allocate uword array for 0%o uwords",
			usize);

	cuword = uwords;
	ulast = (uwords + usize);


	if (dflg)
		printf("0%o uwords from 0x%x to 0x%x\n", usize, uwords, ulast);
}



/* Set up field database. Read in entries from config file, then for eache
 * entry, first sanity-checks, then sets it up. The scan of the table looking
 * for other fields which overlap this one can only be done once the entire
 * table has been read in.
 *
 * The database was set up as a linked list when I thought we were be going to
 * read the field entries (and allocating the structures to hold them) one at a
 * time; the cross-check of the number let us do a single alloc, though. Left as
 * a linked list since it's already done and working, and it might be useful
 * some day.
 *
 * The forward link in each entry is temporarily set to NULL so that we can
 * use findv() to look for duplicate value names during read-in. In the last
 * entry, this is left, and forms the chain end marker.
 * The first write (of bad data) into the forward link of first element (while
 * processing the first element) will be over-written by later writes (the last,
 * while processing the next element).
 */

void	initflddb()

{	flds	*fp, *ofp, *sfp;
	uns	maxubits = 0;
	uns	n;
	char	*cp, *ap;


	if (dflg > 1)
		printf("initflddb\n");


	cp = getcline();

	cp = discws(cp);
	ap = getnum(cp);
	*ap++ = 0;
	nfield = ntoi(cp);

	if (dflg)
		printf("Number of fields: %d\n", nfield);


	flst = ((flds *) malloc(nfield * sizeof(flds)));

	if (flst == NULL)
		nferr("Could not allocate field array for %d fields",
			nfield);

	flast = (flst + nfield);


	for (ofp = flst, fp = flst; (fp < flast); ofp = fp++) {
		rdflddbline(fp);


		if ((fp->f_nbits < 1) || (fp->f_nbits >= MAXPOW))
			ferr("Field '%s' size %d bad", fp->f_nm, fp->f_nbits);


		if ((fp->f_lobit < 0) ||
		    ((fp->f_lobit + fp->f_nbits) > uwidth))
			ferr("Field '%s' start/size %d/%d too large for uword size %d",
				 fp->f_nm, fp->f_lobit, fp->f_nbits, uwidth);


		ofp->f_link = fp;
		fp->f_link = NULL;

		fp->f_max = (pow2tbl[fp->f_nbits] - 1);
		fp->f_mask = (fp->f_max << fp->f_lobit);

		n = (fp->f_lobit + fp->f_nbits);
		if (n > maxubits)
			maxubits = n;


		if (fp->f_type == F_LIT) {
			if (flit != NULL)
				ferr("Duplicate literal field '%'", fp->f_nm);

			flit = fp;
			}


		if (dflg > 1)
			printf("Field: '%s' max: 0%o\n", fp->f_nm, fp->f_max);
		}


	if (dflg)
		printf("Last field: '%s'\n", ofp->f_nm);


	cp = getcline();
	if (*cp != '.')
		ferr("Missing table terminator, '%s' instead", cp);


	if (flit == NULL)
		ferr("No Literal field");

	if (usize > pow2tbl[flit->f_nbits])
		ferr("Literal field 0%o not big enough for ucode size 0%o",
			flit->f_max, usize);

	if (uwidth > maxubits)
		printf("uword width 0%o does not use entire uword size 0%o\n",
			maxubits, uwidth);


	for (fp = flst; (fp != NULL); fp = fp->f_link) {
		for (sfp = flst; (sfp != NULL); sfp = sfp->f_link) {
			if (sfp == fp)
				continue;

			if (fp->f_lobit >= (sfp->f_lobit + sfp->f_nbits))
				continue;
			if ((fp->f_lobit + fp->f_nbits) <= sfp->f_lobit)
				continue;

			ferr("Field '%s' %d/%d overlaps field '%s' %d/%d",
				fp->f_nm, fp->f_lobit, fp->f_nbits,
				sfp->f_nm, sfp->f_lobit, sfp->f_nbits);
			}
		}
}


/* Read a field database line. Not necessary to check for EOF;
 * getcline() will barf, and the conf file format lets us know how many
 * lines to expect.
 *
 * The first entry has to be special-cased (since findf() can't be called
 * with a null list).
 */

void	rdflddbline(fp)
flds	*fp;

{	char	*cp, *ap, **xtp;
	int	i;
	char	ltype;


	cp = getcline();

	if (dflg > 1)
		printf("rdfld: '%s'\n", &ibuf[0]);


	cp = discws(cp);
	ap = gettok(cp, 0);
	*ap++ = 0;

	if ((fp != flst) && (findf(cp) != NULL))
		ferr("Duplicate field name '%s'", cp);


	fp->f_nm = savestring(cp);

	cp = discws(ap);
	ap = gettok(cp, 0);
	*ap++ = 0;
	fp->f_def = savestring(cp);

	cp = discws(ap);
	ap = getnum(cp);
	*ap++ = 0;
	fp->f_lobit = ntoi(cp);

	cp = discws(ap);
	ap = getnum(cp);
	*ap++ = 0;
	fp->f_nbits = ntoi(cp);


	cp = discws(ap);
	ap = gettok(cp, 0);
	*ap++ = 0;

	for (i = 0, xtp = &ftypes[0]; (i < F_MAXTYP); i++) {
		if (strcmp(*xtp++, cp) == 0)
			break;
		}

	if (i >= F_MAXTYP)
		ferr("Field type '%s' not recognized", cp);

	fp->f_type = i;


	cp = discws(ap);
	ap = gettok(cp, 0);
	*ap++ = 0;

	if (*cp == 'v') {
		cp++;
		ltype = L_VAL;
		}
	  else
		ltype = 0;

	for (i = 0, xtp = &ltypes[0]; (i < F_MAXLIT); i++) {
		if (strcmp(*xtp++, cp) == 0)
			break;
		}

	if (i >= F_MAXTYP)
		ferr("Literal type '%s' not recognized", cp);

	fp->f_lit = (ltype | i);


	if (dflg < 2)
		return;

	printf("Field: '%s' default: '%s' lo: %d nbits: %d",
			fp->f_nm, fp->f_def, fp->f_lobit, fp->f_nbits);
	if (fp->f_type != 0)
		printf(" type: %s", ftypes[fp->f_type]);
	if (fp->f_lit != 0)
		printf(" literal: %s", ltypes[(fp->f_lit & ~L_VAL)]);
	if ((fp->f_lit & L_VAL) != 0)
		printf(" (limited)");
	printf("\n");
}



/* Set up value database; similar to field database above.
 * Has to run after field database is set up.
 *
 * Ditto above comments about the use of a linked list, etc.
 */

void	initvaldb()

{	vals	*vp, *ovp;
	flds	*fp;
	char	*cp, *ap;


	if (dflg > 1)
		printf("initvaldb\n");


	cp = getcline();

	cp = discws(cp);
	ap = getnum(cp);
	*ap++ = 0;
	nval = ntoi(cp);

	if (dflg)
		printf("Number of values: %d\n", nval);


	vlst = ((vals *) malloc(nval * sizeof(vals)));

	if (vlst == NULL)
		nferr("Could not allocate value array for %d values",
			nval);

	vlast = (vlst + nval);


	for (ovp = vlst, vp = vlst; (vp < vlast); ovp = vp++) {
		rdvaldbline(vp);

		for (fp = flst; (fp != NULL); fp = fp->f_link)
			if (strcmp(vp->v_field, fp->f_nm) == 0)
				break;


		if (fp == NULL)
			ferr("Value '%s' field '%s' not found",
				 vp->v_nm, vp->v_field);

		if (vp->v_val > fp->f_max)
			ferr("Value '%s' value 0%o too large for field '%s' (max 0%o)",
				 vp->v_nm, vp->v_val, fp->f_nm, fp->f_max);


		vp->v_fp = fp;
		vp->v_ubits = (vp->v_val << fp->f_lobit);

		ovp->v_link = vp;
		vp->v_link = NULL;


		if (dflg > 1) {
			printf("Value: '%s' field: '%s' uword: ",
				vp->v_nm, fp->f_nm);
			printf(uinstp, vp->v_ubits);
			printf("\n");
			}
		}


	if (dflg)
		printf("Last value: '%s'\n", ovp->v_nm);


	cp = getcline();
	if (*cp != '.')
		ferr("Missing table terminator, '%s' instead", cp);

}


/* Read a value database line.
 *
 * Ditto above comments about EOF, the first entry, etc.
 */

void	rdvaldbline(vp)
vals	*vp;

{	char	*cp, *ap, **xtp;
	int	i;


	cp = getcline();

	if (dflg > 1)
		printf("rdval: '%s'\n", &ibuf[0]);


	cp = discws(cp);
	ap = gettok(cp, 0);
	*ap++ = 0;

	if (findf(cp) != NULL)
		ferr("Value has same name as field '%s'", cp);


	if ((vp != vlst) && (findv(cp) != NULL))
		ferr("Duplicate value name '%s'", cp);


	vp->v_nm = savestring(cp);

	cp = discws(ap);
	ap = gettok(cp, 0);
	*ap++ = 0;
	vp->v_field = savestring(cp);

	cp = discws(ap);
	ap = getnum(cp);
	*ap++ = 0;
	vp->v_val = ntoi(cp);

	cp = discws(ap);
	ap = gettok(cp, 0);
	*ap++ = 0;

	if (strcmp(cp, "yes") == 0)
		vp->v_lit = V_LIT;
	  else
		vp->v_lit = 0;


	if (dflg < 2)
		return;

	printf("Value: '%s' field: '%s' val: 0%o",
			vp->v_nm, vp->v_field, vp->v_val);
	printf("%s", ((vp->v_lit != 0) ? " lit: yes" : ""));
	printf("  uword: ");
	printf(uinstp, vp->v_ubits);
	printf("\n");
}


/* Set default values; can only run once both field _and_ value
 * databases are set up.
 */

void	setdefvals()

{	flds	*fp;
	vals	*vp;

	if (dflg > 1)
		printf("setdefvals\n");


	for (fp = flst; (fp != NULL); fp = fp->f_link) {
		if (strcmp(fp->f_def, "none") == 0)
			continue;

		for (vp = vlst; (vp != NULL); vp = vp->v_link) {
			if (strcmp(fp->f_def, vp->v_nm) == 0)
				break;
			}

		if (vp != NULL) {
			fp->f_dp = vp;
			continue;
			}

		ferr("Field '%s' default '%s' not found",
		      fp->f_nm, fp->f_def);
		}
}



/* Read in source. A NULL return from parseline() means there
 * was no uinst on this line of source.
 *
 * The logic for a maximum-sized uprogram is a little complicated.
 * After filling all 'usize' words, the parer must be allowed to go
 * around again, to discard any trailing blank/comment line(s), _but_
 * no uword can result - if so, an error must be indicated.
 * Normally, the loop will 'exit' with a return on EOF; if it actually
 * reads a 'usize'th uinst, it will fall out the bottom, and then we
 * know there's an error.
 */

void	rdusrc()

{	uwrd	*up;
	int	inum, cinum, rval;
	uwrd	*parseline();


   	if (dflg > 1)
		printf("rdusrc '%s'\n", ifnm);


	fnm = ifnm;
	cline = 1;

	for (inum = 0; (inum <= usize); cline++) {
		rval = getiline(ifile, ifnm);

		if (rval == EOF)
			return;

		up = parseline();

		if (up == NULL)
			continue;

		up->u_line = cline;


		if (dflg == 0) {
			inum++;
			continue;
			}


		printf("uwd ");
		printf(addrp, inum);
		printf(": ");
		printf(uinstp, up->u_val);

		if (up->u_lab != NULL)
			printf(" label: '%s'", up->u_lab);
		if (up->u_ref != NULL)
			printf(" ref: '%s'", up->u_ref);
		printf("\n\n");

		inum++;
		}


	if (dflg) {
		printf("excess uwd ");
		printf(addrp, inum);
		printf("\n");
		}

	printf("uprogram too long, maximum length ");
	printf(addrp, usize);
	printf("\n");
	exit(1);
}


/* After reading the entire uprogram, run through it looking for unbound
 * forward label reference, which are now linked.
 */

void	fixrefs()

{	uwrd	*up, *cup;
	int	inum, cinum;

	for (up = uwords; (up < cuword); up++) {
		if (up->u_ref == NULL)
			continue;

		inum = (up - uwords);
		if (dflg > 1) {
			printf("Fwd ref to '%s' in uwrd ", up->u_ref);
			printf(addrp, inum);
			printf("\n");
			}

		for (cup = uwords; (cup < cuword); cup++) {
			if (cup->u_lab == NULL)
				continue;

			if (strcmp(up->u_ref, cup->u_lab) != 0)
				continue;

			break;
			}


		if (cup >= cuword) {
			cline = up->u_line;
			ferr("Label '%s' not found", up->u_ref);
			}


		cinum = (cup - uwords);

		if (dflg) {
			printf("Fwd ref in uwrd ");
			printf(addrp, inum);
			printf(" found at uwrd ");
			printf(addrp, cinum);
			}

		up->u_val |= (cinum << flit->f_lobit);

		if (dflg) {
			printf(" updated uwrd to ");
			printf(uinstp, up->u_val);
			printf("\n");
			}
		}
}



/* Write out binary of ucode.
 */

void	wtucode()

{	uwrd	*up;

	fputs("@0\n", ofile);

	for (up = uwords; (up < cuword); up++) {
		fprintf(ofile, "%06x\n", up->u_val);
		}

	fflush(ofile);

	printf("0%o words of microcode assembled\n", (up - uwords));
}



/* Print ucode listing.
 *
 * The code knows only a tiny bit about the uinsts, its mostly totally table
 * driven, like the assembly side.
 */

void	prlist()

{	uwrd	*up;
	flds	*fp, *lp;
	vals	*vp;
	uinst	lmask, thisop;
	int	inum, lval;
	char	ltype;


	for (fp = flst; (fp != NULL); fp = fp->f_link) {
		if (fp->f_type != F_LIT)
			continue;

		lp = fp;
		lmask = (fp->f_max << fp->f_lobit);
		break;
		}


	for (up = uwords, inum = 0; (up < cuword); up++, inum++) {
		ltype = 0;

		fprintf(lfile, addrp, inum);
		fprintf(lfile, ": ");
		fprintf(lfile, uinstp, up->u_val);
		fprintf(lfile, "  ");

		if (up->u_lab != NULL)
			fprintf(lfile, "%16s:\t", up->u_lab);
		  else
			fprintf(lfile, "\t\t\t");

		if (up->u_val == 0) {
			fprintf(lfile, "nop\n");
			continue;
			}


		for (fp = flst; (fp != NULL); fp = fp->f_link) {
			if ((thisop = (up->u_val & fp->f_mask)) == 0)
				continue;

			if ((fp->f_lit != 0) && ((fp->f_lit & L_VAL) == 0))
				checklit(inum, fp->f_lit, &ltype);

			for (vp	= vlst; (vp != NULL); vp = vp->v_link) {
				if (vp->v_fp != fp)
					continue;

				if (fp->f_type == F_ORD) {
					if (thisop == vp->v_ubits) {
						fprintf(lfile, "%s ", vp->v_nm);
						if (vp->v_lit == V_LIT)
							checklit(inum, (fp->f_lit & ~L_VAL), &ltype);
						break;
						}
					}

				if (fp->f_type == F_BIT) {
					if ((thisop & vp->v_ubits) != 0) {
						fprintf(lfile, "%s ", vp->v_nm);
						if (vp->v_lit == V_LIT)
							checklit(inum, (fp->f_lit & ~L_VAL), &ltype);
						}
					}
				}
			}


		if ((ltype & L_ERR) != 0)
			ltype = L_IMM;

		lval = (up->u_val & lmask);


		if (ltype == L_LBL) {
			showlbl(lval, inum);
			continue;
			}

		if (ltype == L_BITS) {
			showbits(lp, lval);
			continue;
			}

		if (ltype == L_IMM) {
			fprintf(lfile, "\t");
			fprintf(lfile, litp, lval);
			fprintf(lfile, "\n");
			continue;
			}

		fprintf(lfile, "\n");
		}

	fflush(lfile);
}


void	checklit(inum, ntype, ltype)
int	inum;
char	ntype;
char	*ltype;

{	if (*ltype != 0) {
		printf("Warning: literal use clash in uinst: ");
		printf(addrp, inum);
		printf(" previous: ");
		prlittyp(*ltype);
		printf(" new: ");
		prlittyp(ntype);
		printf("\n");
		*ltype |= L_ERR;
		return;
		}

	*ltype = ntype;
}


void	prlittyp(type)
int	type;

{	switch(type) {
	  case L_LBL:	printf("label");
			return;

	  case L_IMM:	printf("immediate");
			return;

	  case L_BITS:	printf("bits");
			return;

	  default:	nferr("Bad type 0%o in literal", type);
	  }
}


void	showlbl(lval, iloc)
int	lval, iloc;

{	uwrd	*up;
	int	inum;

	if (dflg > 1)
		printf("showlbl 0%o 0%o\n", lval, iloc);

	fprintf(lfile, "\t");

	if (lval == iloc) {
		fprintf(lfile, ".\n");
		return;
		}

	for (up = uwords; (up < cuword); up++) {
		if (up->u_lab == NULL)
			continue;

		inum = (up - uwords);

		if (inum == lval) {
			fprintf(lfile, "%s\n", up->u_lab);
			return;
			}
		}

	fprintf(lfile, litp, lval);
	fprintf(lfile, "\n");
}


void	showbits(lp, lval)
flds	*lp;
int	lval;

{	vals	*vp;

	fprintf(lfile, "\t");

	for (vp	= vlst; (vp != NULL); vp = vp->v_link) {
		if (vp->v_fp != lp)
			continue;

		if (lval & vp->v_ubits)
			fprintf(lfile, "%s ", vp->v_nm);

		}

	fprintf(lfile, "\n");
}



/* Parse a line of uassembler.
 *
 * 'sp' generally points to the token we are trying to parse, and 'tp'
 * points to the character _after_ the character after the token; the
 * character after the token is read into 'r', and then that character
 * in the input buffer is zeroed, as a terminator for the token string.
 */

uwrd	*parseline()

{	uwrd	*up = NULL;
	flds	*fp = NULL;
	vals	*vp;
	char	c, r, *sp, *tp;
	int	v;
	int	labelseen = 0;


	sp = &ibuf[0];

	if (dflg)
		printf("ParseLine '%s'\n", sp);


	while (sp < &ibuf[MAXLIN]) {
		c = *sp;

		if (dflg > 1)
			printf("LineParse '%c'\n", c);

		switch (c) {

		  case '\t':
		  case ' ':	sp++;
				continue;

		  case ';':
		  case '/':
  		  case '\r':
		  case '\n':	return (up);

		  default:	break;
		  }


		if (up == NULL)
			up = cuword++;


		if ((c >= 'a') && (c <= 'z')) {
			tp = gettok(sp, 0);
			r = *tp;
			*tp++ = 0;


			if (r == ':') {
				if (labelseen++ != 0)
					ferr("Extra label '%s'", sp);

				if (findlbl(sp) != NULL)
					ferr("Duplicate label '%s'", sp);

				if (findf(sp) != NULL)
					ferr("Label '%s' also field name", sp);

				if (findv(sp) != NULL)
					ferr("Label '%s' also value name", sp);


				up->u_lab = savestring(sp);

				if (dflg > 1)
					printf("Label '%s' added\n", sp);

				goto done;
				}


			if (r == '=') {
				if (fp != NULL)
					ferr("Excess field specifier '%s'", sp);


				fp = findf(sp);
				if (fp == NULL)
					ferr("Unknown field specifier '%s'", sp);

				goto done;
				}


			/* Now reading a symbolic value */

			vp = findv(sp);
			if (vp == NULL)
				ferr("Unknown field value '%s'", sp);


			if ((fp != NULL) && (vp->v_fp != fp))
				ferr("Value '%s' not valid for field '%s'",
					sp, fp->f_nm);

			if (dflg > 1)
				printf("Symbolic value '%s' found\n",
					vp->v_nm);

			up->u_val |= vp->v_ubits;

			fp = NULL;

			goto done;
			}


		if ((c >= '0') && (c <= '9')) {
			tp = getnum(sp);
			r = *tp;
			*tp++ = 0;

			if (fp == NULL)
				ferr("Numeric value '%s' seen with no field", sp);

			v = ntoi(sp);

			if (v > fp->f_max)
				ferr("Value 0%o too large for field '%s'",
					v, fp->f_nm);


			if (dflg > 1)
				printf("Numeric value 0%o seem for field '%s'\n",
					v, fp->f_nm);

			up->u_val |= (v << fp->f_lobit);

			fp = NULL;

			goto done;
			}


		goto bad;


	/* When we get here, if last terminator was a ',' there is
	 * another operator, so go around and collect it; if the terminator
	 * was white-space, there might be a literal, so go get it.
	 * If the terminator was an NL, nothing else left, done.
	 * ':' and '=' are from the first part of a multi-part line, keep
	 * going. Anything else, it's an error.
	 */

	done:	if (dflg > 1)
			printf("Line parser step '%s' '%s'\n", sp, tp);

		sp = tp;


		if ((r == ',') || (r == ':') || (r == '='))
			continue;

		if ((r == '\r') || (r == '\n'))
			return (up);

		if ((r == ' ') || (r == '\t')) {
			parselit(up, sp);
			return (up);
			}


		c = r;

	bad:	ferr("Bad operator character '%c'", c);
		}
}


/* Parse the <literal> part of a line of assembler.
 */

void	parselit(up, sp)
uwrd	*up;
char	*sp;

{	vals	*vp;
	char	c, r, *tp;
	int	v;


	if (dflg > 1)
		printf("ParseLiteral '%s'\n", sp);


	while (sp < &ibuf[MAXLIN]) {
		c = *sp;

		if (dflg > 1)
			printf("LitParse '%c'\n", c);

		switch (c) {

		  case '\t':
		  case ' ':	sp++;
				continue;

		  case ';':
		  case '/':
  		  case '\r':
		  case '\n':	return;

		  default:	break;
		  }


		if (c == '.') {
			tp = ++sp;
			r = *tp;

			v = (up - uwords);

			if (dflg > 1)
				printf("Dot in literal uloc 0%o\n", v);

			up->u_val |= (v << flit->f_lobit);

			goto done;
			}


		if ((c >= 'a') && (c <= 'z')) {
			tp = gettok(sp, 0);
			r = *tp;
			*tp++ = 0;

			vp = findv(sp);

			if (vp == NULL) {
				getlbl(up, sp);
				}
			  else {
				if (vp->v_fp != flit)
					ferr("Value '%s' not valid for literal field", sp);

				up->u_val |= vp->v_ubits;
				}

			goto done;
			}


		if ((c >= '0') && (c <= '9')) {
			tp = getnum(sp);
			r = *tp;
			*tp++ = 0;

			v = ntoi(sp);

			if (v > flit->f_max)
				ferr("Value 0%o too large for literal field\n", v);

			up->u_val |= (v << flit->f_lobit);

			goto done;
			}


		goto bad;


	done:	if (dflg > 1)
			printf("Literal parser step '%s' '%s'\n", sp, tp);

		if  ((r == '\r') || (r == '\n') ||
		     (r == ' ') || (r == '\t') ||
		     (r == '/') || (r == ';'))
			return;

		if (r == '|') {
			sp = tp;
			continue;
			}


		c = r;

	bad:	ferr("Bad literal character '%c'", c);

	}
}


/* Find matching label; if found, save in literal field of uword;
 * if none found, save a forward reference to be resolved at the
 * end of the assembly pass.
 *
 * NOTE: Currently assumes literal is in low bits - need to fix!
 */

void	getlbl(up, sp)
uwrd	*up;
char	*sp;

{	uwrd	*cup;

	if (dflg > 1)
		printf("GetLabel '%s'\n", sp);


	cup = findlbl(sp);

	if (cup == NULL) {
		up->u_ref = savestring(sp);
		return;
		}

	up->u_val |= ((cup - uwords) << flit->f_lobit);
}


uwrd	*findlbl(sp)
char	*sp;

{	uwrd	*cup;

	if (dflg > 1)
		printf("FindLabel '%s'\n", sp);


	for (cup = uwords; (cup < cuword); cup++) {
		if (cup->u_lab == NULL)
			continue;

		if (strcmp(sp, cup->u_lab) == 0) {
			if (dflg > 1)
				printf("Found 0%o\n", (cup - uwords));

			return(cup);
			}
		}


	if (dflg > 2)
		printf("Label not found\n");

	return(NULL);
}



/* Utils - return pointer to matching field/value name.
 */

flds	*findf(ap)
char	*ap;

{	flds	*fp;

	if (dflg > 1)
		printf("FindField: '%s'\n", ap);


	for (fp = flst; (fp != NULL); fp = fp->f_link) {
		if (strcmp(ap, fp->f_nm) == 0)
			break;
		}

	if (fp == NULL) {
		if (dflg > 2)
			printf("Field '%s' not found\n", ap);

		return (NULL);
		}


	if (dflg > 1)
		printf("Found field: '%s'\n", fp->f_nm);

	return (fp);
}


vals	*findv(ap)
char	*ap;

{	vals	*vp;

	if (dflg > 1)
		printf("FindVal: '%s'\n", ap);

	for (vp = vlst; (vp != NULL); vp = vp->v_link) {
		if (strcmp(ap, vp->v_nm) == 0)
			break;
		}

	if (vp == NULL) {
		if (dflg > 2)
			printf("Value '%s' not found\n", ap);

		return (NULL);
		}


	if (dflg > 1)
		printf("Found value: '%s'\n", vp->v_nm);

	return (vp);
}



/* Parser utils - return pointer to first non-numeric/alpha char
 * in input buffer.
 */

char	*gethex(ap)
char	*ap;

{	if (dflg > 2)
		printf("GetHex: '%s'\n", ap);

	while (((*ap >= '0') && (*ap <= '9')) ||
	       ((*ap >= 'A') && (*ap <= 'F')))
		ap++;

	return(ap);
}


char	*getnum(ap)
char	*ap;

{	char	*xap;

	if (dflg > 2)
		printf("GetNum: '%s'\n", ap);

	xap = ap;
	if ((*xap++ == '0') && (*xap++ == 'x'))
		return (gethex(xap));

	while ((*ap >= '0') && (*ap <= '9'))
		ap++;

	return(ap);
}


/* Second arg allows it to be used for strings which include '%',
 * used in format string.
 */

char	*gettok(ap, xc)
char	*ap, xc;

{	char	c;

	if (dflg > 2)
		printf("GetTok: '%s'\n", ap);

	while ((((c = *ap) >= 'a') && (c <= 'z')) ||
	       ((c >= '0') && (c <= '9')) || (c == xc))
		ap++;

	return(ap);
}


/* Convert numbers in ASCII. Works in concert with previous number
 * parser first phase.
 *
 * Only need to check for bad octal digits since getnum() has already
 * range-checked for decimal digits.
 */

int	ntoi(cp)
char	*cp;

{	char	*xcp, maxd, c;
	int	sum, digit, base;


	if (dflg > 2)
		printf("Ntoi: '%s'\n", cp);

	xcp = cp;
	if ((*xcp++ == '0') && (*xcp++ == 'x'))
		return(htoi(xcp));


	if (*cp == '0') {
		base = 8;
		maxd = '7';
		}
	  else {
		base = 10;
		maxd = '9';
		}

	for (sum = 0; ; (sum = ((sum * base) + digit))) {
		c = *cp++;

		if (c == 0)
			return(sum);

		if ((c < '0') || (c > maxd))
			ferr("Bad digit '%c' in octal number", c);

		digit = (c - '0');
		}
}


int	htoi(cp)
char	*cp;

{	char	c;
	int	sum, digit;

	if (dflg > 2)
		printf("Htoi: '%s'\n", cp);

	for (sum = digit = 0; ; (sum = ((sum * 16) + digit))) {
		c = *cp++;

		if (c == 0)
			return(sum);

		if ((c >= '0') && (c <= '9')) {
			digit = (c - '0');
			continue;
			}

		if ((c >= 'A') && (c <= 'F')) {
			digit = ((c - 'A') + 10);
			continue;
			}

		ferr("Bad digit '%c' in hex number", c);
		}
}



/* Various utils.
 *
 * First saves string in string heap. Needs zero-terminated string!
 */

char	*savestring(ap)
char	*ap;

{	char	*sp;

	if (dflg > 2)
		printf("Savestring: '%s'\n", ap);

	sp = lblhp;

	while ((*ap != 0) && (sp < &labels[STRHPSZ]))
		*sp++ = *ap++;

	*sp++ = 0;

	if (sp >= &labels[STRHPSZ])
		nferr("String heap overflow");


	ap = lblhp;
	lblhp = sp;
	return (ap);
}


/* Get a line, ignoring blank lines; returns EOF if no more lines, 0
 * otherwise.
 */

int	getiline(fp, fnm)
FILE	*fp;
char	*fnm;

{	char	*sp, c;

	if (dflg > 1)
		printf("getiline: ");

	for (;;) {
		c = getc(fp);

		if (c == EOF)
			return(EOF);

		if ((c == '\r') || (c == '\n')) {
			cline++;
			continue;
			}


		ibuf[0] = c;

		sp = fgets(&ibuf[1], (MAXLIN - 1), fp);
		if (sp == NULL)
			ferr("Input error");

		if (dflg > 1)
			printf("rd %d '%s'\n", cline, &ibuf[0]);

		return(0);
		}
}


/* Get a line from the config file. Discards comment lines, and
 * barfs on EOF (since this is only called when there should be
 * more stuff there).
 */

char	*getcline()

{	int	rval;

	if (dflg > 2)
		printf("getcline:\n");

	for (;;) {
		rval = getiline(cfile, cfnm);

		if (rval == EOF)
			ferr("Unexpected EOF on configuration file");

		if (dflg > 2)
			printf("rdc '%s'\n", &ibuf[0]);

		if ((ibuf[0] == ';') || (ibuf[0] == '#') || (ibuf[0] == '/')) {
			cline++;
			continue;
			}


		if (dflg > 2)
			printf(" :getcline\n");

		cline++;

		return(&ibuf[0]);
		}
}


/* Discard white space (spaces, tabs).
 */

char	*discws(cp)
char	*cp;

{	char	c;

	for (;;) {
		c = *cp;

		if ((c == ' ') || (c == '\t')) {
			cp++;
			continue;
			}

		return(cp);
		}
}



/* User info stuff.
 */

void	dumpfields()

{	flds	*fp;
	vals	*vp;
	char	lit;

	for (fp = flst; (fp != NULL); fp = fp->f_link) {
		vp = fp->f_dp;
		lit = (fp->f_lit & ~L_VAL);

		printf("Field: '%s' lo: %d nbits: %d max: 0%o",
			fp->f_nm, fp->f_lobit, fp->f_nbits, fp->f_max);
		if (fp->f_type != 0)
			printf(" type: %s", ftypes[fp->f_type]);
		if (lit != 0)
			printf(" literal: %s", ltypes[lit]);
		if ((fp->f_lit & L_VAL) != 0)
			printf(" (limited)");
		printf(" default: '%s'\n", ((vp != NULL) ? vp->v_nm : "<none>"));
		}
}


void	dumpvalues(vnm)
char	*vnm;

{	vals	*vp;
	int	all;

	all = strcmp(vnm, "all");

	for (vp = vlst; (vp != NULL); vp = vp->v_link) {
		if ((all != 0) && (strcmp(vnm, vp->v_field) != 0))
			continue;

		printf("Value: '%s' field: '%s' val: 0%o",
			vp->v_nm, vp->v_field, vp->v_val);
		if (vp->v_lit != 0)
			printf("%s", " lit: yes");
		printf("  uword: ");
		printf(uinstp, vp->v_ubits);
		printf("\n");
		}
}


/* Error handling. nferr() is used for errors not associated with
 * particular file and line (e.g. syntax errors); ferr() for those
 * that are.
 *
 * A tip of the hatly hat to DAB for the varargs stuff.
 */

void	nferr(const char *s, ...)

{	va_list ap;

	va_start(ap, s);
	vprintf(s, ap);
	va_end(ap);
	errex();
}


void	ferr(const char *s, ...)

{	va_list ap;

	printf("%s:%d: ", fnm, cline);
  	va_start(ap, s);
	vprintf(s, ap);
	va_end(ap);
	errex();
}


void	errex()

{	printf("\n");
	exit(1);
}


void	help(errstr)
char	*errstr;

{	printf("%s: uas {-d} {-u} {-f} {-v {fname}} <cfile> <ifile> <ofile> {<lfile>}\n", errstr);

	exit(1);
}