auto notice(P&&... p) -> void {
+ return self.notice(forward(p)...);
+ }
+
+ template auto warning(P&&... p) -> void {
+ return self.warning(forward(p)...);
+ }
+
+ template auto error(P&&... p) -> void {
+ return self.error(forward(p)...);
+ }
+
+ Bass& self;
+};
diff --git a/roms/snes-test-roms/bass-untech/bass/architecture/table/table.cpp b/roms/snes-test-roms/bass-untech/bass/architecture/table/table.cpp
new file mode 100644
index 00000000..d9381d3a
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/architecture/table/table.cpp
@@ -0,0 +1,235 @@
+Table::Table(Bass& self, const string& table) : Architecture(self) {
+ bitval = 0;
+ bitpos = 0;
+ parseTable(table);
+}
+
+auto Table::assemble(const string& statement) -> bool {
+ string s = statement;
+
+ if(s.match("instrument \"*\"")) {
+ s.trim("instrument \"", "\"", 1L);
+ parseTable(s);
+ return true;
+ }
+
+ uint pc = Architecture::pc();
+
+ for(auto& opcode : table) {
+ if(!tokenize(s, opcode.pattern)) continue;
+
+ string_vector args;
+ tokenize(args, s, opcode.pattern);
+ if(args.size() != opcode.number.size()) continue;
+
+ bool mismatch = false;
+ for(auto& format : opcode.format) {
+ if(format.type == Format::Type::Absolute) {
+ if(format.match != Format::Match::Weak) {
+ uint bits = bitLength(args[format.argument]);
+ if(bits != opcode.number[format.argument].bits) {
+ if(format.match == Format::Match::Exact || bits != 0) {
+ mismatch = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+ if(mismatch) continue;
+
+ for(auto& format : opcode.format) {
+ switch(format.type) {
+ case Format::Type::Static: {
+ writeBits(format.data, format.bits);
+ break;
+ }
+
+ case Format::Type::Absolute: {
+ uint data = evaluate(args[format.argument], Bass::Evaluation::Lax);
+ writeBits(data, opcode.number[format.argument].bits);
+ break;
+ }
+
+ case Format::Type::Relative: {
+ int data = evaluate(args[format.argument], Bass::Evaluation::Lax) - (pc + format.displacement);
+ uint bits = opcode.number[format.argument].bits;
+ int min = -(1 << (bits - 1)), max = +(1 << (bits - 1)) - 1;
+ if(data < min || data > max) error("branch out of bounds");
+ writeBits(data, opcode.number[format.argument].bits);
+ break;
+ }
+
+ case Format::Type::Repeat: {
+ uint data = evaluate(args[format.argument], Bass::Evaluation::Lax);
+ for(uint n : range(data)) {
+ writeBits(format.data, opcode.number[format.argument].bits);
+ }
+ break;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+auto Table::bitLength(string& text) const -> uint {
+ auto binLength = [&](const char* p) -> uint {
+ uint length = 0;
+ while(*p) {
+ if(*p == '0' || *p == '1') { p++; length += 1; continue; }
+ return 0;
+ }
+ return length;
+ };
+
+ auto hexLength = [&](const char* p) -> uint {
+ uint length = 0;
+ while(*p) {
+ if(*p >= '0' && *p <= '9') { p++; length += 4; continue; }
+ if(*p >= 'a' && *p <= 'f') { p++; length += 4; continue; }
+ if(*p >= 'A' && *p <= 'F') { p++; length += 4; continue; }
+ return 0;
+ }
+ return length;
+ };
+
+ char* p = text.get();
+ if(*p == '<') { *p = ' '; return 8; }
+ if(*p == '>') { *p = ' '; return 16; }
+ if(*p == '^') { *p = ' '; return 24; }
+ if(*p == '?') { *p = ' '; return 32; }
+ if(*p == ':') { *p = ' '; return 64; }
+ if(*p == '%') return binLength(p + 1);
+ if(*p == '$') return hexLength(p + 1);
+ if(*p == '0' && *(p + 1) == 'b') return binLength(p + 2);
+ if(*p == '0' && *(p + 1) == 'x') return hexLength(p + 2);
+ return 0;
+}
+
+auto Table::writeBits(uint64_t data, uint length) -> void {
+ bitval <<= length;
+ bitval |= data;
+ bitpos += length;
+
+ while(bitpos >= 8) {
+ write(bitval);
+ bitval >>= 8;
+ bitpos -= 8;
+ }
+}
+
+auto Table::parseTable(const string& text) -> bool {
+ auto lines = text.split("\n");
+ for(auto& line : lines) {
+ if(auto position = line.find("//")) line.resize(position()); //remove comments
+
+ if(line == "endian lsb") { setEndian(Bass::Endian::LSB); continue; }
+ if(line == "endian msb") { setEndian(Bass::Endian::MSB); continue; }
+
+ auto part = line.split(";", 1L).strip();
+ if(part.size() != 2) continue;
+
+ Opcode opcode;
+ assembleTableLHS(opcode, part(0));
+ assembleTableRHS(opcode, part(1));
+ table.append(opcode);
+ }
+
+ return true;
+}
+
+auto Table::assembleTableLHS(Opcode& opcode, const string& text) -> void {
+ uint offset = 0;
+
+ auto length = [&] {
+ uint length = 0;
+ while(text[offset + length]) {
+ char n = text[offset + length];
+ if(n == '*') break;
+ length++;
+ }
+ return length;
+ };
+
+ while(text[offset]) {
+ uint size = length();
+ opcode.prefix.append({slice(text, offset, size), size});
+ offset += size;
+
+ if(text[offset] != '*') continue;
+ uint bits = 10 * (text[offset + 1] - '0');
+ bits += text[offset + 2] - '0';
+ opcode.number.append({bits});
+ offset += 3;
+ }
+
+ for(auto& prefix : opcode.prefix) {
+ opcode.pattern.append(prefix.text, "*");
+ }
+ opcode.pattern.trimRight("*", 1L);
+ if(opcode.number.size() == opcode.prefix.size()) opcode.pattern.append("*");
+}
+
+auto Table::assembleTableRHS(Opcode& opcode, const string& text) -> void {
+ uint offset = 0;
+
+ auto list = text.split(" ");
+ for(auto& item : list) {
+ if(item[0] == '$' && item.length() == 3) {
+ Format format = {Format::Type::Static};
+ format.data = toHex((const char*)item + 1);
+ format.bits = (item.length() - 1) * 4;
+ opcode.format.append(format);
+ }
+
+ if(item[0] == '%') {
+ Format format = {Format::Type::Static};
+ format.data = toBinary((const char*)item + 1);
+ format.bits = (item.length() - 1);
+ opcode.format.append(format);
+ }
+
+ if(item[0] == '!') {
+ Format format = {Format::Type::Absolute, Format::Match::Exact};
+ format.argument = item[1] - 'a';
+ opcode.format.append(format);
+ }
+
+ if(item[0] == '=') {
+ Format format = {Format::Type::Absolute, Format::Match::Strong};
+ format.argument = item[1] - 'a';
+ opcode.format.append(format);
+ }
+
+ if(item[0] == '~') {
+ Format format = {Format::Type::Absolute, Format::Match::Weak};
+ format.argument = item[1] - 'a';
+ opcode.format.append(format);
+ }
+
+ if(item[0] == '+') {
+ Format format = {Format::Type::Relative};
+ format.argument = item[2] - 'a';
+ format.displacement = +(item[1] - '0');
+ opcode.format.append(format);
+ }
+
+ if(item[0] == '-') {
+ Format format = {Format::Type::Relative};
+ format.argument = item[2] - 'a';
+ format.displacement = -(item[1] - '0');
+ opcode.format.append(format);
+ }
+
+ if(item[0] == '*') {
+ Format format = {Format::Type::Repeat};
+ format.argument = item[1] - 'a';
+ format.data = toHex((const char*)item + 3);
+ opcode.format.append(format);
+ }
+ }
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/architecture/table/table.hpp b/roms/snes-test-roms/bass-untech/bass/architecture/table/table.hpp
new file mode 100644
index 00000000..eaee833f
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/architecture/table/table.hpp
@@ -0,0 +1,39 @@
+struct Table : Architecture {
+ Table(Bass& self, const string& table);
+ auto assemble(const string& statement) -> bool override;
+
+private:
+ struct Prefix {
+ string text;
+ uint size;
+ };
+
+ struct Number {
+ uint bits;
+ };
+
+ struct Format {
+ enum class Type : uint { Static, Absolute, Relative, Repeat } type;
+ enum class Match : uint { Exact, Strong, Weak } match;
+ uint data;
+ uint bits;
+ uint argument;
+ int displacement;
+ };
+
+ struct Opcode {
+ vector prefix;
+ vector number;
+ vector format;
+ string pattern;
+ };
+
+ auto bitLength(string& text) const -> uint;
+ auto writeBits(uint64_t data, uint bits) -> void;
+ auto parseTable(const string& text) -> bool;
+ auto assembleTableLHS(Opcode& opcode, const string& text) -> void;
+ auto assembleTableRHS(Opcode& opcode, const string& text) -> void;
+
+ vector table;
+ uint64_t bitval, bitpos;
+};
diff --git a/roms/snes-test-roms/bass-untech/bass/bass.cpp b/roms/snes-test-roms/bass-untech/bass/bass.cpp
new file mode 100644
index 00000000..6575ef72
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/bass.cpp
@@ -0,0 +1,82 @@
+//bass-untech
+//license: ISC
+//author: Near
+//forked by: The UnDisbeliever
+//project started: 2013-09-27
+
+#include "bass.hpp"
+#include "core/core.cpp"
+#include "architecture/table/table.cpp"
+
+#include
+auto nall::main(Arguments arguments) -> void {
+ if(!arguments) {
+ print(stderr, "bass-untech v17\n");
+ print(stderr, "\n");
+ print(stderr, "usage:\n");
+ print(stderr, " bass-untech [options] source [source ...]\n");
+ print(stderr, "\n");
+ print(stderr, "options:\n");
+ print(stderr, " -o target specify default output filename [overwrite]\n");
+ print(stderr, " -m target specify default output filename [modify]\n");
+ print(stderr, " -d name[=value] create define with optional value\n");
+ print(stderr, " -c name[=value] create constant with optional value\n");
+ print(stderr, " -sym filename create symbol file\n");
+ print(stderr, " -strict upgrade warnings to errors\n");
+ print(stderr, " -benchmark benchmark performance\n");
+ exit(EXIT_FAILURE);
+ }
+
+ string targetFilename;
+ bool create = false;
+ if(arguments.take("-o", targetFilename)) create = true;
+ if(arguments.take("-m", targetFilename)) create = false;
+
+ vector defines;
+ string define;
+ while(arguments.take("-d", define)) defines.append(define);
+
+ vector constants;
+ string constant;
+ while(arguments.take("-c", constant)) constants.append(constant);
+
+ string symFilename;
+ arguments.take("-sym", symFilename);
+
+ bool strict = arguments.take("-strict");
+ bool benchmark = arguments.take("-benchmark");
+
+ if(arguments.find("-*")) {
+ print(stderr, "error: unrecognized argument(s)\n");
+ exit(EXIT_FAILURE);
+ }
+
+ vector sourceFilenames;
+ for(auto& argument : arguments) sourceFilenames.append(argument);
+
+ clock_t clockStart = clock();
+ Bass bass;
+ bass.target(targetFilename, create);
+ if(symFilename) {
+ bass.symFile(symFilename);
+ }
+ for(auto& sourceFilename : sourceFilenames) {
+ bass.source(sourceFilename);
+ }
+ for(auto& define : defines) {
+ auto p = define.split("=", 1L);
+ bass.define(p(0), p(1));
+ }
+ for(auto& constant : constants) {
+ auto p = constant.split("=", 1L);
+ bass.constant(p(0), p(1, "1"));
+ }
+ if(!bass.assemble(strict)) {
+ print(stderr, "bass: assembly failed\n");
+ exit(EXIT_FAILURE);
+ }
+ clock_t clockFinish = clock();
+ if(benchmark) {
+ print(stderr, "bass: assembled in ", (double)(clockFinish - clockStart) / CLOCKS_PER_SEC, " seconds\n");
+ }
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/bass.hpp b/roms/snes-test-roms/bass-untech/bass/bass.hpp
new file mode 100644
index 00000000..9c710c73
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/bass.hpp
@@ -0,0 +1,9 @@
+#define Architecture NallArchitecture
+#include
+using namespace nall;
+using string_vector = vector;
+#undef Architecture
+
+#include "core/core.hpp"
+#include "architecture/architecture.hpp"
+#include "architecture/table/table.hpp"
diff --git a/roms/snes-test-roms/bass-untech/bass/core/analyze.cpp b/roms/snes-test-roms/bass-untech/bass/core/analyze.cpp
new file mode 100644
index 00000000..9f4fd66b
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/core/analyze.cpp
@@ -0,0 +1,134 @@
+auto Bass::analyze() -> bool {
+ blocks.reset();
+ ip = 0;
+
+ while(ip < program.size()) {
+ Instruction& i = program(ip++);
+ if(!analyzeInstruction(i)) error("unrecognized directive: ", i.statement);
+ }
+
+ return true;
+}
+
+auto Bass::analyzeInstruction(Instruction& i) -> bool {
+ string s = i.statement;
+
+ if(s.match("}") && !blocks) error("} without matching {: ", sourceFilenames[i.fileNumber], ":", i.lineNumber);
+
+ if(s.match("{")) {
+ blocks.append({ip - 1, "block"});
+ i.statement = "block {";
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "block") {
+ blocks.removeRight();
+ i.statement = "} endblock";
+ return true;
+ }
+
+ if(s.match("namespace ?* {")) {
+ blocks.append({ip - 1, "namespace"});
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "namespace") {
+ blocks.removeRight();
+ i.statement = "} endnamespace";
+ return true;
+ }
+
+ if(s.match("function ?* {")) {
+ blocks.append({ip - 1, "function"});
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "function") {
+ blocks.removeRight();
+ i.statement = "} endfunction";
+ return true;
+ }
+
+ if(s.match("macro ?*(*) {")) {
+ blocks.append({ip - 1, "macro"});
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "macro") {
+ uint rp = blocks.right().ip;
+ program[rp].ip = ip;
+ blocks.removeRight();
+ i.statement = "} endmacro";
+ return true;
+ }
+
+ if(s.match("inline ?*(*) {")) {
+ blocks.append({ip - 1, "inline"});
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "inline") {
+ uint rp = blocks.right().ip;
+ program[rp].ip = ip;
+ blocks.removeRight();
+ i.statement = "} endinline";
+ return true;
+ }
+
+ if(s.match("?*: {") || s.match("- {") || s.match("+ {")) {
+ blocks.append({ip - 1, "constant"});
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "constant") {
+ blocks.removeRight();
+ i.statement = "} endconstant";
+ return true;
+ }
+
+ if(s.match("if ?* {")) {
+ s.trim("if ", " {", 1L);
+ blocks.append({ip - 1, "if"});
+ return true;
+ }
+
+ if(s.match("} else if ?* {")) {
+ s.trim("} else if ", " {", 1L);
+ uint rp = blocks.right().ip;
+ program[rp].ip = ip - 1;
+ blocks.right().ip = ip - 1;
+ return true;
+ }
+
+ if(s.match("} else {")) {
+ uint rp = blocks.right().ip;
+ program[rp].ip = ip - 1;
+ blocks.right().ip = ip - 1;
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "if") {
+ uint rp = blocks.right().ip;
+ program[rp].ip = ip - 1;
+ blocks.removeRight();
+ i.statement = "} endif";
+ return true;
+ }
+
+ if(s.match("while ?* {")) {
+ s.trim("while ", " {", 1L);
+ blocks.append({ip - 1, "while"});
+ return true;
+ }
+
+ if(s.match("}") && blocks.right().type == "while") {
+ uint rp = blocks.right().ip;
+ program[rp].ip = ip;
+ blocks.removeRight();
+ i.statement = "} endwhile";
+ i.ip = rp;
+ return true;
+ }
+
+ return true;
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/core/assemble.cpp b/roms/snes-test-roms/bass-untech/bass/core/assemble.cpp
new file mode 100644
index 00000000..8a360f5b
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/core/assemble.cpp
@@ -0,0 +1,356 @@
+auto Bass::initialize() -> void {
+ queue.reset();
+ scope.reset();
+ for(uint n : range(256)) stringTable[n] = n;
+ endian = Endian::LSB;
+ origin = 0;
+ base = 0;
+ lastLabelCounter = 1;
+ nextLabelCounter = 1;
+}
+
+auto Bass::assemble(const string& statement) -> bool {
+ string s = statement;
+
+ if(s.match("block {")) return true;
+ if(s.match("} endblock")) return true;
+
+ //namespace name {
+ if(s.match("namespace ?* {")) {
+ s.trim("namespace ", "{", 1L).strip();
+ if(!validate(s)) error("invalid namespace specifier: ", s);
+ scope.append(s);
+ return true;
+ }
+
+ //}
+ if(s.match("} endnamespace")) {
+ scope.removeRight();
+ return true;
+ }
+
+ //function name {
+ if(s.match("function ?* {")) {
+ s.trim("function ", "{", 1L).strip();
+ setConstant(s, pc());
+ writeSymbolLabel(pc(), s);
+ scope.append(s);
+ return true;
+ }
+
+ //}
+ if(s.match("} endfunction")) {
+ scope.removeRight();
+ return true;
+ }
+
+ //constant name(value)
+ if(s.match("constant ?*")) {
+ auto p = s.trimLeft("constant ", 1L).split("=", 1L).strip();
+ auto v = evaluate(p(1), Evaluation::Lax);
+ if(forwardReference) {
+ setUnknownConstant(p(0));
+ } else {
+ setConstant(p(0), v);
+ }
+ return true;
+ }
+
+ //label: or label: {
+ if(s.match("?*:") || s.match("?*: {")) {
+ s.trimRight(" {", 1L);
+ s.trimRight(":", 1L);
+ setConstant(s, pc());
+ writeSymbolLabel(pc(), s);
+ return true;
+ }
+
+ //- or - {
+ if(s.match("-") || s.match("- {")) {
+ setConstant({"lastLabel#", lastLabelCounter++}, pc());
+ return true;
+ }
+
+ //+ or + {
+ if(s.match("+") || s.match("+ {")) {
+ setConstant({"nextLabel#", nextLabelCounter++}, pc());
+ return true;
+ }
+
+ //}
+ if(s.match("} endconstant")) {
+ return true;
+ }
+
+ //output "filename" [, create]
+ if(s.match("output ?*")) {
+ auto p = split(s.trimLeft("output ", 1L));
+ if(!p(0).match("\"*\"")) error("missing filename");
+ string filename = {filepath(), text(p.take(0))};
+ bool create = (p.size() && p(0) == "create");
+ target(filename, create);
+ return true;
+ }
+
+ //architecture name
+ if(s.match("architecture ?*")) {
+ s.trimLeft("architecture ", 1L);
+ if(s == "none") architecture = new Architecture{*this};
+ else {
+ string location{Path::userData(), "bass/architectures/", s, ".arch"};
+ if(!file::exists(location)) location = {Path::program(), "architectures/", s, ".arch"};
+ if(!file::exists(location)) error("unknown architecture: ", s);
+ architecture = new Table{*this, string::read(location)};
+ }
+ return true;
+ }
+
+ //endian (lsb|msb)
+ if(s.match("endian ?*")) {
+ s.trimLeft("endian ", 1L);
+ if(s == "lsb") { endian = Endian::LSB; return true; }
+ if(s == "msb") { endian = Endian::MSB; return true; }
+ error("invalid endian mode");
+ }
+
+ //origin offset
+ if(s.match("origin ?*")) {
+ s.trimLeft("origin ", 1L);
+ origin = evaluate(s);
+ seek(origin);
+ return true;
+ }
+
+ //base offset
+ if(s.match("base ?*")) {
+ s.trimLeft("base ", 1L);
+ base = evaluate(s) - origin;
+ return true;
+ }
+
+ //enqueue variable [, ...]
+ if(s.match("enqueue ?*")) {
+ auto p = split(s.trimLeft("enqueue ", 1L));
+ for(auto& t : p) {
+ if(t == "origin") {
+ queue.append(origin);
+ } else if(t == "base") {
+ queue.append(base);
+ } else if(t == "pc") {
+ queue.append(origin);
+ queue.append(base);
+ } else {
+ error("unrecognized enqueue variable: ", t);
+ }
+ }
+ return true;
+ }
+
+ //dequeue variable [, ...]
+ if(s.match("dequeue ?*")) {
+ auto p = split(s.trimLeft("dequeue ", 1L));
+ for(auto& t : p) {
+ if(t == "origin") {
+ origin = queue.takeRight().natural();
+ seek(origin);
+ } else if(t == "base") {
+ base = queue.takeRight().integer();
+ } else if(t == "pc") {
+ base = queue.takeRight().integer();
+ origin = queue.takeRight().natural();
+ seek(origin);
+ } else {
+ error("unrecognized dequeue variable: ", t);
+ }
+ }
+ return true;
+ }
+
+ //copy source, target, length
+ if(s.match("copy ?*")) {
+ auto p = split(s.trimLeft("copy ", 1L));
+ if(p.size() == 3) {
+ auto origin = targetFile.offset();
+ auto source = evaluate(p(0));
+ auto target = evaluate(p(1));
+ auto length = evaluate(p(2));
+ vector memory;
+ memory.resize(length);
+ targetFile.seek(source);
+ targetFile.read(memory);
+ targetFile.seek(target);
+ for(uint offset : range(length)) write(memory[offset]);
+ targetFile.seek(origin);
+ return true;
+ }
+ }
+
+ //insert [name, ] filename [, offset] [, length]
+ if(s.match("insert ?*")) {
+ auto p = split(s.trimLeft("insert ", 1L));
+ string name;
+ if(!p(0).match("\"*\"")) name = p.take(0);
+ if(!p(0).match("\"*\"")) error("missing filename");
+ string filename = {filepath(), text(p.take(0))};
+ auto fp = file::open(filename, file::mode::read);
+ if(!fp) error("file not found: ", filename);
+ uint offset = p.size() ? evaluate(p.take(0)) : 0;
+ if(offset > fp.size()) offset = fp.size();
+ uint length = p.size() ? evaluate(p.take(0)) : 0;
+ if(length == 0) length = fp.size() - offset;
+ if(name) {
+ setConstant({name}, pc());
+ setConstant({name, ".size"}, length);
+ writeSymbolLabel(pc(), name);
+ }
+ fp.seek(offset);
+ while(!fp.end() && length--) write(fp.read());
+ return true;
+ }
+
+ //delete filename
+ if(s.match("delete ?*")) {
+ auto p = split(s.trimLeft("delete ", 1L));
+ if(!p(0).match("\"*\"")) error("missing filename");
+ string filename = {filepath(), text(p.take(0))};
+ if(!file::exists(filename)) {
+ warning("file not found: ", filename);
+ return true;
+ }
+ if(!file::remove(filename)) {
+ warning("unable to delete file: ", filename);
+ return true;
+ }
+ return true;
+ }
+
+ //fill length [, with]
+ if(s.match("fill ?*")) {
+ auto p = split(s.trimLeft("fill ", 1L));
+ uint length = evaluate(p(0));
+ uint byte = evaluate(p(1, "0"), Evaluation::Lax);
+ while(length--) write(byte);
+ return true;
+ }
+
+ //map 'char' [, value] [, length]
+ if(s.match("map ?*")) {
+ auto p = split(s.trimLeft("map ", 1L));
+ uint8_t index = evaluate(p(0));
+ int64_t value = evaluate(p(1, "0"));
+ int64_t length = evaluate(p(2, "1"));
+ for(int n : range(length)) {
+ stringTable[index + n] = value + n;
+ }
+ return true;
+ }
+
+ //d[bwldq] ("string"|variable) [, ...]
+ uint dataLength = 0;
+ if(s.beginsWith("db ")) dataLength = 1;
+ if(s.beginsWith("dw ")) dataLength = 2;
+ if(s.beginsWith("dl ")) dataLength = 3;
+ if(s.beginsWith("dd ")) dataLength = 4;
+ if(s.beginsWith("dq ")) dataLength = 8;
+ if(dataLength) {
+ s = slice(s, 3); //remove prefix
+ auto p = split(s);
+ for(auto& t : p) {
+ if(t.match("\"*\"")) {
+ t = text(t);
+ for(auto& b : t) write(stringTable[b], dataLength);
+ } else {
+ write(evaluate(t, Evaluation::Lax), dataLength);
+ }
+ }
+ return true;
+ }
+
+ //ds amount
+ if(s.match("ds ?*")) {
+ s.trimLeft("ds ", 1L);
+ origin += evaluate(s);
+ seek(origin);
+ return true;
+ }
+
+ //tracker enable|disable|reset
+ if(s.match("tracker ?*")) {
+ s.trimLeft("tracker ", 1L).strip();
+ if(s == "enable") {
+ if(writePhase()) tracker.enable = true;
+ return true;
+ }
+ if(s == "disable") {
+ if(writePhase()) tracker.enable = false;
+ return true;
+ }
+ if(s == "reset") {
+ if(writePhase()) tracker.addresses.reset();
+ return true;
+ }
+ }
+
+ //print ("string"|[cast:]variable) [, ...]
+ if(s.match("print ?*")) {
+ if(writePhase()) {
+ s.trimLeft("print ", 1L).strip();
+ print(stderr, assembleString(s));
+ }
+ return true;
+ }
+
+ //notice ("string"|[cast:]variable) [, ...]
+ if(s.match("notice ?*")) {
+ if(writePhase()) {
+ s.trimLeft("notice ", 1L).strip();
+ notice(assembleString(s));
+ }
+ return true;
+ }
+
+ //warning ("string"|[cast:]variable) [, ...]
+ if(s.match("warning ?*")) {
+ if(writePhase()) {
+ s.trimLeft("warning ", 1L).strip();
+ warning(assembleString(s));
+ }
+ return true;
+ }
+
+ //error ("string"|[cast:]variable) [, ...]
+ if(s.match("error ?*")) {
+ if(writePhase()) {
+ s.trimLeft("error ", 1L).strip();
+ error(assembleString(s));
+ }
+ return true;
+ }
+
+ charactersUseMap = true;
+ bool result = architecture->assemble(statement);
+ charactersUseMap = false;
+ return result;
+}
+
+auto Bass::assembleString(const string& parameters) -> string {
+ string result;
+ auto p = split(parameters);
+ for(auto& t : p) {
+ if(t.match("\"*\"")) {
+ result.append(text(t));
+ } else if(t.match("binary:?*")) {
+ t.trimLeft("binary:", 1L);
+ result.append(binary(evaluate(t)));
+ } else if(t.match("hex:?*")) {
+ t.trimLeft("hex:", 1L);
+ result.append(hex(evaluate(t)));
+ } else if(t.match("char:?*")) {
+ t.trimLeft("char:", 1L);
+ result.append((char)evaluate(t));
+ } else {
+ result.append(evaluate(t));
+ }
+ }
+ return result;
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/core/core.cpp b/roms/snes-test-roms/bass-untech/bass/core/core.cpp
new file mode 100644
index 00000000..ee6e6279
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/core/core.cpp
@@ -0,0 +1,197 @@
+#include "evaluate.cpp"
+#include "analyze.cpp"
+#include "execute.cpp"
+#include "assemble.cpp"
+#include "utility.cpp"
+
+auto Bass::target(const string& filename, bool create) -> bool {
+ if(targetFile) targetFile.close();
+ if(!filename) return true;
+
+ //cannot modify a file unless it exists
+ if(!file::exists(filename)) create = true;
+
+ if(!targetFile.open(filename, create ? file::mode::write : file::mode::modify)) {
+ print(stderr, "warning: unable to open target file: ", filename, "\n");
+ return false;
+ }
+
+ tracker.addresses.reset();
+ return true;
+}
+
+auto Bass::symFile(const string& filename) -> bool {
+ if(symbolFile) symbolFile.close();
+ if(!filename) return true;
+
+ if(!symbolFile.open(filename, file::mode::write)) {
+ print(stderr, "warning: unable to open symbol file: ", filename, "\n");
+ return false;
+ }
+
+ return true;
+}
+
+auto Bass::source(const string& filename) -> bool {
+ if(!file::exists(filename)) {
+ print(stderr, "warning: source file not found: ", filename, "\n");
+ return false;
+ }
+
+ uint fileNumber = sourceFilenames.size();
+ sourceFilenames.append(filename);
+
+ string data = file::read(filename);
+ data.transform("\t\r", " ");
+
+ auto lines = data.split("\n");
+ for(uint lineNumber : range(lines.size())) {
+ //remove single-line comments
+ if(auto position = lines[lineNumber].qfind("//")) {
+ lines[lineNumber].resize(position());
+ }
+
+ //allow multiple statements per line, separated by ';'
+ auto blocks = lines[lineNumber].qsplit(";").strip();
+ for(uint blockNumber : range(blocks.size())) {
+ string statement = blocks[blockNumber];
+ strip(statement);
+ if(!statement) continue;
+
+ if(statement.match("include \"?*\"")) {
+ statement.trimLeft("include ", 1L).strip();
+ source({Location::path(filename), text(statement)});
+ } else {
+ Instruction instruction;
+ instruction.statement = statement;
+ instruction.fileNumber = fileNumber;
+ instruction.lineNumber = 1 + lineNumber;
+ instruction.blockNumber = 1 + blockNumber;
+ program.append(instruction);
+ }
+ }
+ }
+
+ return true;
+}
+
+auto Bass::define(const string& name, const string& value) -> void {
+ defines.insert({name, {}, value});
+}
+
+auto Bass::constant(const string& name, const string& value) -> void {
+ try {
+ constantNames.insert(name);
+ constants.insert({name, evaluate(value, Evaluation::Strict)});
+ } catch(...) {
+ }
+}
+
+auto Bass::assemble(bool strict) -> bool {
+ this->strict = strict;
+
+ try {
+ phase = Phase::Analyze;
+ analyze();
+
+ phase = Phase::Query;
+ architecture = new Architecture{*this};
+ execute();
+
+ phase = Phase::Write;
+ architecture = new Architecture{*this};
+ execute();
+ } catch(...) {
+ return false;
+ }
+
+ return true;
+}
+
+//internal
+
+auto Bass::pc() const -> uint {
+ return origin + base;
+}
+
+auto Bass::seek(uint offset) -> void {
+ if(!targetFile) return;
+ if(writePhase()) targetFile.seek(offset);
+}
+
+auto Bass::track(uint length) -> void {
+ if(!tracker.enable) return;
+ uint64_t address = targetFile.offset();
+ for(auto n : range(length)) {
+ if(tracker.addresses.find(address + n)) {
+ error("overwrite detected at address 0x", hex(address + n), " [0x", hex(base + address + n), "]");
+ }
+ tracker.addresses.insert(address + n);
+ }
+}
+
+auto Bass::write(uint64_t data, uint length) -> void {
+ if(writePhase()) {
+ if(targetFile) {
+ track(length);
+ if(endian == Endian::LSB) targetFile.writel(data, length);
+ if(endian == Endian::MSB) targetFile.writem(data, length);
+ } else if(!isatty(fileno(stdout))) {
+ if(endian == Endian::LSB) for(uint n : range(length)) fputc(data >> n * 8, stdout);
+ if(endian == Endian::MSB) for(uint n : reverse(range(length))) fputc(data >> n * 8, stdout);
+ }
+ }
+ origin += length;
+}
+
+auto Bass::writeSymbolLabel(int64_t value, const string& name) -> void {
+ if(writePhase()) {
+ if(symbolFile) {
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+ symbolFile.print(hex(value, 8), ' ', scopedName, '\n');
+ }
+ }
+}
+
+auto Bass::printInstruction() -> void {
+ if(activeInstruction) {
+ auto& i = *activeInstruction;
+ print(stderr, sourceFilenames[i.fileNumber], ":", i.lineNumber, ":", i.blockNumber, ": ", i.statement, "\n");
+ }
+}
+
+auto Bass::printInstructionStack() -> void {
+ printInstruction();
+
+ for(const auto& frame : reverse(frames)) {
+ if(frame.ip > 0 && frame.ip <= program.size()) {
+ auto& i = program[frame.ip - 1];
+ print(stderr, " ", sourceFilenames[i.fileNumber], ":", i.lineNumber, ":", i.blockNumber, ": ", i.statement, "\n");
+ }
+ }
+}
+
+template auto Bass::notice(P&&... p) -> void {
+ string s{forward(p)...};
+ print(stderr, terminal::color::gray("notice: "), s, "\n");
+ printInstructionStack();
+}
+
+template auto Bass::warning(P&&... p) -> void {
+ string s{forward(p)...};
+ print(stderr, terminal::color::yellow("warning: "), s, "\n");
+ printInstructionStack();
+
+ if(!strict) return;
+ struct BassWarning {};
+ throw BassWarning();
+}
+
+template auto Bass::error(P&&... p) -> void {
+ string s{forward(p)...};
+ print(stderr, terminal::color::red("error: "), s, "\n");
+ printInstructionStack();
+
+ struct BassError {};
+ throw BassError();
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/core/core.hpp b/roms/snes-test-roms/bass-untech/bass/core/core.hpp
new file mode 100644
index 00000000..2cedcf60
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/core/core.hpp
@@ -0,0 +1,215 @@
+struct Architecture;
+
+struct Bass {
+ auto target(const string& filename, bool create) -> bool;
+ auto symFile(const string& filename) -> bool;
+ auto source(const string& filename) -> bool;
+ auto define(const string& name, const string& value) -> void;
+ auto constant(const string& name, const string& value) -> void;
+ auto assemble(bool strict = false) -> bool;
+
+ enum class Phase : uint { Analyze, Query, Write };
+ enum class Endian : uint { LSB, MSB };
+ enum class Evaluation : uint { Strict = 0, Lax = 1 }; //strict mode disallows forward-declaration of constants
+
+ struct Instruction {
+ string statement;
+ uint ip;
+
+ uint fileNumber;
+ uint lineNumber;
+ uint blockNumber;
+ };
+
+ struct Macro {
+ Macro() {}
+ Macro(const string& name) : name(name) {}
+ Macro(const string& name, const string_vector& parameters, uint ip, bool inlined) : name(name), parameters(parameters), ip(ip), inlined(inlined) {}
+
+ auto hash() const -> uint { return name.hash(); }
+ auto operator==(const Macro& source) const -> bool { return name == source.name; }
+ auto operator< (const Macro& source) const -> bool { return name < source.name; }
+
+ string name;
+ string_vector parameters;
+ uint ip;
+ bool inlined;
+ };
+
+ struct Define {
+ Define() {}
+ Define(const string& name) : name(name) {}
+ Define(const string& name, const string_vector& parameters, const string& value) : name(name), parameters(parameters), value(value) {}
+
+ auto hash() const -> uint { return name.hash(); }
+ auto operator==(const Define& source) const -> bool { return name == source.name; }
+ auto operator< (const Define& source) const -> bool { return name < source.name; }
+
+ string name;
+ string_vector parameters;
+ string value;
+ };
+
+ using Expression = Define; //Define and Expression structures are identical
+
+ struct Variable {
+ Variable() {}
+ Variable(const string& name) : name(name) {}
+ Variable(const string& name, int64_t value) : name(name), value(value) {}
+
+ auto hash() const -> uint { return name.hash(); }
+ auto operator==(const Variable& source) const -> bool { return name == source.name; }
+ auto operator< (const Variable& source) const -> bool { return name < source.name; }
+
+ string name;
+ int64_t value;
+ };
+
+ using Constant = Variable; //Variable and Constant structures are identical
+
+ struct Array {
+ Array() {}
+ Array(const string& name) : name(name) {}
+ Array(const string& name, vector values) : name(name), values(values) {}
+
+ auto hash() const -> uint { return name.hash(); }
+ auto operator==(const Array& source) const -> bool { return name == source.name; }
+ auto operator< (const Array& source) const -> bool { return name < source.name; }
+
+ string name;
+ vector values;
+ };
+
+ struct Frame {
+ enum class Level : uint {
+ Inline, //use deepest frame (eg for parameters)
+ Active, //use deepest non-inline frame
+ Parent, //use second-deepest non-inline frame
+ Global, //use root frame
+ };
+
+ uint ip;
+ bool inlined;
+
+ hashset macros;
+ hashset defines;
+ hashset expressions;
+ hashset variables;
+ hashset arrays;
+ };
+
+ struct Block {
+ uint ip;
+ string type;
+ };
+
+ struct Tracker {
+ bool enable = false;
+ set addresses;
+ };
+
+protected:
+ auto analyzePhase() const -> bool { return phase == Phase::Analyze; }
+ auto queryPhase() const -> bool { return phase == Phase::Query; }
+ auto writePhase() const -> bool { return phase == Phase::Write; }
+
+ //core.cpp
+ auto pc() const -> uint;
+ auto seek(uint offset) -> void;
+ auto track(uint length) -> void;
+ auto write(uint64_t data, uint length = 1) -> void;
+ auto writeSymbolLabel(int64_t value, const string& name) -> void;
+
+ auto printInstruction() -> void;
+ auto printInstructionStack() -> void;
+ template auto notice(P&&... p) -> void;
+ template auto warning(P&&... p) -> void;
+ template auto error(P&&... p) -> void;
+
+ //evaluate.cpp
+ auto evaluate(const string& expression, Evaluation mode = Evaluation::Strict) -> int64_t;
+ auto evaluate(Eval::Node* node, Evaluation mode) -> int64_t;
+ auto quantifyParameters(Eval::Node* node) -> int64_t;
+ auto evaluateParameters(Eval::Node* node, Evaluation mode) -> vector;
+ auto evaluateExpression(Eval::Node* node, Evaluation mode) -> int64_t;
+ auto evaluateString(Eval::Node* node) -> string;
+ auto evaluateLiteral(Eval::Node* node, Evaluation mode) -> int64_t;
+ auto evaluateSubscript(Eval::Node* node, Evaluation mode) -> int64_t;
+ auto evaluateAssign(Eval::Node* node, Evaluation mode) -> int64_t;
+
+ //analyze.cpp
+ auto analyze() -> bool;
+ auto analyzeInstruction(Instruction& instruction) -> bool;
+
+ //execute.cpp
+ auto execute() -> bool;
+ auto executeInstruction(Instruction& instruction) -> bool;
+
+ //assemble.cpp
+ auto initialize() -> void;
+ auto assemble(const string& statement) -> bool;
+ auto assembleString(const string& parameters) -> string;
+
+ //utility.cpp
+ auto setMacro(const string& name, const string_vector& parameters, uint ip, bool inlined, Frame::Level level) -> void;
+ auto findMacro(const string& name) -> maybe;
+
+ auto setDefine(const string& name, const string_vector& parameters, const string& value, Frame::Level level) -> void;
+ auto findDefine(const string& name) -> maybe;
+
+ auto setExpression(const string& name, const string_vector& parameters, const string& value, Frame::Level level) -> void;
+ auto findExpression(const string& name) -> maybe;
+
+ auto setVariable(const string& name, int64_t value, Frame::Level level) -> void;
+ auto findVariable(const string& name) -> maybe;
+
+ auto setUnknownConstant(const string& name) -> void;
+ auto setConstant(const string& name, int64_t value) -> void;
+ auto findConstant(const string& name) -> maybe;
+ auto findConstantName(const string& name) -> maybe;
+
+ auto setArray(const string& name, const vector& values, Frame::Level level) -> void;
+ auto findArray(const string& name) -> maybe;
+
+ auto evaluateDefines(string& statement) -> void;
+
+ auto filepath() -> string;
+ auto split(const string& s) -> string_vector;
+ auto strip(string& s) -> void;
+ auto validate(const string& s) -> bool;
+ auto text(string s) -> string;
+ auto character(const string& s) -> int64_t;
+
+ //internal state
+ Instruction* activeInstruction = nullptr; //used by notice, warning, error
+ vector program; //parsed source code statements
+ vector blocks; //track the start and end of blocks
+ set defines; //defines specified on the terminal
+ hashset constantNames; //set of constant names, including those with unknown values
+ hashset constants; //constants support forward-declaration
+ vector frames; //macros, defines and variables do not
+ vector conditionals; //track conditional matching
+ string_vector queue; //track enqueue, dequeue directives
+ string_vector scope; //track scope recursion
+ int64_t stringTable[256]; //overrides for d[bwldq] text strings
+ Phase phase; //phase of assembly
+ Endian endian = Endian::LSB; //used for multi-byte writes (d[bwldq], etc)
+ Tracker tracker; //used to track writes to detect overwrites
+ uint macroInvocationCounter; //used for {#} support
+ uint ip = 0; //instruction pointer into program
+ uint origin = 0; //file offset
+ int base = 0; //file offset to memory map displacement
+ uint lastLabelCounter = 1; //- instance counter
+ uint nextLabelCounter = 1; //+ instance counter
+ bool charactersUseMap = false; //0 = '*' parses as ASCII; 1 = '*' uses stringTable[]
+ bool strict = false; //upgrade warnings to errors when true
+
+ bool forwardReference = false; //true if the last evaluate(string) call contained a forward reference
+
+ file_buffer targetFile;
+ file_buffer symbolFile;
+ string_vector sourceFilenames;
+
+ shared_pointer architecture;
+ friend class Architecture;
+};
diff --git a/roms/snes-test-roms/bass-untech/bass/core/evaluate.cpp b/roms/snes-test-roms/bass-untech/bass/core/evaluate.cpp
new file mode 100644
index 00000000..7d8ca459
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/core/evaluate.cpp
@@ -0,0 +1,210 @@
+auto Bass::evaluate(const string& expression, Evaluation mode) -> int64_t {
+ forwardReference = false;
+
+ maybe name;
+ if(expression == "--") name = {"lastLabel#", lastLabelCounter - 2};
+ if(expression == "-" ) name = {"lastLabel#", lastLabelCounter - 1};
+ if(expression == "+" ) name = {"nextLabel#", nextLabelCounter + 0};
+ if(expression == "++") name = {"nextLabel#", nextLabelCounter + 1};
+ if(name) {
+ if(auto constant = findConstant({name()})) return constant().value;
+ if(queryPhase()) return pc();
+ error("relative label not declared");
+ }
+
+ Eval::Node* node = nullptr;
+ try {
+ node = Eval::parse(expression);
+ } catch(const char* reason) {
+ error("malformed expression: ", expression, " [", reason, "]");
+ } catch(...) {
+ error("malformed expression: ", expression);
+ }
+ return evaluate(node, mode);
+}
+
+auto Bass::evaluate(Eval::Node* node, Evaluation mode) -> int64_t {
+ #define p(n) evaluate(node->link[n], mode)
+
+ switch(node->type) {
+ case Eval::Node::Type::Null: return 0; //empty expressions
+ case Eval::Node::Type::Function: return evaluateExpression(node, mode);
+ case Eval::Node::Type::Literal: return evaluateLiteral(node, mode);
+ case Eval::Node::Type::Subscript: return evaluateSubscript(node, mode);
+ case Eval::Node::Type::LogicalNot: return !p(0);
+ case Eval::Node::Type::BitwiseNot: return ~p(0);
+ case Eval::Node::Type::Positive: return +p(0);
+ case Eval::Node::Type::Negative: return -p(0);
+ case Eval::Node::Type::Multiply: return p(0) * p(1);
+ case Eval::Node::Type::Divide: return p(0) / p(1);
+ case Eval::Node::Type::Modulo: return p(0) % p(1);
+ case Eval::Node::Type::Add: return p(0) + p(1);
+ case Eval::Node::Type::Subtract: return p(0) - p(1);
+ case Eval::Node::Type::ShiftLeft: return p(0) << p(1);
+ case Eval::Node::Type::ShiftRight: return p(0) >> p(1);
+ case Eval::Node::Type::BitwiseAnd: return p(0) & p(1);
+ case Eval::Node::Type::BitwiseOr: return p(0) | p(1);
+ case Eval::Node::Type::BitwiseXor: return p(0) ^ p(1);
+ case Eval::Node::Type::Equal: return p(0) == p(1);
+ case Eval::Node::Type::NotEqual: return p(0) != p(1);
+ case Eval::Node::Type::LessThanEqual: return p(0) <= p(1);
+ case Eval::Node::Type::GreaterThanEqual: return p(0) >= p(1);
+ case Eval::Node::Type::LessThan: return p(0) < p(1);
+ case Eval::Node::Type::GreaterThan: return p(0) > p(1);
+ case Eval::Node::Type::LogicalAnd: return p(0) ? p(1) : 0;
+ case Eval::Node::Type::LogicalOr: return !p(0) ? p(1) : 1;
+ case Eval::Node::Type::Condition: return p(0) ? p(1) : p(2);
+ case Eval::Node::Type::Assign: return evaluateAssign(node, mode);
+ }
+
+ #undef p
+ error("unsupported operator");
+ return 0;
+}
+
+//calculates the number of parameters to a function without evaluating its arguments yet
+auto Bass::quantifyParameters(Eval::Node* node) -> int64_t {
+ if(node->type == Eval::Node::Type::Null) return 0;
+ if(node->type == Eval::Node::Type::Separator) return node->link.size();
+ return 1; //any other type here signifies one argument
+}
+
+auto Bass::evaluateParameters(Eval::Node* node, Evaluation mode) -> vector {
+ vector result;
+ if(node->type == Eval::Node::Type::Null) return result;
+ if(node->type != Eval::Node::Type::Separator) { result.append(evaluate(node, mode)); return result; }
+ for(auto& link : node->link) result.append(evaluate(link, mode));
+ return result;
+}
+
+auto Bass::evaluateExpression(Eval::Node* node, Evaluation mode) -> int64_t {
+ string name = node->link[0]->literal;
+ if(auto parameters = quantifyParameters(node->link[1])) name.append("#", parameters);
+
+ if(name == "array.size#1") {
+ string s = evaluateString(node->link[1]);
+ if(auto array = findArray(s)) {
+ return array->values.size();
+ }
+ error("unrecognized array: ", s);
+ return 0;
+ }
+ if(name == "array.sort#1") {
+ string s = evaluateString(node->link[1]);
+ if(auto array = findArray(s)) {
+ array->values.sort();
+ return 0;
+ }
+ error("unrecognized array: ", s);
+ return 0;
+ }
+ if(name == "assert#1") {
+ int64_t result = evaluate(node->link[1], mode);
+ if(result == 0) error("assertion failed");
+ return 0;
+ }
+ if(name == "file.size#1") {
+ string filename = evaluateString(node->link[1]).trim("\"", "\"", 1L);
+ string location = {filepath(), filename};
+ if(file::exists(location)) return file::size(location);
+ error("file not found: ", filename);
+ return 0;
+ }
+ if(name == "file.exists#1") {
+ string filename = evaluateString(node->link[1]).trim("\"", "\"", 1L);
+ string location = {filepath(), filename};
+ return file::exists(location);
+ }
+ if(name == "read#1") {
+ if(!targetFile) error("no target file open for reading");
+ int64_t address = evaluate(node->link[1], mode);
+ auto origin = targetFile.offset();
+ targetFile.seek(address);
+ uint8_t data = targetFile.read();
+ targetFile.seek(origin);
+ return data;
+ }
+ if(name == "origin") return origin;
+ if(name == "base") return base;
+ if(name == "pc") return pc();
+
+ if(auto expression = findExpression(name)) {
+ auto parameters = evaluateParameters(node->link[1], mode);
+ if(parameters) frames.append({0, true});
+ for(auto n : range(parameters.size())) {
+ setVariable(expression().parameters(n), evaluate(parameters(n)), Frame::Level::Inline);
+ }
+ auto result = evaluate(expression().value);
+ if(parameters) frames.removeRight();
+ return result;
+ }
+
+ error("unrecognized expression: ", name);
+ return 0;
+}
+
+//bass' evaluate() only returns int64_t types.
+//this function is used to parse string arguments while performing trivial string concatenation
+//eg "foo" ~ "bar" => "foobar"
+auto Bass::evaluateString(Eval::Node* node) -> string {
+ if(node->type == Eval::Node::Type::Literal) return node->literal;
+ if(node->type == Eval::Node::Type::Concatenate) {
+ string lhs = evaluateString(node->link[0]).trim("\"", "\"", 1L);
+ string rhs = evaluateString(node->link[1]).trim("\"", "\"", 1L);
+ return {"\"", lhs, rhs, "\""};
+ };
+ error("unrecognized string expression");
+ return {};
+}
+
+auto Bass::evaluateLiteral(Eval::Node* node, Evaluation mode) -> int64_t {
+ string& s = node->literal;
+
+ if(s[0] == '0' && s[1] == 'b') return toBinary(s);
+ if(s[0] == '0' && s[1] == 'o') return toOctal(s);
+ if(s[0] == '0' && s[1] == 'x') return toHex(s);
+ if(s[0] >= '0' && s[0] <= '9') return toInteger(s);
+ if(s[0] == '%') return toBinary(s);
+ if(s[0] == '$') return toHex(s);
+ if(s.match("'?*'")) return character(s);
+
+ if(auto variable = findVariable(s)) return variable().value;
+ if(auto constant = findConstant(s)) return constant().value;
+
+ forwardReference = true;
+ if(mode == Evaluation::Lax && queryPhase()) return pc();
+
+ if(auto constantName = findConstantName(s)) {
+ error("constant has unknown value: ", constantName());
+ } else {
+ error("unrecognized variable: ", s);
+ }
+ return 0;
+}
+
+auto Bass::evaluateSubscript(Eval::Node* node, Evaluation mode) -> int64_t {
+ string& s = node->link[0]->literal;
+
+ if(auto array = findArray(s)) {
+ auto index = evaluate(node->link[1], mode);
+ if(index >= array->values.size()) {
+ error("array subscript out of bounds: ", index, " >= ", array->values.size());
+ }
+ return array->values[index];
+ }
+
+ error("unrecognized array: ", s);
+ return 0;
+}
+
+auto Bass::evaluateAssign(Eval::Node* node, Evaluation mode) -> int64_t {
+ string& s = node->link[0]->literal;
+
+ if(auto variable = findVariable(s)) {
+ variable().value = evaluate(node->link[1], mode);
+ return variable().value;
+ }
+
+ error("unrecognized variable assignment: ", s);
+ return 0;
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/core/execute.cpp b/roms/snes-test-roms/bass-untech/bass/core/execute.cpp
new file mode 100644
index 00000000..9246c64f
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/core/execute.cpp
@@ -0,0 +1,211 @@
+auto Bass::execute() -> bool {
+ frames.reset();
+ conditionals.reset();
+ ip = 0;
+ macroInvocationCounter = 0;
+
+ initialize();
+
+ frames.append({0, false});
+ for(auto& define : defines) {
+ setDefine(define.name, {}, define.value, Frame::Level::Inline);
+ }
+
+ while(ip < program.size()) {
+ Instruction& i = program(ip++);
+ if(!executeInstruction(i)) error("unrecognized directive: ", i.statement);
+ }
+
+ frames.removeRight();
+ return true;
+}
+
+auto Bass::executeInstruction(Instruction& i) -> bool {
+ activeInstruction = &i;
+ string s = i.statement;
+ evaluateDefines(s);
+
+ bool global = s.beginsWith("global ");
+ bool parent = s.beginsWith("parent ");
+ if(global && parent) error("multiple frame specifiers are not allowed");
+
+ Frame::Level level = Frame::Level::Active;
+ if(global) s.trimLeft("global ", 1L), level = Frame::Level::Global;
+ if(parent) s.trimLeft("parent ", 1L), level = Frame::Level::Parent;
+
+ if(s.match("macro ?*(*) {")) {
+ bool inlined = false;
+ s.trim("macro ", ") {", 1L);
+ auto p = s.split("(", 1L).strip();
+ auto parameters = split(p(1));
+ setMacro(p(0), parameters, ip, inlined, level);
+ ip = i.ip;
+ return true;
+ }
+
+ if(s.match("inline ?*(*) {")) {
+ bool inlined = true;
+ s.trim("inline ", ") {", 1L);
+ auto p = s.split("(", 1L).strip();
+ auto parameters = split(p(1));
+ setMacro(p(0), parameters, ip, inlined, level);
+ ip = i.ip;
+ return true;
+ }
+
+ if(s.match("define ?*(*)*")) {
+ auto e = s.trimLeft("define ", 1L).split("=", 1L).strip();
+ auto p = e(0).trimRight(")", 1L).split("(", 1L).strip();
+ auto parameters = split(p(1));
+ setDefine(p(0), parameters, e(1), level);
+ return true;
+ }
+
+ if(s.match("define ?*")) {
+ auto p = s.trimLeft("define ", 1L).split("=", 1L).strip();
+ setDefine(p(0), {}, p(1), level);
+ return true;
+ }
+
+ if(s.match("evaluate ?*")) {
+ auto p = s.trimLeft("evaluate ", 1L).split("=", 1L).strip();
+ setDefine(p(0), {}, evaluate(p(1)), level);
+ return true;
+ }
+
+ if(s.match("expression ?*(*)*")) {
+ auto e = s.trimLeft("expression ", 1L).split("=", 1L).strip();
+ auto p = e(0).trimRight(")", 1L).split("(", 1L).strip();
+ auto parameters = split(p(1));
+ setExpression(p(0), parameters, e(1), level);
+ return true;
+ }
+
+ if(s.match("variable ?*")) {
+ auto p = s.trimLeft("variable ", 1L).split("=", 1L).strip();
+ setVariable(p(0), evaluate(p(1)), level);
+ return true;
+ }
+
+ if(s.match("array[?*] ?*")) {
+ auto a = s.trimLeft("array[", 1L).split("]", 1L);
+ auto size = evaluate(a(0));
+ auto p = a(1).split("=", 1L).strip();
+ auto parameters = split(p(1));
+ vector values;
+ for(auto& parameter : parameters) values.append(evaluate(parameter));
+ if(values.size() > size) error("too many array elements: ", values.size(), " > ", size);
+ values.resize(size); //zero-initialize additional elements
+ setArray(p(0), values, level);
+ return true;
+ }
+
+ //evaluate() will evaluate array[index] to a value prior to evaluating =
+ //as a result, array[index] assignment must be manually captured early
+ if(s.match("?*[?*] = ?*")) {
+ auto a = s.split("[", 1L).strip();
+ auto b = a(1).split("]", 1L).strip();
+ auto c = b(1).split("=", 1L).strip();
+ if(auto array = findArray(a(0))) {
+ auto index = evaluate(b(0));
+ if(index >= array->values.size()) error("array subscript out of bounds: ", index, " >= ", array->values.size());
+ auto value = evaluate(c(1));
+ array->values[index] = value;
+ return true;
+ }
+ //fallthrough: this may have matched another expression that wasn't an array[index] assignment
+ }
+
+ if(global || parent) error("invalid frame specifier");
+
+ if(s.match("if ?* {")) {
+ s.trim("if ", " {", 1L).strip();
+ bool match = evaluate(s, Evaluation::Strict);
+ conditionals.append(match);
+ if(match == false) {
+ ip = i.ip;
+ }
+ return true;
+ }
+
+ if(s.match("} else if ?* {")) {
+ if(conditionals.right()) {
+ ip = i.ip;
+ } else {
+ s.trim("} else if ", " {", 1L).strip();
+ bool match = evaluate(s, Evaluation::Strict);
+ conditionals.right() = match;
+ if(match == false) {
+ ip = i.ip;
+ }
+ }
+ return true;
+ }
+
+ if(s.match("} else {")) {
+ if(conditionals.right()) {
+ ip = i.ip;
+ } else {
+ conditionals.right() = true;
+ }
+ return true;
+ }
+
+ if(s.match("} endif")) {
+ conditionals.removeRight();
+ return true;
+ }
+
+ if(s.match("while ?* {")) {
+ s.trim("while ", " {", 1L).strip();
+ bool match = evaluate(s, Evaluation::Strict);
+ if(match == false) ip = i.ip;
+ return true;
+ }
+
+ if(s.match("} endwhile")) {
+ ip = i.ip;
+ return true;
+ }
+
+ if(s.match("?*(*)")) {
+ auto p = string{s}.trimRight(")", 1L).split("(", 1L).strip();
+ auto name = p(0);
+ auto parameters = split(p(1));
+ if(parameters) name.append("#", parameters.size());
+ if(auto macro = findMacro({name})) {
+ frames.append({ip, macro().inlined});
+ if(!frames.right().inlined) scope.append(p(0));
+
+ setDefine("#", {}, {"_", macroInvocationCounter++, "_"}, Frame::Level::Inline);
+ for(uint n : range(parameters.size())) {
+ auto p = macro().parameters(n).split(" ", 1L).strip();
+ if(p.size() == 1) p.prepend("define");
+
+ if(0);
+ else if(p[0] == "define") setDefine(p[1], {}, parameters(n), Frame::Level::Inline);
+ else if(p[0] == "string") setDefine(p[1], {}, text(parameters(n)), Frame::Level::Inline);
+ else if(p[0] == "evaluate") setDefine(p[1], {}, evaluate(parameters(n)), Frame::Level::Inline);
+ else if(p[0] == "variable") setVariable(p[1], evaluate(parameters(n)), Frame::Level::Inline);
+ else error("unsupported parameter type: ", p[0]);
+ }
+
+ ip = macro().ip;
+ return true;
+ }
+ }
+
+ if(s.match("} endmacro") || s.match("} endinline")) {
+ ip = frames.right().ip;
+ if(!frames.right().inlined) scope.removeRight();
+ frames.removeRight();
+ return true;
+ }
+
+ if(assemble(s)) {
+ return true;
+ }
+
+ evaluate(s);
+ return true;
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/core/utility.cpp b/roms/snes-test-roms/bass-untech/bass/core/utility.cpp
new file mode 100644
index 00000000..f782af47
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/core/utility.cpp
@@ -0,0 +1,396 @@
+auto Bass::setMacro(const string& name, const string_vector& parameters, uint ip, bool inlined, Frame::Level level) -> void {
+ if(!validate(name)) error("invalid macro identifier: ", name);
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+ if(parameters) scopedName.append("#", parameters.size());
+
+ for(int n : reverse(range(frames.size()))) {
+ if(level != Frame::Level::Inline) {
+ if(frames[n].inlined) continue;
+ if(level == Frame::Level::Global && n) { continue; }
+ if(level == Frame::Level::Parent && n) { level = Frame::Level::Active; continue; }
+ }
+
+ auto& macros = frames[n].macros;
+ if(auto macro = macros.find({scopedName})) {
+ macro().parameters = parameters;
+ macro().ip = ip;
+ macro().inlined = inlined;
+ } else {
+ macros.insert({scopedName, parameters, ip, inlined});
+ }
+
+ return;
+ }
+}
+
+auto Bass::findMacro(const string& name) -> maybe {
+ for(int n : reverse(range(frames.size()))) {
+ auto& macros = frames[n].macros;
+ auto s = scope;
+ while(true) {
+ string scopedName = {s.merge("."), s ? "." : "", name};
+ if(auto macro = macros.find({scopedName})) {
+ return macro();
+ }
+ if(!s) break;
+ s.removeRight();
+ }
+ }
+
+ return nothing;
+}
+
+auto Bass::setDefine(const string& name, const string_vector& parameters, const string& value, Frame::Level level) -> void {
+ if(!validate(name)) error("invalid define identifier: ", name);
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+ if(parameters) scopedName.append("#", parameters.size());
+
+ for(int n : reverse(range(frames.size()))) {
+ if(level != Frame::Level::Inline) {
+ if(frames[n].inlined) continue;
+ if(level == Frame::Level::Global && n) { continue; }
+ if(level == Frame::Level::Parent && n) { level = Frame::Level::Active; continue; }
+ }
+
+ auto& defines = frames[n].defines;
+ if(auto define = defines.find({scopedName})) {
+ define().parameters = parameters;
+ define().value = value;
+ } else {
+ defines.insert({scopedName, parameters, value});
+ }
+
+ return;
+ }
+}
+
+auto Bass::findDefine(const string& name) -> maybe {
+ for(int n : reverse(range(frames.size()))) {
+ auto& defines = frames[n].defines;
+ auto s = scope;
+ while(true) {
+ string scopedName = {s.merge("."), s ? "." : "", name};
+ if(auto define = defines.find({scopedName})) {
+ return define();
+ }
+ if(!s) break;
+ s.removeRight();
+ }
+ }
+
+ return nothing;
+}
+
+auto Bass::setExpression(const string& name, const string_vector& parameters, const string& value, Frame::Level level) -> void {
+ if(!validate(name)) error("invalid expression identifier: ", name);
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+ if(parameters) scopedName.append("#", parameters.size());
+
+ for(int n : reverse(range(frames.size()))) {
+ if(level != Frame::Level::Inline) {
+ if(frames[n].inlined) continue;
+ if(level == Frame::Level::Global && n) { continue; }
+ if(level == Frame::Level::Parent && n) { level = Frame::Level::Active; continue; }
+ }
+
+ auto& expressions = frames[n].expressions;
+ if(auto expression = expressions.find({scopedName})) {
+ expression().parameters = parameters;
+ expression().value = value;
+ } else {
+ expressions.insert({scopedName, parameters, value});
+ }
+
+ return;
+ }
+}
+
+auto Bass::findExpression(const string& name) -> maybe {
+ for(int n : reverse(range(frames.size()))) {
+ auto& expressions = frames[n].expressions;
+ auto s = scope;
+ while(true) {
+ string scopedName = {s.merge("."), s ? "." : "", name};
+ if(auto expression = expressions.find({scopedName})) {
+ return expression();
+ }
+ if(!s) break;
+ s.removeRight();
+ }
+ }
+
+ return nothing;
+}
+
+auto Bass::setVariable(const string& name, int64_t value, Frame::Level level) -> void {
+ if(!validate(name)) error("invalid variable identifier: ", name);
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+
+ for(int n : reverse(range(frames.size()))) {
+ if(level != Frame::Level::Inline) {
+ if(frames[n].inlined) continue;
+ if(level == Frame::Level::Global && n) { continue; }
+ if(level == Frame::Level::Parent && n) { level = Frame::Level::Active; continue; }
+ }
+
+ auto& variables = frames[n].variables;
+ if(auto variable = variables.find({scopedName})) {
+ variable().value = value;
+ } else {
+ variables.insert({scopedName, value});
+ }
+
+ return;
+ }
+}
+
+auto Bass::findVariable(const string& name) -> maybe {
+ for(int n : reverse(range(frames.size()))) {
+ auto& variables = frames[n].variables;
+ auto s = scope;
+ while(true) {
+ string scopedName = {s.merge("."), s ? "." : "", name};
+ if(auto variable = variables.find({scopedName})) {
+ return variable();
+ }
+ if(!s) break;
+ s.removeRight();
+ }
+ }
+
+ return nothing;
+}
+
+auto Bass::setUnknownConstant(const string& name) -> void {
+ if(!validate(name)) error("invalid constant identifier: ", name);
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+
+ if(writePhase()) error("constant value unknown at write phase: ", scopedName);
+
+ if(constantNames.find(scopedName)) error("constant cannot be modified: ", scopedName);
+ constantNames.insert(scopedName);
+}
+
+auto Bass::setConstant(const string& name, int64_t value) -> void {
+ if(!validate(name)) error("invalid constant identifier: ", name);
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+
+ if(auto constant = constants.find({scopedName})) {
+ if(queryPhase()) error("constant cannot be modified: ", scopedName);
+ if(constant().value != value) error("constant value has changed between the query and write phases: ", scopedName);
+ } else {
+ constantNames.insert(scopedName);
+ constants.insert({scopedName, value});
+ }
+}
+
+auto Bass::findConstant(const string& name) -> maybe {
+ auto s = scope;
+ while(true) {
+ string scopedName = {s.merge("."), s ? "." : "", name};
+ if(auto constant = constants.find({scopedName})) {
+ return constant();
+ }
+ if(!s) break;
+ s.removeRight();
+ }
+
+ return nothing;
+}
+
+auto Bass::findConstantName(const string& name) -> maybe {
+ auto s = scope;
+ while(true) {
+ string scopedName = {s.merge("."), s ? "." : "", name};
+ if(auto constant = constantNames.find({scopedName})) {
+ return constant();
+ }
+ if(!s) break;
+ s.removeRight();
+ }
+
+ return nothing;
+}
+
+auto Bass::setArray(const string& name, const vector& values, Frame::Level level) -> void {
+ if(!validate(name)) error("invalid array identifier: ", name);
+ string scopedName = {scope.merge("."), scope ? "." : "", name};
+
+ for(int n : reverse(range(frames.size()))) {
+ if(level != Frame::Level::Inline) {
+ if(frames[n].inlined) continue;
+ if(level == Frame::Level::Global && n) { continue; }
+ if(level == Frame::Level::Parent && n) { level = Frame::Level::Active; continue; }
+ }
+
+ auto& arrays = frames[n].arrays;
+ if(auto array = arrays.find({scopedName})) {
+ array().values = values;
+ } else {
+ arrays.insert({scopedName, values});
+ }
+
+ return;
+ }
+}
+
+auto Bass::findArray(const string& name) -> maybe {
+ for(int n : reverse(range(frames.size()))) {
+ auto& arrays = frames[n].arrays;
+ auto s = scope;
+ while(true) {
+ string scopedName = {s.merge("."), s ? "." : "", name};
+ if(auto array = arrays.find({scopedName})) {
+ return array();
+ }
+ if(!s) break;
+ s.removeRight();
+ }
+ }
+
+ return nothing;
+}
+
+auto Bass::evaluateDefines(string& s) -> void {
+ for(int x = s.size() - 1, y = -1; x >= 0; x--) {
+ if(s[x] == '}') y = x;
+ if(s[x] == '{' && y > x) {
+ string name = slice(s, x + 1, y - x - 1);
+
+ if(name.match("defined ?*")) {
+ name.trimLeft("defined ", 1L).strip();
+ s = {slice(s, 0, x), findDefine(name) ? 1 : 0, slice(s, y + 1)};
+ return evaluateDefines(s);
+ }
+
+ string_vector parameters;
+ if(name.match("?*(*)")) {
+ auto p = name.trimRight(")", 1L).split("(", 1L).strip();
+ name = p(0);
+ parameters = split(p(1));
+ }
+ if(parameters) name.append("#", parameters.size());
+
+ if(auto define = findDefine(name)) {
+ if(parameters) frames.append({0, true});
+ for(auto n : range(parameters.size())) {
+ auto p = define().parameters(n).split(" ", 1L).strip();
+ if(p.size() == 1) p.prepend("define");
+
+ if(0);
+ else if(p[0] == "define") setDefine(p[1], {}, parameters(n), Frame::Level::Inline);
+ else if(p[0] == "string") setDefine(p[1], {}, text(parameters(n)), Frame::Level::Inline);
+ else if(p[0] == "evaluate") setDefine(p[1], {}, evaluate(parameters(n)), Frame::Level::Inline);
+ else error("unsupported parameter type: ", p[0]);
+ }
+ auto value = define().value;
+ evaluateDefines(value);
+ s = {slice(s, 0, x), value, slice(s, y + 1)};
+ if(parameters) frames.removeRight();
+ return evaluateDefines(s);
+ }
+ }
+ }
+}
+
+auto Bass::filepath() -> string {
+ return Location::path(sourceFilenames[activeInstruction->fileNumber]);
+}
+
+//split argument list by commas, being aware of parenthesis depth and quotes
+auto Bass::split(const string& s) -> string_vector {
+ string_vector result;
+ uint offset = 0;
+ char quoted = 0;
+ uint depth = 0;
+ bool escaped = 0;
+ for(uint n : range(s.size())) {
+ if(s[n] == '\\' && quoted) {
+ escaped = 1;
+ continue;
+ }
+ if(escaped) {
+ escaped = 0;
+ continue;
+ }
+ if(!quoted) {
+ if(s[n] == '\"' || s[n] == '\'') quoted = s[n];
+ } else if(quoted == s[n]) {
+ quoted = 0;
+ }
+ if(s[n] == '(' && !quoted) depth++;
+ if(s[n] == ')' && !quoted) depth--;
+ if(s[n] == ',' && !quoted && !depth) {
+ result.append(slice(s, offset, n - offset));
+ offset = n + 1;
+ }
+ }
+ if(offset < s.size()) result.append(slice(s, offset, s.size() - offset));
+ if(quoted) error("mismatched quotes in expression");
+ if(depth) error("mismatched parentheses in expression");
+ return result.strip();
+}
+
+//reduce all duplicate whitespace segments (eg " ") to single whitespace (" ")
+auto Bass::strip(string& s) -> void {
+ uint offset = 0;
+ char quoted = 0;
+ for(uint n : range(s.size())) {
+ if(!quoted) {
+ if(s[n] == '"' || s[n] == '\'') quoted = s[n];
+ } else if(quoted == s[n]) {
+ quoted = 0;
+ }
+ if(!quoted && s[n] == ' ' && s[n + 1] == ' ') continue;
+ s.get()[offset++] = s[n];
+ }
+ s.resize(offset);
+}
+
+//returns true for valid name identifiers
+auto Bass::validate(const string& s) -> bool {
+ for(uint n : range(s.size())) {
+ char c = s[n];
+ if(c == '_' || c == '#') continue;
+ if(c >= 'A' && c <= 'Z') continue;
+ if(c >= 'a' && c <= 'z') continue;
+ if(c >= '0' && c <= '9' && n) continue;
+ if(c == '.' && n) continue;
+ return false;
+ }
+ return true;
+}
+
+auto Bass::text(string s) -> string {
+ if(!s.match("\"*\"")) warning("string value is unquoted: ", s);
+
+ auto parts = s.qsplit("~").strip();
+ for(auto& p : parts) {
+ p.trim("\"", "\"", 1L);
+ p.replace("\\\\", "\\");
+ p.replace("\\n", "\n");
+ p.replace("\\t", "\t");
+ }
+ return parts.merge();
+}
+
+auto Bass::character(const string& s) -> int64_t {
+ maybe result;
+ if(s[0] == '\'') {
+ if(0);
+ else if(s[1] == '\\' && s[2] == '\\' && s[3] == '\'') result = '\\';
+ else if(s[1] == '\\' && s[2] == '\'' && s[3] == '\'') result = '\'';
+ else if(s[1] == '\\' && s[2] == '\"' && s[3] == '\'') result = '\"';
+ else if(s[1] == '\\' && s[2] == 'n' && s[3] == '\'') result = '\n';
+ else if(s[1] == '\\' && s[2] == 't' && s[3] == '\'') result = '\t';
+ else if(s[2] == '\'') result = s[1];
+ }
+
+ if(!result) {
+ warning("unrecognized character constant: ", s);
+ return 0;
+ }
+
+ if(charactersUseMap) result = stringTable[*result];
+ return *result;
+}
diff --git a/roms/snes-test-roms/bass-untech/bass/data/architectures/spc700.arch b/roms/snes-test-roms/bass-untech/bass/data/architectures/spc700.arch
new file mode 100644
index 00000000..9116b6d3
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/data/architectures/spc700.arch
@@ -0,0 +1,324 @@
+endian lsb
+
+nop ;$00
+brk ;$0f
+rts ;$6f
+rti ;$7f
+xcn ;$9f
+wai ;$ef
+stp ;$ff
+
+clp ;$20
+clc ;$60
+cli ;$c0
+clv ;$e0
+sep ;$40
+sec ;$80
+sei ;$a0
+cmc ;$ed
+
+php ;$0d
+pha ;$2d
+phx ;$4d
+phy ;$6d
+plp ;$8e
+pla ;$ae
+plx ;$ce
+ply ;$ee
+
+inx ;$3d
+iny ;$fc
+dex ;$1d
+dey ;$dc
+
+tax ;$5d
+tay ;$fd
+tsx ;$9d
+txa ;$7d
+txs ;$bd
+tya ;$dd
+
+mul ;$cf
+div ;$9e
+
+das ;$be
+daa ;$df
+
+jst *04 ;=a %0001
+set *08:*03 ;=b %00010 =a
+clr *08:*03 ;=b %10010 =a
+bbs *08:*03=*08 ;=b %00011 =a +3c
+bbc *08:*03=*08 ;=b %10011 =a +3c
+
+jmp (*16,x) ;$1f =a
+jmp *16 ;$5f =a
+jsr *16 ;$3f =a
+jsp *08 ;$4f =a
+
+bne --y=*08 ;$fe +2a
+bne --*08=*08 ;$6e =a +3b
+bne *08,x=*08 ;$de =a +3b
+bne *08=*08 ;$2e =a +3b
+
+bra *08 ;$2f +2a
+bpl *08 ;$10 +2a
+bmi *08 ;$30 +2a
+bvc *08 ;$50 +2a
+bvs *08 ;$70 +2a
+bcc *08 ;$90 +2a
+bcs *08 ;$b0 +2a
+bne *08 ;$d0 +2a
+beq *08 ;$f0 +2a
+
+tsb *16 ;$0e =a
+trb *16 ;$4e =a
+
+inw *08 ;$3a =a
+dew *08 ;$1a =a
+adw *08 ;$7a =a
+sbw *08 ;$9a =a
+cpw *08 ;$5a =a
+ldw *08 ;$ba =a
+stw *08 ;$da =a
+
+orc !*13:*03 ;$2a ~b ~a
+orc *13:*03 ;$0a ~b ~a
+and !*13:*03 ;$6a ~b ~a
+and *13:*03 ;$4a ~b ~a
+eor *13:*03 ;$8a ~b ~a
+ldc *13:*03 ;$aa ~b ~a
+stc *13:*03 ;$ca ~b ~a
+not *13:*03 ;$ea ~b ~a
+
+ora (x) ;$06
+orr (x)=(y) ;$19
+ora (*08,x) ;$07 =a
+ora (*08),y ;$17 =a
+ora #*08 ;$08 =a
+orr *08=#*08 ;$18 =b =a
+ora *16,x ;$15 =a
+ora *16,y ;$16 =a
+ora *08,x ;$14 =a
+orr *08=*08 ;$09 =b =a
+ora *16 ;$05 =a
+ora *08 ;$04 =a
+//
+ora.w *16,x ;$15 ~a
+ora.b *08,x ;$14 ~a
+ora.w *16 ;$05 ~a
+ora.b *08 ;$04 ~a
+
+and (x) ;$26
+and (x)=(y) ;$39
+and (*08,x) ;$27 =a
+and (*08),y ;$37 =a
+and #*08 ;$28 =a
+and *08=#*08 ;$38 =b =a
+and *16,x ;$35 =a
+and *16,y ;$36 =a
+and *08,x ;$34 =a
+and *08=*08 ;$29 =b =a
+and *16 ;$25 =a
+and *08 ;$24 =a
+//
+and.w *16,x ;$35 ~a
+and.b *08,x ;$34 ~a
+and.w *16 ;$25 ~a
+and.b *08 ;$24 ~a
+
+eor (x) ;$46
+eor (x)=(y) ;$59
+eor (*08,x) ;$47 =a
+eor (*08),y ;$57 =a
+eor #*08 ;$48 =a
+eor *08=#*08 ;$58 =b =a
+eor *16,x ;$55 =a
+eor *16,y ;$56 =a
+eor *08,x ;$54 =a
+eor *08=*08 ;$49 =b =a
+eor *16 ;$45 =a
+eor *08 ;$44 =a
+//
+eor.w *16,x ;$55 ~a
+eor.b *08,x ;$54 ~a
+eor.w *16 ;$45 ~a
+eor.b *08 ;$44 ~a
+
+cmp (x) ;$66
+cmp (x)=(y) ;$79
+cmp (*08,x) ;$67 =a
+cmp (*08),y ;$77 =a
+cmp #*08 ;$68 =a
+cmp *08=#*08 ;$78 =b =a
+cmp *16,x ;$75 =a
+cmp *16,y ;$76 =a
+cmp *08,x ;$74 =a
+cmp *08=*08 ;$69 =b =a
+cmp *16 ;$65 =a
+cmp *08 ;$64 =a
+//
+cmp.w *16,x ;$75 ~a
+cmp.b *08,x ;$74 ~a
+cmp.w *16 ;$65 ~a
+cmp.b *08 ;$64 ~a
+
+adc (x) ;$86
+adc (x)=(y) ;$99
+adc (*08,x) ;$87 =a
+adc (*08),y ;$97 =a
+adc #*08 ;$88 =a
+adc *08=#*08 ;$98 =b =a
+adc *16,x ;$95 =a
+adc *16,y ;$96 =a
+adc *08,x ;$94 =a
+adc *08=*08 ;$89 =b =a
+adc *16 ;$85 =a
+adc *08 ;$84 =a
+//
+adc.w *16,x ;$95 ~a
+adc.b *08,x ;$94 ~a
+adc.w *16 ;$85 ~a
+adc.b *08 ;$84 ~a
+
+sbc (x) ;$a6
+sbc (x)=(y) ;$b9
+sbc (*08,x) ;$a7 =a
+sbc (*08),y ;$b7 =a
+sbc #*08 ;$a8 =a
+sbc *08=#*08 ;$b8 =b =a
+sbc *16,x ;$b5 =a
+sbc *16,y ;$b6 =a
+sbc *08,x ;$b4 =a
+sbc *08=*08 ;$a9 =b =a
+sbc *16 ;$a5 =a
+sbc *08 ;$a4 =a
+//
+sbc.w *16,x ;$b5 ~a
+sbc.b *08,x ;$b4 ~a
+sbc.w *16 ;$a5 ~a
+sbc.b *08 ;$a4 ~a
+
+sta (x) ;$c6
+sta (x++) ;$af
+sta (*08,x) ;$c7 =a
+sta (*08),y ;$d7 =a
+str *08=#*08 ;$8f =b =a
+sta *16,x ;$d5 =a
+sta *16,y ;$d6 =a
+sta *08,x ;$d4 =a
+str *08=*08 ;$fa =b =a
+sta *16 ;$c5 =a
+sta *08 ;$c4 =a
+//
+sta.w *16,x ;$d5 ~a
+sta.b *08,x ;$d4 ~a
+sta.w *16 ;$c5 ~a
+sta.b *08 ;$c4 ~a
+
+lda (x) ;$e6
+lda (x++) ;$bf
+lda (*08,x) ;$e7 =a
+lda (*08),y ;$f7 =a
+lda #*08 ;$e8 =a
+lda *16,x ;$f5 =a
+lda *16,y ;$f6 =a
+lda *08,x ;$f4 =a
+lda *16 ;$e5 =a
+lda *08 ;$e4 =a
+//
+lda.w *16,x ;$f5 ~a
+lda.b *08,x ;$f4 ~a
+lda.w *16 ;$e5 ~a
+lda.b *08 ;$e4 ~a
+
+stx *08,y ;$d9 =a
+stx *16 ;$c9 =a
+stx *08 ;$d8 =a
+//
+stx.w *16 ;$c9 ~a
+stx.b *08 ;$d8 ~a
+
+sty *08,x ;$db =a
+sty *16 ;$cc =a
+sty *08 ;$cb =a
+//
+sty.w *16 ;$cc ~a
+sty.b *08 ;$cb ~a
+
+ldx #*08 ;$cd =a
+ldx *08,y ;$f9 =a
+ldx *16 ;$e9 =a
+ldx *08 ;$f8 =a
+//
+ldx.w *16 ;$e9 ~a
+ldx.b *08 ;$f8 ~a
+
+ldy #*08 ;$8d =a
+ldy *08,x ;$fb =a
+ldy *16 ;$ec =a
+ldy *08 ;$eb =a
+//
+ldy.w *16 ;$ec ~a
+ldy.b *08 ;$eb ~a
+
+cpx #*08 ;$c8 =a
+cpx *16 ;$1e =a
+cpx *08 ;$3e =a
+//
+cpx.w *16 ;$1e ~a
+cpx.b *08 ;$3e ~a
+
+cpy #*08 ;$ad =a
+cpy *16 ;$5e =a
+cpy *08 ;$7e =a
+//
+cpy.w *16 ;$5e ~a
+cpy.b *08 ;$7e ~a
+
+asl ;$1c
+asl *08,x ;$1b =a
+asl *16 ;$0c =a
+asl *08 ;$0b =a
+//
+asl.w *16 ;$0c ~a
+asl.b *08 ;$0b ~a
+
+lsr ;$5c
+lsr *08,x ;$5b =a
+lsr *16 ;$4c =a
+lsr *08 ;$4b =a
+//
+lsr.w *16 ;$4c ~a
+lsr.b *08 ;$4b ~a
+
+rol ;$3c
+rol *08,x ;$3b =a
+rol *16 ;$2c =a
+rol *08 ;$2b =a
+//
+rol.w *16 ;$2c ~a
+rol.b *08 ;$2b ~a
+
+ror ;$7c
+ror *08,x ;$7b =a
+ror *16 ;$6c =a
+ror *08 ;$6b =a
+//
+ror.w *16 ;$6c ~a
+ror.b *08 ;$6b ~a
+
+inc ;$bc
+inc *08,x ;$bb =a
+inc *16 ;$ac =a
+inc *08 ;$ab =a
+//
+inc.w *16 ;$ac ~a
+inc.b *08 ;$ab ~a
+
+dec ;$9c
+dec *08,x ;$9b =a
+dec *16 ;$8c =a
+dec *08 ;$8b =a
+//
+dec.w *16 ;$8c ~a
+dec.b *08 ;$8b ~a
diff --git a/roms/snes-test-roms/bass-untech/bass/data/architectures/wdc65816-strict.arch b/roms/snes-test-roms/bass-untech/bass/data/architectures/wdc65816-strict.arch
new file mode 100644
index 00000000..1efbee73
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/data/architectures/wdc65816-strict.arch
@@ -0,0 +1,341 @@
+endian lsb
+
+asl ;$0a
+clc ;$18
+cld ;$d8
+cli ;$58
+clv ;$b8
+dec ;$3a
+dex ;$ca
+dey ;$88
+inc ;$1a
+inx ;$e8
+iny ;$c8
+lsr ;$4a
+nop ;$ea
+pha ;$48
+phb ;$8b
+phd ;$0b
+phk ;$4b
+php ;$08
+phx ;$da
+phy ;$5a
+pla ;$68
+plb ;$ab
+pld ;$2b
+plp ;$28
+plx ;$fa
+ply ;$7a
+rol ;$2a
+ror ;$6a
+rti ;$40
+rtl ;$6b
+rts ;$60
+sec ;$38
+sed ;$f8
+sei ;$78
+stp ;$db
+tad ;$5b
+tas ;$1b
+tax ;$aa
+tay ;$a8
+tda ;$7b
+tsa ;$3b
+tsx ;$ba
+txa ;$8a
+txs ;$9a
+txy ;$9b
+tya ;$98
+tyx ;$bb
+wai ;$cb
+xba ;$eb
+xce ;$fb
+//
+tcd ;$5b
+tcs ;$1b
+tdc ;$7b
+tsc ;$3b
+
+ora *08,s ;$03 =a
+ora (*08,s),y ;$13 =a
+ora (*08,x) ;$01 =a
+ora (*08),y ;$11 =a
+ora [*08],y ;$17 =a
+ora (*08) ;$12 =a
+ora [*08] ;$07 =a
+//
+ora.w #*16 ;$09 ~a
+ora.b #*08 ;$09 ~a
+ora.w *16,y ;$19 ~a
+ora.l *24,x ;$1f ~a
+ora.w *16,x ;$1d ~a
+ora.b *08,x ;$15 ~a
+ora.l *24 ;$0f ~a
+ora.w *16 ;$0d ~a
+ora.b *08 ;$05 ~a
+
+and *08,s ;$23 =a
+and (*08,s),y ;$33 =a
+and (*08,x) ;$21 =a
+and (*08),y ;$31 =a
+and [*08],y ;$37 =a
+and (*08) ;$32 =a
+and [*08] ;$27 =a
+//
+and.w #*16 ;$29 ~a
+and.b #*08 ;$29 ~a
+and.w *16,y ;$39 ~a
+and.l *24,x ;$3f ~a
+and.w *16,x ;$3d ~a
+and.b *08,x ;$35 ~a
+and.l *24 ;$2f ~a
+and.w *16 ;$2d ~a
+and.b *08 ;$25 ~a
+
+eor *08,s ;$43 =a
+eor (*08,s),y ;$53 =a
+eor (*08,x) ;$41 =a
+eor (*08),y ;$51 =a
+eor [*08],y ;$57 =a
+eor (*08) ;$52 =a
+eor [*08] ;$47 =a
+//
+eor.w #*16 ;$49 ~a
+eor.b #*08 ;$49 ~a
+eor.w *16,y ;$59 ~a
+eor.l *24,x ;$5f ~a
+eor.w *16,x ;$5d ~a
+eor.b *08,x ;$55 ~a
+eor.l *24 ;$4f ~a
+eor.w *16 ;$4d ~a
+eor.b *08 ;$45 ~a
+
+adc *08,s ;$63 =a
+adc (*08,s),y ;$73 =a
+adc (*08,x) ;$61 =a
+adc (*08),y ;$71 =a
+adc [*08],y ;$77 =a
+adc (*08) ;$72 =a
+adc [*08] ;$67 =a
+//
+adc.w #*16 ;$69 ~a
+adc.b #*08 ;$69 ~a
+adc.w *16,y ;$79 ~a
+adc.l *24,x ;$7f ~a
+adc.w *16,x ;$7d ~a
+adc.b *08,x ;$75 ~a
+adc.l *24 ;$6f ~a
+adc.w *16 ;$6d ~a
+adc.b *08 ;$65 ~a
+
+sta *08,s ;$83 =a
+sta (*08,s),y ;$93 =a
+sta (*08,x) ;$81 =a
+sta (*08),y ;$91 =a
+sta [*08],y ;$97 =a
+sta (*08) ;$92 =a
+sta [*08] ;$87 =a
+//
+sta.w *16,y ;$99 ~a
+sta.l *24,x ;$9f ~a
+sta.w *16,x ;$9d ~a
+sta.b *08,x ;$95 ~a
+sta.l *24 ;$8f ~a
+sta.w *16 ;$8d ~a
+sta.b *08 ;$85 ~a
+
+lda *08,s ;$a3 =a
+lda (*08,s),y ;$b3 =a
+lda (*08,x) ;$a1 =a
+lda (*08),y ;$b1 =a
+lda [*08],y ;$b7 =a
+lda (*08) ;$b2 =a
+lda [*08] ;$a7 =a
+//
+lda.w #*16 ;$a9 ~a
+lda.b #*08 ;$a9 ~a
+lda.w *16,y ;$b9 ~a
+lda.l *24,x ;$bf ~a
+lda.w *16,x ;$bd ~a
+lda.b *08,x ;$b5 ~a
+lda.l *24 ;$af ~a
+lda.w *16 ;$ad ~a
+lda.b *08 ;$a5 ~a
+
+cmp *08,s ;$c3 =a
+cmp (*08,s),y ;$d3 =a
+cmp (*08,x) ;$c1 =a
+cmp (*08),y ;$d1 =a
+cmp [*08],y ;$d7 =a
+cmp (*08) ;$d2 =a
+cmp [*08] ;$c7 =a
+//
+cmp.w #*16 ;$c9 ~a
+cmp.b #*08 ;$c9 ~a
+cmp.w *16,y ;$d9 ~a
+cmp.l *24,x ;$df ~a
+cmp.w *16,x ;$dd ~a
+cmp.b *08,x ;$d5 ~a
+cmp.l *24 ;$cf ~a
+cmp.w *16 ;$cd ~a
+cmp.b *08 ;$c5 ~a
+
+sbc *08,s ;$e3 =a
+sbc (*08,s),y ;$f3 =a
+sbc (*08,x) ;$e1 =a
+sbc (*08),y ;$f1 =a
+sbc [*08],y ;$f7 =a
+sbc (*08) ;$f2 =a
+sbc [*08] ;$e7 =a
+//
+sbc.w #*16 ;$e9 ~a
+sbc.b #*08 ;$e9 ~a
+sbc.w *16,y ;$f9 ~a
+sbc.l *24,x ;$ff ~a
+sbc.w *16,x ;$fd ~a
+sbc.b *08,x ;$f5 ~a
+sbc.l *24 ;$ef ~a
+sbc.w *16 ;$ed ~a
+sbc.b *08 ;$e5 ~a
+
+//
+asl.w *16,x ;$1e ~a
+asl.b *08,x ;$16 ~a
+asl.w *16 ;$0e ~a
+asl.b *08 ;$06 ~a
+
+//
+lsr.w *16,x ;$5e ~a
+lsr.b *08,x ;$56 ~a
+lsr.w *16 ;$4e ~a
+lsr.b *08 ;$46 ~a
+
+//
+rol.w *16,x ;$3e ~a
+rol.b *08,x ;$36 ~a
+rol.w *16 ;$2e ~a
+rol.b *08 ;$26 ~a
+
+//
+ror.w *16,x ;$7e ~a
+ror.b *08,x ;$76 ~a
+ror.w *16 ;$6e ~a
+ror.b *08 ;$66 ~a
+
+//
+inc.w *16,x ;$fe ~a
+inc.b *08,x ;$f6 ~a
+inc.w *16 ;$ee ~a
+inc.b *08 ;$e6 ~a
+
+//
+dec.w *16,x ;$de ~a
+dec.b *08,x ;$d6 ~a
+dec.w *16 ;$ce ~a
+dec.b *08 ;$c6 ~a
+
+//
+bit.w #*16 ;$89 ~a
+bit.b #*08 ;$89 ~a
+bit.w *16,x ;$3c ~a
+bit.b *08,x ;$34 ~a
+bit.w *16 ;$2c ~a
+bit.b *08 ;$24 ~a
+
+//
+cpx.w #*16 ;$e0 ~a
+cpx.b #*08 ;$e0 ~a
+cpx.w *16 ;$ec ~a
+cpx.b *08 ;$e4 ~a
+
+//
+cpy.w #*16 ;$c0 ~a
+cpy.b #*08 ;$c0 ~a
+cpy.w *16 ;$cc ~a
+cpy.b *08 ;$c4 ~a
+
+//
+ldx.w #*16 ;$a2 ~a
+ldx.b #*08 ;$a2 ~a
+ldx.w *16,y ;$be ~a
+ldx.b *08,y ;$b6 ~a
+ldx.w *16 ;$ae ~a
+ldx.b *08 ;$a6 ~a
+
+//
+ldy.w #*16 ;$a0 ~a
+ldy.b #*08 ;$a0 ~a
+ldy.w *16,x ;$bc ~a
+ldy.b *08,x ;$b4 ~a
+ldy.w *16 ;$ac ~a
+ldy.b *08 ;$a4 ~a
+
+//
+stx.b *08,y ;$96 ~a
+stx.w *16 ;$8e ~a
+stx.b *08 ;$86 ~a
+
+//
+sty.b *08,x ;$94 ~a
+sty.w *16 ;$8c ~a
+sty.b *08 ;$84 ~a
+
+//
+stz.w *16,x ;$9e ~a
+stz.b *08,x ;$74 ~a
+stz.w *16 ;$9c ~a
+stz.b *08 ;$64 ~a
+
+//
+trb.w *16 ;$1c ~a
+trb.b *08 ;$14 ~a
+
+//
+tsb.w *16 ;$0c ~a
+tsb.b *08 ;$04 ~a
+
+jmp (*16,x) ;$7c =a
+jmp (*16) ;$6c =a
+jmp [*16] ;$dc =a
+jmp *16 ;$4c =a
+jml *24 ;$5c =a
+
+jsr (*16,x) ;$fc =a
+jsr *16 ;$20 =a
+jsl *24 ;$22 =a
+
+brl #*16 ;$82 =a
+bra #*08 ;$80 =a
+bpl #*08 ;$10 =a
+bmi #*08 ;$30 =a
+bvc #*08 ;$50 =a
+bvs #*08 ;$70 =a
+bcc #*08 ;$90 =a
+bcs #*08 ;$b0 =a
+bne #*08 ;$d0 =a
+beq #*08 ;$f0 =a
+//
+brl *16 ;$82 +3a
+bra *08 ;$80 +2a
+bpl *08 ;$10 +2a
+bmi *08 ;$30 +2a
+bvc *08 ;$50 +2a
+bvs *08 ;$70 +2a
+bcc *08 ;$90 +2a
+bcs *08 ;$b0 +2a
+bne *08 ;$d0 +2a
+beq *08 ;$f0 +2a
+
+mvp *08=*08 ;$44 =a =b
+mvn *08=*08 ;$54 =a =b
+
+pea *16 ;$f4 =a
+pei (*08) ;$d4 =a
+per *16 ;$62 =a
+
+rep #*08 ;$c2 =a
+sep #*08 ;$e2 =a
+
+brk #*08 ;$00 =a
+cop #*08 ;$02 =a
+wdm #*08 ;$42 =a
diff --git a/roms/snes-test-roms/bass-untech/bass/data/architectures/wdc65816.arch b/roms/snes-test-roms/bass-untech/bass/data/architectures/wdc65816.arch
new file mode 100644
index 00000000..70a913ce
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/data/architectures/wdc65816.arch
@@ -0,0 +1,487 @@
+endian lsb
+
+asl ;$0a
+clc ;$18
+cld ;$d8
+cli ;$58
+clv ;$b8
+dec ;$3a
+dex ;$ca
+dey ;$88
+inc ;$1a
+inx ;$e8
+iny ;$c8
+lsr ;$4a
+nop ;$ea
+pha ;$48
+phb ;$8b
+phd ;$0b
+phk ;$4b
+php ;$08
+phx ;$da
+phy ;$5a
+pla ;$68
+plb ;$ab
+pld ;$2b
+plp ;$28
+plx ;$fa
+ply ;$7a
+rol ;$2a
+ror ;$6a
+rti ;$40
+rtl ;$6b
+rts ;$60
+sec ;$38
+sed ;$f8
+sei ;$78
+stp ;$db
+tad ;$5b
+tas ;$1b
+tax ;$aa
+tay ;$a8
+tda ;$7b
+tsa ;$3b
+tsx ;$ba
+txa ;$8a
+txs ;$9a
+txy ;$9b
+tya ;$98
+tyx ;$bb
+wai ;$cb
+xba ;$eb
+xce ;$fb
+//
+tcd ;$5b
+tcs ;$1b
+tdc ;$7b
+tsc ;$3b
+
+asl #*08 ;*a:$0a
+dec #*08 ;*a:$3a
+dex #*08 ;*a:$ca
+dey #*08 ;*a:$88
+inc #*08 ;*a:$1a
+inx #*08 ;*a:$e8
+iny #*08 ;*a:$c8
+lsr #*08 ;*a:$4a
+nop #*08 ;*a:$ea
+rol #*08 ;*a:$2a
+ror #*08 ;*a:$6a
+
+ora #*16 ;$09 =a
+ora #*08 ;$09 =a
+ora *08,s ;$03 =a
+ora (*08,s),y ;$13 =a
+ora (*08,x) ;$01 =a
+ora (*08),y ;$11 =a
+ora [*08],y ;$17 =a
+ora (*08) ;$12 =a
+ora [*08] ;$07 =a
+ora *16,y ;$19 =a
+ora *24,x ;$1f =a
+ora *16,x ;$1d =a
+ora *08,x ;$15 =a
+ora *24 ;$0f =a
+ora *16 ;$0d =a
+ora *08 ;$05 =a
+//
+ora.w #*16 ;$09 ~a
+ora.b #*08 ;$09 ~a
+ora.w *16,y ;$19 ~a
+ora.l *24,x ;$1f ~a
+ora.w *16,x ;$1d ~a
+ora.b *08,x ;$15 ~a
+ora.l *24 ;$0f ~a
+ora.w *16 ;$0d ~a
+ora.b *08 ;$05 ~a
+
+and #*16 ;$29 =a
+and #*08 ;$29 =a
+and *08,s ;$23 =a
+and (*08,s),y ;$33 =a
+and (*08,x) ;$21 =a
+and (*08),y ;$31 =a
+and [*08],y ;$37 =a
+and (*08) ;$32 =a
+and [*08] ;$27 =a
+and *16,y ;$39 =a
+and *24,x ;$3f =a
+and *16,x ;$3d =a
+and *08,x ;$35 =a
+and *24 ;$2f =a
+and *16 ;$2d =a
+and *08 ;$25 =a
+//
+and.w #*16 ;$29 ~a
+and.b #*08 ;$29 ~a
+and.w *16,y ;$39 ~a
+and.l *24,x ;$3f ~a
+and.w *16,x ;$3d ~a
+and.b *08,x ;$35 ~a
+and.l *24 ;$2f ~a
+and.w *16 ;$2d ~a
+and.b *08 ;$25 ~a
+
+eor #*16 ;$49 =a
+eor #*08 ;$49 =a
+eor *08,s ;$43 =a
+eor (*08,s),y ;$53 =a
+eor (*08,x) ;$41 =a
+eor (*08),y ;$51 =a
+eor [*08],y ;$57 =a
+eor (*08) ;$52 =a
+eor [*08] ;$47 =a
+eor *16,y ;$59 =a
+eor *24,x ;$5f =a
+eor *16,x ;$5d =a
+eor *08,x ;$55 =a
+eor *24 ;$4f =a
+eor *16 ;$4d =a
+eor *08 ;$45 =a
+//
+eor.w #*16 ;$49 ~a
+eor.b #*08 ;$49 ~a
+eor.w *16,y ;$59 ~a
+eor.l *24,x ;$5f ~a
+eor.w *16,x ;$5d ~a
+eor.b *08,x ;$55 ~a
+eor.l *24 ;$4f ~a
+eor.w *16 ;$4d ~a
+eor.b *08 ;$45 ~a
+
+adc #*16 ;$69 =a
+adc #*08 ;$69 =a
+adc *08,s ;$63 =a
+adc (*08,s),y ;$73 =a
+adc (*08,x) ;$61 =a
+adc (*08),y ;$71 =a
+adc [*08],y ;$77 =a
+adc (*08) ;$72 =a
+adc [*08] ;$67 =a
+adc *16,y ;$79 =a
+adc *24,x ;$7f =a
+adc *16,x ;$7d =a
+adc *08,x ;$75 =a
+adc *24 ;$6f =a
+adc *16 ;$6d =a
+adc *08 ;$65 =a
+//
+adc.w #*16 ;$69 ~a
+adc.b #*08 ;$69 ~a
+adc.w *16,y ;$79 ~a
+adc.l *24,x ;$7f ~a
+adc.w *16,x ;$7d ~a
+adc.b *08,x ;$75 ~a
+adc.l *24 ;$6f ~a
+adc.w *16 ;$6d ~a
+adc.b *08 ;$65 ~a
+
+sta *08,s ;$83 =a
+sta (*08,s),y ;$93 =a
+sta (*08,x) ;$81 =a
+sta (*08),y ;$91 =a
+sta [*08],y ;$97 =a
+sta (*08) ;$92 =a
+sta [*08] ;$87 =a
+sta *16,y ;$99 =a
+sta *24,x ;$9f =a
+sta *16,x ;$9d =a
+sta *08,x ;$95 =a
+sta *24 ;$8f =a
+sta *16 ;$8d =a
+sta *08 ;$85 =a
+//
+sta.w *16,y ;$99 ~a
+sta.l *24,x ;$9f ~a
+sta.w *16,x ;$9d ~a
+sta.b *08,x ;$95 ~a
+sta.l *24 ;$8f ~a
+sta.w *16 ;$8d ~a
+sta.b *08 ;$85 ~a
+
+lda #*16 ;$a9 =a
+lda #*08 ;$a9 =a
+lda *08,s ;$a3 =a
+lda (*08,s),y ;$b3 =a
+lda (*08,x) ;$a1 =a
+lda (*08),y ;$b1 =a
+lda [*08],y ;$b7 =a
+lda (*08) ;$b2 =a
+lda [*08] ;$a7 =a
+lda *16,y ;$b9 =a
+lda *24,x ;$bf =a
+lda *16,x ;$bd =a
+lda *08,x ;$b5 =a
+lda *24 ;$af =a
+lda *16 ;$ad =a
+lda *08 ;$a5 =a
+//
+lda.w #*16 ;$a9 ~a
+lda.b #*08 ;$a9 ~a
+lda.w *16,y ;$b9 ~a
+lda.l *24,x ;$bf ~a
+lda.w *16,x ;$bd ~a
+lda.b *08,x ;$b5 ~a
+lda.l *24 ;$af ~a
+lda.w *16 ;$ad ~a
+lda.b *08 ;$a5 ~a
+
+cmp #*16 ;$c9 =a
+cmp #*08 ;$c9 =a
+cmp *08,s ;$c3 =a
+cmp (*08,s),y ;$d3 =a
+cmp (*08,x) ;$c1 =a
+cmp (*08),y ;$d1 =a
+cmp [*08],y ;$d7 =a
+cmp (*08) ;$d2 =a
+cmp [*08] ;$c7 =a
+cmp *16,y ;$d9 =a
+cmp *24,x ;$df =a
+cmp *16,x ;$dd =a
+cmp *08,x ;$d5 =a
+cmp *24 ;$cf =a
+cmp *16 ;$cd =a
+cmp *08 ;$c5 =a
+//
+cmp.w #*16 ;$c9 ~a
+cmp.b #*08 ;$c9 ~a
+cmp.w *16,y ;$d9 ~a
+cmp.l *24,x ;$df ~a
+cmp.w *16,x ;$dd ~a
+cmp.b *08,x ;$d5 ~a
+cmp.l *24 ;$cf ~a
+cmp.w *16 ;$cd ~a
+cmp.b *08 ;$c5 ~a
+
+sbc #*16 ;$e9 =a
+sbc #*08 ;$e9 =a
+sbc *08,s ;$e3 =a
+sbc (*08,s),y ;$f3 =a
+sbc (*08,x) ;$e1 =a
+sbc (*08),y ;$f1 =a
+sbc [*08],y ;$f7 =a
+sbc (*08) ;$f2 =a
+sbc [*08] ;$e7 =a
+sbc *16,y ;$f9 =a
+sbc *24,x ;$ff =a
+sbc *16,x ;$fd =a
+sbc *08,x ;$f5 =a
+sbc *24 ;$ef =a
+sbc *16 ;$ed =a
+sbc *08 ;$e5 =a
+//
+sbc.w #*16 ;$e9 ~a
+sbc.b #*08 ;$e9 ~a
+sbc.w *16,y ;$f9 ~a
+sbc.l *24,x ;$ff ~a
+sbc.w *16,x ;$fd ~a
+sbc.b *08,x ;$f5 ~a
+sbc.l *24 ;$ef ~a
+sbc.w *16 ;$ed ~a
+sbc.b *08 ;$e5 ~a
+
+asl *16,x ;$1e =a
+asl *08,x ;$16 =a
+asl *16 ;$0e =a
+asl *08 ;$06 =a
+//
+asl.w *16,x ;$1e ~a
+asl.b *08,x ;$16 ~a
+asl.w *16 ;$0e ~a
+asl.b *08 ;$06 ~a
+
+lsr *16,x ;$5e =a
+lsr *08,x ;$56 =a
+lsr *16 ;$4e =a
+lsr *08 ;$46 =a
+//
+lsr.w *16,x ;$5e ~a
+lsr.b *08,x ;$56 ~a
+lsr.w *16 ;$4e ~a
+lsr.b *08 ;$46 ~a
+
+rol *16,x ;$3e =a
+rol *08,x ;$36 =a
+rol *16 ;$2e =a
+rol *08 ;$26 =a
+//
+rol.w *16,x ;$3e ~a
+rol.b *08,x ;$36 ~a
+rol.w *16 ;$2e ~a
+rol.b *08 ;$26 ~a
+
+ror *16,x ;$7e =a
+ror *08,x ;$76 =a
+ror *16 ;$6e =a
+ror *08 ;$66 =a
+//
+ror.w *16,x ;$7e ~a
+ror.b *08,x ;$76 ~a
+ror.w *16 ;$6e ~a
+ror.b *08 ;$66 ~a
+
+inc *16,x ;$fe =a
+inc *08,x ;$f6 =a
+inc *16 ;$ee =a
+inc *08 ;$e6 =a
+//
+inc.w *16,x ;$fe ~a
+inc.b *08,x ;$f6 ~a
+inc.w *16 ;$ee ~a
+inc.b *08 ;$e6 ~a
+
+dec *16,x ;$de =a
+dec *08,x ;$d6 =a
+dec *16 ;$ce =a
+dec *08 ;$c6 =a
+//
+dec.w *16,x ;$de ~a
+dec.b *08,x ;$d6 ~a
+dec.w *16 ;$ce ~a
+dec.b *08 ;$c6 ~a
+
+bit #*16 ;$89 =a
+bit #*08 ;$89 =a
+bit *16,x ;$3c =a
+bit *08,x ;$34 =a
+bit *16 ;$2c =a
+bit *08 ;$24 =a
+//
+bit.w #*16 ;$89 ~a
+bit.b #*08 ;$89 ~a
+bit.w *16,x ;$3c ~a
+bit.b *08,x ;$34 ~a
+bit.w *16 ;$2c ~a
+bit.b *08 ;$24 ~a
+
+cpx #*16 ;$e0 =a
+cpx #*08 ;$e0 =a
+cpx *16 ;$ec =a
+cpx *08 ;$e4 =a
+//
+cpx.w #*16 ;$e0 ~a
+cpx.b #*08 ;$e0 ~a
+cpx.w *16 ;$ec ~a
+cpx.b *08 ;$e4 ~a
+
+cpy #*16 ;$c0 =a
+cpy #*08 ;$c0 =a
+cpy *16 ;$cc =a
+cpy *08 ;$c4 =a
+//
+cpy.w #*16 ;$c0 ~a
+cpy.b #*08 ;$c0 ~a
+cpy.w *16 ;$cc ~a
+cpy.b *08 ;$c4 ~a
+
+ldx #*16 ;$a2 =a
+ldx #*08 ;$a2 =a
+ldx *16,y ;$be =a
+ldx *08,y ;$b6 =a
+ldx *16 ;$ae =a
+ldx *08 ;$a6 =a
+//
+ldx.w #*16 ;$a2 ~a
+ldx.b #*08 ;$a2 ~a
+ldx.w *16,y ;$be ~a
+ldx.b *08,y ;$b6 ~a
+ldx.w *16 ;$ae ~a
+ldx.b *08 ;$a6 ~a
+
+ldy #*16 ;$a0 =a
+ldy #*08 ;$a0 =a
+ldy *16,x ;$bc =a
+ldy *08,x ;$b4 =a
+ldy *16 ;$ac =a
+ldy *08 ;$a4 =a
+//
+ldy.w #*16 ;$a0 ~a
+ldy.b #*08 ;$a0 ~a
+ldy.w *16,x ;$bc ~a
+ldy.b *08,x ;$b4 ~a
+ldy.w *16 ;$ac ~a
+ldy.b *08 ;$a4 ~a
+
+stx *08,y ;$96 =a
+stx *16 ;$8e =a
+stx *08 ;$86 =a
+//
+stx.b *08,y ;$96 ~a
+stx.w *16 ;$8e ~a
+stx.b *08 ;$86 ~a
+
+sty *08,x ;$94 =a
+sty *16 ;$8c =a
+sty *08 ;$84 =a
+//
+sty.b *08,x ;$94 ~a
+sty.w *16 ;$8c ~a
+sty.b *08 ;$84 ~a
+
+stz *16,x ;$9e =a
+stz *08,x ;$74 =a
+stz *16 ;$9c =a
+stz *08 ;$64 =a
+//
+stz.w *16,x ;$9e ~a
+stz.b *08,x ;$74 ~a
+stz.w *16 ;$9c ~a
+stz.b *08 ;$64 ~a
+
+trb *16 ;$1c =a
+trb *08 ;$14 =a
+//
+trb.w *16 ;$1c ~a
+trb.b *08 ;$14 ~a
+
+tsb *16 ;$0c =a
+tsb *08 ;$04 =a
+//
+tsb.w *16 ;$0c ~a
+tsb.b *08 ;$04 ~a
+
+jmp (*16,x) ;$7c =a
+jmp (*16) ;$6c =a
+jmp [*16] ;$dc =a
+jmp *16 ;$4c =a
+jml *24 ;$5c =a
+
+jsr (*16,x) ;$fc =a
+jsr *16 ;$20 =a
+jsl *24 ;$22 =a
+
+brl #*16 ;$82 =a
+bra #*08 ;$80 =a
+bpl #*08 ;$10 =a
+bmi #*08 ;$30 =a
+bvc #*08 ;$50 =a
+bvs #*08 ;$70 =a
+bcc #*08 ;$90 =a
+bcs #*08 ;$b0 =a
+bne #*08 ;$d0 =a
+beq #*08 ;$f0 =a
+//
+brl *16 ;$82 +3a
+bra *08 ;$80 +2a
+bpl *08 ;$10 +2a
+bmi *08 ;$30 +2a
+bvc *08 ;$50 +2a
+bvs *08 ;$70 +2a
+bcc *08 ;$90 +2a
+bcs *08 ;$b0 +2a
+bne *08 ;$d0 +2a
+beq *08 ;$f0 +2a
+
+mvp *08=*08 ;$44 =a =b
+mvn *08=*08 ;$54 =a =b
+
+pea *16 ;$f4 =a
+pei (*08) ;$d4 =a
+per *16 ;$62 =a
+
+rep #*08 ;$c2 =a
+sep #*08 ;$e2 =a
+
+brk #*08 ;$00 =a
+cop #*08 ;$02 =a
+wdm #*08 ;$42 =a
diff --git a/roms/snes-test-roms/bass-untech/bass/doc/bass.html b/roms/snes-test-roms/bass-untech/bass/doc/bass.html
new file mode 100644
index 00000000..c8c7ef49
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/bass/doc/bass.html
@@ -0,0 +1,709 @@
+
+
+ bass-untech documentation
+
+
+
+ bass-untech v17
+ DISCLAIMER: bass-untech is a fork of Near's bass assembler
+ Author: Near
+ Forked By: The UnDisbeliever
+ License: ISC
+
+
+ Terminal Usage
+ bass-untech [options] source [source ...]
+
+ Options
+
+ -o target will specify the default target filename, and overwrite
+ any existing file by said filename.
+
+ -m target will specify the default target filenamd, and will
+ modify, rather than replace, any existing file by said name.
+
+ -d name[=value] will create a define with the given name, and
+ assign to it either an empty value or the value provided.
+
+ -c name[=value] will create a constant with the given name, and
+ assign to it either a value of 1 or the value provided.
+
+ -sym filename will create a symbol file with the given filename.
+ The symbol file will contain the pc address and scoped name for every
+ named label.
+
+ -strict will abort the assembly process on warnings.
+
+ -benchmark will display the time required to assemble the source.
+
+
+ Architecture
+ bass is a multi-pass assembler which can be driven by tables to support
+ multiple architectures.
+
+ Parsing consists of the following phases:
+
+ Tokenize
+
+ The tokenize phase will combine all source files, and insert any
+ nested include statements into a single stream of instructions.
+
+ Analyze
+
+ The analyze phase will parse blocks, such as macros and functions,
+ and note where they begin and end.
+
+ Execute
+
+ The execute phase will recurse macro invocations, substitute
+ defines and evaluate conditional expressions.
+
+ Query
+
+ The query phase invokes the execute phase, and computes the
+ values of constants and labels.
+
+ Write
+
+ The write phase invokes the execute phase, uses the
+ previously computed values for constants and labels, and writes to any
+ opened output file.
+
+ Tokenizing
+ Initially, each source file specified on the terminal is loaded in. For
+ each source file, all tabs (\t) and carriage returns (\r) are converted to
+ spaces, and each line is split by line feeds (\n). Next, each line is
+ clipped at the first appearance of a comment marker (//). Then, each line is
+ split by any semicolons (;) not appearing inside of quoted strings.
+ That is to say, semicolons can be used inside of quoted strings. Using
+ semicolons outside of strings splits the line into multiple statements. The
+ semicolon acts as a statement separator, and not as a statement terminator,
+ meaning that a semicolon is not required at the end of each line. Finally,
+ if the statement is an include directive, the source file parser will
+ be invoked recursively to load in nested source files.
+
+ Names
+ Macros, functions, defines, variables and constants must be in the
+ following format:
+
+ [_A-Za-z][_A-Za-z0-9.]*
+
+
+ Numbers
+ Valid numbers must be in one of the following formats:
+
+ [0-9]+ integer
+ 0b[01]+ binary
+ 0o[0-7]+ octal
+ 0x[0-9a-f]+ hex
+ %[01]+ binary
+ $[0-9a-f]+ hex
+
+
+ Numbers may be prefixed with - or + if desired.
+
+ Numbers may also use ' as a digit separator. For example:
+
+ 123'456'789 //same as 123456789
+ 0b1001'0110 //same as 0b10010110
+
+
+ Strings
+ Strings are surrounded by double-quotes. They support the following
+ escape sequences:
+
+
+ \\ = backslash (\)
+ \' = single-quote (')
+ \" = double-quote (")
+ \n = new line
+ \t = tab
+
+
+ Strings may also be concatenated via the ~ operator, which is useful
+ for string construction via defines:
+
+
+ "foo" ~ "bar" //equivalent to "foobar"
+
+
+ Characters
+ Characters are surrounded by single-quotes, and evaluate to integer
+ values which can be used inside of expressions. They support the same escape
+ sequences as strings.
+
+ Note that characters are not escaped for block tokenization. That means
+ you must use '\b' instead of ';' to avoid splitting the character into two
+ separate statements.
+
+ Execution
+ Execution acts much like a scripting language. Statements are evaluated
+ and a control flow (stack frame) is maintained.
+
+ Expressions
+ Expressions can be used to transform variables or constants by use of
+ parameters. Expressions may be recursive.
+
+ Example:
+
+ expression sum(x, y) = x + y
+ print sum(1, 2), "\n" //prints 3
+
+
+ Defines
+ Defines can be used to substitute values in expressions. The
+ define keyword allows specifying an exact expression to substitute,
+ whereas the evaluate keyword will evaluate the expression to an
+ integer value. The latter is useful for conditional expressions. Defines
+ must be declared before being used, and can be re-declared later on.
+
+ Example:
+
+ define x = 1 + 2
+ print "{x}\n" //prints "1 + 2\n"
+ evaluate x = {x} + 3 //x = evaluate(1 + 2 + 3)
+ print "{x}\n" //prints "6\n"
+
+
+ Defines can also take arguments for substitution.
+
+ Example:
+
+ define sum(x, y) = ({x} + {y})
+ print "{sum(1,2)}\n" //prints "(1 + 2)\n"
+
+
+ Invocation
+ Defines can be invoked with: {defineName}. Defines with parameters
+ can be invoked with {defineName(parameter, ...)}. If a define is not
+ matched, there is no error, the literal {defineName} will be passed
+ along to the assembler verbatim.
+
+ Parsing
+ Defines are evaluated from right-to-left order, meaning that expressions
+ such as {x{y}} will first expand {y}, and then the result of
+ that expression, {x...}.
+
+ Existence
+ It is possible to test if a define has been declared or not by using this
+ special syntax: {defined name}
+
+
+ //create {value} if it does not yet exist
+ if !{defined value} {
+ define value(...)
+ }
+
+
+ {defined name} is substituted with either 1 (if a define by the
+ given name exists) or 0 (if it does not.)
+
+ Macros
+ Macros are supported. They can take zero or more arguments, and name
+ overloading with differing arity is possible. Recursion is supported, but
+ requires conditionals in order to break infinite recursion. Macros must be
+ declared before being used, and can be re-declared later on.
+
+ By default, macro parameters are simply the names of the values, and are
+ passed in as defines. It is also possible to specify the type of the
+ parameter, which will cause the invocation to pass the value in as the
+ requested type. Supported types are: define, evaluate and variable.
+
+ Example:
+
+ macro seek(offset) {
+ origin {offset} & 0x3fffff
+ base 0xc00000 | {offset}
+ }
+
+ seek(0xc08000)
+
+ macro test(define a, evaluate b, variable c, d) {
+ //{d} has no type, so it defaults to "define d"
+ }
+
+ test(1+2, 1+2, 1+2, 1+2) //{a} = 1+2, {b} = 3, c = 3, {d} = 1+2
+
+
+ Invocation Counter
+ Because expanded macros are passed directly to the assembler, a macro
+ with a label name cannot be expanded twice in the same scope, or the label
+ name will be declared twice, resulting in an error. The special token
+ {#} can be used in a label name, where it will be substituted with a
+ numeric value that increments every time a macro is invoked.
+
+ Note that the invocation counter may not work as expected inside of
+ recursive macros. Only use this for top-level macros.
+
+ Invocation
+ Macros can be invoked with the syntax: macroName(parameter, parameter,
+ ...). If a macro is not matched, there is no error, the literal
+ macroName(...) will be passed along to the assembly phase. Note that
+ macros cannot appear inside expressions: the macro invocation must be the
+ entire statement.
+
+ Stack Frame
+ Every time a macro is invoked, a new object stack frame is created, which
+ will supercede all previous stack frames. All macro arguments, as well as
+ any objects declared inside of said macro, are appended to the new frame.
+ When the macro completes execution, said frame is destroyed, and said
+ objects are lost. Note that this does not apply to constants, which must
+ always be placed in the global frame to support forward-declarations.
+
+ It is however possible to access the global frame by prefixing object
+ creation with the global keyword, for example:
+
+
+ macro square(value) {
+ global evaluate result({value} * {value})
+ }
+
+ square(16)
+ print "{square.result}\n" //prints 256
+
+
+ Further, it is also possible to reference the parent frame by prefixing
+ object creation with the parent keyword, which is useful for
+ recursive macros, or to represent macro return values. For example:
+
+
+ macro factorial(variable n) {
+ parent variable result = 1
+ if n >= 1 {
+ factorial(n - 1)
+ result = n * factorial.result
+ }
+ }
+
+ factorial(10)
+ print factorial.result, "\n" //prints 3628800
+
+
+ Inline Macros
+ Macros can also be created without a stack frame by using the
+ inline keyword, which will cause any objects created inside of them
+ to appear in the same frame as the macro was invoked in. For example:
+
+
+ inline square(variable value) {
+ variable result = value * value
+ }
+
+ function main {
+ square(16)
+ }
+
+ print main.result, "\n" //prints 256
+
+
+ This is obviously not a good idea to use for recursive macros.
+
+ Conditional Expressions
+ bass supports traditional conditional expressions.
+
+ Example:
+
+ define x = 16
+ while {x} > 0 {
+ print "{x}\n"
+ evaluate x = {x} - 1
+ }
+ if {x} > 16 {
+ ...
+ } else if {x} > 8 {
+ ...
+ } else {
+ ...
+ }
+
+
+ Variables and constants can be used in conditional expressions. Just note
+ that variables must be declared before they can be used in expressions. Only
+ constants support forward-declaration.
+
+ Assembly
+ Any statements that fall through the execute phase are passed into the
+ assembly phase.
+
+ Variables and Constants
+ Variables and constants hold integer values. Variables must be declared
+ before being used, but can be redefined. Constants can be used before their
+ declaration, but subsequently cannot be redefined. Labels are stored as
+ constants.
+
+ Expressions in a constant statement can contain forward references. Just
+ remember that bass-untech does not perform delayed evaluation and will
+ abort assembly if the constant's value is unknown when used in a command, a
+ conditional expression, or the write phase.
+
+ Example:
+
+ variable x = 16
+ lda #x //16
+
+ variable x = 32
+ lda #x //32
+
+ lda #y //64
+ constant y = 64
+
+ constant z = VeryLongLabelName
+ lda z //VeryLongLabelName
+
+
+ Arrays
+ Arrays of variables can be created. The size of the array is fixed once
+ it has been created, but the array can be redefined later on to another
+ size if desired. Array elements not specified initially are initialized to
+ zeroes.
+
+ Example:
+
+ array[4] x = 1,2,4,8
+ array[2] y
+
+ y[1] = x[3]
+ print y[0], ",", y[1], "\n" //prints 0,8
+
+ array[8] x //recreates a new array with eight entries
+
+
+ Labels
+ Labels can be created with the syntax: labelName:
+
+ Example:
+
+ loop:
+ dex; bne loop
+
+
+ Anonymous Labels
+ Labels without names can be created using - and +.
+
+ Example:
+
+ -; beq +; lsr; dex; bne -; +
+
+ -; bra ++ //A: go to D
+ -; bra + //B: go to C
+ +; bra - //C: go to B
+ +; bra -- //D: go to A
+
+
+ Invocation:
+ The previous - label can be referenced with -, and the next + label can
+ be referenced with +. The second to last - label can be referenced with --,
+ and the second to next + label can be referenced with ++. Deeper scoping is
+ not supported: you will have to switch to named labels at this point.
+
+ Scoping
+ Macros, defines, variables and constants can be scoped. This allows reuse
+ of common names like loop and finish inside of scopes, without
+ causing declaration collisions. Note that labels are stored as constants,
+ meaning that scoping also applies to labels.
+
+ It's also important to understand that for macro scoping, the macro
+ name's scope is determined where the macro is declared, and the actual scope
+ used while executing a macro is determined where the macro is invoked.
+
+ Example:
+
+ variable offset = 16
+
+ namespace information {
+ variable length = 32
+
+ lda #offset //16
+ lda #length //32
+ }
+
+ lda #offset //16
+ lda #information.length //32
+
+
+ Scoped Labels
+ It is possible to declare a scope and label at the same time, which is a
+ useful way to mark functions and their boundaries.
+
+ Example:
+
+ function main {
+ subroutine:
+ }
+
+ jsr main.subroutine
+
+
+ Unscoped Blocks
+ It is also possible to create blocks which do not create scopes. These
+ are used strictly for code clarity, and have no functional effect.
+
+ Example:
+
+ labelName: {
+ }
+
+ - {
+ }
+
+ + {
+ }
+
+ {
+ }
+
+
+ include "filename"
+ Note that this command is parsed in the very first phase, and is only
+ noted here for completeness. It includes another source file in place of
+ this command.
+
+ Do not attempt conditional recursion on the same source file, as this
+ will result in an infinite loop which will eventually exhaust all memory.
+
+
+ output "filename" [, create]
+ This command can be used in place of the -o filename [-create]
+ command-line argument, or in addition to it, and can open multiple files
+ sequentially for output (only one output file can be open at a time.) The
+ create parameter, if specified, states to overwrite the target file if it
+ already exists. Otherwise, the file is opened in modification mode.
+
+ architecture name
+ This command will change the currently active architecture. An
+ architecture is essentially a processor that bass supports.
+
+ bass will first try to select any built-in architecture by the given
+ name, which allows bass to support architectures written as C++ modules.
+ Currently, the only built-in architecture is none, which is also the
+ default state at the start of assembly.
+
+ When no built-in architecture is found, bass will instead use its
+ table-driver assembler architecture. This architecture takes a text file as
+ input, which defines all supported opcodes and their encodings for a given
+ processor.
+
+ The name is transformed to name.arch, and bass tries to find said
+ file in two locations: first, in the architectures/ subdirectory next
+ to the main bass executable. And second, in
+ ~/.local/share/bass/architectures/ or
+ %localappdata%/bass/architectures/, depending upon your OS.
+
+ bass ships with a variety of pre-made table architecture files. On
+ Linux/BSD, users should run make install to place these files into
+ the appropriate location to be used.
+
+ bass is also extensible, so users can add their own table architecture
+ files to support additional processors. Architectures written in C++ will
+ however require recompiling bass to include said architecture.
+
+ Note that the architecture command will also change the current endian
+ mode of bass, to match that of the given processor architecture.
+
+ In the event that name does not match a built-in architecture, and
+ no appropriate name.arch file can be found, this command will
+ generate an error.
+
+ endian (lsb|msb)
+ This command controls whether multi-byte values (eg from dw and dd) are
+ output in little-endian (lsb) or big-endian (msb) format.
+
+ origin offset
+ This command seeks the output file write cursor to the specified
+ location.
+
+ base offset
+ This command creates a signed displacement against the origin value,
+ which is used when computing the pc (program counter) value for labels. This
+ command allows mapping file address space into a virtual memory address
+ space.
+
+ (enqueue|dequeue) variable [, ...]
+ This can be used to save and restore internal state. Currently supported
+ values are: origin, base, pc.
+
+ copy source, target, length
+ This command copies a block from the currently open file to another
+ location within the file. It does this by reading the entire block in first,
+ and then writing said block out, so be careful with overlapping addresses.
+
+
+ insert [name, ] "filename" [, offset] [, length]
+ This command inserts a binary file into the target file. You can
+ optionally specify a name, offset and length. If you specify a name, it will
+ create a label by the given name, which contains the address where the data
+ begins, and it will also create name.size, which contains the size of the
+ included data. If you specify an offset, it will seek that far into the
+ referenced filename before copying the data. If you want to specify a
+ length, you must specify an offset first, and the length will determine the
+ maximum number of bytes to copy from the referenced filename.
+
+ delete "filename"
+ This command deletes a file from disk. Useful for removing temporary work
+ files needed by a project being assembled.
+
+ fill length [, with]
+ Inserts length number of bytes into the target file. The default
+ fill byte is 0x00, but can be specified via with.
+
+ map 'char' [, value] [, length]
+ Modifies the mappings for strings passed to db, dw, etc. This can be used
+ to map strings to custom tilemaps that do not follow traditional ASCII
+ values.
+
+ char is the first value to modify, value is the value to
+ map said char to, and length can be used for contiguous entries. For
+ instance, if A-Z appear sequentially, give a value of 26 for the length, to
+ avoid having to declare 26 separate assignments. Each step of length
+ increments both the char and value by exactly one, so the characters must be
+ contiguous with both ASCII and your custom map for this to work.
+
+ If you wish to restore the table to its default ASCII values, use the
+ following command:
+
+ map 0, 0, 256
+
+ d[bwldq] ("string"|variable|constant) [, ...]
+ Inserts binary data directly into the target file. db stores 8-bit
+ values, dw stores 16-bit values, dl stored 24-bit values, dd stored 32-bit
+ values and dq stores 64-bit values.
+
+ print ("string"|variable) [, ...]
+ Prints information to the terminal. Useful for debugging.
+
+ The print directive also supports formatting prefixes for variable or
+ constant expressions. These are: binary, hex, and char.
+ Example:
+
+
+ print "%", binary:15 //prints %1111
+ print "$", hex:65536 //prints $10000
+ print "'", char:65, "'" //prints 'A'
+
+
+ ds offset
+ Seeks forward or backward from the current output file write address. The
+ value can be positive (to seek forward) or negative (to seek backward.) This
+ is useful for skipping bytes when in file modification mode.
+
+ tracker enable|disable|reset
+ Tracks writes to a given output file when enabled. Selecting a new output
+ file automatically clears the tracking list. This is useful when using bass
+ as a patching assembler to detect when the same file address is written to
+ more than once. If this happens while the tracker is enabled, an error is
+ produced.
+
+ Note: disabling the tracker does not clear the previously tracked
+ addresses, in case you only wish to intentionally disable it for a short
+ time. If you want to clear the tracking history, use the reset argument.
+
+ notice "string"
+ Prints a notice to the terminal, but continues assembly.
+
+ warning "string"
+ Prints a warning to the terminal, but continues assembly.
+
+ error "string"
+ Prints an error to the terminal, and aborts assembly.
+
+ Functions
+ bass supports built-in functions. The syntax is equivalent to macros,
+ however they are used in expressions rather than as statements, and they
+ always return a numeric value.
+
+ Example:
+
+ seek(0x8000) //this is a macro statement
+ ...
+ if pc() > 0x8fff { //this is a function used inside an assembler statement
+ ...
+ }
+
+
+ array.size(name)
+ Returns the number of elements in an array, or produces an error if the
+ array is not defined.
+
+ array.sort(name)
+ Sorts the specified array in ascending order.
+
+ assert(expression)
+ Produces an error if the expression evaluates to zero.
+
+ file.size("filename")
+ Returns the size of "filename" on disk, or produces an error if the file
+ is not found.
+
+ file.exists("filename")
+ Returns 1 if "filename" exists, or 0 if not.
+
+ read(address)
+ Reads a byte from the currently open output file, or produces an error if
+ there is no file currently open. The address provided is the origin, or
+ literal file address. The base offset is not factored in when this function
+ is used.
+
+ Important note: the resulting values read from a target file are only
+ valid during the write phase of assembly! If you rely on the value read
+ back during a previous pass to control outputting code, bass may assemble
+ the source code incorrectly. Use this function with caution. It is mostly
+ intended for when bass is used in patching mode.
+
+ origin()
+ Returns the current origin.
+
+ base()
+ Returns the current base.
+
+ pc()
+ Returns the current program counter (origin + base.)
+
+ The End
+ Hopefully this has been informative. The best way to learn is through
+ practice, so please do experiment and see what you can come up with!
+
+ Thank you for using bass!
+
+
diff --git a/roms/snes-test-roms/bass-untech/nall/GNUmakefile b/roms/snes-test-roms/bass-untech/nall/GNUmakefile
new file mode 100644
index 00000000..95833fd8
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/GNUmakefile
@@ -0,0 +1,248 @@
+# disable built-in rules and variables
+MAKEFLAGS := Rr
+.SUFFIXES:
+
+[0-9] = 0 1 2 3 4 5 6 7 8 9
+[A-Z] = A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+[a-z] = a b c d e f g h i j k l m n o p q r s t u v w x y z
+[markup] = ` ~ ! @ \# $$ % ^ & * ( ) - _ = + [ { ] } \ | ; : ' " , < . > / ?
+[all] = $([0-9]) $([A-Z]) $([a-z]) $([markup])
+[empty] :=
+[space] := $([empty]) $([empty])
+
+# platform detection
+ifeq ($(platform),)
+ ifeq ($(OS),Windows_NT)
+ platform := windows
+ endif
+endif
+
+ifeq ($(platform),)
+ uname := $(shell uname)
+ ifeq ($(uname),)
+ platform := windows
+ else ifneq ($(findstring Windows,$(uname)),)
+ platform := windows
+ else ifneq ($(findstring NT,$(uname)),)
+ platform := windows
+ else ifneq ($(findstring Darwin,$(uname)),)
+ platform := macos
+ else ifneq ($(findstring Linux,$(uname)),)
+ platform := linux
+ else ifneq ($(findstring BSD,$(uname)),)
+ platform := bsd
+ else
+ $(error unknown platform, please specify manually.)
+ endif
+endif
+
+# common commands
+ifeq ($(shell echo ^^),^)
+ # cmd
+ delete = $(info Deleting $1 ...) @del /q $(subst /,\,$1)
+ rdelete = $(info Deleting $1 ...) @del /s /q $(subst /,\,$1) && if exist $(subst /,\,$1) (rmdir /s /q $(subst /,\,$1))
+else
+ # sh
+ delete = $(info Deleting $1 ...) @rm -f $1
+ rdelete = $(info Deleting $1 ...) @rm -rf $1
+endif
+
+compiler.c = $(compiler) -x c -std=c11
+compiler.cpp = $(compiler) -x c++ -std=c++17 -fno-operator-names
+compiler.objc = $(compiler) -x objective-c -std=c11
+compiler.objcpp = $(compiler) -x objective-c++ -std=c++17 -fno-operator-names
+
+flags.c = -x c -std=c11
+flags.cpp = -x c++ -std=c++17 -fno-operator-names
+flags.objc = -x objective-c -std=c11
+flags.objcpp = -x objective-c++ -std=c++17 -fno-operator-names
+flags.deps = -MMD -MP -MF $(@:.o=.d)
+
+# compiler detection
+ifeq ($(compiler),)
+ ifeq ($(platform),windows)
+ compiler := g++
+ compiler.cpp = $(compiler) -x c++ -std=gnu++17
+ flags.cpp = -x c++ -std=gnu++17 -fno-operator-names
+ else ifeq ($(platform),macos)
+ compiler := clang++
+ else ifeq ($(platform),linux)
+ compiler := g++
+ else ifeq ($(platform),bsd)
+ compiler := clang++
+ else
+ compiler := g++
+ endif
+endif
+
+# build optimization levels
+ifeq ($(build),debug)
+ flags += -Og -g -DBUILD_DEBUG
+else ifeq ($(build),stable)
+ flags += -O1 -DBUILD_STABLE
+else ifeq ($(build),minified)
+ flags += -Os -DBUILD_MINIFIED
+else ifeq ($(build),release)
+ flags += -O2 -DBUILD_RELEASE
+else ifeq ($(build),optimized)
+ flags += -O3 -DBUILD_OPTIMIZED
+else
+ $(error unrecognized build type.)
+endif
+
+# link-time optimization
+ifeq ($(lto),true)
+ flags += -fwhole-program -flto -fno-fat-lto-objects
+ options += -fwhole-program -flto=jobserver
+endif
+
+# openmp support
+ifeq ($(openmp),true)
+ # macOS Xcode does not ship with OpenMP support
+ ifneq ($(platform),macos)
+ flags += -fopenmp
+ options += -fopenmp
+ endif
+endif
+
+# clang settings
+ifeq ($(findstring clang++,$(compiler)),clang++)
+ flags += -fno-strict-aliasing -fwrapv -Wno-everything
+# gcc settings
+else ifeq ($(findstring g++,$(compiler)),g++)
+ flags += -fno-strict-aliasing -fwrapv -Wno-trigraphs
+endif
+
+# windows settings
+ifeq ($(platform),windows)
+ options += -mthreads -lpthread -lws2_32 -lole32
+ options += $(if $(findstring g++,$(compiler)),-static -static-libgcc -static-libstdc++)
+ options += $(if $(findstring true,$(console)),-mconsole,-mwindows)
+ windres := windres
+endif
+
+# macos settings
+ifeq ($(platform),macos)
+ flags += -stdlib=libc++
+ options += -lc++ -lobjc
+endif
+
+# linux settings
+ifeq ($(platform),linux)
+ options += -ldl
+endif
+
+# bsd settings
+ifeq ($(platform),bsd)
+ flags += -I/usr/local/include
+ options += -Wl,-rpath=/usr/local/lib
+ options += -Wl,-rpath=/usr/local/lib/gcc8
+ options += -lstdc++ -lm
+endif
+
+# threading support
+ifeq ($(threaded),true)
+ ifneq ($(filter $(platform),linux bsd),)
+ flags += -pthread
+ options += -pthread -lrt
+ endif
+endif
+
+# paths
+ifeq ($(object.path),)
+ object.path := obj
+endif
+
+ifeq ($(output.path),)
+ output.path := out
+endif
+
+# rules
+default: all;
+
+nall.verbose:
+ $(info Compiler Flags:)
+ $(foreach n,$(sort $(call unique,$(flags))),$(if $(filter-out -I%,$n),$(info $([space]) $n)))
+ $(info Linker Options:)
+ $(foreach n,$(sort $(call unique,$(options))),$(if $(filter-out -l%,$n),$(info $([space]) $n)))
+
+%.o: $<
+ $(info Compiling $(subst ../,,$<) ...)
+ @$(call compile)
+
+# function compile([arguments])
+compile = \
+ $(strip \
+ $(if $(filter %.c,$<), \
+ $(compiler.c) $(flags.deps) $(flags) $1 -c $< -o $@ \
+ ,$(if $(filter %.cpp,$<), \
+ $(compiler.cpp) $(flags.deps) $(flags) $1 -c $< -o $@ \
+ )) \
+ )
+
+# function rwildcard(directory, pattern)
+rwildcard = \
+ $(strip \
+ $(filter $(if $2,$2,%), \
+ $(foreach f, \
+ $(wildcard $1*), \
+ $(eval t = $(call rwildcard,$f/)) \
+ $(if $t,$t,$f) \
+ ) \
+ ) \
+ )
+
+# function unique(source)
+unique = \
+ $(eval __temp :=) \
+ $(strip \
+ $(foreach s,$1,$(if $(filter $s,$(__temp)),,$(eval __temp += $s))) \
+ $(__temp) \
+ )
+
+# function strtr(source, from, to)
+strtr = \
+ $(eval __temp := $1) \
+ $(strip \
+ $(foreach c, \
+ $(join $(addsuffix :,$2),$3), \
+ $(eval __temp := \
+ $(subst $(word 1,$(subst :, ,$c)),$(word 2,$(subst :, ,$c)),$(__temp)) \
+ ) \
+ ) \
+ $(__temp) \
+ )
+
+# function strupper(source)
+strupper = $(call strtr,$1,$([a-z]),$([A-Z]))
+
+# function strlower(source)
+strlower = $(call strtr,$1,$([A-Z]),$([a-z]))
+
+# function strlen(source)
+strlen = \
+ $(eval __temp := $(subst $([space]),_,$1)) \
+ $(words \
+ $(strip \
+ $(foreach c, \
+ $([all]), \
+ $(eval __temp := \
+ $(subst $c,$c ,$(__temp)) \
+ ) \
+ ) \
+ $(__temp) \
+ ) \
+ )
+
+# function streq(source)
+streq = $(if $(filter-out xx,x$(subst $1,,$2)$(subst $2,,$1)x),,1)
+
+# function strne(source)
+strne = $(if $(filter-out xx,x$(subst $1,,$2)$(subst $2,,$1)x),1,)
+
+# prefix
+ifeq ($(platform),windows)
+ prefix := $(subst $([space]),\$([space]),$(strip $(call strtr,$(LOCALAPPDATA),\,/)))
+else
+ prefix := $(HOME)/.local
+endif
diff --git a/roms/snes-test-roms/bass-untech/nall/adaptive-array.hpp b/roms/snes-test-roms/bass-untech/nall/adaptive-array.hpp
new file mode 100644
index 00000000..9ca84e7c
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/adaptive-array.hpp
@@ -0,0 +1,64 @@
+//deprecated
+
+#pragma once
+
+#include
+#include
+
+namespace nall {
+
+template
+struct adaptive_array {
+ auto capacity() const -> uint { return Capacity; }
+ auto size() const -> uint { return _size; }
+
+ auto reset() -> void {
+ for(uint n : range(_size)) _pool.t[n].~T();
+ _size = 0;
+ }
+
+ auto operator[](uint index) -> T& {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(index >= Capacity) throw out_of_bounds{};
+ #endif
+ return _pool.t[index];
+ }
+
+ auto operator[](uint index) const -> const T& {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(index >= Capacity) throw out_of_bounds{};
+ #endif
+ return _pool.t[index];
+ }
+
+ auto append() -> T& {
+ new(_pool.t + _size) T;
+ return _pool.t[_size++];
+ }
+
+ auto append(const T& value) -> void {
+ new(_pool.t + _size++) T(value);
+ }
+
+ auto append(T&& value) -> void {
+ new(_pool.t + _size++) T(move(value));
+ }
+
+ auto begin() { return &_pool.t[0]; }
+ auto end() { return &_pool.t[_size]; }
+
+ auto begin() const { return &_pool.t[0]; }
+ auto end() const { return &_pool.t[_size]; }
+
+private:
+ union U {
+ U() {}
+ ~U() {}
+ T t[Capacity];
+ } _pool;
+ uint _size = 0;
+};
+
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/algorithm.hpp b/roms/snes-test-roms/bass-untech/nall/algorithm.hpp
new file mode 100644
index 00000000..34565f11
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/algorithm.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include
+
+#undef min
+#undef max
+
+namespace nall {
+
+template constexpr auto min(const T& t, const U& u) -> T {
+ return t < u ? t : (T)u;
+}
+
+template constexpr auto min(const T& t, const U& u, P&&... p) -> T {
+ return t < u ? min(t, forward(p)...) : min(u, forward
(p)...);
+}
+
+template constexpr auto max(const T& t, const U& u) -> T {
+ return t > u ? t : (T)u;
+}
+
+template constexpr auto max(const T& t, const U& u, P&&... p) -> T {
+ return t > u ? max(t, forward(p)...) : max(u, forward
(p)...);
+}
+
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/any.hpp b/roms/snes-test-roms/bass-untech/nall/any.hpp
new file mode 100644
index 00000000..d7e789a9
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/any.hpp
@@ -0,0 +1,83 @@
+#pragma once
+
+#include
+#include
+
+namespace nall {
+
+struct any {
+ any() = default;
+ any(const any& source) { operator=(source); }
+ any(any&& source) { operator=(move(source)); }
+ template any(const T& value) { operator=(value); }
+ ~any() { reset(); }
+
+ explicit operator bool() const { return container; }
+ auto reset() -> void { if(container) { delete container; container = nullptr; } }
+
+ auto type() const -> const std::type_info& {
+ return container ? container->type() : typeid(void);
+ }
+
+ template auto is() const -> bool {
+ return type() == typeid(typename remove_reference::type);
+ }
+
+ template auto get() -> T& {
+ if(!is()) throw;
+ return static_cast::type>*>(container)->value;
+ }
+
+ template auto get() const -> const T& {
+ if(!is()) throw;
+ return static_cast::type>*>(container)->value;
+ }
+
+ template auto get(const T& fallback) const -> const T& {
+ if(!is()) return fallback;
+ return static_cast::type>*>(container)->value;
+ }
+
+ template auto operator=(const T& value) -> any& {
+ using auto_t = typename conditional::value, typename remove_extent::type>::type*, T>::type;
+
+ if(type() == typeid(auto_t)) {
+ static_cast*>(container)->value = (auto_t)value;
+ } else {
+ if(container) delete container;
+ container = new holder((auto_t)value);
+ }
+
+ return *this;
+ }
+
+ auto operator=(const any& source) -> any& {
+ if(container) { delete container; container = nullptr; }
+ if(source.container) container = source.container->copy();
+ return *this;
+ }
+
+ auto operator=(any&& source) -> any& {
+ if(container) delete container;
+ container = source.container;
+ source.container = nullptr;
+ return *this;
+ }
+
+private:
+ struct placeholder {
+ virtual ~placeholder() = default;
+ virtual auto type() const -> const std::type_info& = 0;
+ virtual auto copy() const -> placeholder* = 0;
+ };
+ placeholder* container = nullptr;
+
+ template struct holder : placeholder {
+ holder(const T& value) : value(value) {}
+ auto type() const -> const std::type_info& { return typeid(T); }
+ auto copy() const -> placeholder* { return new holder(value); }
+ T value;
+ };
+};
+
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/arguments.hpp b/roms/snes-test-roms/bass-untech/nall/arguments.hpp
new file mode 100644
index 00000000..6fb706d1
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/arguments.hpp
@@ -0,0 +1,161 @@
+#pragma once
+
+#include
+#include
+#include
+#include
+
+namespace nall {
+
+struct Arguments {
+ Arguments(int argc, char** argv);
+ Arguments(vector arguments);
+
+ explicit operator bool() const { return (bool)arguments; }
+ auto size() const -> uint { return arguments.size(); }
+
+ auto operator[](uint index) -> string& { return arguments[index]; }
+ auto operator[](uint index) const -> const string& { return arguments[index]; }
+
+ auto programPath() const -> string;
+ auto programName() const -> string;
+ auto programLocation() const -> string;
+
+ auto find(string_view name) const -> bool;
+ auto find(string_view name, bool& argument) const -> bool;
+ auto find(string_view name, string& argument) const -> bool;
+
+ auto begin() const { return arguments.begin(); }
+ auto end() const { return arguments.end(); }
+
+ auto rbegin() const { return arguments.rbegin(); }
+ auto rend() const { return arguments.rend(); }
+
+ auto take() -> string;
+ auto take(string_view name) -> bool;
+ auto take(string_view name, bool& argument) -> bool;
+ auto take(string_view name, string& argument) -> bool;
+
+ auto begin() { return arguments.begin(); }
+ auto end() { return arguments.end(); }
+
+ auto rbegin() { return arguments.rbegin(); }
+ auto rend() { return arguments.rend(); }
+
+private:
+ auto construct() -> void;
+
+ string programArgument;
+ vector arguments;
+};
+
+inline auto Arguments::construct() -> void {
+ if(!arguments) return;
+
+ //extract and pre-process program argument
+ programArgument = arguments.takeFirst();
+ programArgument = {Path::real(programArgument), Location::file(programArgument)};
+
+ //normalize path and file arguments
+ for(auto& argument : arguments) {
+ if(directory::exists(argument)) argument.transform("\\", "/").trimRight("/").append("/");
+ else if(file::exists(argument)) argument.transform("\\", "/").trimRight("/");
+ }
+}
+
+inline Arguments::Arguments(int argc, char** argv) {
+ #if defined(PLATFORM_WINDOWS)
+ utf8_arguments(argc, argv);
+ #endif
+ for(uint index : range(argc)) arguments.append(argv[index]);
+ construct();
+}
+
+inline Arguments::Arguments(vector arguments) {
+ this->arguments = arguments;
+ construct();
+}
+
+inline auto Arguments::programPath() const -> string {
+ return Location::path(programArgument);
+}
+
+inline auto Arguments::programName() const -> string {
+ return Location::file(programArgument);
+}
+
+inline auto Arguments::programLocation() const -> string {
+ return programArgument;
+}
+
+inline auto Arguments::find(string_view name) const -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::find(string_view name, bool& argument) const -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() >= index
+ && (arguments[index + 1] == "true" || arguments[index + 1] == "false")) {
+ argument = arguments[index + 1] == "true";
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::find(string_view name, string& argument) const -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() >= index) {
+ argument = arguments[index + 1];
+ return true;
+ }
+ }
+ return false;
+}
+
+//
+
+inline auto Arguments::take() -> string {
+ if(!arguments) return {};
+ return arguments.takeFirst();
+}
+
+inline auto Arguments::take(string_view name) -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name)) {
+ arguments.remove(index);
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::take(string_view name, bool& argument) -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() > index + 1
+ && (arguments[index + 1] == "true" || arguments[index + 1] == "false")) {
+ arguments.remove(index);
+ argument = arguments.take(index) == "true";
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::take(string_view name, string& argument) -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() > index + 1) {
+ arguments.remove(index);
+ argument = arguments.take(index);
+ return true;
+ }
+ }
+ return false;
+}
+
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/arithmetic.hpp b/roms/snes-test-roms/bass-untech/nall/arithmetic.hpp
new file mode 100644
index 00000000..388370f1
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/arithmetic.hpp
@@ -0,0 +1,89 @@
+#pragma once
+
+//multi-precision arithmetic
+//warning: each size is quadratically more expensive than the size before it!
+
+#include
+#include
+#include
+#include
+
+#include
+
+namespace nall {
+ template struct ArithmeticNatural;
+ template<> struct ArithmeticNatural< 8> { using type = uint8_t; };
+ template<> struct ArithmeticNatural< 16> { using type = uint16_t; };
+ template<> struct ArithmeticNatural< 32> { using type = uint32_t; };
+ template<> struct ArithmeticNatural< 64> { using type = uint64_t; };
+ #if INTMAX_BITS >= 128
+ template<> struct ArithmeticNatural<128> { using type = uint128_t; };
+ #endif
+}
+
+#if INTMAX_BITS < 128
+#define PairBits 128
+#define TypeBits 64
+#define HalfBits 32
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+#endif
+
+#define PairBits 256
+#define TypeBits 128
+#define HalfBits 64
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 512
+#define TypeBits 256
+#define HalfBits 128
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 1024
+#define TypeBits 512
+#define HalfBits 256
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 2048
+#define TypeBits 1024
+#define HalfBits 512
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 4096
+#define TypeBits 2048
+#define HalfBits 1024
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 8192
+#define TypeBits 4096
+#define HalfBits 2048
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+namespace nall {
+ //TODO: these types are for expressing smaller bit ranges in class interfaces
+ //for instance, XChaCha20 taking a 192-bit nonce
+ //however, they still allow more bits than expressed ...
+ //some sort of wrapper needs to be devised to ensure these sizes are masked and wrap appropriately
+
+ using uint192_t = uint256_t;
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/arithmetic/barrett.hpp b/roms/snes-test-roms/bass-untech/nall/arithmetic/barrett.hpp
new file mode 100644
index 00000000..7774b027
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/arithmetic/barrett.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+namespace nall {
+
+template struct BarrettReduction {
+ using type = typename ArithmeticNatural<1 * Bits>::type;
+ using pair = typename ArithmeticNatural<2 * Bits>::type;
+
+ explicit BarrettReduction(type modulo) : modulo(modulo), factor(pair(1) + -pair(modulo) / modulo) {}
+
+ //return => value % modulo
+ auto operator()(pair value) const -> type {
+ pair hi, lo;
+ mul(value, factor, hi, lo);
+ pair remainder = value - hi * modulo;
+ return remainder < modulo ? remainder : remainder - modulo;
+ }
+
+private:
+ const pair modulo;
+ const pair factor;
+};
+
+template auto operator%(T value, const BarrettReduction& modulo) {
+ return modulo(value);
+}
+
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/arithmetic/natural.hpp b/roms/snes-test-roms/bass-untech/nall/arithmetic/natural.hpp
new file mode 100644
index 00000000..cc1bd907
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/arithmetic/natural.hpp
@@ -0,0 +1,344 @@
+#include
+
+#define ConcatenateType(Size) uint##Size##_t
+#define DeclareType(Size) ConcatenateType(Size)
+
+#define Pair DeclareType(PairBits)
+#define Type DeclareType(TypeBits)
+#define Half DeclareType(HalfBits)
+
+//pick the larger of two types to prevent unnecessary data clamping
+#define Cast (typename conditional= sizeof(T), Pair, T>::type)
+
+namespace nall {
+//namespace Arithmetic {
+
+struct Pair {
+ Pair() = default;
+ explicit constexpr Pair(const Pair& source) : hi(source.hi), lo(source.lo) {}
+ template constexpr Pair(const Hi& hi, const Lo& lo) : hi(hi), lo(lo) {}
+ template Pair(const T& source) { _set(*this, source); }
+
+ explicit operator bool() const { return hi | lo; }
+ template operator T() const { T value; _get(*this, value); return value; }
+
+ auto operator+() const -> Pair { return *this; }
+ auto operator-() const -> Pair { return Pair(0) - *this; }
+ auto operator~() const -> Pair { return {~hi, ~lo}; }
+ auto operator!() const -> bool { return !(hi || lo); }
+
+ auto operator++() -> Pair& { lo++; hi += lo == 0; return *this; }
+ auto operator--() -> Pair& { hi -= lo == 0; lo--; return *this; }
+
+ auto operator++(int) -> Pair { Pair r = *this; lo++; hi += lo == 0; return r; }
+ auto operator--(int) -> Pair { Pair r = *this; hi -= lo == 0; lo--; return r; }
+
+ auto operator* (const Pair& rhs) const -> Pair { return mul(*this, rhs); }
+ auto operator/ (const Pair& rhs) const -> Pair { Pair q, r; div(*this, rhs, q, r); return q; }
+ auto operator% (const Pair& rhs) const -> Pair { Pair q, r; div(*this, rhs, q, r); return r; }
+ auto operator+ (const Pair& rhs) const -> Pair { return {hi + rhs.hi + (lo + rhs.lo < lo), lo + rhs.lo}; }
+ auto operator- (const Pair& rhs) const -> Pair { return {hi - rhs.hi - (lo - rhs.lo > lo), lo - rhs.lo}; }
+ auto operator<<(const Pair& rhs) const -> Pair { return shl(*this, rhs); }
+ auto operator>>(const Pair& rhs) const -> Pair { return shr(*this, rhs); }
+ auto operator& (const Pair& rhs) const -> Pair { return {hi & rhs.hi, lo & rhs.lo}; }
+ auto operator| (const Pair& rhs) const -> Pair { return {hi | rhs.hi, lo | rhs.lo}; }
+ auto operator^ (const Pair& rhs) const -> Pair { return {hi ^ rhs.hi, lo ^ rhs.lo}; }
+ auto operator==(const Pair& rhs) const -> bool { return hi == rhs.hi && lo == rhs.lo; }
+ auto operator!=(const Pair& rhs) const -> bool { return hi != rhs.hi || lo != rhs.lo; }
+ auto operator>=(const Pair& rhs) const -> bool { return hi > rhs.hi || (hi == rhs.hi && lo >= rhs.lo); }
+ auto operator<=(const Pair& rhs) const -> bool { return hi < rhs.hi || (hi == rhs.hi && lo <= rhs.lo); }
+ auto operator> (const Pair& rhs) const -> bool { return hi > rhs.hi || (hi == rhs.hi && lo > rhs.lo); }
+ auto operator< (const Pair& rhs) const -> bool { return hi < rhs.hi || (hi == rhs.hi && lo < rhs.lo); }
+
+ template auto& operator*= (const T& rhs) { return *this = *this * Pair(rhs); }
+ template auto& operator/= (const T& rhs) { return *this = *this / Pair(rhs); }
+ template auto& operator%= (const T& rhs) { return *this = *this % Pair(rhs); }
+ template auto& operator+= (const T& rhs) { return *this = *this + Pair(rhs); }
+ template auto& operator-= (const T& rhs) { return *this = *this - Pair(rhs); }
+ template auto& operator<<=(const T& rhs) { return *this = *this << Pair(rhs); }
+ template auto& operator>>=(const T& rhs) { return *this = *this >> Pair(rhs); }
+ template auto& operator&= (const T& rhs) { return *this = *this & Pair(rhs); }
+ template auto& operator|= (const T& rhs) { return *this = *this | Pair(rhs); }
+ template auto& operator^= (const T& rhs) { return *this = *this ^ Pair(rhs); }
+
+ template auto operator* (const T& rhs) const { return Cast(*this) * Cast(rhs); }
+ template auto operator/ (const T& rhs) const { return Cast(*this) / Cast(rhs); }
+ template auto operator% (const T& rhs) const { return Cast(*this) % Cast(rhs); }
+ template auto operator+ (const T& rhs) const { return Cast(*this) + Cast(rhs); }
+ template auto operator- (const T& rhs) const { return Cast(*this) - Cast(rhs); }
+ template auto operator<<(const T& rhs) const { return Cast(*this) << Cast(rhs); }
+ template auto operator>>(const T& rhs) const { return Cast(*this) >> Cast(rhs); }
+ template auto operator& (const T& rhs) const { return Cast(*this) & Cast(rhs); }
+ template auto operator| (const T& rhs) const { return Cast(*this) | Cast(rhs); }
+ template auto operator^ (const T& rhs) const { return Cast(*this) ^ Cast(rhs); }
+
+ template auto operator==(const T& rhs) const -> bool { return Cast(*this) == Cast(rhs); }
+ template auto operator!=(const T& rhs) const -> bool { return Cast(*this) != Cast(rhs); }
+ template auto operator>=(const T& rhs) const -> bool { return Cast(*this) >= Cast(rhs); }
+ template auto operator<=(const T& rhs) const -> bool { return Cast(*this) <= Cast(rhs); }
+ template auto operator> (const T& rhs) const -> bool { return Cast(*this) > Cast(rhs); }
+ template auto operator< (const T& rhs) const -> bool { return Cast(*this) < Cast(rhs); }
+
+private:
+ Type lo;
+ Type hi;
+
+ friend auto upper(const Pair&) -> Type;
+ friend auto lower(const Pair&) -> Type;
+ friend auto bits(Pair) -> uint;
+ friend auto square(const Pair&) -> Pair;
+ friend auto square(const Pair&, Pair&, Pair&) -> void;
+ friend auto mul(const Pair&, const Pair&) -> Pair;
+ friend auto mul(const Pair&, const Pair&, Pair&, Pair&) -> void;
+ friend auto div(const Pair&, const Pair&, Pair&, Pair&) -> void;
+ template friend auto shl(const Pair&, const T&) -> Pair;
+ template friend auto shr(const Pair&, const T&) -> Pair;
+};
+
+template<> struct ArithmeticNatural {
+ using type = Pair;
+};
+
+#define ConcatenateUDL(Size) _u##Size
+#define DeclareUDL(Size) ConcatenateUDL(Size)
+
+alwaysinline auto operator"" DeclareUDL(PairBits)(const char* s) -> Pair {
+ Pair p = 0;
+ if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
+ s += 2;
+ while(*s) {
+ auto c = *s++;
+ if(c == '\'');
+ else if(c >= '0' && c <= '9') p = (p << 4) + (c - '0');
+ else if(c >= 'a' && c <= 'f') p = (p << 4) + (c - 'a' + 10);
+ else if(c >= 'A' && c <= 'F') p = (p << 4) + (c - 'A' + 10);
+ else break;
+ }
+ } else {
+ while(*s) {
+ auto c = *s++;
+ if(c == '\'');
+ else if(c >= '0' && c <= '9') p = (p << 3) + (p << 1) + (c - '0');
+ else break;
+ }
+ }
+ return p;
+}
+
+#undef ConcatenateUDL
+#undef DeclareUDL
+
+template alwaysinline auto _set(Pair& lhs, const T& rhs) -> enable_if_t<(sizeof(Pair) == sizeof(T))> {
+ lhs = rhs;
+}
+
+template alwaysinline auto _set(Pair& lhs, const T& rhs) -> enable_if_t<(sizeof(Pair) > sizeof(T))> {
+ lhs = {0, rhs};
+}
+
+template alwaysinline auto _set(Pair& lhs, const T& rhs) -> enable_if_t<(sizeof(Pair) < sizeof(T))> {
+ lhs = {lower(rhs) >> TypeBits, lower(rhs)};
+}
+
+template alwaysinline auto _get(const Pair& lhs, T& rhs) -> enable_if_t<(sizeof(T) == sizeof(Pair))> {
+ rhs = lhs;
+}
+
+template alwaysinline auto _get(const Pair& lhs, T& rhs) -> enable_if_t<(sizeof(T) > sizeof(Pair))> {
+ rhs = {0, lhs};
+}
+
+template alwaysinline auto _get(const Pair& lhs, T& rhs) -> enable_if_t<(sizeof(T) < sizeof(Pair))> {
+ rhs = lower(lhs);
+}
+
+alwaysinline auto upper(const Pair& value) -> Type { return value.hi; }
+alwaysinline auto lower(const Pair& value) -> Type { return value.lo; }
+
+alwaysinline auto bits(Pair value) -> uint {
+ if(value.hi) {
+ uint bits = TypeBits;
+ while(value.hi) value.hi >>= 1, bits++;
+ return bits;
+ } else {
+ uint bits = 0;
+ while(value.lo) value.lo >>= 1, bits++;
+ return bits;
+ }
+}
+
+//Bits * Bits => Bits
+inline auto square(const Pair& lhs) -> Pair {
+ static const Type Mask = (Type(0) - 1) >> HalfBits;
+ Type a = lhs.hi >> HalfBits, b = lhs.hi & Mask, c = lhs.lo >> HalfBits, d = lhs.lo & Mask;
+ Type dd = square(d), dc = d * c, db = d * b, da = d * a;
+ Type cc = square(c), cb = c * b;
+
+ Pair r0 = Pair(dd);
+ Pair r1 = Pair(dc) + Pair(dc) + Pair(r0 >> HalfBits);
+ Pair r2 = Pair(db) + Pair(cc) + Pair(db) + Pair(r1 >> HalfBits);
+ Pair r3 = Pair(da) + Pair(cb) + Pair(cb) + Pair(da) + Pair(r2 >> HalfBits);
+
+ return {(r3.lo & Mask) << HalfBits | (r2.lo & Mask), (r1.lo & Mask) << HalfBits | (r0.lo & Mask)};
+}
+
+//Bits * Bits => 2 * Bits
+inline auto square(const Pair& lhs, Pair& hi, Pair& lo) -> void {
+ static const Type Mask = (Type(0) - 1) >> HalfBits;
+ Type a = lhs.hi >> HalfBits, b = lhs.hi & Mask, c = lhs.lo >> HalfBits, d = lhs.lo & Mask;
+ Type dd = square(d), dc = d * c, db = d * b, da = d * a;
+ Type cc = square(c), cb = c * b, ca = c * a;
+ Type bb = square(b), ba = b * a;
+ Type aa = square(a);
+
+ Pair r0 = Pair(dd);
+ Pair r1 = Pair(dc) + Pair(dc) + Pair(r0 >> HalfBits);
+ Pair r2 = Pair(db) + Pair(cc) + Pair(db) + Pair(r1 >> HalfBits);
+ Pair r3 = Pair(da) + Pair(cb) + Pair(cb) + Pair(da) + Pair(r2 >> HalfBits);
+ Pair r4 = Pair(ca) + Pair(bb) + Pair(ca) + Pair(r3 >> HalfBits);
+ Pair r5 = Pair(ba) + Pair(ba) + Pair(r4 >> HalfBits);
+ Pair r6 = Pair(aa) + Pair(r5 >> HalfBits);
+ Pair r7 = Pair(r6 >> HalfBits);
+
+ hi = {(r7.lo & Mask) << HalfBits | (r6.lo & Mask), (r5.lo & Mask) << HalfBits | (r4.lo & Mask)};
+ lo = {(r3.lo & Mask) << HalfBits | (r2.lo & Mask), (r1.lo & Mask) << HalfBits | (r0.lo & Mask)};
+}
+
+//Bits * Bits => Bits
+alwaysinline auto mul(const Pair& lhs, const Pair& rhs) -> Pair {
+ static const Type Mask = (Type(0) - 1) >> HalfBits;
+ Type a = lhs.hi >> HalfBits, b = lhs.hi & Mask, c = lhs.lo >> HalfBits, d = lhs.lo & Mask;
+ Type e = rhs.hi >> HalfBits, f = rhs.hi & Mask, g = rhs.lo >> HalfBits, h = rhs.lo & Mask;
+
+ Pair r0 = Pair(d * h);
+ Pair r1 = Pair(c * h) + Pair(d * g) + Pair(r0 >> HalfBits);
+ Pair r2 = Pair(b * h) + Pair(c * g) + Pair(d * f) + Pair(r1 >> HalfBits);
+ Pair r3 = Pair(a * h) + Pair(b * g) + Pair(c * f) + Pair(d * e) + Pair(r2 >> HalfBits);
+
+ return {(r3.lo & Mask) << HalfBits | (r2.lo & Mask), (r1.lo & Mask) << HalfBits | (r0.lo & Mask)};
+}
+
+//Bits * Bits => 2 * Bits
+alwaysinline auto mul(const Pair& lhs, const Pair& rhs, Pair& hi, Pair& lo) -> void {
+ static const Type Mask = (Type(0) - 1) >> HalfBits;
+ Type a = lhs.hi >> HalfBits, b = lhs.hi & Mask, c = lhs.lo >> HalfBits, d = lhs.lo & Mask;
+ Type e = rhs.hi >> HalfBits, f = rhs.hi & Mask, g = rhs.lo >> HalfBits, h = rhs.lo & Mask;
+
+ Pair r0 = Pair(d * h);
+ Pair r1 = Pair(c * h) + Pair(d * g) + Pair(r0 >> HalfBits);
+ Pair r2 = Pair(b * h) + Pair(c * g) + Pair(d * f) + Pair(r1 >> HalfBits);
+ Pair r3 = Pair(a * h) + Pair(b * g) + Pair(c * f) + Pair(d * e) + Pair(r2 >> HalfBits);
+ Pair r4 = Pair(a * g) + Pair(b * f) + Pair(c * e) + Pair(r3 >> HalfBits);
+ Pair r5 = Pair(a * f) + Pair(b * e) + Pair(r4 >> HalfBits);
+ Pair r6 = Pair(a * e) + Pair(r5 >> HalfBits);
+ Pair r7 = Pair(r6 >> HalfBits);
+
+ hi = {(r7.lo & Mask) << HalfBits | (r6.lo & Mask), (r5.lo & Mask) << HalfBits | (r4.lo & Mask)};
+ lo = {(r3.lo & Mask) << HalfBits | (r2.lo & Mask), (r1.lo & Mask) << HalfBits | (r0.lo & Mask)};
+}
+
+alwaysinline auto div(const Pair& lhs, const Pair& rhs, Pair& quotient, Pair& remainder) -> void {
+ if(!rhs) throw std::runtime_error("division by zero");
+ quotient = 0, remainder = lhs;
+ if(!lhs || lhs < rhs) return;
+
+ auto count = bits(lhs) - bits(rhs);
+ Pair x = rhs << count;
+ Pair y = Pair(1) << count;
+ if(x > remainder) x >>= 1, y >>= 1;
+ while(remainder >= rhs) {
+ if(remainder >= x) remainder -= x, quotient |= y;
+ x >>= 1, y >>= 1;
+ }
+}
+
+template alwaysinline auto shl(const Pair& lhs, const T& rhs) -> Pair {
+ if(!rhs) return lhs;
+ auto shift = (uint)rhs;
+ if(shift < TypeBits) {
+ return {lhs.hi << shift | lhs.lo >> (TypeBits - shift), lhs.lo << shift};
+ } else {
+ return {lhs.lo << (shift - TypeBits), 0};
+ }
+}
+
+template alwaysinline auto shr(const Pair& lhs, const T& rhs) -> Pair {
+ if(!rhs) return lhs;
+ auto shift = (uint)rhs;
+ if(shift < TypeBits) {
+ return {lhs.hi >> shift, lhs.hi << (TypeBits - shift) | lhs.lo >> shift};
+ } else {
+ return {0, lhs.hi >> (shift - TypeBits)};
+ }
+}
+
+template alwaysinline auto rol(const Pair& lhs, const T& rhs) -> Pair {
+ return lhs << rhs | lhs >> (PairBits - rhs);
+}
+
+template alwaysinline auto ror(const Pair& lhs, const T& rhs) -> Pair {
+ return lhs >> rhs | lhs << (PairBits - rhs);
+}
+
+#define EI enable_if_t::value>
+
+template auto& operator*= (T& lhs, const Pair& rhs) { return lhs = lhs * T(rhs); }
+template auto& operator/= (T& lhs, const Pair& rhs) { return lhs = lhs / T(rhs); }
+template auto& operator%= (T& lhs, const Pair& rhs) { return lhs = lhs % T(rhs); }
+template auto& operator+= (T& lhs, const Pair& rhs) { return lhs = lhs + T(rhs); }
+template auto& operator-= (T& lhs, const Pair& rhs) { return lhs = lhs - T(rhs); }
+template auto& operator<<=(T& lhs, const Pair& rhs) { return lhs = lhs << T(rhs); }
+template auto& operator>>=(T& lhs, const Pair& rhs) { return lhs = lhs >> T(rhs); }
+template auto& operator&= (T& lhs, const Pair& rhs) { return lhs = lhs & T(rhs); }
+template auto& operator|= (T& lhs, const Pair& rhs) { return lhs = lhs | T(rhs); }
+template auto& operator^= (T& lhs, const Pair& rhs) { return lhs = lhs ^ T(rhs); }
+
+template auto operator* (const T& lhs, const Pair& rhs) { return Cast(lhs) * Cast(rhs); }
+template auto operator/ (const T& lhs, const Pair& rhs) { return Cast(lhs) / Cast(rhs); }
+template auto operator% (const T& lhs, const Pair& rhs) { return Cast(lhs) % Cast(rhs); }
+template auto operator+ (const T& lhs, const Pair& rhs) { return Cast(lhs) + Cast(rhs); }
+template auto operator- (const T& lhs, const Pair& rhs) { return Cast(lhs) - Cast(rhs); }
+template auto operator<<(const T& lhs, const Pair& rhs) { return Cast(lhs) << Cast(rhs); }
+template auto operator>>(const T& lhs, const Pair& rhs) { return Cast(lhs) >> Cast(rhs); }
+template auto operator& (const T& lhs, const Pair& rhs) { return Cast(lhs) & Cast(rhs); }
+template auto operator| (const T& lhs, const Pair& rhs) { return Cast(lhs) | Cast(rhs); }
+template auto operator^ (const T& lhs, const Pair& rhs) { return Cast(lhs) ^ Cast(rhs); }
+
+template auto operator==(const T& lhs, const Pair& rhs) { return Cast(lhs) == Cast(rhs); }
+template auto operator!=(const T& lhs, const Pair& rhs) { return Cast(lhs) != Cast(rhs); }
+template auto operator>=(const T& lhs, const Pair& rhs) { return Cast(lhs) >= Cast(rhs); }
+template auto operator<=(const T& lhs, const Pair& rhs) { return Cast(lhs) <= Cast(rhs); }
+template auto operator> (const T& lhs, const Pair& rhs) { return Cast(lhs) > Cast(rhs); }
+template auto operator< (const T& lhs, const Pair& rhs) { return Cast(lhs) < Cast(rhs); }
+
+#undef EI
+
+template<> struct stringify {
+ stringify(Pair source) {
+ char _output[1 + sizeof(Pair) * 3];
+ auto p = (char*)&_output;
+ do {
+ Pair quotient, remainder;
+ div(source, 10, quotient, remainder);
+ *p++ = remainder + '0';
+ source = quotient;
+ } while(source);
+ _size = p - _output;
+ *p = 0;
+ for(int x = _size - 1, y = 0; x >= 0 && y < _size; x--, y++) _data[x] = _output[y];
+ }
+
+ auto data() const -> const char* { return _data; }
+ auto size() const -> uint { return _size; }
+ char _data[1 + sizeof(Pair) * 3];
+ uint _size;
+};
+
+}
+
+#undef ConcatenateType
+#undef DeclareType
+#undef Pair
+#undef Type
+#undef Half
+#undef Cast
diff --git a/roms/snes-test-roms/bass-untech/nall/arithmetic/unsigned.hpp b/roms/snes-test-roms/bass-untech/nall/arithmetic/unsigned.hpp
new file mode 100644
index 00000000..5ed7ecd6
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/arithmetic/unsigned.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+namespace nall {
+
+template::value>>
+inline auto upper(T value) -> T {
+ return value >> sizeof(T) * 4;
+}
+
+template::value>>
+inline auto lower(T value) -> T {
+ static const T Mask = ~T(0) >> sizeof(T) * 4;
+ return value & Mask;
+}
+
+template::value>, enable_if_t::value>>
+inline auto mul(T lhs, U rhs) -> uintmax {
+ return lhs * rhs;
+}
+
+template::value>>
+inline auto square(T value) -> uintmax {
+ return value * value;
+}
+
+template
+inline auto rol(T lhs, U rhs, enable_if_t::value>* = 0) -> T {
+ return lhs << rhs | lhs >> sizeof(T) * 8 - rhs;
+}
+
+template
+inline auto ror(T lhs, U rhs, enable_if_t::value>* = 0) -> T {
+ return lhs >> rhs | lhs << sizeof(T) * 8 - rhs;
+}
+
+#if INTMAX_BITS >= 128
+inline auto operator"" _u128(const char* s) -> uint128_t {
+ uint128_t p = 0;
+ if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
+ s += 2;
+ while(*s) {
+ auto c = *s++;
+ if(c == '\'');
+ else if(c >= '0' && c <= '9') p = (p << 4) + (c - '0');
+ else if(c >= 'a' && c <= 'f') p = (p << 4) + (c - 'a' + 10);
+ else if(c >= 'A' && c <= 'F') p = (p << 4) + (c - 'A' + 10);
+ else break;
+ }
+ } else {
+ while(*s) {
+ auto c = *s++;
+ if(c == '\'');
+ else if(c >= '0' && c <= '9') p = (p << 3) + (p << 1) + (c - '0');
+ else break;
+ }
+ }
+ return p;
+}
+#endif
+
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/array-span.hpp b/roms/snes-test-roms/bass-untech/nall/array-span.hpp
new file mode 100644
index 00000000..4590e42e
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/array-span.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include
+
+namespace nall {
+
+template struct array_span : array_view {
+ using type = array_span;
+ using super = array_view;
+
+ array_span() {
+ super::_data = nullptr;
+ super::_size = 0;
+ }
+
+ array_span(nullptr_t) {
+ super::_data = nullptr;
+ super::_size = 0;
+ }
+
+ array_span(void* data, uint64_t size) {
+ super::_data = (T*)data;
+ super::_size = (int)size;
+ }
+
+ operator T*() { return (T*)super::operator const T*(); }
+
+ auto operator[](uint index) -> T& { return (T&)super::operator[](index); }
+
+ template auto data() -> U* { return (U*)super::_data; }
+ template auto data() const -> const U* { return (const U*)super::_data; }
+
+ auto begin() -> iterator { return {(T*)super::_data, (uint)0}; }
+ auto end() -> iterator { return {(T*)super::_data, (uint)super::_size}; }
+
+ auto rbegin() -> reverse_iterator { return {(T*)super::_data, (uint)super::_size - 1}; }
+ auto rend() -> reverse_iterator { return {(T*)super::_data, (uint)-1}; }
+
+ auto write(T value) -> void {
+ operator[](0) = value;
+ super::_data++;
+ super::_size--;
+ }
+
+ auto span(uint offset, uint length) const -> type {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(offset + length >= super::_size) throw out_of_bounds{};
+ #endif
+ return {super::_data + offset, length};
+ }
+
+ //array_span specializations
+ template auto writel(U value, uint size) -> void;
+ template auto writem(U value, uint size) -> void;
+ template auto writevn(U value, uint size) -> void;
+ template auto writevi(U value, uint size) -> void;
+};
+
+//array_span
+
+template<> inline auto array_span::write(uint8_t value) -> void {
+ operator[](0) = value;
+ _data++;
+ _size--;
+}
+
+template<> template inline auto array_span::writel(U value, uint size) -> void {
+ for(uint byte : range(size)) write(value >> byte * 8);
+}
+
+template<> template inline auto array_span::writem(U value, uint size) -> void {
+ for(uint byte : reverse(range(size))) write(value >> byte * 8);
+}
+
+template<> template inline auto array_span::writevn(U value, uint size) -> void {
+ while(true) {
+ auto byte = value & 0x7f;
+ value >>= 7;
+ if(value == 0) return write(0x80 | byte);
+ write(byte);
+ value--;
+ }
+}
+
+template<> template inline auto array_span::writevi(U value, uint size) -> void {
+ bool negate = value < 0;
+ if(negate) value = ~value;
+ value = value << 1 | negate;
+ writevn(value);
+}
+
+}
diff --git a/roms/snes-test-roms/bass-untech/nall/array-view.hpp b/roms/snes-test-roms/bass-untech/nall/array-view.hpp
new file mode 100644
index 00000000..06e68994
--- /dev/null
+++ b/roms/snes-test-roms/bass-untech/nall/array-view.hpp
@@ -0,0 +1,138 @@
+#pragma once
+
+#include
+#include
+#include
+
+namespace nall {
+
+template struct array_view {
+ using type = array_view;
+
+ array_view() {
+ _data = nullptr;
+ _size = 0;
+ }
+
+ array_view(nullptr_t) {
+ _data = nullptr;
+ _size = 0;
+ }
+
+ array_view(const void* data, uint64_t size) {
+ _data = (const T*)data;
+ _size = (int)size;
+ }
+
+ explicit operator bool() const { return _data && _size > 0; }
+
+ operator const T*() const {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(_size < 0) throw out_of_bounds{};
+ #endif
+ return _data;
+ }
+
+ auto operator++() -> type& { _data++; _size--; return *this; }
+ auto operator--() -> type& { _data--; _size++; return *this; }
+
+ auto operator++(int) -> type { auto copy = *this; ++(*this); return copy; }
+ auto operator--(int) -> type { auto copy = *this; --(*this); return copy; }
+
+ auto operator-=(int distance) -> type& { _data -= distance; _size += distance; return *this; }
+ auto operator+=(int distance) -> type& { _data += distance; _size -= distance; return *this; }
+
+ auto operator[](uint index) const -> const T& {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(index >= _size) throw out_of_bounds{};
+ #endif
+ return _data[index];
+ }
+
+ auto operator()(uint index, const T& fallback = {}) const -> T {
+ if(index >= _size) return fallback;
+ return _data[index];
+ }
+
+ template auto data() const -> const U* { return (const U*)_data; }
+ template auto size() const -> uint64_t { return _size * sizeof(T) / sizeof(U); }
+
+ auto begin() const -> iterator_const { return {_data, (uint)0}; }
+ auto end() const -> iterator_const { return {_data, (uint)_size}; }
+
+ auto rbegin() const -> reverse_iterator_const { return {_data, (uint)_size - 1}; }
+ auto rend() const -> reverse_iterator_const { return {_data, (uint)-1}; }
+
+ auto read() -> T {
+ auto value = operator[](0);
+ _data++;
+ _size--;
+ return value;
+ }
+
+ auto view(uint offset, uint length) const -> type {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(offset + length >= _size) throw out_of_bounds{};
+ #endif
+ return {_data + offset, length};
+ }
+
+ //array_view specializations
+ template auto readl(U& value, uint size) -> U;
+ template auto readm(U& value, uint size) -> U;
+ template auto readvn(U& value, uint size) -> U;
+ template auto readvi(U& value, uint size) -> U;
+
+ template auto readl(U& value, uint offset, uint size) -> U { return view(offset, size).readl(value, size); }
+
+ template auto readl(uint size) -> U { U value; return readl(value, size); }
+ template auto readm(uint size) -> U { U value; return readm(value, size); }
+ template auto readvn(uint size) -> U { U value; return readvn(value, size); }
+ template auto readvi(uint size) -> U { U value; return readvi(value, size); }
+
+ template auto readl(uint offset, uint size) -> U { U value; return readl(value, offset, size); }
+
+protected:
+ const T* _data;
+ int _size;
+};
+
+//array_view
+
+template<> template inline auto array_view::readl(U& value, uint size) -> U {
+ value = 0;
+ for(uint byte : range(size)) value |= (U)read() << byte * 8;
+ return value;
+}
+
+template<> template inline auto array_view