#include <stdio.h>
#include <string.h>

/* Assemble simple source syntax into mymips:
	<label>: <arith op> <field>, <field>, <field>
	<label>: <memory op> <field>, <field>(<field>)
	<label>: <conditional branch op> <field>, <field>
	<label>: <branch op> <field>
where "<label>:" is optional, fields are separated by whitespace or commas,
and "#" ignores the rest of the line.
For <memory op> instructions, (<field>3) may be omitted;  if present, the
parentheses are required, and the register number fills the "srca" field of
the compiled instruction.  <field>2 may begin with "$" to use the register
form of the instruction;  otherwise, the immediate form is compiled.
For <arith op>s, if <field>3 begins with "$", a register form of
instruction is complied; otherwise, an immediate form.  The pseudo-ops
supported are:
	.asciiz	<string>
	.word	<field>
	.end	<field>
	.space	<field>
<string> is a sequence of characters delimited by whitespace, '(', ')', and
','.  Use \n, \t, \ , and \0 to represent NEWLINE, TAB, SPACE, and NULL,
and use \, \(, and \) to represent the unadorned characters within <string>.
*/
/* Register usage "agreements" and names are as follows:
#	Numeric Symbolic Usage
0	$0	$zero	Holds zero
1	$1	$v0	Subroutine return value
2	$2	$a0	Subroutine argument 1, not preserved by subroutines
3	$3	$a1	Subroutine argument 2, not preserved by subroutines
4	$4	$t0	Temp, not preserved by subroutines
5	$5	$t1	Temp, not preserved by subroutines
6	$6	$t2	Temp, not preserved by subroutines
7	$7	$s0	Temp, preserved by subroutines
8	$8	$s1	Temp, preserved by subroutines
9	$9	$s2	Temp, preserved by subroutines
10	$10	$s3	Temp, preserved by subroutines
11	$11	$s4	Temp, preserved by subroutines
12	$12	$s5	Temp, preserved by subroutines
13	$13	$s6	Temp, preserved by subroutines
14	$14	$sp	Stack pointer, restored by subroutines
15	$15	$ra	Return address, restored by subroutines
*/
#define SIZE 1019
#define LINES 1000
char str[10000], *tbl[SIZE], *strfree;
int type[SIZE],val[SIZE];
int oph[LINES];
char *lines[LINES][6];
int ln;
char tr[256];

void err(char *m, char *s) {
	int i;

	fprintf(stderr,"%s ",m);
	if (*s) fprintf(stderr,"'%s' ",s);
	fprintf(stderr,"at line %d:", ln+1);
	for (i=0; (i<5)&&lines[ln][i] ; i++) fprintf(stderr," %s",lines[ln][i]);
	fprintf(stderr,"\n");
	exit(1);
	}

int hash(char *p) {
	int k=0;
	while (*p) k = (k<<2) ^ *p++;
	return k;
	}

int look(char *p) {
	unsigned int h=hash(p);
	unsigned int h2 = (h%(SIZE-3))+1;

	h = h % SIZE;
	while (tbl[h] && strcmp(tbl[h],p))
		h = (h+=h2)<SIZE? h : h-SIZE;
	return h;
	}

void def(char *p, int ty, int v) {
	int lc=look(p);

	if (tbl[lc]) err("Previously defined symbol", p);
	tbl[lc]=p;
	type[lc]=ty;
	val[lc]=v;
	}

/* Max fields in source line, +1:
		 il as en wo sp ar ba bl me ""  */
int fields[23] = {2, 3, 3, 3, 3, 5, 3, 4, 5, 2 };

