updated interactive mode

switched to clap for command parsing
added breakpoints
added memory range printing now it is possible to print certain range of memory
added pretty table print for memory printing

Author: poneciak57

src/interactive.rs

@@ -0,0 +1,98 @@
+use std::io;
+
+use clap::{Error, Parser, Subcommand};
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum InteractiveState {
+    DISABLED,
+    ENABLED,
+    WAITING_FOR_BREAKPOINT,
+}
+
+impl InteractiveState {
+    pub fn is_enabled(&self) -> bool { return *self == Self::ENABLED }
+    pub fn is_disabled(&self) -> bool { return *self == Self::DISABLED }
+    pub fn is_waiting_bp(&self) -> bool { return *self == Self::WAITING_FOR_BREAKPOINT }
+}
+
+#[derive(Parser, Debug)]
+#[command(name = ">", about = "An interactive debuging tool", long_about = None)]
+pub struct InteractiveCli {
+    #[command(subcommand)]
+    pub cmd: Command,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum Command {
+    /// Proceed to the next instruction (alias: n)
+    #[command(alias = "n")]
+    NEXT,
+
+    /// Continue until the next breakpoint (alias: nb)
+    #[command(alias = "nb")] 
+    NEXT_BREAKPOINT,
+
+    /// Add a breakpoint at a specified line (alias: ab)
+    #[command(alias = "ab")]
+    ADD_BREAKPOINT {
+        /// Line number for the breakpoint
+        line: usize,
+    },
+
+    /// Delete a breakpoint at a specified line if exists (alias: db)
+    #[command(alias = "db")]
+    DELETE_BREAKPOINT {
+        /// Line number of the breakpoint to delete
+        line: usize,
+    },
+
+    /// List all breakpoints (alias: lb)
+    #[command(alias = "lb")]
+    LIST_BREAKPOINTS,
+
+    /// Aborts execution (alias: q)
+    #[command(alias = "q")]
+    QUIT,
+
+    /// Disables interactive mode and finishes execution (alias: f)
+    #[command(alias = "f")]
+    FINISH,
+
+    /// Print memory from a start address to an end address (alias: m)
+    #[command(alias = "m")]
+    MEM {
+        /// Inclusive start address of memory
+        #[arg(short = 'f', long = "from", short, default_value_t = 0)]
+        from: usize,
+        /// Exclusive end address of memory
+        #[arg(short, long, default_value_t = 512)]
+        to: usize,
+        /// File where u want to store a snapshot
+        #[arg(long = "file")]
+        file: Option<String>
+    },
+}
+
+impl InteractiveCli {
+
+    pub fn read() -> Result<InteractiveCli, Error> {
+        let mut input = String::new();
+        io::stdin().read_line(&mut input).expect("Failed to read line");
+        let mut args: Vec<&str> = input.trim().split_whitespace().collect();
+        args.insert(0, "");
+        InteractiveCli::try_parse_from(args)
+    }
+
+    pub fn print_start_baner() {
+        println!("_________  ________   _   ____  ___");
+        println!("| ___ \\  \\/  /  __ \\ | | | |  \\/  |");
+        println!("| |_/ / .  . | /  \\/ | | | | .  . |");
+        println!("|  __/| |\\/| | |     | | | | |\\/| |");
+        println!("| |   | |  | | \\__/\\ \\ \\_/ / |  | |");
+        println!("\\_|   \\_|  |_\\/____/  \\___/|_|  |_| by poneciak");
+        println!("Welcome to interactive mode type 'help' for more info");
+        println!("Every instruction is displayed and then you can type your command");
+        println!("");
+    }
+}

src/lib.rs

@@ -1,3 +1,5 @@
 pub mod parser;
 pub mod instruction;
-pub mod processor;
+pub mod processor;
+pub mod mem;
+pub mod interactive;

src/main.rs

@@ -1,7 +1,7 @@
 use std::{fs, path::PathBuf};
 
 use clap::{command, Parser};
-use pmc_interpreter::{parser::parse, processor::PROC};
+use pmc_interpreter::{interactive::InteractiveState, parser::parse, processor::PROC};
 
 /// A simple PMC
 #[derive(Parser, Debug)]
@@ -23,7 +23,11 @@ fn main() {
     let mut mem = parse(&content);
     let mut proc = PROC::new();
     // mem.print_range(0..30);
-    proc.run(&mut mem, cli.interactive);
-    mem.dump_all(Some("mem.out".to_string()));
+    let interactive_state = if cli.interactive {
+        InteractiveState::ENABLED
+    } else {
+        InteractiveState::DISABLED
+    };
+    proc.run(&mut mem, interactive_state);
     //mem.dump_all();
 }

src/mem.rs

@@ -0,0 +1,96 @@
+use std::fs::OpenOptions;
+use std::io::{self, Write};
+
+
+use crate::instruction::Instruction;
+
+pub struct MEM {
+    pub(crate) inner: [Instruction; 512],
+}
+
+impl MEM {
+
+    pub(crate) fn new(inner: [Instruction; 512]) -> Self {
+        Self { inner }
+    }
+
+    pub(crate) fn set(&mut self, i: u16, val: u16, interactive: bool) {
+        if i >= 512 {
+            panic!("Adress out of bounds. Tried to access memory at index: {}", i);
+        }
+        if interactive { println!("{:<2}Modified MEM[{}] = {}", "", i, val); }
+        self.inner[i as usize] = Instruction { raw: val };    
+    }
+
+    pub(crate) fn get(&self, i: u16) -> Instruction {
+        if i >= 512 {
+            panic!("Adress out of bounds. Tried to access memory at index: {}", i);
+        }
+        self.inner[i as usize]
+    }
+
+    pub(crate) fn get_raw(&self, i: u16) -> u16 {
+        unsafe { self.get(i).raw }
+    }
+
+
+    pub fn write_to_file(&self, filename: String, range: std::ops::Range<usize>) {
+        let mut file = OpenOptions::new()
+            .write(true)
+            .append(false)
+            .create(true)
+            .open(&filename)
+            .expect("Expected output file creation");
+        self.print_table(&mut file, range)
+            .expect("Expected successfull write to file");
+        println!("{:<2}Written memory snapshot to {}", "", filename);
+        return;
+    }
+
+    pub fn print(&self, range: std::ops::Range<usize>) {
+        self.print_table(&mut io::stdout(), range)
+            .expect("Expected successfull print to stdout");
+    }
+
+    fn print_table<W: Write>(&self, out: &mut W, range: std::ops::Range<usize>) -> io::Result<()> {
+        let headers = ["ID", "Binary repr", "Instruction repr", "Number repr"];
+        let col_widths = [4, 17, 20, 15];
+
+        // headers
+        for (header, &width) in headers.iter().zip(&col_widths) {
+            write!(out, "{:<width$} ", header, width = width)?;
+        }
+        writeln!(out)?;
+
+        // separator line
+        for &width in &col_widths {
+            write!(out, "{:-<width$}", "", width = width)?;
+        }
+        writeln!(out)?;
+
+        // rows
+        for i in range {
+            let row: [String; 4];
+            unsafe {
+                let inner = self.inner[i as usize].inner;
+                let sgn = if inner.sign() == 1 { '-' } else { '+' };
+
+                let binary_raw = format!("{:0>15b}", self.inner[i as usize].raw);
+                let instruction = format!("{} {:?} {:?} {}", sgn, inner.code(), inner.adrt(), inner.adr());
+                let number = format!("{}", self.inner[i as usize].raw);
+                row = [
+                    i.to_string(),
+                    binary_raw,
+                    instruction,
+                    number
+                ];
+            }
+            for (cell, &width) in row.iter().zip(&col_widths) {
+                write!(out, "{:<width$} ", cell, width = width)?;
+            }
+            writeln!(out)?;
+        }
+        writeln!(out)?;
+        Ok(())
+    }
+}

src/parser.rs

@@ -1,4 +1,4 @@
-use crate::{instruction::{Adrt, Code, InnerInstruction, Instruction}, processor::MEM};
+use crate::{instruction::{Adrt, Code, InnerInstruction, Instruction}, mem::MEM};