xasm/xasm.d

// xasm 3.1.0 by Piotr Fusik <fox@scene.pl>
// http://xasm.atari.org
// Can be compiled with DMD v2.073.

// Poetic License:
//
// This work 'as-is' we provide.
// No warranty express or implied.
// We've done our best,
// to debug and test.
// Liability for damages denied.
//
// Permission is granted hereby,
// to copy, share, and modify.
// Use as is fit,
// free or for profit.
// These rights, on this notice, rely.

import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.path;
import std.stdio;

version (Windows) {
	import core.sys.windows.windows;
}

int readByte(File *file) {
	char c;
	if (file.readf("%c", &c) != 1)
		return -1;
	return c;
}

const string TITLE = "xasm 3.1.0";

string sourceFilename = null;
bool[26] options;
string[26] optionParameters;
string[] commandLineDefinitions = null;
string makeTarget;
string[] makeSources = null;

int exitCode = 0;

int totalLines;

bool pass2 = false;

bool optionFill; // opt f
bool option5200; // opt g
bool optionHeaders; // opt h
bool optionListing; // opt l
bool optionObject; // opt o
bool optionUnusedLabels; // opt u

string currentFilename;
int lineNo;
int includeLevel = 0;
string line;
int column;

bool foundEnd;

class AssemblyError : Exception {
	this(string msg) {
		super(msg);
	}
}

class Label {
	int value;
	bool unused = true;
	bool unknownInPass1 = false;
	bool passed = false;

	this(int value) {
		this.value = value;
	}
}

Label[string] labelTable;
Label currentLabel;

alias int function(int a, int b) OperatorFunction;

bool inOpcode = false;

struct ValOp {
	int value;
	OperatorFunction func;
	int priority;
}

ValOp[] valOpStack;

int value;
bool unknownInPass1;

enum AddrMode {
	ACCUMULATOR = 0,
	IMMEDIATE = 1,
	ABSOLUTE = 2,
	ZEROPAGE = 3,
	ABSOLUTE_X = 4,
	ZEROPAGE_X = 5,
	ABSOLUTE_Y = 6,
	ZEROPAGE_Y = 7,
	INDIRECT_X = 8,
	INDIRECT_Y = 9,
	INDIRECT = 10,
	ABS_OR_ZP = 11, // temporarily used in readAddrMode
	STANDARD_MASK = 15,
	INCREMENT = 0x20,
	DECREMENT = 0x30,
	ZERO = 0x40
}

AddrMode addrMode;

enum OrgModifier {
	NONE,
	FORCE_HEADER,
	FORCE_FFFF,
	RELOCATE
}

int origin = -1;
int loadOrigin;
int loadingOrigin;
ushort[] blockEnds;
int blockIndex;

bool repeating; // line
int repeatCounter; // line

bool instructionBegin;
bool pairing;

bool willSkip;
bool skipping;
ushort[] skipOffsets;
int skipOffsetsIndex = 0;

int repeatOffset; // instruction repeat

bool wereManyInstructions;

alias void function(int move) MoveFunction;

int value1;
AddrMode addrMode1;
int value2;
AddrMode addrMode2;

struct IfContext {
	bool condition;
	bool wasElse;
	bool aConditionMatched;
}

IfContext[] ifContexts;

File listingStream;
char[32] listingLine;
int listingColumn;
string lastListedFilename = null;

File objectStream;

int objectBytes = 0;

bool getOption(char letter) {
	assert(letter >= 'a' && letter <= 'z');
	return options[letter - 'a'];
}

void warning(string msg, bool error = false) {
	stdout.flush();
	version (Windows) {
		HANDLE stderrHandle = GetStdHandle(STD_ERROR_HANDLE);
		CONSOLE_SCREEN_BUFFER_INFO csbi;
		GetConsoleScreenBufferInfo(stderrHandle, &csbi);
		SetConsoleTextAttribute(stderrHandle, (csbi.wAttributes & ~0xf) | (error ? 12 : 14));
		scope (exit) SetConsoleTextAttribute(stderrHandle, csbi.wAttributes);
	}
	if (line !is null)
		stderr.writeln(line);
	stderr.writefln("%s (%d) %s: %s", currentFilename, lineNo, error ? "ERROR" : "WARNING", msg);
	exitCode = 1;
}

void illegalCharacter() {
	throw new AssemblyError("Illegal character");
}

bool eol() {
	return column >= line.length;
}

char readChar() {
	if (eol())
		throw new AssemblyError("Unexpected end of line");
	return line[column++];
}

int readDigit(int base) {
	if (eol()) return -1;
	int r = line[column];
	if (r >= '0' && r <= '9') {
		r -= '0';
	} else {
		r &= 0xdf;
		if (r >= 'A' && r <= 'Z')
			r -= 'A' - 10;
		else
			return -1;
	}
	if (r < base) {
		column++;
		return r;
	}
	return -1;
}

int readNumber(int base) {
	long r = readDigit(base);
	if (r < 0)
		illegalCharacter();
	do {
		int d = readDigit(base);
		if (d < 0)
			return cast(int) r;
		r = r * base + d;
	} while (r <= 0x7fffffff);
	throw new AssemblyError("Number too big");
}

void readSpaces() {
	switch (readChar()) {
	case '\t':
	case ' ':
		break;
	default:
		throw new AssemblyError("Space expected");
	}
	while (!eol()) {
		switch (line[column]) {
		case '\t':
		case ' ':
			column++;
			break;
		default:
			return;
		}
	}
}

string readLabel() {
	string label;
	while (!eol()) {
		char c = line[column++];
		if (c >= '0' && c <= '9' || c == '_') {
			label ~= c;
			continue;
		}
		c &= 0xdf;
		if (c >= 'A' && c <= 'Z') {
			label ~= c;
			continue;
		}
		column--;
		break;
	}
	return label >= "A" ? label : null;
}

void readComma() {
	if (readChar() != ',')
		throw new AssemblyError("Bad or missing function parameter");
}

string readInstruction() {
	string r;
	for (int i = 0; i < 3; i++) {
		char c = readChar() & 0xdf;
		if (c < 'A' || c > 'Z')
			throw new AssemblyError("Illegal instruction");
		r ~= c;
	}
	return r;
}

string readFunction() {
	if (column + 5 >= line.length) return null;
	if (line[column + 3] != '(') return null;
	string r;
	for (int i = 0; i < 3; i++) {
		char c = line[column + i] & 0xdf;
		if (c < 'A' || c > 'Z') return null;
		r ~= c;
	}
	column += 4;
	return r;
}

string readFilename() {
	readSpaces();
	char delimiter = readChar();
	switch (delimiter) {
	case '"':
	case '\'':
		string filename;
		char c;
		while ((c = readChar()) != delimiter)
			filename ~= c;
		return filename;
	default:
		illegalCharacter();
	}
	assert(0);
}

void readStringChar(char c) {
	if (readChar() != c)
		throw new AssemblyError("String error");
}

ubyte[] readString() {
	if (eol()) return null;
	char delimiter = readChar();
	switch (delimiter) {
	case '"':
	case '\'':
		ubyte[] r;
		for (;;) {
			char c = readChar();
			if (c == delimiter) {
				if (eol()) return r;
				if (line[column] != delimiter) {
					if (line[column] == '*') {
						column++;
						foreach (ref ubyte b; r)
							b ^= 0x80;
					}
					return r;
				}
				column++;
			}
			r ~= cast(ubyte) c;
		}
	default:
		column--;
		return null;
	}
}

void checkNoExtraCharacters() {
	if (eol()) return;
	switch (line[column]) {
	case '\t':
	case ' ':
		return;
	default:
		throw new AssemblyError("Extra characters on line");
	}
}

void checkOriginDefined() {
	if (origin < 0)
		throw new AssemblyError("No ORG specified");
}

int operatorPlus(int a, int b) {
	return b;
}

int operatorMinus(int a, int b) {
	return -b;
}

int operatorLow(int a, int b) {
	return b & 0xff;
}

int operatorHigh(int a, int b) {
	return (b >> 8) & 0xff;
}

int operatorLogicalNot(int a, int b) {
	return !b;
}

int operatorBitwiseNot(int a, int b) {
	return ~b;
}

int operatorAdd(int a, int b) {
	long r = cast(long) a + b;
	if (r < -0x80000000L || r > 0x7fffffffL)
		throw new AssemblyError("Arithmetic overflow");
	return a + b;
}

int operatorSubtract(int a, int b) {
	long r = cast(long) a - b;
	if (r < -0x80000000L || r > 0x7fffffffL)
		throw new AssemblyError("Arithmetic overflow");
	return a - b;
}

int operatorMultiply(int a, int b) {
	long r = cast(long) a * b;
	if (r < -0x80000000L || r > 0x7fffffffL)
		throw new AssemblyError("Arithmetic overflow");
	return a * b;
}

int operatorDivide(int a, int b) {
	if (b == 0)
		throw new AssemblyError("Divide by zero");
	return a / b;
}

int operatorModulus(int a, int b) {
	if (b == 0)
		throw new AssemblyError("Divide by zero");
	return a % b;
}

int operatorAnd(int a, int b) {
	return a & b;
}

int operatorOr(int a, int b) {
	return a | b;
}

int operatorXor(int a, int b) {
	return a ^ b;
}

int operatorEqual(int a, int b) {
	return a == b;
}

int operatorNotEqual(int a, int b) {
	return a != b;
}

int operatorLess(int a, int b) {
	return a < b;
}