void init() {
	int i;

	for (i=0; i<256; i++) tr[i]=i;
	tr['\n']=' ';
	tr['n']='\n';
	tr['t']='\t';
	tr['0']='\0';

	def("",9,0);
	def(".asciiz",1,0);
	def(".end",2,0);
	def(".word",3,0);
	def(".space",4,0);
/*
Op-code   Name          Definition
0         syscall       Action(a)                                   See table
1         Load          R[d] = MEMORY[e() + R[a]] (word); PC=PC+4
2         Load Byte     R[d] = MEMORY[e() + R[a]] (byte); PC=PC+4
3         Store         MEMORY[e() + R[a]] = R[d] (word); PC=PC+4
4         Store Byte    MEMORY[e() + R[a]] = R[d] (byte); PC=PC+4
5         Add           R[d] = R[a] + e(); PC=PC+4
6         Subtract      R[d] = R[a] - e(); PC=PC+4
7         Shift         R[d] = R[a] << e(); PC=PC+4                 See below
8         And           R[d] = R[a] & eu(); PC=PC+4
9         Or            R[d] = R[a] | eu(); PC=PC+4
10        Xor           R[d] = R[a] ^ eu(); PC=PC+4
14        Branch        if (Op(d,R[a])) PC = e(); else PC=PC+4
15        Branch+link   R[15] = PC+4; PC = e()
*/
	def("syscall",6,0);	/* one operand to imm/srcb */
	def("lw",8,1);		/* memory reference */
	def("lb",8,2);		/*   lw $d,loc($a) or lw $d,$b,$a */
	def("sw",8,3);
	def("sb",8,4);
	def("add",5,5);		/* arith */
	def("sub",5,6);		/*   add $d,$a,$b or add $d,$a,imm */
	def("sla",5,7);
	def("and",5,8);
	def("or",5,9);
	def("xor",5,10);
	def("bal",6,0xF0);	/* bal target */
/*
Op(d,x) is defined by the following table:

d   Op(d,x)
0   1         (always branch)
1   x<0
2   x==0
3   x<=0
4   x>0
5   x!=0
6   x>=0
7   0         (never branch = no-op)
*/
	def("b",6,0xE0);	/* b target */
	def("bltz",7,0xE1);	/* bltz $a,target */
	def("beqz",7,0xE2);
	def("blez",7,0xE3);
	def("bgtz",7,0xE4);
	def("bnez",7,0xE5);
	def("bgez",7,0xE6);
	def("nop",6,0xE7);	/* nop imm */

	def("$0",0,0);
	def("$zero",0,0);
	def("$1",0,1);
	def("$v0",0,1);
	def("$2",0,2);
	def("$a0",0,2);
	def("$3",0,3);
	def("$a1",0,3);
	def("$4",0,4);
	def("$t0",0,4);
	def("$5",0,5);
	def("$t1",0,5);
	def("$6",0,6);
	def("$t2",0,6);
	def("$7",0,7);
	def("$s0",0,7);
	def("$8",0,8);
	def("$s1",0,8);
	def("$9",0,9);
	def("$s2",0,9);
	def("$10",0,10);
	def("$s3",0,10);
	def("$11",0,11);
	def("$s4",0,11);
	def("$12",0,12);
	def("$s5",0,12);
	def("$13",0,13);
	def("$s6",0,13);
	def("$14",0,14);
	def("$sp",0,14);
	def("$15",0,15);
	def("$ra",0,15);
	}

int buf[256];

int eval(char *p) {
	char c=*p;
	int ii=0;

	if (isalpha(c)||(c=='$')) {
		ii = look(p);
		if (!tbl[ii] || type[ii]) err("Undefined or misused symbol", p);
		return val[ii];
		}
	sscanf(p,"%i",&ii);
	return ii;
	}

int procimm(char *p) {
	int res;

	if (p[0]=='$') 
		res = (eval(p) & 0xf);
	else	res = (1<<19) | (eval(p) & 0x7ffff) ;
	return res;
	}

