Allow unresolved or resolved version of a core

Author: ian-h-chamberlain

src/cli.rs

@@ -14,20 +14,27 @@ struct CliOptions {
     /// Output file; defaults to stdout
     #[structopt(long, short, parse(from_os_str))]
     output_file: Option<PathBuf>,
+
+    /// Whether or not labels, expressions, etc. should be resolved in the output
+    #[structopt(long, short)]
+    resolve: bool,
 }
 
 pub fn run() -> Result<(), Box<dyn Error>> {
     let cli_options = CliOptions::from_args();
 
     let input_program = fs::read_to_string(cli_options.input_file)?;
 
-    let parsed_input = parser::parse(input_program.as_str())?;
-    let parse_output = parsed_input.dump();
+    let mut parsed_core = parser::parse(input_program.as_str())?;
+
+    if cli_options.resolve {
+        parsed_core.resolve()?;
+    }
 
     if let Some(output_path) = cli_options.output_file {
-        fs::write(output_path, parse_output)?;
+        fs::write(output_path, format!("{}", parsed_core))?;
     } else {
-        println!("{}", parse_output);
+        println!("{}", parsed_core);
     };
 
     Ok(())

src/load_file.rs

@@ -8,7 +8,7 @@ pub use types::{AddressMode, Modifier, Opcode, Value};
 
 pub const DEFAULT_CORE_SIZE: usize = 8000;
 
-type InstructionSet = Box<[Option<Instruction>]>;
+type Instructions = Box<[Option<Instruction>]>;
 type LabelMap = HashMap<String, usize>;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -109,14 +109,15 @@ impl Instruction {
 }
 
 pub struct Core {
-    instructions: InstructionSet,
+    instructions: Instructions,
+    resolved: Option<Instructions>,
     labels: LabelMap,
 }
 
 impl PartialEq for Core {
-    // TODO: should this impl resolve the instructions? Depends on the use case
     fn eq(&self, other: &Self) -> bool {
-        self.instructions == other.instructions
+        (self.resolved.is_some() && self.resolved == other.resolved)
+            || self.instructions == other.instructions
     }
 }
 
@@ -128,35 +129,35 @@ impl Default for Core {
 
 impl fmt::Debug for Core {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            formatter,
-            "Labels: {:?}\nCore:\n{}",
-            self.labels,
-            self.dump()
-        )
+        if self.resolved.is_some() {
+            write!(formatter, "{}", self)
+        } else {
+            write!(formatter, "<unresolved core>")
+        }
     }
 }
 
 impl Core {
     pub fn new(core_size: usize) -> Self {
         Core {
             instructions: vec![None; core_size].into_boxed_slice(),
-            labels: HashMap::new(),
+            resolved: None,
+            labels: LabelMap::new(),
         }
     }
 
     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)
+        match &self.resolved {
+            Some(instructions) => instructions,
+            None => &self.instructions,
+        }
+        .get(index)?
+        .clone()
     }
 
     pub fn set(&mut self, index: usize, value: Instruction) {
         self.instructions[index] = Some(value);
+        // TODO need to re-resolve here? Or make caller do it
     }
 
     pub fn add_label(&mut self, index: usize, label: String) -> Result<(), String> {
@@ -181,8 +182,8 @@ impl Core {
         self.labels.get(label).copied()
     }
 
-    pub fn resolve(&self) -> Result<Self, String> {
-        let instructions = self
+    pub fn resolve(&mut self) -> Result<&mut Self, String> {
+        let resolved = self
             .instructions
             .iter()
             .enumerate()
@@ -192,29 +193,29 @@ impl Core {
                     .map(|instruction| instruction.resolve(i, &self.labels))
                     .transpose()
             })
-            .collect::<Result<InstructionSet, String>>()?;
+            .collect::<Result<_, String>>()?;
 
-        Ok(Self {
-            instructions,
-            ..Default::default()
-        })
+        self.resolved = Some(resolved);
+
+        Ok(self)
     }
+}
 
-    pub fn dump(&self) -> String {
-        // TODO: convert to fmt::Display - this will require some upfront
-        // validation that all labels are valid, etc
-        // It may be desirable to have Debug be a dump() of the load file and
-        // Display show the original parsed document (or something like that)
-        match self.resolve() {
-            Err(msg) => msg,
-            Ok(core) => core
-                .instructions
-                .iter()
-                .filter_map(Option::as_ref)
-                .fold(String::new(), |result, instruction| {
-                    result + &instruction.to_string() + "\n"
-                }),
-        }
+impl fmt::Display for Core {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match &self.resolved {
+                None => &self.instructions,
+                Some(instructions) => instructions,
+            }
+            .iter()
+            .filter_map(Option::as_ref)
+            .fold(String::new(), |result, instruction| {
+                result + &instruction.to_string() + "\n"
+            })
+        )
     }
 }
 
@@ -303,12 +304,10 @@ mod tests {
             },
         );
 
-        let resolved_core = core.resolve().expect("Should resolve all labels in core");
+        core.resolve().expect("Should resolve all labels in core");
 
         assert_eq!(
-            resolved_core
-                .get(3)
-                .expect("Should have instruction at pos 5"),
+            core.get(3).expect("Should have instruction at pos 5"),
             Instruction {
                 field_a: Field {
                     value: Value::Literal(4),

src/parser.rs

@@ -92,9 +92,7 @@ pub fn parse(file_contents: &str) -> Result<Core, Error> {
         }
     }
 
-    // TODO: keep the original core or use the resolved one?
-    // Probably it should keep a resolved copy in itself
-    Ok(core.resolve()?)
+    Ok(core)
 }
 
 fn parse_instruction(mut instruction_pairs: Pairs<grammar::Rule>) -> Instruction {
@@ -246,7 +244,12 @@ mod tests {
             Instruction::new(Opcode::Jmp, Field::direct(-1), Field::immediate(0)),
         );
 
-        let parsed = parse(simple_input).expect("Should parse simple file");
+        expected_core
+            .resolve()
+            .expect("Should resolve a core with no labels");
+
+        let mut parsed = parse(simple_input).expect("Should parse simple file");
+        parsed.resolve().expect("Parsed file should resolve");
 
         assert_eq!(parsed, expected_core);
     }

tests/dump_test.rs

@@ -4,12 +4,15 @@ fn run_test(input: &str, expected_output: &str) {
     eprintln!("Parsing warrior:");
     eprintln!("{}", input);
 
-    let core = corewa_rs::parse(input).expect("Failed to parse input");
+    let mut core = corewa_rs::parse(input).expect("Failed to parse input");
+    core.resolve().expect("Failed to resolve parsed input");
+
+    // TODO: dump and check output of pre-resolved core
 
     eprintln!("Loaded core:");
     eprintln!("{:?}", core);
 
-    assert_eq!(core.dump(), expected_output);
+    assert_eq!(format!("{}", core), expected_output);
 }
 
 #[test]