int operatorGreater(int a, int b) {
	return a > b;
}

int operatorLessEqual(int a, int b) {
	return a <= b;
}

int operatorGreaterEqual(int a, int b) {
	return a >= b;
}

int operatorShiftLeft(int a, int b) {
	if (b < 0)
		return operatorShiftRight(a, -b);
	if (a != 0 && b >= 32)
		throw new AssemblyError("Arithmetic overflow");
	long r = cast(long) a << b;
	if (r & 0xffffffff00000000L)
		throw new AssemblyError("Arithmetic overflow");
	return a << b;
}

int operatorShiftRight(int a, int b) {
	if (b < 0)
		return operatorShiftLeft(a, -b);
	if (b >= 32)
		b = 31;
	return a >> b;
}

int operatorLogicalAnd(int a, int b) {
	return a && b;
}

int operatorLogicalOr(int a, int b) {
	return a || b;
}

void pushValOp(int value, OperatorFunction func, int priority) {
	ValOp valOp;
	valOp.value = value;
	valOp.func = func;
	valOp.priority = priority;
	valOpStack ~= valOp;
}

void readValue() {
	assert(valOpStack.length == 0);
	unknownInPass1 = false;
	int priority = 0;
	do {
		int operand;
		char c = readChar();
		switch (c) {
		case '[':
			priority += 10;
			continue;
		case '+':
			pushValOp(0, &operatorPlus, priority + 8);
			continue;
		case '-':
			pushValOp(0, &operatorMinus, priority + 8);
			continue;
		case '<':
			pushValOp(0, &operatorLow, priority + 8);
			continue;
		case '>':
			pushValOp(0, &operatorHigh, priority + 8);
			continue;
		case '!':
			pushValOp(0, &operatorLogicalNot, priority + 4);
			continue;
		case '~':
			pushValOp(0, &operatorBitwiseNot, priority + 8);
			continue;
		case '(':
			throw new AssemblyError("Use square brackets instead");
		case '*':
			checkOriginDefined();
			operand = origin;
			break;
		case '#':
			if (!repeating)
				throw new AssemblyError("'#' is allowed only in repeated lines");
			operand = repeatCounter;
			break;
		case '\'':
		case '"':
			operand = readChar();
			if (operand == c)
				readStringChar(c);
			readStringChar(c);
			if (!eol() && line[column] == '*') {
				column++;
				operand ^= 0x80;
			}
			break;
		case '^':
			switch (readChar()) {
			case '0':
				operand = option5200 ? 0xc000 : 0xd000;
				break;
			case '1':
				operand = option5200 ? 0xc010 : 0xd010;
				break;
			case '2':
				operand = option5200 ? 0xe800 : 0xd200;
				break;
			case '3':
				if (option5200)
					throw new AssemblyError("There's no PIA chip in Atari 5200");
				operand = 0xd300;
				break;
			case '4':
				operand = 0xd400;
				break;
			default:
				illegalCharacter();
			}
			int d = readDigit(16);
			if (d < 0)
				illegalCharacter();
			operand += d;
			break;
		case '{':
			if (inOpcode)
				throw new AssemblyError("Nested opcodes not supported");
			ValOp[] savedValOpStack = valOpStack;
			AddrMode savedAddrMode = addrMode;
			bool savedUnknownInPass1 = unknownInPass1;
			bool savedInstructionBegin = instructionBegin;
			valOpStack.length = 0;
			inOpcode = true;
			assemblyInstruction(readInstruction());
			if (readChar() != '}')
				throw new AssemblyError("Missing '}'");
			assert(!instructionBegin);
			inOpcode = false;
			valOpStack = savedValOpStack;
			addrMode = savedAddrMode;
			unknownInPass1 = savedUnknownInPass1;
			instructionBegin = savedInstructionBegin;
			operand = value;
			break;
		case '$':
			operand = readNumber(16);
			break;
		case '%':
			operand = readNumber(2);
			break;
		default:
			column--;
			if (c >= '0' && c <= '9') {
				operand = readNumber(10);
				break;
			}
			string label = readLabel();
			if (label is null)
				illegalCharacter();
			if (label in labelTable) {
				Label l = labelTable[label];
				operand = l.value;
				l.unused = false;
				if (pass2) {
					if (l.passed) {
						if (l.unknownInPass1)
							unknownInPass1 = true;
					} else {
						if (l.unknownInPass1)
							throw new AssemblyError("Illegal forward reference");
						unknownInPass1 = true;
					}
				} else {
					if (l.unknownInPass1)
						unknownInPass1 = true;
				}
			} else {
				if (pass2)
					throw new AssemblyError("Undeclared label: " ~ label);
				unknownInPass1 = true;
			}
			break;
		}
		while (!eol() && line[column] == ']') {
			column++;
			priority -= 10;
			if (priority < 0)
				throw new AssemblyError("Unmatched bracket");
		}
		if (eol()) {
			if (priority != 0)
				throw new AssemblyError("Unmatched bracket");
			pushValOp(operand, &operatorPlus, 1);
		} else {
			switch (line[column++]) {
			case '+':
				pushValOp(operand, &operatorAdd, priority + 6);
				break;
			case '-':
				pushValOp(operand, &operatorSubtract, priority + 6);
				break;
			case '*':
				pushValOp(operand, &operatorMultiply, priority + 7);
				break;
			case '/':
				pushValOp(operand, &operatorDivide, priority + 7);
				break;
			case '%':
				pushValOp(operand, &operatorModulus, priority + 7);
				break;
			case '<':
				switch (readChar()) {
				case '<':
					pushValOp(operand, &operatorShiftLeft, priority + 7);
					break;
				case '=':
					pushValOp(operand, &operatorLessEqual, priority + 5);
					break;
				case '>':
					pushValOp(operand, &operatorNotEqual, priority + 5);
					break;
				default:
					column--;
					pushValOp(operand, &operatorLess, priority + 5);
					break;
				}
				break;
			case '=':
				switch (readChar()) {
				default:
					column--;
					goto case '=';
				case '=':
					pushValOp(operand, &operatorEqual, priority + 5);
					break;
				}
				break;
			case '>':
				switch (readChar()) {
				case '>':
					pushValOp(operand, &operatorShiftRight, priority + 7);
					break;
				case '=':
					pushValOp(operand, &operatorGreaterEqual, priority + 5);
					break;
				default:
					column--;
					pushValOp(operand, &operatorGreater, priority + 5);
					break;
				}
				break;
			case '!':
				switch (readChar()) {
				case '=':
					pushValOp(operand, &operatorNotEqual, priority + 5);
					break;
				default:
					illegalCharacter();
				}
				break;
			case '&':
				switch (readChar()) {
				case '&':
					pushValOp(operand, &operatorLogicalAnd, priority + 3);
					break;
				default:
					column--;
					pushValOp(operand, &operatorAnd, priority + 7);
					break;
				}
				break;
			case '|':
				switch (readChar()) {
				case '|':
					pushValOp(operand, &operatorLogicalOr, priority + 2);
					break;
				default:
					column--;
					pushValOp(operand, &operatorOr, priority + 6);
					break;
				}
				break;
			case '^':
				pushValOp(operand, &operatorXor, priority + 6);
				break;
			default:
				column--;
				if (priority != 0)
					throw new AssemblyError("Unmatched bracket");
				pushValOp(operand, &operatorPlus, 1);
				break;
			}
		}
		for (;;) {
			immutable sp = valOpStack.length - 1;
			if (sp <= 0 || valOpStack[sp].priority > valOpStack[sp - 1].priority)
				break;
			int operand1 = valOpStack[sp - 1].value;
			OperatorFunction func1 = valOpStack[sp - 1].func;
			valOpStack[sp - 1] = valOpStack[sp];
			valOpStack.length = sp;
			if (pass2 || !unknownInPass1) { // skip operations if unknown operands
				valOpStack[sp - 1].value = func1(operand1, valOpStack[sp - 1].value);
			}
		}
	} while (valOpStack.length != 1 || valOpStack[0].priority != 1);
	value = valOpStack[0].value;
	valOpStack.length = 0;
}

debug int testValue(string l) {
	line = l;
	column = 0;
	readValue();
	writefln("Value of %s is %x", l, value);
	return value;
}

unittest {
	assert(testValue("123") == 123);
	assert(testValue("$1234abCd") == 0x1234abcd);
	assert(testValue("%101") == 5);
	assert(testValue("^07") == 0xd007);
	assert(testValue("^1f") == 0xd01f);
	assert(testValue("^23") == 0xd203);
	assert(testValue("^31") == 0xd301);
	assert(testValue("^49") == 0xd409);
	assert(testValue("!0") == 1);
	assert(testValue("<$1234") == 0x34);
	assert(testValue(">$1234567") == 0x45);
	assert(testValue("1+2") == 3);
	assert(testValue("1+2*3") == 7);
	assert(testValue("[1+2]*3") == 9);
	assert(testValue("{nop}") == 0xea);
	assert(testValue("{CLC}+{sec}") == 0x50);
	assert(testValue("{Jsr}") == 0x20);
	assert(testValue("{bit a:}") == 0x2c);
	assert(testValue("{bIt $7d}") == 0x24);
}

void mustBeKnownInPass1() {
	if (unknownInPass1)
		throw new AssemblyError("Label not defined before");
}

void readWord() {
	readValue();
	if ((!unknownInPass1 || pass2) && (value < -0xffff || value > 0xffff))
		throw new AssemblyError("Value out of range");
}

