assembler.c

/*
 * Copyright (c) 2012, Brian Swetland
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are met:
 *
 *   Redistributions of source code must retain the above copyright notice, 
 *   this list of conditions and the following disclaimer.
 *
 *   Redistributions in binary form must reproduce the above copyright 
 *   notice, this list of conditions and the following disclaimer in the 
 *   documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

/* A DCPU-16 Assembler */

/* DCPU-16 Spec is Copyright 2012 Mojang */
/* http://0x10c.com/doc/dcpu-16.txt */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <getopt.h>

typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;

#define countof(a) (sizeof(a) / sizeof((a)[0]))

extern u16 *disassemble(u16 *pc, char *out);

static u16 image[65536] = { 0, };
static u8 note[65536] = { 0, };
static u16 PC = 0;
static FILE *fin;
static const char *filename = "";
static int linenumber = 0;

static char linebuffer[128] = { 0, };
static char *lineptr = linebuffer;
static int token;
static char tstring[128];
static u16 tnumber;

enum outformat {
	OUTFORMAT_PRETTY,
	OUTFORMAT_HEX,
	OUTFORMAT_BINARY,
};

void die(const char *fmt, ...) {
	va_list ap;
	fprintf(stderr,"%s:%d: ", filename, linenumber);
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fprintf(stderr,"\n");
	if (linebuffer[0])
		fprintf(stderr,"%s:%d: >> %s <<\n", filename, linenumber, linebuffer);
	exit(1);
}

struct fixup {
	struct fixup *next;
	struct label *label;
	u16 pc;
};

struct label {
	struct label *next;
	u16 pc;
	u16 defined;
	char name[1];
};

struct label *labels = 0;
struct fixup *fixups = 0;

struct label *mklabel(const char *name, u16 pc, u16 def) {
	struct label *l;
	for (l = labels; l; l = l->next) {
		if (!strcasecmp(name, l->name)) {
			if (def) {
				if (l->defined)
					die("cannot redefine label: %s", name);
				l->defined = def;
				l->pc = pc;
			}
			return l;
		}
	}
	l = malloc(sizeof(*l) + strlen(name));
	l->defined = def;
	l->pc = pc;
	strcpy(l->name, name);
	l->next = labels;
	labels = l;
	return l;
}

void use_label(const char *name, u16 pc) {
	struct label *l = mklabel(name, 0, 0);
	if (l->defined) {
		image[pc] = l->pc;
	} else {
		struct fixup *f = malloc(sizeof(*f));
		f->next = fixups;
		f->pc = pc;
		f->label = l;
		fixups = f;
	}	
}

void set_label(const char *name, u16 pc) {
	mklabel(name, pc, 1);
}

void resolve_fixups(void) {
	struct fixup *f;
	for (f = fixups; f; f = f->next) {
		if (f->label->defined) {
			image[f->pc] = f->label->pc;
		} else {
			die("undefined reference to '%s' at 0x%04x", f->label->name, f->pc);
		}
	}
}

enum tokens {
	tA, tB, tC, tX, tY, tZ, tI, tJ,
	tR0, tR1, tR2, tR3, tR4, tR5, tR6, tR7,
	tSET, tADD, tSUB, tMUL, tDIV, tMOD, tSHL,
	tSHR, tAND, tBOR, tXOR, tIFE, tIFN, tIFG, tIFB,
	tJSR,
	tPOP, tPEEK, tPUSH, tSP, tPC, tO,
	tJMP, tMOV, tNOP,
	tDATA, tDAT, tDW, tWORD,
	tCOMMA, tOBRACK, tCBRACK, tCOLON, tPLUS,
	tSTRING, tQSTRING, tNUMBER, tEOF,
};
static const char *tnames[] = {
	"A", "B", "C", "X", "Y", "Z", "I", "J",
	"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
	"SET", "ADD", "SUB", "MUL", "DIV", "MOD", "SHL",
	"SHR", "AND", "BOR", "XOR", "IFE", "IFN", "IFG", "IFB",
	"JSR",
	"POP", "PEEK", "PUSH", "SP", "PC", "O",
	"JMP", "MOV", "NOP",
	"DATA", "DAT", "DW", "WORD",
	",", "[", "]", ":", "+",
	"<STRING>", "<QUOTED-STRING>", "<NUMBER>", "<EOF>",
};
#define LASTKEYWORD	tWORD

