- Fixed some bugs in the emulator.

- Started work on implementing the Super VIA emulation.
- Added support for disabling disassembly per
  instruction, when in debug mode.
- Did some more work on rewriting the SuB Suite to
  work with the new calling convention.
- Rewrote the symbol handling code in the emulator's
  assembler, to make it both simpler, and to add
  support for arbitrarily deep symbol scopes.
- Added support for arbitrarily deep local symbol
  scopes.

  For example, to declare a symbol of depth 2, you add
  two '@' characters to the start of the symbol name.

  In other words, the number of '@' characters before
  the symbol name is what determines the scope of that
  symbol.

  And to use a symbol thats outside the current
  scope, you would use the same syntax as using a
  struct member, so you would do `global.local`.

1 files changed, 56 insertions, 0 deletions

diff --git a/programs/sub-suite/subasm-syntax b/programs/sub-suite/subasm-syntax
new file mode 100644
index 0000000..1337914
--- /dev/null
+++ b/programs/sub-suite/subasm-syntax
@@ -0,0 +1,56 @@
+/* Assembly language syntax for SuBAsm. */
+
+/* Comments begin with "/*", and end with "*/".
+ * Directives begin with a `\`.
+ */
+
+/* mnemonic is the instruction name/mnemonic.
+ * expr is an expression.
+ * Indirect Indexed means applying the index after the indirection.
+ * Indexed Indirect means applying the index before the indirection.
+ */
+
+Expression syntax:
+	/* TODO */
+Instruction syntax:
+	Base ISA, and Base Extension:
+		Implied:
+			<mnemonic>
+		B register:
+			<mnemonic> b
+		Absolute/Zero Matrix:
+			/* [, <x|y>] means Indexed with x, or y. */
+			<mnemonic> <expr>[, <x|y>]
+		Immediate Data:
+			<mnemonic> #<expr>
+		Absolute/Zero Matrix Indirect:
+			/* Indexing with x means Indexed Indirect.
+			 * Indexing with y means Indirect Indexed.
+			 */
+			<mnemonic> (<expr>[, x])[, y]
+		E Indirect:
+			<mnemonic> (e)
+	Orthogonal Extension:
+		<mnemonic> <operand>[, operand]
+		Operand syntax:
+			<\(
+				/* The operand starts with a register.
+				 * If the statment is inside brackets, then
+				 * it's a register indirect mode.
+				 */
+				[(]reg[+<reg>][\(+|-\)<expr>][)]
+				/* The operand starts with an expression.
+				 * If the statment is inside brackets, then
+				 * it's an indirect mode.
+				 */
+				|[(]expr
+				/* Is the operand using Indirect, or Indirect Indexed? */
+				\if (ind || ind_indexed) {
+					[)]
+				\}
+				[\(+|-\)<reg[+<reg>]>]
+				/* Is the operand using Indexed Indirect? */
+				\if (indexed_ind) {
+					[)]
+				\}
+			\)>