void readUnsignedWord() {
	readWord();
	if ((!unknownInPass1 || pass2) && value < 0)
		throw new AssemblyError("Value out of range");
}

void readKnownPositive() {
	readValue();
	mustBeKnownInPass1();
	if (value <= 0)
		throw new AssemblyError("Value out of range");
}

void optionalIncDec() {
	if (eol()) return;
	switch (line[column]) {
	case '+':
		column++;
		addrMode += AddrMode.INCREMENT;
		return;
	case '-':
		column++;
		addrMode += AddrMode.DECREMENT;
		return;
	default:
		return;
	}
}

void readAddrMode() {
	readSpaces();
	char c = readChar();
	switch (c) {
	case '@':
		addrMode = AddrMode.ACCUMULATOR;
		return;
	case '#':
	case '<':
	case '>':
		addrMode = AddrMode.IMMEDIATE;
		if (inOpcode && line[column] == '}')
			return;
		readWord();
		final switch (c) {
		case '#':
			break;
		case '<':
			value &= 0xff;
			break;
		case '>':
			value = (value >> 8) & 0xff;
			break;
		}
		return;
	case '(':
		if (inOpcode) {
			switch (readChar()) {
			case ',':
				switch (readChar()) {
				case 'X':
				case 'x':
					break;
				default:
					illegalCharacter();
				}
				if (readChar() != ')')
					throw new AssemblyError("Need parenthesis");
				addrMode = AddrMode.INDIRECT_X;
				return;
			case ')':
				if (readChar() == ',') {
					switch (readChar()) {
					case 'Y':
					case 'y':
						break;
					default:
						illegalCharacter();
					}
					addrMode = AddrMode.INDIRECT_Y;
					return;
				} else {
					column--;
					addrMode = AddrMode.INDIRECT;
					return;
				}
			default:
				column--;
				break;
			}
		}
		readUnsignedWord();
		switch (readChar()) {
		case ',':
			switch (readChar()) {
			case 'X':
			case 'x':
				addrMode = AddrMode.INDIRECT_X;
				break;
			case '0':
				addrMode = cast(AddrMode) (AddrMode.INDIRECT_X + AddrMode.ZERO);
				break;
			default:
				illegalCharacter();
			}
			if (readChar() != ')')
				throw new AssemblyError("Need parenthesis");
			return;
		case ')':
			if (eol()) {
				addrMode = AddrMode.INDIRECT;
				return;
			}
			if (line[column] == ',') {
				column++;
				switch (readChar()) {
				case 'Y':
				case 'y':
					addrMode = AddrMode.INDIRECT_Y;
					break;
				case '0':
					addrMode = cast(AddrMode) (AddrMode.INDIRECT_Y + AddrMode.ZERO);
					break;
				default:
					illegalCharacter();
				}
				optionalIncDec();
				return;
			}
			addrMode = AddrMode.INDIRECT;
			return;
		default:
			illegalCharacter();
		}
		break;
	case 'A':
	case 'a':
		if (!eol() && line[column] == ':') {
			column++;
			addrMode = AddrMode.ABSOLUTE;
		} else {
			addrMode = AddrMode.ABS_OR_ZP;
			column--;
		}
		break;
	case 'Z':
	case 'z':
		if (!eol() && line[column] == ':') {
			column++;
			addrMode = AddrMode.ZEROPAGE;
		} else {
			addrMode = AddrMode.ABS_OR_ZP;
			column--;
		}
		break;
	default:
		addrMode = AddrMode.ABS_OR_ZP;
		column--;
		break;
	}
	// absolute or zeropage addressing, optionally indexed
	if (inOpcode && (addrMode == AddrMode.ABSOLUTE || addrMode == AddrMode.ZEROPAGE)) {
		switch (readChar()) {
		case '}':
			column--;
			return;
		case ',':
			switch (readChar()) {
			case 'X':
			case 'x':
				addrMode += cast(AddrMode) (AddrMode.ABSOLUTE_X - AddrMode.ABSOLUTE);
				return;
			case 'Y':
			case 'y':
				addrMode += cast(AddrMode) (AddrMode.ABSOLUTE_Y - AddrMode.ABSOLUTE);
				return;
			default:
				illegalCharacter();
			}
			return;
		default:
			column--;
			break;
		}
	}
	readUnsignedWord();
	if (addrMode == AddrMode.ABS_OR_ZP) {
		if (unknownInPass1 || value > 0xff)
			addrMode = AddrMode.ABSOLUTE;
		else
			addrMode = AddrMode.ZEROPAGE;
	}
	if (eol()) return;
	if (line[column] == ',') {
		column++;
		switch (readChar()) {
		case 'X':
		case 'x':
			addrMode += cast(AddrMode) (AddrMode.ABSOLUTE_X - AddrMode.ABSOLUTE);
			optionalIncDec();
			return;
		case 'Y':
		case 'y':
			addrMode += cast(AddrMode) (AddrMode.ABSOLUTE_Y - AddrMode.ABSOLUTE);
			optionalIncDec();
			return;
		default:
			illegalCharacter();
		}
	}
}

void readAbsoluteAddrMode() {
	if (inOpcode && readChar() == '}') {
		column--;
	} else {
		readAddrMode();
		switch (addrMode) {
		case AddrMode.ABSOLUTE:
		case AddrMode.ZEROPAGE:
			break;
		default:
			illegalAddrMode();
		}
	}
	addrMode = AddrMode.ABSOLUTE;
}

debug AddrMode testAddrMode(string l) {
	line = l;
	column = 0;
	readAddrMode();
	writefln("Addressing mode of \"%s\" is %x", l, addrMode);
	return addrMode;
}

unittest {
	assert(testAddrMode(" @") == AddrMode.ACCUMULATOR);
	assert(testAddrMode(" #0") == AddrMode.IMMEDIATE);
	assert(testAddrMode(" $abc,x-") == cast(AddrMode) (AddrMode.ABSOLUTE_X + AddrMode.DECREMENT));
	assert(testAddrMode(" $ab,Y+") == cast(AddrMode) (AddrMode.ZEROPAGE_Y + AddrMode.INCREMENT));
	assert(testAddrMode(" (0,x)") == AddrMode.INDIRECT_X);
	assert(testAddrMode(" ($ff),Y+") == cast(AddrMode) (AddrMode.INDIRECT_Y + AddrMode.INCREMENT));
	assert(testAddrMode(" ($abcd)") == AddrMode.INDIRECT);
	inOpcode = true;
	assert(testAddrMode(" a:}") == AddrMode.ABSOLUTE);
	assert(testAddrMode(" z:}") == AddrMode.ZEROPAGE);
	assert(testAddrMode(" a:,x}") == AddrMode.ABSOLUTE_X);
	assert(testAddrMode(" z:,y}") == AddrMode.ZEROPAGE_Y);
	assert(testAddrMode(" (,X)}") == AddrMode.INDIRECT_X);
	assert(testAddrMode(" (),y}") == AddrMode.INDIRECT_Y);
	assert(testAddrMode(" ()}") == AddrMode.INDIRECT);
	inOpcode = false;
}

bool inFalseCondition() {
	foreach (IfContext ic; ifContexts) {
		if (!ic.condition) return true;
	}
	return false;
}

string makeEscape(string s) {
	return s.replace("$", "$$");
}

File openInputFile(string filename) {
	if (find(makeSources, filename).empty)
		makeSources ~= filename;
	try {
		return File(filename);
	} catch (Exception e) {
		throw new AssemblyError(e.msg);
	}
}

File openOutputFile(char letter, string defaultExt) {
	string filename = optionParameters[letter - 'a'];
	if (filename is null)
		filename = sourceFilename.setExtension(defaultExt);
	if (letter == 'o')
		makeTarget = makeEscape(filename);
	try {
		return File(filename, "wb");
	} catch (Exception e) {
		throw new AssemblyError(e.msg);
	}
}

void ensureListingFileOpen(char letter, string msg) {
	if (!listingStream.isOpen) {
		listingStream = openOutputFile(letter, "lst");
		if (!getOption('q'))
			write(msg);
		listingStream.writeln(TITLE);
	}
}

void listNibble(int x) {
	listingLine[listingColumn++] = cast(char) (x <= 9 ? x + '0' : x + ('A' - 10));
}

void listByte(ubyte x) {
	listNibble(x >> 4);
	listNibble(x & 0xf);
}

void listWord(ushort x) {
	listByte(cast(ubyte) (x >> 8));
	listByte(cast(ubyte) x);
}

void listLine() {
	if (!optionListing || !getOption('l') || line is null)
		return;
	assert(pass2);
	if (inFalseCondition() && !getOption('c'))
		return;
	if (getOption('i') && includeLevel > 0)
		return;
	ensureListingFileOpen('l', "Writing listing file...\n");
	if (currentFilename != lastListedFilename) {
		listingStream.writeln("Source: ", currentFilename);
		lastListedFilename = currentFilename;
	}
	int i = 4;
	int x = lineNo;
	while (x > 0 && i >= 0) {
		listingLine[i--] = '0' + x % 10;
		x /= 10;
	}
	while (i >= 0)
		listingLine[i--] = ' ';
	listingLine[5] = ' ';
	while (listingColumn < 32)
		listingLine[listingColumn++] = ' ';
	listingStream.writefln("%.32s%s", listingLine, line);
}

void listCommentLine() {
	if (currentLabel is null)
		listingColumn = 6;
	else {
		assert(!inFalseCondition());
		checkOriginDefined();
	}
	listLine();
}

