Specialization of InstructionSpec into VmInstructionSpec and DataDirectiveSpec

Author: fl4tisjustice

mgs-spec-bank/datadirectives/base.yaml

@@ -3,15 +3,15 @@
   flags: [~stringid_16]
 
 - name: "StringID"
-  operands: [int16]
+  operands: [uint16]
   flags: [stringid_16]
 
 - name: "dw"
-  operands: [int16]
+  operands: [uint16]
   flags: []
 
 - name: "Adr"
-  operands: [int16]
+  operands: [uint16]
   flags: []
 
 - name: "dd"

src/MagesScriptTool/DataDirective.cs

@@ -2,12 +2,6 @@
 
 namespace MagesScriptTool;
 
-sealed class DataDirectiveSpec {
-	public readonly string Name;
-	public readonly ImmutableArray<OperandKind> Operands;
-
-	public DataDirectiveSpec(string name, ImmutableArray<OperandKind> operands) {
-		Name = name;
-		Operands = operands;
-	}
+sealed class DataDirectiveSpec : InstructionSpec {
+	public DataDirectiveSpec(string name, ImmutableArray<OperandKind> operands) : base(name, operands) {}
 }

src/MagesScriptTool/DataDirectiveEncoding.cs

@@ -1,20 +1,24 @@
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Text;
+using System.Xml;
 
 namespace MagesScriptTool;
 
 sealed class InstructionEncoding {
-	readonly ImmutableTree<byte, InstructionSpec> _tree;
-	readonly ImmutableDictionary<string, InstructionSpec> _table;
+	readonly ImmutableTree<byte, VmInstructionSpec> _opcodeTree;
+	readonly ImmutableDictionary<string, InstructionSpec> _specTable;
 
-	InstructionEncoding(ImmutableTree<byte, InstructionSpec> tree, ImmutableDictionary<string, InstructionSpec> table) {
-		_tree = tree;
-		_table = table;
+	InstructionEncoding(ImmutableTree<byte, VmInstructionSpec> opcodeTree, ImmutableDictionary<string, InstructionSpec> specTable) {
+		_opcodeTree = opcodeTree;
+		_specTable = specTable;
 	}
 
 	public void Encode(Stream stream, Instruction instruction) {
-		InstructionSpec spec = _table[instruction.Name];
-		PutBytes(stream, spec.Opcode.AsSpan());
+		InstructionSpec spec = _specTable[instruction.Name];
+		if (spec is VmInstructionSpec vmInstructionSpec) {
+			PutBytes(stream, vmInstructionSpec.Opcode.AsSpan());
+		}
 		ImmutableArray<OperandKind> kinds = spec.Operands;
 		ImmutableArray<ExpressionNode> operands = instruction.Operands;
 		if (operands.Length != kinds.Length) {
@@ -32,9 +36,22 @@ public Instruction Decode(Stream stream) {
 		foreach (OperandKind operandSpec in operandSpecs) {
 			operands.Add(DecodeOperand(stream, operandSpec));
 		}
-		return new(spec.Name, [..operands]);
+		return new (spec.Name, [..operands]);
 	}
 
+	public Instruction Decode(Stream stream, string dataDirective) {
+		DataDirectiveSpec spec = _specTable.GetValueOrDefault(dataDirective) switch {
+			DataDirectiveSpec dataDirectiveSpec => dataDirectiveSpec,
+			_ => throw new Exception($"Unrecognized data directive name: {dataDirective}")
+		};
+		
+		ImmutableArray<OperandKind> operandSpecs = spec.Operands;
+		List<ExpressionNode> operands = [];
+		foreach (OperandKind operandSpec in operandSpecs) {
+			operands.Add(DecodeOperand(stream, operandSpec));
+		}
+		return new (spec.Name, [..operands]);
+	}
 	static void EncodeOperand(Stream stream, OperandKind kind, ExpressionNode operand) {
 		switch (kind) {
 			case OperandKind.Expr: {
@@ -45,6 +62,7 @@ static void EncodeOperand(Stream stream, OperandKind kind, ExpressionNode operan
 				EncodeOperandInt8(stream, operand);
 				break;
 			}
+			case OperandKind.UInt16:
 			case OperandKind.Int16: {
 				EncodeOperandInt16(stream, operand);
 				break;
@@ -95,17 +113,17 @@ static void PutBytes(Stream stream, ReadOnlySpan<byte> data) {
 		stream.Write(data);
 	}
 
-	InstructionSpec DecodeOpcode(Stream stream) {
+	VmInstructionSpec DecodeOpcode(Stream stream) {
 		long start = stream.Position;
-		ImmutableTree<byte, InstructionSpec> cursor = _tree;
+		ImmutableTree<byte, VmInstructionSpec> cursor = _opcodeTree;
 		while (true) {
 			byte b = GetByte(stream);
-			ImmutableTree<byte, InstructionSpec>? next = cursor[b];
+			ImmutableTree<byte, VmInstructionSpec>? next = cursor[b];
 			if (next is null) {
 				throw new Exception($"Unrecognized instruction at {start}.");
 			}
 			cursor = next;
-			if (cursor.Value is InstructionSpec opcodeSpec) {
+			if (cursor.Value is VmInstructionSpec opcodeSpec) {
 				return opcodeSpec;
 			}
 		}
@@ -115,6 +133,7 @@ static ExpressionNode DecodeOperand(Stream stream, OperandKind kind) {
 		return kind switch {
 			OperandKind.Expr => ExpressionEncoding.Decode(stream),
 			OperandKind.Int8 => DecodeOperandInt8(stream),
+			OperandKind.UInt16 => DecodeOperandUInt16(stream),
 			OperandKind.Int16 => DecodeOperandInt16(stream),
 			OperandKind.Int32 => DecodeOperandInt32(stream),
 			OperandKind.Str => DecodeOperandStr(stream),
@@ -138,6 +157,13 @@ static ExpressionNodeNumber DecodeOperandInt8(Stream stream) {
 		return new(value);
 	}
 
+	static ExpressionNodeNumber DecodeOperandUInt16(Stream stream) {
+		int value = 0;
+		value |= GetByte(stream) << 0;
+		value |= GetByte(stream) << 8;
+		return new(value);
+	}
+
 	static ExpressionNodeNumber DecodeOperandInt16(Stream stream) {
 		int value = 0;
 		value |= GetByte(stream) << 0;
@@ -169,10 +195,10 @@ static int SignExtend(int value, int length) {
 		return value | ~(sign - 1);
 	}
 
-	public static InstructionEncoding BuildFrom(ImmutableArray<InstructionSpec> opcodeSpecs) {
-		ImmutableTree<byte, InstructionSpec> tree = BuildOpcodeTree(opcodeSpecs);
+	public static InstructionEncoding BuildFrom(ImmutableArray<InstructionSpec> specs) {
+		ImmutableTree<byte, VmInstructionSpec> tree = BuildOpcodeTree(specs);
 		Dictionary<string, InstructionSpec> table = [];
-		foreach (InstructionSpec spec in opcodeSpecs) {
+		foreach (InstructionSpec spec in specs) {
 			if (table.ContainsKey(spec.Name)) {
 				throw new Exception($"Duplicate instruction name: {spec.Name}.");
 			}
@@ -181,14 +207,16 @@ public static InstructionEncoding BuildFrom(ImmutableArray<InstructionSpec> opco
 		return new(tree, table.ToImmutableDictionary());
 	}
 
-	static ImmutableTree<byte, InstructionSpec> BuildOpcodeTree(ImmutableArray<InstructionSpec> specs) {
-		Tree<byte, InstructionSpec> tree = new();
+	static ImmutableTree<byte, VmInstructionSpec> BuildOpcodeTree(ImmutableArray<InstructionSpec> specs) {
+		Tree<byte, VmInstructionSpec> tree = new();
 		foreach (InstructionSpec spec in specs) {
-			ImmutableArray<byte> opcode = spec.Opcode;
+			if (spec is not VmInstructionSpec) continue;
+			VmInstructionSpec vmInstructionSpec = (VmInstructionSpec)spec;
+			ImmutableArray<byte> opcode = vmInstructionSpec.Opcode;
 			if (opcode.Length == 0) {
 				throw new Exception($"Empty opcode: {spec.Name}.");
 			}
-			Tree<byte, InstructionSpec> cursor = tree;
+			Tree<byte, VmInstructionSpec> cursor = tree;
 			for (int i = 0; i < opcode.Length; i++) {
 				if (cursor.HasValue) {
 					throw new Exception($"Duplicate opcode prefix: {Convert.ToHexString(opcode.AsSpan()[..i])}.");
@@ -201,7 +229,7 @@ static ImmutableTree<byte, InstructionSpec> BuildOpcodeTree(ImmutableArray<Instr
 			if (cursor.HasValue) {
 				throw new Exception($"Duplicate opcode: {Convert.ToHexString(opcode.AsSpan())}.");
 			}
-			cursor.Value = spec;
+			cursor.Value = vmInstructionSpec;
 		}
 		return tree.ToImmutableTree();
 	}

src/MagesScriptTool/DataDirectiveSpec.cs

@@ -0,0 +1,5 @@
+namespace MagesScriptTool;
+enum InstructionKind {
+    VM_INSTRUCTION,
+    DATA_DIRECTIVE
+};

src/MagesScriptTool/DataDirectivesSpec.cs

@@ -2,14 +2,12 @@
 
 namespace MagesScriptTool;
 
-sealed class InstructionSpec {
+abstract class InstructionSpec {
 	public readonly string Name;
-	public readonly ImmutableArray<byte> Opcode;
 	public readonly ImmutableArray<OperandKind> Operands;
 
-	public InstructionSpec(string name, ImmutableArray<byte> opcode, ImmutableArray<OperandKind> operands) {
+	public InstructionSpec(string name, ImmutableArray<OperandKind> operands) {
 		Name = name;
-		Opcode = opcode;
 		Operands = operands;
 	}
 }

src/MagesScriptTool/InstructionEncoding.cs

@@ -4,6 +4,7 @@ enum OperandKind {
 	Expr,
 	UInt8,
 	Int8,
+	UInt16,
 	Int16,
 	Int32,
 	Str,