Resolve labels to relative offsets

Also fix test output which was mismatched for #0 -> $0 and update Core to use
a boxed slice instead of a Vec (no resizing).

It seems likely there will need to be a "resolved" and "unresolved" view of
the core, one for use with load file format + emulation, and one for parse
validation.

Author: ian-h-chamberlain

src/load_file.rs

@@ -4,6 +4,8 @@ use std::{
     string::ToString,
 };
 
+type LabelMap = HashMap<String, usize>;
+
 pub const DEFAULT_CORE_SIZE: usize = 8000;
 
 enum_string!(pub Opcode {
@@ -148,6 +150,24 @@ impl Field {
             value: Value::Literal(value),
         }
     }
+
+    pub fn resolve(&self, from: usize, labels: &LabelMap) -> Result<Self, String> {
+        match &self.value {
+            Value::Literal(_) => Ok(self.clone()),
+            Value::Label(label) => {
+                let label_value = labels
+                    .get(label)
+                    .ok_or_else(|| format!("Label '{}' not found", &label))?;
+
+                let value = Value::Literal((*label_value as i32) - (from as i32));
+
+                Ok(Self {
+                    address_mode: self.address_mode,
+                    value,
+                })
+            }
+        }
+    }
 }
 
 impl ToString for Field {
@@ -180,6 +200,17 @@ impl Instruction {
             field_b,
         }
     }
+
+    pub fn resolve(&self, from: usize, labels: &LabelMap) -> Result<Self, String> {
+        let field_a = self.field_a.resolve(from, labels)?;
+        let field_b = self.field_b.resolve(from, labels)?;
+        Ok(Self {
+            opcode: self.opcode,
+            modifier: self.modifier,
+            field_a,
+            field_b,
+        })
+    }
 }
 
 impl ToString for Instruction {
@@ -196,24 +227,30 @@ impl ToString for Instruction {
 
 #[derive(PartialEq)]
 pub struct Core {
-    instructions: Vec<Instruction>,
-    labels: HashMap<String, usize>,
+    instructions: Box<[Option<Instruction>]>,
+    labels: LabelMap,
 }
 
 impl Core {
     pub fn new(core_size: usize) -> Self {
         Core {
-            instructions: vec![Instruction::default(); core_size],
+            instructions: vec![None; core_size].into_boxed_slice(),
             labels: HashMap::new(),
         }
     }
 
-    pub fn get(&self, index: usize) -> Option<&Instruction> {
-        self.instructions.get(index)
+    pub fn get(&self, index: usize) -> Option<Instruction> {
+        self.instructions.get(index)?.clone()
+    }
+
+    pub fn get_resolved(&self, index: usize) -> Result<Instruction, String> {
+        self.get(index)
+            .unwrap_or_default()
+            .resolve(index, &self.labels)
     }
 
     pub fn set(&mut self, index: usize, value: Instruction) {
-        self.instructions[index] = value;
+        self.instructions[index] = Some(value);
     }
 
     pub fn add_label(&mut self, index: usize, label: String) -> Result<(), String> {
@@ -238,21 +275,22 @@ impl Core {
         self.labels.get(label).copied()
     }
 
-    pub fn dump_all(&self) -> String {
-        self.instructions
-            .iter()
-            .fold(String::new(), |result, instruction| {
-                result + &instruction.to_string() + "\n"
-            })
-    }
-
     pub fn dump(&self) -> String {
-        self.instructions
+        let resolve_result: Result<Vec<_>, String> = self
+            .instructions
             .iter()
-            .filter(|&instruction| *instruction != Instruction::default())
-            .fold(String::new(), |result, instruction| {
+            .filter(|&maybe_instruction| maybe_instruction.is_some())
+            .map(|instruction| instruction.as_ref().unwrap())
+            .enumerate()
+            .map(|(i, instruction)| instruction.resolve(i, &self.labels))
+            .collect();
+
+        match resolve_result {
+            Err(msg) => msg,
+            Ok(resolved) => resolved.iter().fold(String::new(), |result, instruction| {
                 result + &instruction.to_string() + "\n"
-            })
+            }),
+        }
     }
 }
 
@@ -435,4 +473,44 @@ mod tests {
         assert!(core.label_address("goblin").is_none());
         assert!(core.label_address("never_mentioned").is_none());
     }
+
+    // TODO: add test for unresolvable label
+    #[test]
+    fn resolve_labels() {
+        let mut core = Core::new(200);
+
+        core.add_label(123, "baz".into()).expect("Should add baz");
+        core.add_label(0, "foo".into()).expect("Should add foo");
+
+        core.set(
+            5,
+            Instruction {
+                field_a: Field {
+                    value: Value::Label("baz".into()),
+                    ..Default::default()
+                },
+                field_b: Field {
+                    value: Value::Label("foo".into()),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        );
+
+        let resolved = core.get_resolved(5).expect("Should resolve instruction");
+        assert_eq!(
+            resolved,
+            Instruction {
+                field_a: Field {
+                    value: Value::Literal(118),
+                    ..Default::default()
+                },
+                field_b: Field {
+                    value: Value::Literal(-5),
+                    ..Default::default()
+                },
+                ..Default::default()
+            }
+        )
+    }
 }

src/parser.rs

@@ -383,4 +383,6 @@ mod tests {
 
         assert_eq!(parsed, expected_core);
     }
+
+    // TODO: parse error for unresolvable label
 }

tests/data/test.red

@@ -3,7 +3,8 @@ preload
 dat   1  ,  2
 mov 1, 0
 
-jmp 123
+jmp loop
+jmp begin
 
 begin:  add # 1, @ 2
         sub 3, 4

tests/data/test_loadfile.red

@@ -1,26 +1,27 @@
-MOV.I #0, $1
+MOV.I $0, $1
 DAT.F $1, $2
-MOV.I $1, #0
-JMP.B $123, #0
+MOV.I $1, $0
+JMP.B $16, #0
+JMP.B $1, #0
 ADD.AB #1, @2
 SUB.F $3, $4
 MUL.F $5, $6
 DIV.F $7, $8
 MOD.F $9, $10
-JMZ.B #0, #0
-JMN.B #0, #0
-DJN.B #0, #0
-CMP.I #0, #0
-SEQ.I #0, #0
-SNE.I #0, #0
-SLT.B #0, #0
-SPL.B #0, #0
-NOP.B #0, #0
+JMZ.B $0, #0
+JMN.B $0, #0
+DJN.B $0, #0
+CMP.B $0, #0
+SEQ.B $0, #0
+SNE.B $0, #0
+SLT.B $0, #0
+SPL.B $0, #0
+NOP.B $0, #0
 MOV.A $1, $2
 MOV.B $1, $2
 MOV.AB $1, $2
 MOV.BA $1, $2
 MOV.F $1, $2
 MOV.X $1, $2
 MOV.I $1, $2
-JMP.B $-22, #0
+JMP.B $-7, #0

tests/dump.rs

@@ -13,7 +13,6 @@ fn run_test(input: &str, expected_output: &str) {
 }
 
 #[test]
-#[ignore = "Fails because labels are not yet converted to offsets"]
 fn dump_all_opcodes() {
     run_test(
         include_str!("data/test.red"),