void listLabelTable() {
	if (optionParameters['t' - 'a'] !is null && listingStream.isOpen)
		listingStream.close();
	ensureListingFileOpen('t', "Writing label table...\n");
	listingStream.writeln("Label table:");
	foreach (string name; sort(labelTable.keys)) {
		Label l = labelTable[name];
		listingStream.write(l.unused ? 'n' : ' ');
		listingStream.write(l.unknownInPass1 ? '2' : ' ');
		int value = l.value;
		char sign = ' ';
		if (value < 0) {
			sign = '-';
			value = -value;
		}
		listingStream.writefln(
			(l.value & 0xffff0000) != 0 ? " %s%08X %s" : "     %s%04X %s",
			sign, value, name);
	}
}

debug ubyte[] objectBuffer;

void objectByte(ubyte b) {
	debug {
		objectBuffer ~= b;
	} else {
		assert(pass2);
		if (!optionObject) return;
		if (!objectStream.isOpen) {
			objectStream = openOutputFile('o', "obx");
			if (!getOption('q'))
				writeln("Writing object file...");
		}
		try {
			objectStream.write(cast(char) b);
		} catch (Exception e) {
			throw new AssemblyError("Error writing object file");
		}
	}
	objectBytes++;
}

void objectWord(ushort w) {
	objectByte(cast(ubyte) w);
	objectByte(cast(ubyte) (w >> 8));
}

void putByte(ubyte b) {
	if (inOpcode) {
		if (instructionBegin) {
			value = b;
			instructionBegin = false;
		}
		return;
	}
	if (willSkip) {
		assert(!pass2);
		willSkip = false;
		skipping = true;
	}
	if (skipping) {
		assert(!pass2);
		skipOffsets[$ - 1]++;
	}
	if (instructionBegin) {
		repeatOffset = -2;
		instructionBegin = false;
	}
	repeatOffset--;
	if (optionFill && loadingOrigin >= 0 && loadingOrigin != loadOrigin) {
		if (loadingOrigin > loadOrigin)
			throw new AssemblyError("Can't fill from higher to lower memory location");
		if (pass2) {
			while (loadingOrigin < loadOrigin) {
				objectByte(0xff);
				loadingOrigin++;
			}
		}
	}
	debug {
		objectByte(b);
	}
	if (pass2) {
		debug {
		} else {
			objectByte(b);
		}
		if (listingColumn < 29) {
			listByte(b);
			listingLine[listingColumn++] = ' ';
		} else {
			listingLine[29] = '+';
			listingColumn = 30;
		}
	}
	if (optionHeaders) {
		if (origin < 0)
			throw new AssemblyError("No ORG specified");
		assert(blockIndex >= 0);
		if (!pass2) {
			blockEnds[blockIndex] = cast(ushort) loadOrigin;
		}
	}
	if (origin >= 0) {
		origin++;
		loadingOrigin = ++loadOrigin;
	}
}

void putWord(ushort w) {
	putByte(cast(ubyte) w);
	putByte(cast(ubyte) (w >> 8));
}

void putCommand(ubyte b) {
	putByte(b);
	if (inOpcode) return;
	switch (addrMode & AddrMode.STANDARD_MASK) {
	case AddrMode.ACCUMULATOR:
		break;
	case AddrMode.IMMEDIATE:
	case AddrMode.ZEROPAGE:
	case AddrMode.ZEROPAGE_X:
	case AddrMode.ZEROPAGE_Y:
	case AddrMode.INDIRECT_X:
	case AddrMode.INDIRECT_Y:
		if (pass2 && (value < -0xff || value > 0xff))
			throw new AssemblyError("Value out of range");
		putByte(cast(ubyte) value);
		break;
	case AddrMode.ABSOLUTE:
	case AddrMode.ABSOLUTE_X:
	case AddrMode.ABSOLUTE_Y:
	case AddrMode.INDIRECT:
		putWord(cast(ushort) value);
		break;
	default:
		assert(0);
	}
	switch (addrMode) {
	case cast(AddrMode) (AddrMode.ABSOLUTE_X + AddrMode.INCREMENT):
	case cast(AddrMode) (AddrMode.ZEROPAGE_X + AddrMode.INCREMENT):
		putByte(0xe8);
		break;
	case cast(AddrMode) (AddrMode.ABSOLUTE_X + AddrMode.DECREMENT):
	case cast(AddrMode) (AddrMode.ZEROPAGE_X + AddrMode.DECREMENT):
		putByte(0xca);
		break;
	case cast(AddrMode) (AddrMode.ABSOLUTE_Y + AddrMode.INCREMENT):
	case cast(AddrMode) (AddrMode.ZEROPAGE_Y + AddrMode.INCREMENT):
	case cast(AddrMode) (AddrMode.INDIRECT_Y + AddrMode.INCREMENT):
	case cast(AddrMode) (AddrMode.INDIRECT_Y + AddrMode.INCREMENT + AddrMode.ZERO):
		putByte(0xc8);
		break;
	case cast(AddrMode) (AddrMode.ABSOLUTE_Y + AddrMode.DECREMENT):
	case cast(AddrMode) (AddrMode.ZEROPAGE_Y + AddrMode.DECREMENT):
	case cast(AddrMode) (AddrMode.INDIRECT_Y + AddrMode.DECREMENT):
	case cast(AddrMode) (AddrMode.INDIRECT_Y + AddrMode.DECREMENT + AddrMode.ZERO):
		putByte(0x88);
		break;
	default:
		break;
	}
}

void noOpcode() {
	if (inOpcode)
		throw new AssemblyError("Can't get opcode of this");
}

void directive() {
	noOpcode();
	if (repeating)
		throw new AssemblyError("Can't repeat this directive");
	if (pairing)
		throw new AssemblyError("Can't pair this directive");
}

void noRepeatSkipDirective() {
	directive();
	if (willSkip)
		throw new AssemblyError("Can't skip over this");
	repeatOffset = 0;
}

void illegalAddrMode() {
	throw new AssemblyError("Illegal addressing mode");
}

void addrModeForMove(int move) {
	final switch (move) {
	case 0:
		readAddrMode();
		break;
	case 1:
		value = value1;
		addrMode = addrMode1;
		break;
	case 2:
		value = value2;
		addrMode = addrMode2;
		break;
	}
}

void assemblyAccumulator(ubyte b, ubyte prefix, int move) {
	addrModeForMove(move);
	if (prefix != 0)
		putByte(prefix);
	switch (addrMode & AddrMode.STANDARD_MASK) {
	case AddrMode.ACCUMULATOR:
	case AddrMode.INDIRECT:
		illegalAddrMode();
		break;
	case AddrMode.IMMEDIATE:
		if (b == 0x80) {
			// STA #
			illegalAddrMode();
		}
		putCommand(cast(ubyte) (b + 9));
		break;
	case AddrMode.ABSOLUTE:
		putCommand(cast(ubyte) (b + 0xd));
		break;
	case AddrMode.ZEROPAGE:
		putCommand(cast(ubyte) (b + 5));
		break;
	case AddrMode.ABSOLUTE_X:
		putCommand(cast(ubyte) (b + 0x1d));
		break;
	case AddrMode.ZEROPAGE_X:
		putCommand(cast(ubyte) (b + 0x15));
		break;
	case AddrMode.ZEROPAGE_Y:
		addrMode -= 1;
		goto case AddrMode.ABSOLUTE_Y;
	case AddrMode.ABSOLUTE_Y:
		putCommand(cast(ubyte) (b + 0x19));
		break;
	case AddrMode.INDIRECT_X:
		if ((addrMode & AddrMode.ZERO) != 0)
			putWord(0x00a2);
		putCommand(cast(ubyte) (b + 1));
		break;
	case AddrMode.INDIRECT_Y:
		if ((addrMode & AddrMode.ZERO) != 0)
			putWord(0x00a0);
		putCommand(cast(ubyte) (b + 0x11));
		break;
	default:
		assert(0);
	}
}

void assemblyShift(ubyte b) {
	readAddrMode();
	switch (addrMode & AddrMode.STANDARD_MASK) {
	case AddrMode.ACCUMULATOR:
		if (b == 0xc0 || b == 0xe0) {
			// INC @, DEC @
			illegalAddrMode();
		}
		putByte(cast(ubyte) (b + 0xa));
		break;
	case AddrMode.ABSOLUTE:
		putCommand(cast(ubyte) (b + 0xe));
		break;
	case AddrMode.ZEROPAGE:
		putCommand(cast(ubyte) (b + 6));
		break;
	case AddrMode.ABSOLUTE_X:
		putCommand(cast(ubyte) (b + 0x1e));
		break;
	case AddrMode.ZEROPAGE_X:
		putCommand(cast(ubyte) (b + 0x16));
		break;
	default:
		illegalAddrMode();
	}
}

void assemblyCompareIndex(ubyte b) {
	readAddrMode();
	switch (addrMode) {
	case AddrMode.IMMEDIATE:
		putCommand(b);
		break;
	case AddrMode.ABSOLUTE:
		putCommand(cast(ubyte) (b + 0xc));
		break;
	case AddrMode.ZEROPAGE:
		putCommand(cast(ubyte) (b + 4));
		break;
	default:
		illegalAddrMode();
	}
}

void assemblyLda(int move) {
	assemblyAccumulator(0xa0, 0, move);
}

