Fix #46

Fix cli parameters being ignored/overwritten if a program is specified.
This was due to the master reset being executed when the program was
loaded. Should be fixed now, a test was added.

Author: MalteT

Diff for: emulator-2a-lib/src/machine/mod.rs

@@ -75,22 +75,36 @@ impl Machine {
             raw: RawMachine::new(),
             step_mode: StepMode::Real,
         };
-        m.set_input_fc(config.input_fc);
-        m.set_input_fd(config.input_fd);
-        m.set_input_fe(config.input_fe);
-        m.set_input_ff(config.input_ff);
-        m.set_digital_input1(config.digital_input1);
-        m.set_temp(config.temp);
-        m.set_jumper1(config.jumper1);
-        m.set_jumper2(config.jumper2);
-        m.set_analog_input1(config.analog_input1);
-        m.set_analog_input2(config.analog_input2);
-        m.set_universal_input_output1(config.universal_input_output1);
-        m.set_universal_input_output2(config.universal_input_output2);
-        m.set_universal_input_output3(config.universal_input_output3);
+        m.apply_configuration(config);
         m
     }
 
+    pub fn new_with_program(config: MachineConfig, program: ByteCode) -> Self {
+        let mut m = Machine {
+            raw: RawMachine::new(),
+            step_mode: StepMode::Real,
+        };
+        m.load(program);
+        m.apply_configuration(config);
+        m
+    }
+
+    fn apply_configuration(&mut self, config: MachineConfig) {
+        self.set_input_fc(config.input_fc);
+        self.set_input_fd(config.input_fd);
+        self.set_input_fe(config.input_fe);
+        self.set_input_ff(config.input_ff);
+        self.set_digital_input1(config.digital_input1);
+        self.set_temp(config.temp);
+        self.set_jumper1(config.jumper1);
+        self.set_jumper2(config.jumper2);
+        self.set_analog_input1(config.analog_input1);
+        self.set_analog_input2(config.analog_input2);
+        self.set_universal_input_output1(config.universal_input_output1);
+        self.set_universal_input_output2(config.universal_input_output2);
+        self.set_universal_input_output3(config.universal_input_output3);
+    }
+
     /// Get the currently active [`StepMode`].
     pub const fn step_mode(&self) -> StepMode {
         self.step_mode

Diff for: emulator-2a-lib/src/runner/mod.rs

@@ -78,10 +78,9 @@ impl<'a> RunnerConfig<'a> {
     /// This executes the runner and checks all verifications.
     pub fn run(&self) -> Result<RunResults, ParserError> {
         // Prepare the machine
-        let mut machine = Machine::new(self.machine_config.clone());
         let parsed = AsmParser::parse(self.program)?;
         let bytecode = Translator::compile(&parsed);
-        machine.load(bytecode);
+        let mut machine = Machine::new_with_program(self.machine_config.clone(), bytecode);
         // Initialize variables
         let before_emulation = Instant::now();
         let mut emulated_cycles = 0;

Diff for: emulator-2a/src/args.rs

@@ -88,7 +88,7 @@ pub enum RunVerifySubcommand {
     Verify(RunVerifyArgs),
 }
 
-#[derive(Debug, Clone, StructOpt)]
+#[derive(Debug, Default, Clone, StructOpt)]
 pub struct RunVerifyArgs {
     /// The expected machine state after emulation.
     ///

Diff for: emulator-2a/src/runner/mod.rs

@@ -76,3 +76,32 @@ where
         format!("{}", val.to_string().bright_yellow())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::args::{InitialMachineConfiguration, RunVerifyArgs};
+
+    use super::*;
+
+    #[test]
+    fn flags_are_not_ignored_if_program_is_given() {
+        let run_args = RunArgs {
+            init: InitialMachineConfiguration {
+                fc: 1,
+                fd: 2,
+                fe: 3,
+                ff: 4,
+                ..Default::default()
+            },
+            program: "../testing/programs/26-specific-input.asm".into(),
+            cycles: 1000,
+            resets: vec![],
+            interrupts: vec![],
+            verify: Some(RunVerifySubcommand::Verify(RunVerifyArgs {
+                state: Some(State::Running),
+                ..Default::default()
+            })),
+        };
+        execute_runner_with_args_and_print_results(&run_args).unwrap();
+    }
+}

Diff for: emulator-2a/src/tui/mod.rs

@@ -70,33 +70,37 @@ pub struct Tui {
 
 impl Tui {
     /// Creates a new Tui and shows it.
-    pub fn new(args: &InteractiveArgs) -> Self {
-        let machine = MachineState::new(&args.init);
+    pub fn new(args: &InteractiveArgs) -> Result<Self, Error> {
+        let (machine, program_display_state) = if let Some(path) = args.program.as_ref() {
+            let program = helpers::read_asm_file(&path)?;
+            let bytecode = Translator::compile(&program);
+            (
+                MachineState::new_with_program(&args.init, path, bytecode.clone()),
+                ProgramDisplayState::from_bytecode(&bytecode),
+            )
+        } else {
+            (MachineState::new(&args.init), ProgramDisplayState::empty())
+        };
         let events = Events::new();
         let input_field = InputState::new();
         let keybinding_state = KeybindingHelpState::init();
-        let program_display_state = ProgramDisplayState::empty();
         let measured_freq = 0.0;
-        Tui {
+        Ok(Tui {
             machine,
             events,
             input_field,
             keybinding_state,
             program_display_state,
             measured_freq,
-        }
+        })
     }
     /// Create a new TUI from the given command line arguments
     /// and start it immidiately.
     pub fn run_with_args(args: &InteractiveArgs) -> Result<(), Error> {
-        let tui = Tui::new(args);
-        tui.run(args.program.as_ref())
+        Tui::new(args)?.run()
     }
-    /// Run the main loop using the optional asm program.
-    pub fn run<P>(mut self, path: Option<P>) -> Result<(), Error>
-    where
-        P: Into<PathBuf>,
-    {
+    /// Run the main loop.
+    pub fn run(mut self) -> Result<(), Error> {
         // This tries to clean everything even if the program panics.
         defer! {
             disable_raw_mode().map_err(Error::crossterm_exit).ok();
@@ -112,10 +116,6 @@ impl Tui {
         // Clear the terminal and hide the cursor
         backend.clear()?;
         backend.hide_cursor()?;
-        // Run program if given.
-        if let Some(path) = path {
-            self.load_program(path)?;
-        }
         // Prepare for main loop
         let mut last_draw;
         // Loop until exit is requested

Diff for: emulator-2a/src/tui/supervisor_wrapper.rs

@@ -97,6 +97,24 @@ impl MachineState {
             program: None,
         }
     }
+    /// Create a new MachineState with a program.
+    ///
+    /// The difference between this and [`new`] is, that the program will be loaded
+    /// before the configuration is applied. This allows the configuration to apply
+    /// input register values.
+    pub fn new_with_program<P: Into<PathBuf>>(
+        conf: &InitialMachineConfiguration,
+        path: P,
+        program: ByteCode,
+    ) -> Self {
+        MachineState {
+            part: Part::RegisterBlock,
+            machine: Machine::new_with_program(conf.clone().into(), program),
+            draw_counter: 0,
+            auto_run_mode: false,
+            program: Some(path.into()),
+        }
+    }
     /// Select another part for display.
     pub fn show(&mut self, part: Part) {
         self.part = part;

Diff for: testing/programs/26-specific-input.asm

@@ -0,0 +1,22 @@
+#! mrasm
+
+; This program will error halt the machine if the following input is not present:
+; FC = 1
+; FD = 2
+; FE = 3
+; FF = 4
+
+START:
+    CMP (0xFC), 1
+    JZC ERR
+    CMP (0xFD), 2
+    JZC ERR
+    CMP (0xFE), 3
+    JZC ERR
+    CMP (0xFF), 4
+    JZC ERR
+    JR START
+
+ERR:
+    .DB 0
+