int _next(void) {
	char c, *x;
nextline:
	if (!*lineptr) {
		if (feof(fin)) return tEOF;
		if (fgets(linebuffer, 128, fin) == 0) return tEOF;
		lineptr = linebuffer;
		linenumber++;
	}
	while (*lineptr <= ' ') {
		if (*lineptr == 0) goto nextline;
		lineptr++;
	}
	switch ((c = *lineptr++)) {
	case ',': return tCOMMA;
	case '+': return tPLUS;
	case '[': return tOBRACK;
	case ']': return tCBRACK;
	case ':': return tCOLON;
	case '/': case ';': case '#': *lineptr = 0; goto nextline;
	case '"':
		x = tstring;
		for (;;) {
			switch((c = *lineptr++)) {
			case 0:
				die("unterminated string");
			case '"':
				*x = 0;
				return tQSTRING;
			case '\\':
				switch((c = *lineptr++)) {
				case 'n': *x++ = '\n'; break;
				case 't': *x++ = '\t'; break;
				case 'r': *x++ = '\r'; break;
				default:
					*x++ = c; break;
				}
				break;
			default:
				*x++ = c;
			}
		}
	default:
		if (isdigit(c) || ((c == '-') && isdigit(*lineptr))) {
			tnumber = strtoul(lineptr-1, &lineptr, 0);
			return tNUMBER;
		}
		if (isalpha(c) || c == '_') {
			int n;
			x = tstring;
			lineptr--;
			while (isalnum(*lineptr) || *lineptr == '_')
				*x++ = tolower(*lineptr++);
			*x = 0;
			for (n = 0; n <= LASTKEYWORD; n++)
				if (!strcasecmp(tnames[n], tstring))
					return n;
			return tSTRING;
		}
		if ((c == '\'') && (*(lineptr+1) == '\'')) {
			tnumber = (u16) (*lineptr++);
			lineptr++;
			return tNUMBER;
		}
		die("illegal character '%c'", c);
		return tEOF;
	}
}

int next(void) {
	token = _next();

	//fprintf(stderr,"%3d %s\n", token, tnames[token]);
	return token;
}

void expect(int t) {
	if (next() != t)
		die("expecting %s, found %s", tnames[t], tnames[token]);
}

void assemble_imm_or_label(void) {
	do {
		next();
		if (token == tNUMBER) {
			note[PC] = 'd';
			image[PC++] = tnumber;
		} else if (token == tSTRING) {
			note[PC] = 'd';
			image[PC] = 0;
			use_label(tstring, PC++);
		} else if (token == tQSTRING) {
			char *x = tstring;
			while (*x) {
				note[PC] = 'd';
				image[PC++] = *x++;
			}
		} else {
			die("expected number or label");
		}
		next();
	} while (token == tCOMMA);
}

int assemble_operand(void) {
	u16 n;

	next();
	switch (token) {
	case tA: case tB: case tC: case tX:
	case tY: case tZ: case tI: case tJ:
		return token & 7;
	case tR0: case tR1: case tR2: case tR3:
	case tR4: case tR5: case tR6: case tR7:
		return (token - 8) & 7;
	case tPOP: return 0x18;
	case tPEEK: return 0x19;
	case tPUSH: return 0x1a;
	case tSP: return 0x1b;
	case tPC: return 0x1c;
	case tO: return 0x1d;
	case tNUMBER:
		if (tnumber < 0x20)
			return tnumber + 0x20;
		image[PC++] = tnumber;
		return 0x1f;
	case tSTRING:
		image[PC] = 0;
		use_label(tstring, PC++);
		return 0x1f;
	default:
		if (token != tOBRACK)
			die("expected [");
	}

	/* we must have seen a '[' */
	next();
	switch (token) {
	case tA: case tB: case tC: case tX:
	case tY: case tZ: case tI: case tJ:
		n = token & 7;
		next();
		if (token == tCBRACK)
			return 0x08 | n;
		if ((token != tCOMMA) && (token != tPLUS))
			die("expected , or +");
		next();
		if (token == tSTRING) {
			use_label(tstring, PC++);
		} else if (token == tNUMBER) {
			image[PC++] = tnumber;
		} else {
			die("expected immediate value");
		}
		expect(tCBRACK);
		return 0x10 | n;
	case tSTRING:
		use_label(tstring, PC++);
	case tNUMBER:
		if (token == tNUMBER)
			image[PC++] = tnumber;

		next();
		if (token == tCBRACK) {
			return 0x1e;
		} else if ((token == tCOMMA) || (token == tPLUS)) {
			next();
			if ((token >= tA) && (token <= tJ)) {
				n = 0x10 | (token & 7);
			} else {
				die("invalid register");
			}
			expect(tCBRACK);
			return n;
		} else {
			die("invalid operand");
		}
	default:
		die("invalid operand");
	}
	return 0;
}