void assemblyLdx(int move) {
	addrModeForMove(move);
	switch (addrMode & AddrMode.STANDARD_MASK) {
	case AddrMode.IMMEDIATE:
		putCommand(0xa2);
		break;
	case AddrMode.ABSOLUTE:
		putCommand(0xae);
		break;
	case AddrMode.ZEROPAGE:
		putCommand(0xa6);
		break;
	case AddrMode.ABSOLUTE_Y:
		putCommand(0xbe);
		break;
	case AddrMode.ZEROPAGE_Y:
		putCommand(0xb6);
		break;
	default:
		illegalAddrMode();
	}
}

void assemblyLdy(int move) {
	addrModeForMove(move);
	switch (addrMode & AddrMode.STANDARD_MASK) {
	case AddrMode.IMMEDIATE:
		putCommand(0xa0);
		break;
	case AddrMode.ABSOLUTE:
		putCommand(0xac);
		break;
	case AddrMode.ZEROPAGE:
		putCommand(0xa4);
		break;
	case AddrMode.ABSOLUTE_X:
		putCommand(0xbc);
		break;
	case AddrMode.ZEROPAGE_X:
		putCommand(0xb4);
		break;
	default:
		illegalAddrMode();
	}
}

void assemblySta(int move) {
	assemblyAccumulator(0x80, 0, move);
}

void assemblyStx(int move) {
	addrModeForMove(move);
	switch (addrMode & AddrMode.STANDARD_MASK) {
	case AddrMode.ABSOLUTE:
		putCommand(0x8e);
		break;
	case AddrMode.ZEROPAGE:
		putCommand(0x86);
		break;
	case AddrMode.ABSOLUTE_Y:
		addrMode += 1;
		goto case AddrMode.ZEROPAGE_Y;
	case AddrMode.ZEROPAGE_Y:
		putCommand(0x96);
		break;
	default:
		illegalAddrMode();
	}
}

void assemblySty(int move) {
	addrModeForMove(move);
	switch (addrMode & AddrMode.STANDARD_MASK) {
	case AddrMode.ABSOLUTE:
		putCommand(0x8c);
		break;
	case AddrMode.ZEROPAGE:
		putCommand(0x84);
		break;
	case AddrMode.ABSOLUTE_X:
		addrMode += 1;
		goto case AddrMode.ZEROPAGE_X;
	case AddrMode.ZEROPAGE_X:
		putCommand(0x94);
		break;
	default:
		illegalAddrMode();
	}
}

void assemblyBit() {
	readAddrMode();
	switch (addrMode) {
	case AddrMode.ABSOLUTE:
		putCommand(0x2c);
		break;
	case AddrMode.ZEROPAGE:
		putCommand(0x24);
		break;
	default:
		illegalAddrMode();
	}
}

void putJump() {
	switch (addrMode) {
	case AddrMode.ZEROPAGE:
		addrMode = AddrMode.ABSOLUTE;
		goto case AddrMode.ABSOLUTE;
	case AddrMode.ABSOLUTE:
		putCommand(0x4c);
		break;
	case AddrMode.INDIRECT:
		if (pass2 && (value & 0xff) == 0xff)
			warning("Buggy indirect jump");
		putCommand(0x6c);
		break;
	default:
		illegalAddrMode();
	}
}

void assemblyJmp() {
	readAddrMode();
	putJump();
}

void assemblyConditionalJump(ubyte b) {
	noOpcode();
	readAddrMode();
	if ((addrMode == AddrMode.ABSOLUTE || addrMode == AddrMode.ZEROPAGE)
	 && pass2 && origin >= 0 && value - origin - 2 >= -0x80 && value - origin - 2 <= 0x7f) {
		warning("Plain branch instruction would be sufficient");
	}
	putByte(b);
	putByte(3);
	putJump();
}

void assemblyJsr() {
	readAbsoluteAddrMode();
	putCommand(0x20);
}

ubyte calculateBranch(int offset) {
	if (offset < -0x80 || offset > 0x7f) {
		int dist = offset < 0 ? -offset - 0x80 : offset - 0x7f;
		throw new AssemblyError("Branch out of range by " ~ to!string(dist) ~ " bytes");
	}
	return cast(ubyte) offset;
}

void assemblyBranch(ubyte b) {
	readAbsoluteAddrMode();
	if (inOpcode) {
		putByte(b);
		return;
	}
	checkOriginDefined();
	putByte(b);
	putByte(pass2 ? calculateBranch(value - origin - 1) : 0);
}

void assemblyRepeat(ubyte b) {
	noOpcode();
	int offset = repeatOffset;
	if (offset >= 0)
		throw new AssemblyError("No instruction to repeat");
	if (pass2 && wereManyInstructions)
		warning("Repeating only the last instruction");
	putByte(b);
	putByte(calculateBranch(offset));
}

void assemblySkip(ubyte b) {
	noOpcode();
	if (willSkip) {
		skipOffsets[$ - 1] = 2;
		willSkip = false;
	}
	putByte(b);
	if (pass2)
		putByte(calculateBranch(skipOffsets[skipOffsetsIndex++]));
	else {
		putByte(0);
		skipOffsets ~= 0;
		willSkip = true;
	}
}

void assemblyInw() {
	noOpcode();
	readAddrMode();
	switch (addrMode) {
	case AddrMode.ABSOLUTE:
		putCommand(0xee);
		putWord(0x03d0);
		value++;
		putCommand(0xee);
		break;
	case AddrMode.ZEROPAGE:
		putCommand(0xe6);
		putWord(0x02d0);
		value++;
		putCommand(0xe6);
		break;
	case AddrMode.ABSOLUTE_X:
		putCommand(0xfe);
		putWord(0x03d0);
		value++;
		putCommand(0xfe);
		break;
	case AddrMode.ZEROPAGE_X:
		putCommand(0xf6);
		putWord(0x02d0);
		value++;
		putCommand(0xf6);
		break;
	default:
		illegalAddrMode();
	}
}

void assemblyMove() {
	noOpcode();
	readAddrMode();
	value1 = value;
	addrMode1 = addrMode;
	bool unknown1 = unknownInPass1;
	readAddrMode();
	value2 = value;
	addrMode2 = addrMode;
	unknownInPass1 = unknown1;
}

void assemblyMoveByte(MoveFunction load, MoveFunction store) {
	assemblyMove();
	load(1);
	store(2);
}

void assemblyMoveWord(MoveFunction load, MoveFunction store, ubyte inc, ubyte dec) {
	assemblyMove();
	switch (addrMode2) {
	case AddrMode.ABSOLUTE:
	case AddrMode.ZEROPAGE:
	case AddrMode.ABSOLUTE_X:
	case AddrMode.ZEROPAGE_X:
	case AddrMode.ABSOLUTE_Y:
	case AddrMode.ZEROPAGE_Y:
		break;
	default:
		illegalAddrMode();
	}
	switch (addrMode1) {
	case AddrMode.IMMEDIATE:
		int high = value1 >> 8;
		value1 &= 0xff;
		load(1);
		store(2);
		value2++;
		if (unknownInPass1) {
			value1 = high;
			load(1);
		} else {
			if (inc != 0 && cast(ubyte) (value1 + 1) == high)
				putByte(inc);
			else if (dec != 0 && cast(ubyte) (value1 - 1) == high)
				putByte(dec);
			else if (value1 != high) {
				value1 = high;
				load(1);
			}
		}
		store(2);
		break;
	case AddrMode.ABSOLUTE:
	case AddrMode.ZEROPAGE:
	case AddrMode.ABSOLUTE_X:
	case AddrMode.ZEROPAGE_X:
	case AddrMode.ABSOLUTE_Y:
	case AddrMode.ZEROPAGE_Y:
		load(1);
		store(2);
		value1++;
		value2++;
		load(1);
		store(2);
		break;
	default:
		illegalAddrMode();
	}
}

void storeDtaNumber(int val, char letter) {
	int limit = 0xffff;
	if (letter == 'b') limit = 0xff;
	if ((!unknownInPass1 || pass2) && (val < -limit || val > limit))
		throw new AssemblyError("Value out of range");
	final switch (letter) {
	case 'a':
		putWord(cast(ushort) val);
		break;
	case 'b':
	case 'l':
		putByte(cast(ubyte) val);
		break;
	case 'h':
		putByte(cast(ubyte) (val >> 8));
		break;
	}
}

void assemblyDtaInteger(char letter) {
	if (readFunction() == "SIN") {
		readWord();
		int sinCenter = value;
		readComma();
		readWord();
		int sinAmp = value;
		readComma();
		readKnownPositive();
		int sinPeriod = value;
		int sinMin = 0;
		int sinMax = sinPeriod - 1;
		switch (readChar()) {
		case ')':
			break;
		case ',':
			readUnsignedWord();
			mustBeKnownInPass1();
			sinMin = value;
			readComma();
			readUnsignedWord();
			mustBeKnownInPass1();
			sinMax = value;
			if (readChar() != ')') {
				illegalCharacter();
			}
			break;
		default:
			illegalCharacter();
		}
		while (sinMin <= sinMax) {
			int val = sinCenter + cast(int) rint(sinAmp * sin(sinMin * 2 * PI / sinPeriod));
			storeDtaNumber(val, letter);
			sinMin++;
		}
		return;
	}
	readWord();
	storeDtaNumber(value, letter);
}

bool realSign;

int realExponent;

long realMantissa;

