Merge pull request #7 from MalteT/ui-overhaul

Ui overhaul

Author: MalteT

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "emulator-2a"
-version = "4.1.0"
+version = "4.2.1"
 authors = ["Malte Tammena <[email protected]>"]
 edition = "2018"
 license = "GPL-3.0"
@@ -13,7 +13,7 @@ path = "src/main.rs"
 
 [dependencies]
 log = "0.4.0"
-pretty_env_logger = "0.3.0"
+pretty_env_logger = "0.4.0"
 bitflags = "1.0.0"
 pest = "2.1.0"
 pest_derive = "2.1.0"
@@ -23,6 +23,7 @@ lazy_static = "1.3.0"
 humantime = "2.0.1"
 rand = "0.7.0"
 paw = "1.0.0"
+unicode-width = { version = "0.1.8", optional = true }
 rustyline = { version = "5.0.3", optional = true }
 nom = { version = "5.1.0", optional = true }
 scopeguard = { version = "1.1.0", optional = true }
@@ -38,23 +39,23 @@ version = "0.3.15"
 features = ["wrap_help", "paw"]
 
 [dependencies.tui]
-version = "0.8.0"
+version = "0.9.5"
 # TODO: Use termion for linux and mac as soon as #1197 (https://github.com/rust-lang/cargo/issues/1197) is fixed
 default-features = false
 features = ["crossterm"]
 optional = true
 
 [dependencies.crossterm]
 # Use tui's version
-version = "^0.14"
+version = "^0.17"
 
 [features]
 default = ["interactive-tui"]
 # Enable the interactive tui
-interactive-tui = ["tui", "rustyline", "nom", "scopeguard"]
+interactive-tui = ["tui", "rustyline", "nom", "scopeguard", "unicode-width"]
 # The std::fmt::Display implementation defaults to Display::to_utf8_string
 # instead of Display::to_ascii_string
 utf8 = []
 
 [profile.release]
-opt-level = 1
+lto = true

src/args.rs

@@ -2,6 +2,8 @@ use structopt::StructOpt;
 
 use std::{num::ParseIntError, path::PathBuf};
 
+use crate::machine::State;
+
 #[derive(Debug, StructOpt)]
 #[structopt(author = "Malte Tammena <[email protected]>")]
 /// Emulator for the Minirechner 2a microcomputer.
@@ -47,6 +49,49 @@ pub struct RunArgs {
     /// i.e. if the machine halts.
     #[structopt(name = "CYCLES")]
     pub cycles: usize,
+    #[structopt(subcommand)]
+    pub verify: Option<RunVerifySubcommand>,
+}
+
+#[derive(Debug, StructOpt)]
+pub enum RunVerifySubcommand {
+    /// Verify the machine state after emulation has finished.
+    ///
+    /// This does nothing if no expectations are given.
+    /// Specify any number of expectations using the flags listed below.
+    ///
+    /// If any discrepance between the given expectations and the emulation
+    /// results is found an error code of 1 is returned.
+    Verify(RunVerifyArgs),
+}
+
+#[derive(Debug, StructOpt)]
+pub struct RunVerifyArgs {
+    /// The expected machine state after emulation.
+    ///
+    /// `stopped` expects the machine to have halted naturally because
+    /// the machine executed a STOP instruction.
+    ///
+    /// `error` expects the machine to have halted because an error occured.
+    /// This error can have different origins, i.e. a stack overflow or the
+    /// execution of the 0x00 instruction. The most common causes of an error stop
+    /// are a missing stackpointer initialisation or a missing program/missing jump
+    /// at the end of the program.
+    ///
+    /// `running` expects the machine to not have halted for any reason. Of course
+    /// halting and then continueing execution is valid aswell.
+    #[structopt(long, value_name = "STATE",
+                parse(from_str = parse_state),
+                possible_values = &["stopped", "error", "running"])]
+    pub state: Option<State>,
+    /// Expected output in register FE after emulation.
+    #[structopt(long, value_name = "BYTE",
+                parse(try_from_str = parse_u8_auto_radix))]
+    pub fe: Option<u8>,
+    /// Expected output in register FF after emulation.
+    #[structopt(long, value_name = "BYTE",
+                parse(try_from_str = parse_u8_auto_radix))]
+    pub ff: Option<u8>,
 }
 
 #[derive(Debug, StructOpt)]