void assemble_binop(void) {
	u16 pc = PC++;
	int a, b;
	int op = token;

	/* alias for push x, pop x */
	if (token == tPUSH) {
		op = tSET;
		a = 0x1a; // push
		b = assemble_operand();
	} else if (token == tPOP) {
		op = tSET;
		a = assemble_operand();
		b = 0x18; // pop
	} else if (token == tNOP) {
		// SET 0,0
		op = tSET;
		a = 0x20;
		b = 0x20;
	} else {
		a = assemble_operand();
		expect(tCOMMA);
		b = assemble_operand();
	}

	/* token to opcode */
	op -= (tSET - 1);
	image[pc] = op | (a << 4) | (b << 10);
}

void assemble_jump(void) {
	u16 pc = PC++;
	image[pc] = 0x01c1 | (assemble_operand() << 10);
}

void assemble(const char *fn) {
	u16 pc, n;
	fin = fopen(fn, "r");
	filename = fn;
	linenumber = 0;
	if (!fin) die("cannot read file");

	for (;;) {
		next();
again:
		switch (token) {
		case tEOF:
			goto done;
		case tSTRING:
			expect(tCOLON);
			set_label(tstring, PC);
			continue;
		case tCOLON:
			expect(tSTRING);
			set_label(tstring, PC);
			continue;
		case tWORD: case tDAT: case tDATA: case tDW:
			assemble_imm_or_label();
			goto again;
		case tJMP: // alias for SET PC, ...
			assemble_jump();
			continue;
		case tMOV: // alias for SET
			token = tSET;
		case tSET: case tADD: case tSUB: case tMUL:
		case tDIV: case tMOD: case tSHL: case tSHR:
		case tAND: case tBOR: case tXOR: case tIFE:
		case tIFN: case tIFG: case tIFB:
		case tPUSH: case tPOP: case tNOP:
			assemble_binop();
			continue;
		case tJSR:
			pc = PC++;
			n = assemble_operand();
			image[pc] = (n << 10) | 0x0010;
			continue;
		default:
			die("unexpected: %s", tnames[token]);
		}
	}
done:
	fclose(fin);
}

void emit(const char *fn, enum outformat format) {
	FILE *fp;
	u16 *pc = image;
	u16 *end = image + PC;
	u16 *dis = pc;
	filename = fn;
	linenumber = 0;

	if (!strcmp(fn, "-")) {
		fp = stdout;
	} else {
		fp = fopen(fn, "w");
	}
	if (!fp) die("cannot write file");

	while (pc < end) {
		if (format == OUTFORMAT_PRETTY) {
			if (note[pc-image] == 'd') {
				fprintf(fp, "%04x\n", *pc);
				dis = pc + 1;
			} else if (pc == dis) {
				char out[128];
				dis = disassemble(pc, out);
				fprintf(fp, "%04x\t%04x:\t%s\n", *pc, (unsigned)(pc-image), out);
			} else {
				fprintf(fp, "%04x\n", *pc);
			}
		} else if (format == OUTFORMAT_HEX) {
			fprintf(fp, "%04x\n", *pc);
		} else if (format == OUTFORMAT_BINARY) {
			/* XXX handle host endian */
			fwrite(pc, sizeof(*pc), 1, fp);
		}
		pc++;
	}
	if (fp != stdout)
		fclose(fp);
}

static void usage(int argc, char **argv)
{
	fprintf(stderr, "usage: %s [-o output] [-O output_format] <input file(s)>\n", argv[0]);
	fprintf(stderr, "\toutput_format can be one of: pretty, hex, binary\n");
}

int main(int argc, char **argv) {
	const char *outfn = "out.hex";
	enum outformat oformat = OUTFORMAT_PRETTY;

	for (;;) {
		int c;
		int option_index = 0;

		static struct option long_options[] = {
			{"help", 0, 0, 'h'},
			{"output", 1, 0, 'o'},
			{"outformat", 1, 0, 'O'},
			{0, 0, 0, 0},
		};

		c = getopt_long(argc, argv, "ho:O:", long_options, &option_index);
		if (c == -1)
			break;

		switch (c) {
			case 'h':
				usage(argc, argv);
				return 0;
			case 'o':
				outfn = optarg;
				break;
			case 'O':
				if (!strcasecmp(optarg, "binary")) {
					oformat = OUTFORMAT_BINARY;
				} else if (!strcasecmp(optarg, "hex")) {
					oformat = OUTFORMAT_HEX;
				} else if (!strcasecmp(optarg, "pretty")) {
					oformat = OUTFORMAT_PRETTY;
				} else {
					usage(argc, argv);
					return 1;
				}
				break;
			default:
				usage(argc, argv);
				return 1;
		}
	}

	if (argc - optind < 1) {
		usage(argc, argv);
		return 1;
	}

	argc -= optind;
	argv += optind;

	while (argc >= 1) {
		assemble(argv[0]);
		argv++;
		argc--;
	}

	if (PC != 0) {
		linebuffer[0] = 0;
		resolve_fixups();
		emit(outfn, oformat);
	}
	return 0;
}