void putReal() {
	if (realMantissa == 0) {
		putWord(0);
		putWord(0);
		putWord(0);
		return;
	}
	while (realMantissa < 0x1000000000L) {
		realMantissa <<= 4;
		realExponent--;
	}
	if ((realExponent & 1) != 0) {
		if (realMantissa & 0xf)
			throw new AssemblyError("Out of precision");
		realMantissa >>= 4;
	}
	realExponent = (realExponent + 0x89) >> 1;
	if (realExponent < 64 - 49)
		throw new AssemblyError("Out of precision");
	if (realExponent > 64 + 49)
		throw new AssemblyError("Number too big");
	putByte(cast(ubyte) (realSign ? realExponent + 0x80 : realExponent));
	putByte(cast(ubyte) (realMantissa >> 32));
	putByte(cast(ubyte) (realMantissa >> 24));
	putByte(cast(ubyte) (realMantissa >> 16));
	putByte(cast(ubyte) (realMantissa >> 8));
	putByte(cast(ubyte) realMantissa);
}

bool readSign() {
	switch (readChar()) {
	case '+':
		return false;
	case '-':
		return true;
	default:
		column--;
		return false;
	}
}

void readExponent() {
	bool sign = readSign();
	char c = readChar();
	if (c < '0' || c > '9')
		illegalCharacter();
	int e = c - '0';
	c = readChar();
	if (c >= '0' && c <= '9')
		e = 10 * e + c - '0';
	else
		column--;
	realExponent += sign ? -e : e;
	putReal();
}

void readFraction() {
	for (;;) {
		char c = readChar();
		if (c >= '0' && c <= '9') {
			if (c != '0' && realMantissa >= 0x1000000000L)
				throw new AssemblyError("Out of precision");
			realMantissa <<= 4;
			realMantissa += c - '0';
			realExponent--;
			continue;
		}
		if (c == 'E' || c == 'e') {
			readExponent();
			return;
		}
		column--;
		putReal();
		return;
	}
}

void assemblyDtaReal() {
	realSign = readSign();
	realExponent = 0;
	realMantissa = 0;
	char c = readChar();
	if (c == '.') {
		readFraction();
		return;
	}
	if (c < '0' || c > '9')
		illegalCharacter();
	do {
		if (realMantissa < 0x1000000000L) {
			realMantissa <<= 4;
			realMantissa += c - '0';
		} else {
			if (c != '0')
				throw new AssemblyError("Out of precision");
			realExponent++;
		}
		c = readChar();
	} while (c >= '0' && c <= '9');
	switch (c) {
	case '.':
		readFraction();
		break;
	case 'E':
	case 'e':
		readExponent();
		break;
	default:
		column--;
		putReal();
		break;
	}
}

void assemblyDtaNumbers(char letter) {
	if (eol() || line[column] != '(') {
		column--;
		assemblyDtaInteger('b');
		return;
	}
	column++;
	for (;;) {
		final switch (letter) {
		case 'a':
		case 'b':
		case 'h':
		case 'l':
			assemblyDtaInteger(letter);
			break;
		case 'r':
			assemblyDtaReal();
			break;
		}
		switch (readChar()) {
		case ')':
			return;
		case ',':
			break;
		default:
			illegalCharacter();
		}
	}
}

void assemblyDta() {
	noOpcode();
	readSpaces();
	for (;;) {
		switch (readChar()) {
		case 'A':
		case 'a':
			assemblyDtaNumbers('a');
			break;
		case 'B':
		case 'b':
			assemblyDtaNumbers('b');
			break;
		case 'C':
		case 'c':
			ubyte[] s = readString();
			if (s is null) {
				column--;
				assemblyDtaInteger('b');
				break;
			}
			foreach (ubyte b; s) {
				putByte(b);
			}
			break;
		case 'D':
		case 'd':
			ubyte[] s = readString();
			if (s is null) {
				column--;
				assemblyDtaInteger('b');
				break;
			}
			foreach (ubyte b; s) {
				final switch (b & 0x60) {
				case 0x00:
					putByte(cast(ubyte) (b + 0x40));
					break;
				case 0x20:
				case 0x40:
					putByte(cast(ubyte) (b - 0x20));
					break;
				case 0x60:
					putByte(b);
					break;
				}
			}
			break;
		case 'H':
		case 'h':
			assemblyDtaNumbers('h');
			break;
		case 'L':
		case 'l':
			assemblyDtaNumbers('l');
			break;
		case 'R':
		case 'r':
			assemblyDtaNumbers('r');
			break;
		default:
			column--;
			assemblyDtaInteger('b');
			break;
		}
		if (eol() || line[column] != ',')
			break;
		column++;
	}
}

void assemblyEqu() {
	directive();
	if (currentLabel is null)
		throw new AssemblyError("Label name required");
	currentLabel.value = 0;
	readSpaces();
	readValue();
	currentLabel.value = value;
	currentLabel.unknownInPass1 = unknownInPass1;
	if (optionListing) {
		listingLine[6] = '=';
		int val = value;
		listingLine[7] = ' ';
		if (val < 0) {
			listingLine[7] = '-';
			val = -val;
		}
		listingColumn = 8;
		if ((val & 0xffff0000) != 0)
			listWord(cast(ushort) (val >> 16));
		else {
			while (listingColumn < 12)
				listingLine[listingColumn++] = ' ';
		}
		listWord(cast(ushort) val);
	}
}

void assemblyEnd() {
	directive();
	assert(!foundEnd);
	foundEnd = true;
}

void assemblyIftEli() {
	ifContexts[$ - 1].condition = true;
	if (!inFalseCondition()) {
		readSpaces();
		readValue();
		mustBeKnownInPass1();
		if (value != 0)
			ifContexts[$ - 1].aConditionMatched = true;
		else
			listLine();
		ifContexts[$ - 1].condition = value != 0;
	}
}

void checkMissingIft() {
	if (ifContexts.length == 0)
		throw new AssemblyError("Missing IFT");
}

void assemblyIft() {
	directive();
	ifContexts.length++;
	assemblyIftEli();
}

void assemblyEliEls() {
	directive();
	checkMissingIft();
	if (ifContexts[$ - 1].wasElse)
		throw new AssemblyError("EIF expected");
}

void assemblyEli() {
	assemblyEliEls();
	if (ifContexts[$ - 1].aConditionMatched) {
		ifContexts[$ - 1].condition = false;
		return;
	}
	assemblyIftEli();
}

void assemblyEls() {
	assemblyEliEls();
	with (ifContexts[$ - 1]) {
		if (condition && aConditionMatched)
			listLine();
		wasElse = true;
		condition = !aConditionMatched;
	}
}

void assemblyEif() {
	directive();
	checkMissingIft();
	ifContexts.length--;
}

void assemblyErt() {
	directive();
	readSpaces();
	readValue();
	if (pass2 && value != 0)
		throw new AssemblyError("User-defined error");
}

bool readOption() {
	switch (readChar()) {
	case '-':
		return false;
	case '+':
		return true;
	default:
		illegalCharacter();
	}
	assert(0);
}

void assemblyOpt() {
	directive();
	readSpaces();
	while (!eol()) {
		switch (line[column++]) {
		case 'F':
		case 'f':
			optionFill = readOption();
			break;
		case 'G':
		case 'g':
			option5200 = readOption();
			break;
		case 'H':
		case 'h':
			optionHeaders = readOption();
			break;
		case 'L':
		case 'l':
			optionListing = readOption() && !pass2;
			break;
		case 'O':
		case 'o':
			optionObject = readOption();
			break;
		case 'U':
		case 'u':
			optionUnusedLabels = readOption();
			break;
		default:
			column--;
			return;
		}
	}
}

void originWord(ushort value, char listingChar) {
	objectWord(value);
	listWord(value);
	listingLine[listingColumn++] = listingChar;
}

OrgModifier readOrgModifier() {
	readSpaces();
	if (column + 2 < line.length && line[column + 1] == ':') {
		switch (line[column]) {
		case 'F':
		case 'f':
			checkHeadersOn();
			column += 2;
			return OrgModifier.FORCE_FFFF;
		case 'A':
		case 'a':
			checkHeadersOn();
			column += 2;
			return OrgModifier.FORCE_HEADER;
		case 'R':
		case 'r':
			column += 2;
			return OrgModifier.RELOCATE;
		default:
			break;
		}
	}
	return OrgModifier.NONE;
}

void setOrigin(int addr, OrgModifier modifier) {
	origin = loadOrigin = addr;
	bool requestedHeader = modifier != OrgModifier.NONE;
	if (requestedHeader || loadingOrigin < 0 || (addr != loadingOrigin && !optionFill)) {
		blockIndex++;
		if (!pass2) {
			assert(blockIndex == blockEnds.length);
			blockEnds ~= cast(ushort) (addr - 1);
		}
		if (pass2 && optionHeaders) {
			if (addr - 1 == blockEnds[blockIndex]) {
				if (requestedHeader)
					throw new AssemblyError("Cannot generate an empty block");
				return;
			}
			if (modifier == OrgModifier.FORCE_FFFF || objectBytes == 0) {
				assert(requestedHeader || addr != loadingOrigin);
				originWord(0xffff, '>');
				listingLine[listingColumn++] = ' ';
			}
			if (requestedHeader || addr != loadingOrigin) {
				originWord(cast(ushort) addr, '-');
				originWord(blockEnds[blockIndex], '>');
				listingLine[listingColumn++] = ' ';
				loadingOrigin = -1;
			}
		}
	}
}

void checkHeadersOn() {
	if (!optionHeaders)
		throw new AssemblyError("Illegal when Atari file headers disabled");
}