@@ -175,3 +220,12 @@ fn parse_u8_auto_radix(num: &str) -> Result<u8, ParseIntError> {
         u8::from_str_radix(num, 10)
     }
 }
+
+fn parse_state(state: &str) -> State {
+    match state.to_lowercase().as_str() {
+        "stopped" => State::Stopped,
+        "error" => State::ErrorStopped,
+        "running" => State::Running,
+        _ => unreachable!(),
+    }
+}

src/error.rs

@@ -2,7 +2,6 @@
 //!
 //! This module defines the error type used through-out the program.
 
-use crossterm::ErrorKind as CrosstermErrorKind;
 use failure::Fail;
 use parser2a::parser::ParserError;
 use pest::error::Error as PestError;
@@ -23,17 +22,17 @@ pub enum Error {
     TestFileParsingError(#[cause] PestError<TestRule>),
     /// Thrown when a test failes.
     TestFailed(String, String),
-    /// Invalid CLI input.
-    InvalidInput(String),
     /// Initialization of tui failed.
+    #[cfg(feature = "interactive-tui")]
     TuiInitializationFailed(#[cause] IOError),
     /// Crossterm backend initialization failed.
-    CrosstermInitializationFailed(#[cause] CrosstermErrorKind),
+    #[cfg(feature = "interactive-tui")]
+    CrosstermInitializationFailed(#[cause] crossterm::ErrorKind),
     /// Crossterm backend exit failed.
-    CrosstermExitFailed(#[cause] CrosstermErrorKind),
-    /// The emulator was compiled without the 'interactive-tui' feature.
-    #[cfg(not(feature = "interactive-tui"))]
-    CompiledWithoutInteractiveFeature,
+    #[cfg(feature = "interactive-tui")]
+    CrosstermExitFailed(#[cause] crossterm::ErrorKind),
+    /// Verification of a run failed. The first field is an explanation.
+    RunVerificationFailed(String),
 }
 
 impl From<IOError> for Error {
@@ -63,32 +62,33 @@ impl fmt::Display for Error {
             }
             Error::TestFileParsingError(pe) => write!(f, "{}", pe),
             Error::TestFailed(n, r) => write!(f, "Test {:?} failed: {}", n, r),
-            Error::InvalidInput(s) => write!(f, "{}", s),
+            #[cfg(feature = "interactive-tui")]
             Error::TuiInitializationFailed(ioe) => write!(f, "Tui init failed: {}", ioe),
+            #[cfg(feature = "interactive-tui")]
             Error::CrosstermInitializationFailed(cek) => {
                 write!(f, "Crossterm init failed: {}", cek)
             }
+            #[cfg(feature = "interactive-tui")]
             Error::CrosstermExitFailed(cek) => write!(f, "Crossterm exit failed: {}", cek),
-            #[cfg(not(feature = "interactive-tui"))]
-            Error::CompiledWithoutInteractiveFeature => {
-                use colored::Colorize;
-                write!(
-                    f,
-                    r#"Cannot start interactive session. The 2a-emulator was compiled without the 'interactive-tui' feature. To include the feature during compilation, add: `{}`"#,
-                    "--features interactive-tui".bold().yellow()
-                )
-            }
+            Error::RunVerificationFailed(reason) => write!(
+                f,
+                "Verification failed: {:?} did not match expectations",
+                reason
+            ),
         }
     }
 }
 
 impl Error {
-    pub fn crossterm_init(err: CrosstermErrorKind) -> Self {
+    #[cfg(feature = "interactive-tui")]
+    pub fn crossterm_init(err: crossterm::ErrorKind) -> Self {
         Error::CrosstermInitializationFailed(err)
     }
-    pub fn crossterm_exit(err: CrosstermErrorKind) -> Self {
+    #[cfg(feature = "interactive-tui")]
+    pub fn crossterm_exit(err: crossterm::ErrorKind) -> Self {
         Error::CrosstermExitFailed(err)
     }
+    #[cfg(feature = "interactive-tui")]
     pub fn tui_init(err: IOError) -> Self {
         Error::TuiInitializationFailed(err)
     }

src/helpers/constants.rs

@@ -9,4 +9,8 @@ lazy_static! {
     pub static ref RED: Style = Style::default().fg(Color::Red);
     pub static ref LIGHTRED: Style = Style::default().fg(Color::LightRed);
     pub static ref GREEN: Style = Style::default().fg(Color::Green);
+    pub static ref BOLD: Style = Style::default().modifier(Modifier::BOLD);
+    pub static ref DIMMED_BOLD: Style = Style::default().modifier(Modifier::BOLD | Modifier::DIM);
+    pub static ref YELLOW_BOLD: Style = Style::default().fg(Color::Yellow).modifier(Modifier::BOLD);
+    pub static ref RED_BOLD: Style = Style::default().fg(Color::Red).modifier(Modifier::BOLD);
 }

src/machine/bus.rs

@@ -316,6 +316,12 @@ impl Bus {
     pub fn is_timer_edge_int_enabled(&self) -> bool {
         self.micr.contains(MICR::TIMER_EDGE_INTERRUPT_ENABLE)
     }
+    /// Get the contents of the main memory.
+    ///
+    /// The main memory ranges from 0x00 - 0xEF.
+    pub fn memory(&self) -> &[u8; 0xF0] {
+        &self.ram
+    }
     /// Did anything trigger an interrupt in the UART?
     fn has_uart_interrupt(&self) -> bool {
         if self.ucr.contains(UCR::INT_ON_RX_READY) {

src/machine/mod.rs

@@ -12,7 +12,7 @@ mod register;
 mod signal;
 
 pub use alu::Alu;
-pub use board::DASR;
+pub use board::{Board, DASR};
 pub use bus::Bus;
 pub use instruction::Instruction;
 pub use mp_ram::{MP28BitWord, MicroprogramRam};
@@ -151,46 +151,6 @@ impl Machine {
     pub fn output_ff(&self) -> u8 {
         self.bus.output_ff()
     }
-    /// Get the currently executed lines of the program.
-    ///
-    /// # Arguments
-    /// - `context` The amount of lines before and after the currently executed line.
-    ///
-    /// # Returns
-    /// - A tuple with a list of [`String`]s of asm lines and the index of the one
-    /// currently executed by the machine.
-    pub fn get_current_lines(&self, context: isize) -> (usize, Vec<&String>) {
-        // If no program is loaded, no lines are available, prevent errors
-        if self.program_lines.is_empty() {
-            return (0, vec![]);
-        }
-        let current_byte_index = self.reg.get(RegisterNumber::R3) as isize;
-        // Find current line
-        let mut counter = current_byte_index;
-        let mut index: isize = 0;
-        while counter >= 0 && index < self.program_lines.len() as isize {
-            counter -= self.program_lines[index as usize].1 as isize;
-            if counter >= 0 {
-                index += 1;
-            }
-        }
-        let mut middle = context;
-        // Find left border
-        let left = if index - context >= 0 {
-            (index - context) as usize
-        } else {
-            middle += index - context;
-            0
-        };
-        // Find right border
-        let right = if index + context < self.program_lines.len() as isize {
-            (index + context) as usize
-        } else {
-            self.program_lines.len() - 1
-        };
-        let ret: Vec<_> = self.program_lines.iter().map(|(x, _)| x).collect();
-        (middle as usize, ret[left..=right].into())
-    }
     /// Next clock rising edge.
     pub fn clk(&mut self) {
         // Increase the counter

src/machine/register.rs

@@ -132,7 +132,7 @@ impl Register {
     }
     /// Update the CO flag.
     pub fn update_co(&mut self, co: bool) {
-        let co = (co as u8) << 0;
+        let co = co as u8;
         self.content[4] = (self.content[4] & 0b1111_1110) | co;
     }
     /// Update the ZO flag.
@@ -168,6 +168,10 @@ impl Register {
         }
         valid
     }
+    /// Get the content of all registers.
+    pub fn content(&self) -> &[u8; 8] {
+        &self.content
+    }
 }
 
 impl From<RegisterNumber> for usize {