void pass2() {
	int i,j,k;
	int res,isndx;
	char *t;

	ln=0;
	while (1) {
		j=oph[ln];	/* opcode h value for line i */
		switch (type[j]) {
	case 1:	/* .ascii */
		strncpy((char *)buf,lines[ln][2],256);
		k = strlen((char *)buf);
		k = (k>>2)+1;
		for (i=0; i<k; i++) printf("%08X\n",buf[i]);
		break;
	case 2:	/* .end */
		printf("-1 %05X\n", eval(lines[ln][2]));
		return;
	case 3: /* .word */
		printf("%08X\n", eval(lines[ln][2]));
		break;
	case 4: /* .space */
		k=eval(lines[ln][2]);
		k = ((k+3)>>2);
		for (i=0; i<k; i++) printf("%08X\n",0);
		break;
	case 5:	/* op $dest, $a, { $b | imm }  */
		res = (val[j]<<28) |
			((eval(lines[ln][2]) & 0xf) << 24) |
			((eval(lines[ln][3]) & 0xf) << 20) |
			procimm(lines[ln][4]);
		printf("%08X\n", res);
		break;
	case 6: /* bal imm OR bal $b */
		res = (val[j]<<24) | procimm(lines[ln][2]);
		printf("%08X\n", res);
		break;
	case 7: /* bltz $a imm OR bltz $a $b  ($d value in val[]) */
		res = (val[j]<<24) | 
			((eval(lines[ln][2]) & 0xf) << 20) |
			procimm(lines[ln][3]);
		printf("%08X\n", res);
		break;
	case 8: /* lw $d loc OR lw $d loc($a) OR lw $d $b($a) */
		res = (val[j]<<28) | 
			((eval(lines[ln][2]) & 0xf) << 24) |
			procimm(lines[ln][3]);
		t = lines[ln][4];
		isndx = (t[0]=='(') && (t[1]=='$');
		if (!isndx && (lines[ln][3][0]=='$'))
			err("Memory address format illegal", lines[ln][3] );
		if (isndx) res |= ((eval(t+1) & 0xf) << 20);
		printf("%08X\n", res);
		break;
	case 9: /* blank line */
		break;
	default:
		err("Undefined opcode type", "");
		}
	ln++;
	}
	}

/* Looks as if I can read entire input, 1 char at a time, parse it into
an array indexed by line and field.  Use a switch on characters, singling
out specials, and treating everything else as default.  The second pass
would go over this parsed stuff, one line at a time, emitting hex.  */

int main() {
	char c;
	int fl,s,p,i;
	int loc=0;

	init();
	strfree = str;
	p=ln=fl=s=0;
	lines[ln][fl]=strfree;

	while((c=getchar())!=EOF) {
	switch (c) {
case ' ': case '\t': case ')':
	if (s) break;
case ',':
	*strfree++='\0';
split:
	s=1;
	fl++;
	if (fl>5) err("Too many fields", "");
	lines[ln][fl]=strfree;
	break;
case '\\':
	c = tr[getchar()];
default:
	if (!isalnum(c) && (fl==0)) err("Illegal character", lines[ln][0] );
	*strfree++ = c;
	s = 0;
	break;
case '#':
	while ((c=getchar())!='\n')if (c==EOF) break;
case '\n':
	if (!s) {
		*strfree++='\0';
		fl++;
		}
	for (i=fl; i<5; i++) lines[ln][i]="";
	oph[ln]=look(lines[ln][1]);
	if ((type[oph[ln]]>0)&&(fl>fields[type[oph[ln]]])) err("Too many fields",
	"");

	switch (type[oph[ln]]) {
case 0:
	err("Undefined Opcode", lines[ln][1] );
	break;
case 1:	/* .ascii */
	loc += ((strlen(lines[ln][2])>>2) + 1)<<2;
	break;
case 2:	/* end */
	pass2();
	return 0;
case 4:	/* space */
	loc += ((eval(lines[ln][2])+3>>2))<<2;
	break;
case 9: /* blank line */
	break;
default:
	loc += 4;
	}

	ln++; s=p=fl=0;
	lines[ln][fl]=strfree;
	break;
case ':':
	*strfree++='\0';
	if (fl>0) err("Must place label definition first:", lines[ln][fl]);
	if(!isalpha(lines[ln][0][0])) err("Badly formed label", lines[ln][0] );
	def(lines[ln][0],0,loc);
	goto split;
case '(':
	if (!s) {
		*strfree++='\0';
		fl++;
		if (fl>4) err("Too many fields", "");
		lines[ln][fl]=strfree;
		}
	*strfree++=c;
	s=1;
	break;
	};
	}
	err("unexpected EOF", "");
	}