void assemblyOrg() {
	noRepeatSkipDirective();
	OrgModifier modifier = readOrgModifier();
	readUnsignedWord();
	mustBeKnownInPass1();
	if (modifier == OrgModifier.RELOCATE) {
		checkOriginDefined();
		origin = value;
	}
	else {
		setOrigin(value, modifier);
	}
}

void assemblyRunIni(ushort addr) {
	noRepeatSkipDirective();
	checkHeadersOn();
	loadingOrigin = -1; // don't fill
	OrgModifier modifier = readOrgModifier();
	if (modifier == OrgModifier.RELOCATE)
		throw new AssemblyError("r: invalid here");
	setOrigin(addr, modifier);
	readUnsignedWord();
	putWord(cast(ushort) (value));
	loadingOrigin = -1; // don't fill
}

void assemblyIcl() {
	directive();
	string filename = readFilename();
	checkNoExtraCharacters();
	listLine();
	includeLevel++;
	assemblyFile(filename);
	includeLevel--;
	line = null;
}

void assemblyIns() {
	string filename = readFilename();
	int offset = 0;
	int length = -1;
	if (!eol() && line[column] == ',') {
		column++;
		readValue();
		mustBeKnownInPass1();
		offset = value;
		if (!eol() && line[column] == ',') {
			column++;
			readKnownPositive();
			length = value;
		}
	}
	File stream = openInputFile(filename);
	scope (exit) stream.close();
	try {
		stream.seek(offset, offset >= 0 ? SEEK_SET : SEEK_END);
	} catch (Exception e) {
		throw new AssemblyError("Error seeking file");
	}
	if (inOpcode)
		length = 1;
	while (length != 0) {
		int b = readByte(&stream);
		if (b < 0) {
			if (length > 0)
				throw new AssemblyError("File is too short");
			break;
		}
		putByte(cast(ubyte) b);
		if (length > 0) length--;
	}
}

void assemblyInstruction(string instruction) {
	if (!inOpcode && origin < 0 && currentLabel !is null && instruction != "EQU")
		throw new AssemblyError("No ORG specified");
	instructionBegin = true;
	switch (instruction) {
	case "ADC":
		assemblyAccumulator(0x60, 0, 0);
		break;
	case "ADD":
		assemblyAccumulator(0x60, 0x18, 0);
		break;
	case "AND":
		assemblyAccumulator(0x20, 0, 0);
		break;
	case "ASL":
		assemblyShift(0x00);
		break;
	case "BCC":
		assemblyBranch(0x90);
		break;
	case "BCS":
		assemblyBranch(0xb0);
		break;
	case "BEQ":
		assemblyBranch(0xf0);
		break;
	case "BIT":
		assemblyBit();
		break;
	case "BMI":
		assemblyBranch(0x30);
		break;
	case "BNE":
		assemblyBranch(0xd0);
		break;
	case "BPL":
		assemblyBranch(0x10);
		break;
	case "BRK":
		putByte(0x00);
		break;
	case "BVC":
		assemblyBranch(0x50);
		break;
	case "BVS":
		assemblyBranch(0x70);
		break;
	case "CLC":
		putByte(0x18);
		break;
	case "CLD":
		putByte(0xd8);
		break;
	case "CLI":
		putByte(0x58);
		break;
	case "CLV":
		putByte(0xb8);
		break;
	case "CMP":
		assemblyAccumulator(0xc0, 0, 0);
		break;
	case "CPX":
		assemblyCompareIndex(0xe0);
		break;
	case "CPY":
		assemblyCompareIndex(0xc0);
		break;
	case "DEC":
		assemblyShift(0xc0);
		break;
	case "DEX":
		putByte(0xca);
		break;
	case "DEY":
		putByte(0x88);
		break;
	case "DTA":
		assemblyDta();
		break;
	case "EIF":
		assemblyEif();
		break;
	case "ELI":
		assemblyEli();
		break;
	case "ELS":
		assemblyEls();
		break;
	case "END":
		assemblyEnd();
		break;
	case "EOR":
		assemblyAccumulator(0x40, 0, 0);
		break;
	case "EQU":
		assemblyEqu();
		break;
	case "ERT":
		assemblyErt();
		break;
	case "ICL":
		assemblyIcl();
		break;
	case "IFT":
		assemblyIft();
		break;
	case "INC":
		assemblyShift(0xe0);
		break;
	case "INI":
		assemblyRunIni(0x2e2);
		break;
	case "INS":
		assemblyIns();
		break;
	case "INX":
		putByte(0xe8);
		break;
	case "INY":
		putByte(0xc8);
		break;
	case "INW":
		assemblyInw();
		break;
	case "JCC":
		assemblyConditionalJump(0xb0);
		break;
	case "JCS":
		assemblyConditionalJump(0x90);
		break;
	case "JEQ":
		assemblyConditionalJump(0xd0);
		break;
	case "JMI":
		assemblyConditionalJump(0x10);
		break;
	case "JMP":
		assemblyJmp();
		break;
	case "JNE":
		assemblyConditionalJump(0xf0);
		break;
	case "JPL":
		assemblyConditionalJump(0x30);
		break;
	case "JSR":
		assemblyJsr();
		break;
	case "JVC":
		assemblyConditionalJump(0x70);
		break;
	case "JVS":
		assemblyConditionalJump(0x50);
		break;
	case "LDA":
		assemblyAccumulator(0xa0, 0, 0);
		break;
	case "LDX":
		assemblyLdx(0);
		break;
	case "LDY":
		assemblyLdy(0);
		break;
	case "LSR":
		assemblyShift(0x40);
		break;
	case "MVA":
		assemblyMoveByte(&assemblyLda, &assemblySta);
		break;
	case "MVX":
		assemblyMoveByte(&assemblyLdx, &assemblyStx);
		break;
	case "MVY":
		assemblyMoveByte(&assemblyLdy, &assemblySty);
		break;
	case "MWA":
		assemblyMoveWord(&assemblyLda, &assemblySta, 0, 0);
		break;
	case "MWX":
		assemblyMoveWord(&assemblyLdx, &assemblyStx, 0xe8, 0xca);
		break;
	case "MWY":
		assemblyMoveWord(&assemblyLdy, &assemblySty, 0xc8, 0x88);
		break;
	case "NOP":
		putByte(0xea);
		break;
	case "OPT":
		assemblyOpt();
		break;
	case "ORA":
		assemblyAccumulator(0x00, 0, 0);
		break;
	case "ORG":
		assemblyOrg();
		break;
	case "PHA":
		putByte(0x48);
		break;
	case "PHP":
		putByte(0x08);
		break;
	case "PLA":
		putByte(0x68);
		break;
	case "PLP":
		putByte(0x28);
		break;
	case "RCC":
		assemblyRepeat(0x90);
		break;
	case "RCS":
		assemblyRepeat(0xb0);
		break;
	case "REQ":
		assemblyRepeat(0xf0);
		break;
	case "RMI":
		assemblyRepeat(0x30);
		break;
	case "RNE":
		assemblyRepeat(0xd0);
		break;
	case "ROL":
		assemblyShift(0x20);
		break;
	case "ROR":
		assemblyShift(0x60);
		break;
	case "RPL":
		assemblyRepeat(0x10);
		break;
	case "RTI":
		putByte(0x40);
		break;
	case "RTS":
		putByte(0x60);
		break;
	case "RUN":
		assemblyRunIni(0x2e0);
		break;
	case "RVC":
		assemblyRepeat(0x50);
		break;
	case "RVS":
		assemblyRepeat(0x70);
		break;
	case "SBC":
		assemblyAccumulator(0xe0, 0, 0);
		break;
	case "SCC":
		assemblySkip(0x90);
		break;
	case "SCS":
		assemblySkip(0xb0);
		break;
	case "SEC":
		putByte(0x38);
		break;
	case "SED":
		putByte(0xf8);
		break;
	case "SEI":
		putByte(0x78);
		break;
	case "SEQ":
		assemblySkip(0xf0);
		break;
	case "SMI":
		assemblySkip(0x30);
		break;
	case "SNE":
		assemblySkip(0xd0);
		break;
	case "SPL":
		assemblySkip(0x10);
		break;
	case "STA":
		assemblyAccumulator(0x80, 0, 0);
		break;
	case "STX":
		assemblyStx(0);
		break;
	case "STY":
		assemblySty(0);
		break;
	case "SUB":
		assemblyAccumulator(0xe0, 0x38, 0);
		break;
	case "SVC":
		assemblySkip(0x50);
		break;
	case "SVS":
		assemblySkip(0x70);
		break;
	case "TAX":
		putByte(0xaa);
		break;
	case "TAY":
		putByte(0xa8);
		break;
	case "TSX":
		putByte(0xba);
		break;
	case "TXA":
		putByte(0x8a);
		break;
	case "TXS":
		putByte(0x9a);
		break;
	case "TYA":
		putByte(0x98);
		break;
	default:
		throw new AssemblyError("Illegal instruction");
	}
	skipping = false;
}

debug ubyte[] testInstruction(string l) {
	objectBuffer.length = 0;
	line = l;
	column = 0;
	assemblyInstruction(readInstruction());
	write(line, " assembles to");
	foreach (ubyte b; objectBuffer)
		writef(" %02x", b);
	writeln();
	return objectBuffer;
}

unittest {
	assert(testInstruction("nop") == cast(ubyte[]) x"ea");
	assert(testInstruction("add (5,0)") == cast(ubyte[]) x"18a2006105");
	assert(testInstruction("mwa #$abcd $1234") == cast(ubyte[]) x"a9cd8d3412a9ab8d3512");
	assert(testInstruction("dta 5,d'Foo'*,a($4589)") == cast(ubyte[]) x"05a6efef8945");
	assert(testInstruction("dta r(1,12,123,1234567890,12345678900000,.5,.03,000.1664534589,1e97)")
	 == cast(ubyte[]) x"400100000000 401200000000 410123000000 441234567890 461234567890 3f5000000000 3f0300000000 3f1664534589 701000000000");
}

void assemblyPair() {
	assert(!inOpcode);
	string instruction = readInstruction();
	if (!eol() && line[column] == ':') {
		pairing = true;
		column++;
		string instruction2 = readInstruction();
		int savedColumn = column;
		if (willSkip)
			warning("Skipping only the first instruction");
		assemblyInstruction(instruction);
		checkNoExtraCharacters();
		column = savedColumn;
		wereManyInstructions = false;
		assemblyInstruction(instruction2);
		wereManyInstructions = true;
	} else {
		pairing = false;
		assemblyInstruction(instruction);
		wereManyInstructions = false;
	}
}

void assemblyLine() {
	debug {
		writeln(line);
	}
	lineNo++;
	totalLines++;
	column = 0;
	listingColumn = 6;
	if (origin >= 0) {
		listWord(cast(ushort) origin);
		listingLine[listingColumn++] = ' ';
	}
	string label = readLabel();
	currentLabel = null;
	if (label !is null) {
		if (!inFalseCondition()) {
			if (!pass2) {
				if (label in labelTable)
					throw new AssemblyError("Label declared twice");
				currentLabel = new Label(origin);
				labelTable[label] = currentLabel;
			} else {
				assert(label in labelTable);
				currentLabel = labelTable[label];
				currentLabel.passed = true;
				if (currentLabel.unused && getOption('u') && optionUnusedLabels)
					warning("Unused label: " ~ label);
			}
		}
		if (eol()) {
			listCommentLine();
			return;
		}
		readSpaces();
	}
	commentOrRep: for (;;) {
		if (eol()) {
			listCommentLine();
			return;
		}
		switch (line[column]) {
		case '\t':
		case ' ':
			column++;
			continue;
		case '*':
		case ';':
		case '|':
			listCommentLine();
			return;
		case ':':
			if (inFalseCondition()) {
				listCommentLine();
				return;
			}
			column++;
			readUnsignedWord();
			mustBeKnownInPass1();
			int repeatLimit = value;
			if (repeatLimit == 0) {
				listCommentLine();
				return;
			}
			readSpaces();
			repeating = true;
			if (repeatLimit == 1)
				break;
			if (willSkip)
				warning("Skipping only the first instruction");
			int savedColumn = column;
			for (repeatCounter = 0; repeatCounter < repeatLimit; repeatCounter++) {
				column = savedColumn;
				assemblyPair();
			}
			checkNoExtraCharacters();
			listLine();
			wereManyInstructions = true;
			return;
		default:
			repeating = false;
			break commentOrRep;
		}
	}
	if (inFalseCondition()) {
		switch (readInstruction()) {
		case "END":
			assemblyEnd();
			break;
		case "IFT":
			assemblyIft();
			break;
		case "ELI":
			assemblyEli();
			break;
		case "ELS":
			assemblyEls();
			break;
		case "EIF":
			assemblyEif();
			break;
		default:
			listCommentLine();
			return;
		}
		checkNoExtraCharacters();
		listCommentLine();
		return;
	}
	assemblyPair();
	checkNoExtraCharacters();
	listLine();
}

void assemblyFile(string filename) {
	filename = filename.defaultExtension("asx");
	if (getOption('p'))
		filename = absolutePath(filename);
	File stream = openInputFile(filename);
	scope (exit) stream.close();
	string oldFilename = currentFilename;
	int oldLineNo = lineNo;
	currentFilename = filename;
	lineNo = 0;
	foundEnd = false;
	line = "";
	readChar: while (!foundEnd) {
		int b = readByte(&stream);
		switch (b) {
		case -1:
			break readChar;
		case '\r':
			assemblyLine();
			line = "";
			b = readByte(&stream);
			if (b < 0)
				break readChar;
			if (b != '\n')
				line ~= cast(char) b;
			break;
		case '\n':
		case 0x9b:
			assemblyLine();
			line = "";
			break;
		default:
			line ~= cast(char) b;
			break;
		}
	}
	if (!foundEnd)
		assemblyLine();
	foundEnd = false;
	currentFilename = oldFilename;
	lineNo = oldLineNo;
}

void assemblyPass() {
	origin = -1;
	loadOrigin = -1;
	loadingOrigin = -1;
	blockIndex = -1;
	optionFill = false;
	option5200 = false;
	optionHeaders = true;
	optionListing = pass2;
	optionObject = true;
	optionUnusedLabels = true;
	willSkip = false;
	skipping = false;
	repeatOffset = 0;
	wereManyInstructions = false;
	currentFilename = "command line";
	lineNo = 0;
	foreach (definition; commandLineDefinitions) {
		line = replaceFirst(definition, "=", " equ ");
		assemblyLine();
	}
	line = null;
	totalLines = 0;
	assemblyFile(sourceFilename);
	if (ifContexts.length != 0)
		throw new AssemblyError("Missing EIF");
	if (willSkip)
		throw new AssemblyError("Can't skip over this");
}

pure bool isOption(string arg) {
	if (arg.length < 2) return false;
	if (arg[0] == '-') return true;
	if (arg[0] != '/') return false;
	if (arg.length == 2) return true;
	if (arg[2] == ':') return true;
	return false;
}

void setOption(char letter) {
	assert(letter >= 'a' && letter <= 'z');
	if (options[letter - 'a']) {
		exitCode = 3;
		return;
	}
	options[letter - 'a'] = true;
}

int main(string[] args) {
	for (int i = 1; i < args.length; i++) {
		string arg = args[i];
		if (isOption(arg)) {
			char letter = arg[1];
			if (letter >= 'A' && letter <= 'Z')
				letter += 'a' - 'A';
			switch (letter) {
			case 'c':
			case 'i':
			case 'm':
			case 'p':
			case 'q':
			case 'u':
				if (arg.length != 2)
					exitCode = 3;
				setOption(letter);
				break;
			case 'd':
				string definition = null;
				if (arg[0] == '/') {
					if (arg.length >= 3 && arg[2] == ':')
						definition = arg[3 .. $];
				} else if (i + 1 < args.length && !isOption(args[i + 1]))
					definition = args[++i];
				if (definition is null || find(definition, '=').empty)
					exitCode = 3;
				commandLineDefinitions ~= definition;
				break;
			case 'l':
			case 't':
			case 'o':
				setOption(letter);
				string filename = null;
				if (arg[0] == '/') {
					if (arg.length >= 3 && arg[2] == ':')
						filename = arg[3 .. $];
				} else if (i + 1 < args.length && !isOption(args[i + 1]))
					filename = args[++i];
				if (filename is null && (letter == 'o' || arg.length != 2))
					exitCode = 3;
				optionParameters[letter - 'a'] = filename;
				break;
			default:
				exitCode = 3;
				break;
			}
			continue;
		}
		if (sourceFilename !is null)
			exitCode = 3;
		sourceFilename = arg;
	}
	if (sourceFilename is null)
		exitCode = 3;
	if (!getOption('q'))
		writeln(TITLE);
	if (exitCode != 0) {
		write(
`Syntax: xasm source [options]
/c             Include false conditionals in listing
/d:label=value Define a label
/i             Don't list included files
/l[:filename]  Generate listing
/o:filename    Set object file name
/M             Print Makefile rule
/p             Print absolute paths in listing and error messages
/q             Suppress info messages
/t[:filename]  List label table
/u             Warn of unused labels
`);
		return exitCode;
	}
	try {
		assemblyPass();
		pass2 = true;
		assemblyPass();
		if (getOption('t') && labelTable.length > 0)
			listLabelTable();
	} catch (AssemblyError e) {
		warning(e.msg, true);
		exitCode = 2;
	}
	listingStream.close();
	objectStream.close();
	if (exitCode <= 1) {
		if (!getOption('q')) {
			writefln("%d lines of source assembled", totalLines);
			if (objectBytes > 0)
				writefln("%d bytes written to the object file", objectBytes);
		}
		if (getOption('m')) {
			writef("%s:", makeTarget);
			foreach (filename; makeSources)
				writef(" %s", makeEscape(filename));
			write("\n\txasm");
			for (int i = 1; i < args.length; i++) {
				string arg = args[i];
				if (isOption(arg)) {
					char letter = arg[1];
					if (letter >= 'A' && letter <= 'Z')
						letter += 'a' - 'A';
					switch (letter) {
					case 'm':
						break;
					case 'o':
						if (arg[0] == '/')
							writef(" /%c:$@", arg[1]);
						else {
							writef(" -%c $@", arg[1]);
							++i;
						}
						break;
					default:
						if (arg[0] == '-'
						 && (letter == 'd' || letter == 'l' || letter == 't')
						 && i + 1 < args.length && !isOption(args[i + 1])) {
							writef(" %s %s", arg, makeEscape(args[++i]));
						}
						else {
							writef(" %s", makeEscape(arg));
						}
						break;
					}
					continue;
				}
				write(" $<");
			}
			writeln();
		}
	}
	return exitCode;
}