Merge remote-tracking branch 'origin/main'

# Conflicts:
#	README.md

Cargo.lock

@@ -4,4 +4,4 @@ version = 3
 
 [[package]]
 name = "m8db"
-version = "0.1.0"
+version = "1.3.0"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "m8db"
-version = "0.1.0"
+version = "1.3.0"
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

README.md

@@ -4,16 +4,20 @@ Debugger and interpreter for the M8 pseudo-assembly language. Inspired by `gdb`
 
 More infos: https://github.com/ah1m1/M8NI
 
-Usage: `$ ./m8db <filename>`
+Usage: `$ ./m8db (filename)`
 
 
 # Instructions:  
 * `INC r`
 * `DEC r`
 * `JUMP label`
+* `JUMP line`
 * `STOP`
 * `IS_ZERO r label`
+* `IS_ZERO r line`
 * `.labelname`
 
-Where `r` is a register number and `label` is a label name.  
+`# anything` is a comment
+
+Where `r` is a register number, `line` is a line number and `label` is a label name.  
 `IS_ZERO` jumps to `label` if `r` is zero

src/main.rs

@@ -1,15 +1,7 @@
-mod db;
-mod stmt;
+mod parse;
+mod run;
 
 fn main() {
-    let filename = match std::env::args().nth(1) {
-        Some(name) => name,
-        None => {
-            eprintln!("error: no file provided.\nUsage: <filename>");
-            return;
-        }
-    };
-
     println!(
         "m8db - M8 Debugger
 (C) Nilstrieb (https://github.com/Nilstrieb/m8db)
@@ -17,14 +9,5 @@ Type 'help' for help
     "
     );
 
-    let program = std::fs::read_to_string(filename).unwrap();
-    let statements = match stmt::parse(&program) {
-        Ok(stmts) => stmts,
-        Err(str) => {
-            eprintln!("{}", str);
-            return;
-        }
-    };
-    db::run(statements);
-    println!("Execution finished.");
+    run::start(std::env::args().nth(1));
 }

src/parse.rs

@@ -0,0 +1,257 @@
+use std::collections::HashMap;
+use std::fmt::Formatter;
+use std::num::ParseIntError;
+
+/// A span referencing the line where a statement came from. Starts at 0
+#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct Span(pub usize);
+
+impl Span {
+    pub fn line_number(&self) -> usize {
+        self.0 + 1
+    }
+}
+
+/// A line number, starts at 1
+#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct LineNumber(pub usize);
+
+impl LineNumber {
+    pub fn span(&self) -> Span {
+        Span(self.0 - 1)
+    }
+}
+
+/// An index into a `Vm` `Stmt`
+#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct StmtIdx(pub usize);
+
+/// A register index
+#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct Register(pub usize);
+
+#[derive(Debug, Copy, Clone)]
+pub enum Stmt {
+    Inc(Register),
+    Dec(Register),
+    IsZero(Register, StmtIdx),
+    Jump(StmtIdx),
+    Stop,
+}
+
+#[derive(Debug, Clone)]
+pub struct Code<'a> {
+    pub stmts: Vec<Stmt>,
+    /// Has the same length as `stmts`, points to line numbers where the instructions come from
+    pub span: Vec<Span>,
+    pub code_lines: Vec<&'a str>,
+    pub file_name: String,
+}
+
+#[derive(Debug, Clone)]
+enum IrStmt<'a> {
+    Inc(Register),
+    Dec(Register),
+    IsZeroLabel(Register, &'a str),
+    IsZeroLine(Register, LineNumber),
+    JumpLabel(&'a str),
+    JumpLine(LineNumber),
+    Label(&'a str),
+    Stop,
+    None,
+}
+
+#[derive(Debug)]
+struct ParseErr {
+    span: Span,
+    inner: ParseErrInner,
+}
+
+impl ParseErr {
+    fn new(span: Span, inner: ParseErrInner) -> Self {
+        Self { span, inner }
+    }
+}
+
+#[derive(Debug)]
+pub enum ParseErrInner {
+    OutOfBoundsLineRef(LineNumber),
+    LabelNotFound(String),
+    ParseIntErr(ParseIntError),
+    NoRegister,
+    NoLabelOrLine,
+    IllegalStmt(String),
+}
+
+type StdResult<T, E> = std::result::Result<T, E>;
+type Result<T> = StdResult<T, ParseErr>;
+
+impl std::fmt::Display for ParseErr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "error on line '{}': ", self.span.line_number())?;
+        match &self.inner {
+            ParseErrInner::OutOfBoundsLineRef(referenced) => {
+                write!(f, "Referencing line '{}': out of bounds", referenced.0,)
+            }
+            ParseErrInner::LabelNotFound(label) => write!(f, "Label '{}' not found", label,),
+            ParseErrInner::ParseIntErr(err) => write!(f, "{}", err),
+            ParseErrInner::NoRegister => write!(f, "No register provided"),
+            ParseErrInner::NoLabelOrLine => write!(f, "No label or line provided"),
+            ParseErrInner::IllegalStmt(stmt) => write!(f, "Illegal statement: '{}'", stmt),
+        }?;
+        write!(f, ".")
+    }
+}
+
+fn resolve_line_number(
+    stmts: &[(IrStmt, Span)],
+    number: LineNumber,
+    span: Span,
+) -> Result<StmtIdx> {
+    match stmts
+        .iter()
+        .position(|(_, stmt_span)| stmt_span.line_number() == number.0)
+    {
+        Some(stmt_number) => Ok(StmtIdx(stmt_number)),
+        None => Err(ParseErr::new(
+            span,
+            ParseErrInner::OutOfBoundsLineRef(number),
+        )),
+    }
+}
+
+fn resolve_label(labels: &HashMap<&str, StmtIdx>, span: Span, label: &str) -> Result<StmtIdx> {
+    match labels.get(label) {
+        Some(line) => Ok(*line),
+        None => Err(ParseErr::new(
+            span,
+            ParseErrInner::LabelNotFound(label.to_owned()),
+        )),
+    }
+}
+
+pub fn parse(text: &str, file_name: String) -> StdResult<Code, String> {
+    let mut labels = HashMap::new();
+
+    let mut ir_statements = Vec::new();
+    let mut statement_number = StmtIdx(0);
+
+    let code_lines = text.lines().collect::<Vec<_>>();
+
+    for (line_index, line) in code_lines.iter().enumerate() {
+        let span = Span(line_index);
+        let result = parse_line(span, line);
+        match result {
+            Ok(IrStmt::Label(name)) => {
+                labels.insert(name, statement_number);
+            }
+            Ok(IrStmt::None) => {}
+            Ok(stmt) => {
+                statement_number.0 += 1;
+                ir_statements.push((stmt, span));
+            }
+            Err(err) => return Err(err.to_string()),
+        }
+    }
+
+    let statements: Result<Vec<_>> = ir_statements
+        .iter()
+        .filter(|stmt| !matches!(stmt, (IrStmt::None, _)))
+        .map(|(stmt, span)| match *stmt {
+            IrStmt::Inc(r) => Ok((Stmt::Inc(r), *span)),
+            IrStmt::Dec(r) => Ok((Stmt::Dec(r), *span)),
+            IrStmt::IsZeroLine(r, line_number) => Ok((
+                Stmt::IsZero(r, resolve_line_number(&ir_statements, line_number, *span)?),
+                *span,
+            )),
+            IrStmt::JumpLine(line_number) => Ok((
+                Stmt::Jump(resolve_line_number(&ir_statements, line_number, *span)?),
+                *span,
+            )),
+            IrStmt::IsZeroLabel(r, label) => Ok((
+                Stmt::IsZero(r, resolve_label(&labels, *span, label)?),
+                *span,
+            )),
+            IrStmt::JumpLabel(label) => {
+                Ok((Stmt::Jump(resolve_label(&labels, *span, label)?), *span))
+            }
+            IrStmt::Stop => Ok((Stmt::Stop, *span)),
+            IrStmt::Label(_) => unreachable!(),
+            IrStmt::None => unreachable!(),
+        })
+        .collect();
+
+    statements
+        .map(|vec| {
+            let (stmts, span) = vec.iter().cloned().unzip();
+            Code {
+                stmts,
+                span,
+                code_lines,
+                file_name,
+            }
+        })
+        .map_err(|err| err.to_string())
+}
+
+fn parse_line(span: Span, line: &str) -> Result<IrStmt> {
+    let no_label_or_line_number = || ParseErr::new(span, ParseErrInner::NoLabelOrLine);
+
+    let mut iter = line.split_whitespace();
+    let first = iter.next();
+    let first = match first {
+        Some(first) => first,
+        None => return Ok(IrStmt::None),
+    };
+
+    Ok(match first {
+        "INC" => {
+            let register = next_register(&mut iter, span)?;
+            IrStmt::Inc(register)
+        }
+        "DEC" => {
+            let register = next_register(&mut iter, span)?;
+            IrStmt::Dec(register)
+        }
+        "IS_ZERO" => {
+            let register = next_register(&mut iter, span)?;
+            let jump_target = iter.next().ok_or_else(no_label_or_line_number)?;
+            if let Ok(line_number) = jump_target.parse::<usize>() {
+                IrStmt::IsZeroLine(register, LineNumber(line_number))
+            } else {
+                IrStmt::IsZeroLabel(register, jump_target)
+            }
+        }
+        "JUMP" => {
+            let jump_target = iter.next().ok_or_else(no_label_or_line_number)?;
+            if let Ok(line_number) = jump_target.parse::<usize>() {
+                IrStmt::JumpLine(LineNumber(line_number))
+            } else {
+                IrStmt::JumpLabel(jump_target)
+            }
+        }
+        "STOP" => IrStmt::Stop,
+        stmt => {
+            if let Some(stripped) = stmt.strip_prefix('.') {
+                IrStmt::Label(stripped)
+            } else if stmt.starts_with('#') {
+                IrStmt::None
+            } else {
+                return Err(ParseErr::new(
+                    span,
+                    ParseErrInner::IllegalStmt(stmt.to_owned()),
+                ));
+            }
+        }
+    })
+}
+
+fn next_register<'a>(iter: &mut impl Iterator<Item = &'a str>, span: Span) -> Result<Register> {
+    iter.next()
+        .ok_or_else(|| ParseErr::new(span, ParseErrInner::NoRegister))?
+        .parse()
+        .map(|num| Register(num))
+        .map_err(|parse_err: ParseIntError| {
+            ParseErr::new(span, ParseErrInner::ParseIntErr(parse_err))
+        })
+}

src/run.rs

@@ -1,14 +1,17 @@
-use crate::stmt::{Code, LineNumber, Span, Stmt};
+use crate::parse;
+use crate::parse::{Code, LineNumber, Register, Span, Stmt, StmtIdx};
 use std::io::Write;
+use std::path::Path;
 
 #[derive(Debug, Clone)]
 struct Vm<'a> {
     stmts: Vec<Stmt>,
     span: Vec<Span>,
     code_lines: Vec<&'a str>,
-    pc: usize,
+    pc: StmtIdx,
     registers: Vec<usize>,
-    breakpoints: Vec<usize>,
+    breakpoints: Vec<StmtIdx>,
+    file_name: String,
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -22,19 +25,19 @@ enum VmState {
 impl Vm<'_> {
     fn step(&mut self) -> VmState {
         let pc = self.pc;
-        match self.stmts.get(pc).cloned() {
-            Some(Stmt::Inc(r)) => self.registers[r] += 1,
-            Some(Stmt::Dec(r)) => self.registers[r] -= 1,
-            Some(Stmt::IsZero(r, line)) => {
-                if self.registers[r] == 0 {
-                    self.pc = line - 1;
+        match self.stmts.get(pc.0).cloned() {
+            Some(Stmt::Inc(r)) => self.registers[r.0] += 1,
+            Some(Stmt::Dec(r)) => self.registers[r.0] -= 1,
+            Some(Stmt::IsZero(r, index)) => {
+                if self.registers[r.0] == 0 {
+                    self.pc = StmtIdx(index.0 - 1);
                 }
             }
-            Some(Stmt::Jump(line)) => self.pc = line - 1,
+            Some(Stmt::Jump(index)) => self.pc = StmtIdx(index.0 - 1),
             Some(Stmt::Stop) => return VmState::Stop,
             None => return VmState::OutOfBounds,
         }
-        self.pc += 1;
+        self.pc.0 += 1;
         if self.breakpoints.contains(&self.pc) {
             VmState::Break
         } else {
@@ -54,8 +57,11 @@ impl Vm<'_> {
         }
     }
 
-    fn statement_at_span(&self, search_span: Span) -> Option<usize> {
-        self.span.iter().position(|span| *span >= search_span)
+    fn statement_at_span(&self, search_span: Span) -> Option<StmtIdx> {
+        self.span
+            .iter()
+            .position(|span| *span >= search_span)
+            .map(|idx| StmtIdx(idx))
     }
 }
 
@@ -69,23 +75,80 @@ enum VmRunKind {
 enum VmInstruction {
     Step,
     Run(VmRunKind),
-    Break(usize),
-    Set(usize, usize),
+    Break(StmtIdx),
+    Set(Register, usize),
+    Stop,
 }
 
-pub fn run(code: Code) {
+pub fn start(program_path: Option<String>) {
+    if let Some(path) = program_path {
+        read_and_run(&path);
+    }
+
+    loop {
+        match loading_input() {
+            LoadInstruction::Quit => return,
+            LoadInstruction::Load(path) => read_and_run(&path),
+        }
+    }
+}
+
+fn read_and_run(path: &str) {
+    let path = Path::new(path);
+
+    match std::fs::read_to_string(path) {
+        Ok(content) => match parse::parse(&content, filename(path)) {
+            Ok(stmts) => run(stmts),
+            Err(why) => eprintln!("{}", why),
+        },
+        Err(why) => eprintln!("error while reading file: {}.", why),
+    };
+}
+
+#[derive(Debug, Clone)]
+enum LoadInstruction {
+    Quit,
+    Load(String),
+}
+
+fn loading_input() -> LoadInstruction {
+    loop {
+        let input = get_input(None);
+        let mut iter = input.split_whitespace();
+        if let Some(str) = iter.next() {
+            match str {
+                "l" | "load" => match iter.next() {
+                    Some(path) => return LoadInstruction::Load(path.to_owned()),
+                    None => println!("error: No file path provided to load from."),
+                },
+                "h" | "help" => print_load_help(),
+                "q" | "quit" => return LoadInstruction::Quit,
+                cmd => println!("error: Unknown command: {}.", cmd),
+            }
+        }
+    }
+}
+
+fn filename(path: &Path) -> String {
+    path.file_stem().unwrap().to_str().unwrap().to_owned()
+}
+
+fn run(code: Code) {
+    println!("Loaded {}.", code.file_name);
     let max_register_index = max_register(&code.stmts);
     let mut vm = Vm {
         stmts: code.stmts,
         span: code.span,
         code_lines: code.code_lines,
-        pc: 0,
+        file_name: code.file_name,
+        pc: StmtIdx(0),
         registers: vec![0; max_register_index + 1],
         breakpoints: vec![],
     };
 
     loop {
         match debug_input(&vm) {
+            VmInstruction::Stop => break,
             VmInstruction::Run(time_kind) => match vm.run(time_kind) {
                 VmState::Stop => break,
                 VmState::OutOfBounds => {
@@ -94,14 +157,21 @@ pub fn run(code: Code) {
                     eprintln!("error: Program ran out of bounds.");
                     return;
                 }
-                VmState::Run => unreachable!(),
+                VmState::Run => {
+                    unreachable!("internal error: Program still running after returning from run.")
+                }
                 _ => {}
             },
-            VmInstruction::Step => {
-                if let VmState::Stop = vm.step() {
-                    break;
+            VmInstruction::Step => match vm.step() {
+                VmState::Stop => break,
+                VmState::OutOfBounds => {
+                    print_program(&vm);
+                    print_registers(&vm);
+                    eprintln!("error: Program ran out of bounds.");
+                    return;
                 }
-            }
+                _ => {}
+            },
             VmInstruction::Break(line) => {
                 let position = vm.breakpoints.iter().position(|point| *point == line);
                 match position {
@@ -111,20 +181,21 @@ pub fn run(code: Code) {
                     }
                 }
             }
-            VmInstruction::Set(r, value) => vm.registers[r] = value,
+            VmInstruction::Set(r, value) => vm.registers[r.0] = value,
         }
     }
+    println!("Execution finished.");
 }
 
 fn debug_input(vm: &Vm) -> VmInstruction {
     loop {
-        let input = get_input();
-        let mut iter = input.split_ascii_whitespace();
+        let input = get_input(Some(&vm.file_name));
+        let mut iter = input.split_whitespace();
         if let Some(str) = iter.next() {
             match str {
                 "r" | "register" => print_registers(vm),
                 "p" | "program" => print_program(vm),
-                "h" | "?" | "help" => print_help(),
+                "h" | "?" | "help" => print_debug_help(),
                 "b" | "break" => match iter.next() {
                     Some(line_number) => match line_number.parse::<usize>() {
                         Ok(line_number) => {
@@ -133,7 +204,7 @@ fn debug_input(vm: &Vm) -> VmInstruction {
                                     Some(pos) => pos,
                                     None => {
                                         println!(
-                                            "Line number '{}' out of bounds for length {}.",
+                                            "error: Line number '{}' out of bounds for length {}.",
                                             line_number,
                                             vm.code_lines.len()
                                         );
@@ -142,13 +213,13 @@ fn debug_input(vm: &Vm) -> VmInstruction {
                                 };
                             return VmInstruction::Break(stmt_pos);
                         }
-                        Err(_) => println!("Invalid argument provided"),
+                        Err(_) => println!("error: Invalid argument provided."),
                     },
                     None => print_breakpoints(vm),
                 },
                 "set" => match parse_set_command(&mut iter) {
                     Some((reg, value)) => return VmInstruction::Set(reg, value),
-                    None => println!("Invalid arguments provided"),
+                    None => println!("error: Invalid arguments provided."),
                 },
                 "c" | "continue" => {
                     if let Some("time") = iter.next() {
@@ -157,25 +228,26 @@ fn debug_input(vm: &Vm) -> VmInstruction {
                     return VmInstruction::Run(VmRunKind::WithoutTime);
                 }
                 "s" | "step" => return VmInstruction::Step,
-                _ => {}
+                "q" | "quit" => return VmInstruction::Stop,
+                cmd => println!("error: Unknown command: {}.", cmd),
             }
         }
     }
 }
 
-fn parse_set_command<'a>(iter: &mut impl Iterator<Item = &'a str>) -> Option<(usize, usize)> {
-    let reg: usize = iter.next().and_then(|reg| reg.parse().ok())?;
-    let value: usize = iter.next().and_then(|value| value.parse().ok())?;
-    Some((reg, value))
+fn parse_set_command<'a>(iter: &mut impl Iterator<Item = &'a str>) -> Option<(Register, usize)> {
+    let reg = iter.next().and_then(|reg| reg.parse().ok())?;
+    let value = iter.next().and_then(|value| value.parse().ok())?;
+    Some((Register(reg), value))
 }
 
 fn max_register(stmts: &[Stmt]) -> usize {
     stmts
         .iter()
         .map(|stmt| match stmt {
-            Stmt::Inc(r) => *r,
-            Stmt::Dec(r) => *r,
-            Stmt::IsZero(r, _) => *r,
+            Stmt::Inc(r) => r.0,
+            Stmt::Dec(r) => r.0,
+            Stmt::IsZero(r, _) => r.0,
             Stmt::Jump(_) => 0,
             Stmt::Stop => 0,
         })
@@ -193,31 +265,22 @@ fn print_registers(vm: &Vm) {
 fn print_program(vm: &Vm) {
     use std::cmp::min;
 
-    // todo rewrite all of this, it's terrible!
+    if let Some(span_pc) = vm.span.get(vm.pc.0) {
+        println!("Program:");
 
-    println!(
-        "Program: (pc = {}, line = {})",
-        vm.pc,
-        vm.span
-            .get(vm.pc)
-            .cloned()
-            .unwrap_or(Span(vm.span.len()))
-            .line_number()
-    );
-    let lower_stmt = if vm.pc > 5 { vm.pc - 5 } else { 0 };
-    let len = vm.stmts.len();
-    let higher_stmt = if len < 5 { len } else { min(vm.pc + 5, len) };
+        let lower = span_pc.0.saturating_sub(5);
+        let higher = min(vm.code_lines.len(), span_pc.0 + 6);
 
-    let lower_code = vm.span[lower_stmt].0;
-    let higher_code = vm.span[higher_stmt - 1].0;
-
-    for line_index in lower_code..higher_code {
-        let code_line = vm.code_lines[line_index];
-        if line_index == vm.span.get(vm.pc).cloned().unwrap_or(Span(vm.span.len())).0 {
-            println!("> {}  {}", line_index + 1, code_line)
-        } else {
-            println!("{}  {}", line_index + 1, code_line);
+        for line_index in lower..higher {
+            let code_line = vm.code_lines[line_index];
+            if line_index == span_pc.0 {
+                println!("> {}  {}", Span(line_index).line_number(), code_line);
+            } else {
+                println!("{}  {}", Span(line_index).line_number(), code_line);
+            }
         }
+    } else {
+        println!("Reached the end of the program.");
     }
 }
 
@@ -228,13 +291,24 @@ fn print_breakpoints(vm: &Vm) {
     ",
         vm.breakpoints
             .iter()
-            .map(|p| p.to_string())
+            .map(|p| p.0.to_string())
             .collect::<Vec<String>>()
             .join(", ")
     );
 }
 
-fn print_help() {
+fn print_load_help() {
+    println!(
+        "List of commands and their aliases:
+
+    load (l) <filename> -- Load and run a program
+    quit (q) -- Quits the program
+    help (h, ?) -- Shows this help page
+    "
+    );
+}
+
+fn print_debug_help() {
     println!(
         "List of commands and their aliases:
 
@@ -244,14 +318,18 @@ fn print_help() {
     continue (c) (time) -- Run the program until the next breakpoint, add 'time' to display execution time
     register (r) -- Shows the contents of the registers
     program (p) -- Shows where the program currently is
+    quit (q) -- Stop execution of the current program
     help (h, ?) -- Shows this help page
     "
     );
 }
 
-fn get_input() -> String {
+fn get_input(prompt: Option<&str>) -> String {
     let mut input_buf = String::new();
-    print!("(m8db) ");
+    match prompt {
+        None => print!("(m8db) "),
+        Some(text) => print!("(m8db - {}) ", text),
+    }
     std::io::stdout().flush().unwrap();
     std::io::stdin().read_line(&mut input_buf).unwrap();
     input_buf.trim().to_owned()

src/stmt.rs

@@ -1,234 +0,0 @@
-use std::collections::HashMap;
-use std::fmt::Formatter;
-use std::num::ParseIntError;
-
-/// A span referencing the line where a statement came from. Starts at 0
-#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Span(pub usize);
-
-impl Span {
-    pub fn line_number(&self) -> usize {
-        self.0 + 1
-    }
-}
-
-/// A line number, starts at 1
-#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct LineNumber(pub usize);
-
-impl LineNumber {
-    pub fn span(&self) -> Span {
-        Span(self.0 - 1)
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum Stmt {
-    Inc(usize),
-    Dec(usize),
-    IsZero(usize, usize),
-    Jump(usize),
-    Stop,
-}
-
-#[derive(Debug, Clone)]
-pub struct Code<'a> {
-    pub stmts: Vec<Stmt>,
-    /// Has the same length as `stmts`, points to line numbers where the instructions come from
-    pub span: Vec<Span>,
-    pub code_lines: Vec<&'a str>,
-}
-
-enum IrStmt<'a> {
-    Inc(usize),
-    Dec(usize),
-    IsZeroLabel(usize, &'a str),
-    IsZeroLine(usize, LineNumber),
-    JumpLabel(&'a str),
-    JumpLine(LineNumber),
-    Label(&'a str),
-    Stop,
-}
-
-pub fn parse(text: &str) -> Result<Code, String> {
-    let mut labels = HashMap::new();
-
-    let mut statements = Vec::new();
-    let mut statement_number = 0;
-
-    let code_lines = text.lines().collect::<Vec<_>>();
-
-    for (line_index, line) in code_lines.iter().enumerate() {
-        if line.split_whitespace().next().is_none() {
-            continue;
-        }
-        let result = parse_line(line);
-        match result {
-            Ok(IrStmt::Label(name)) => {
-                labels.insert(name, statement_number);
-            }
-            Ok(stmt) => {
-                statement_number += 1;
-                statements.push((stmt, Span(line_index)));
-            }
-            Err(msg) => return Err(format!("error on line '{}': {}", line_index - 1, msg)),
-        }
-    }
-
-    let result: Result<Vec<(Stmt, Span)>, String> = statements
-        .iter()
-        .map(|(stmt, span)| match *stmt {
-            IrStmt::Inc(r) => Ok((Stmt::Inc(r), *span)),
-            IrStmt::Dec(r) => Ok((Stmt::Dec(r), *span)),
-            IrStmt::IsZeroLine(r, line_number) => Ok((
-                Stmt::IsZero(
-                    r,
-                    match statements
-                        .iter()
-                        .position(|(_, stmt_span)| stmt_span.line_number() == line_number.0)
-                    {
-                        Some(stmt_number) => stmt_number,
-                        None => {
-                            return Err(format!(
-                                "Referencing line '{}' on line '{}': {}, out of bounds",
-                                line_number.0,
-                                span.line_number(),
-                                code_lines[span.0]
-                            ))
-                        }
-                    },
-                ),
-                *span,
-            )),
-            IrStmt::JumpLine(line_number) => Ok((
-                Stmt::Jump(
-                    match statements
-                        .iter()
-                        .position(|(_, stmt_span)| stmt_span.line_number() == line_number.0)
-                    {
-                        Some(stmt_number) => stmt_number,
-                        None => {
-                            return Err(format!(
-                                "Referencing line '{}' on line '{}': {}, out of bounds",
-                                line_number.0,
-                                span.line_number(),
-                                code_lines[span.0]
-                            ))
-                        }
-                    },
-                ),
-                *span,
-            )),
-            IrStmt::IsZeroLabel(r, label) => Ok((
-                Stmt::IsZero(
-                    r,
-                    match labels.get(label) {
-                        Some(line) => *line,
-                        None => {
-                            return Err(format!(
-                                "Label '{}' not found on line '{}'",
-                                label,
-                                span.line_number()
-                            ))
-                        }
-                    },
-                ),
-                *span,
-            )),
-            IrStmt::JumpLabel(label) => Ok((
-                Stmt::Jump(match labels.get(label) {
-                    Some(line) => *line,
-                    None => {
-                        return Err(format!(
-                            "Label '{}' not found on line {}",
-                            label,
-                            span.line_number()
-                        ))
-                    }
-                }),
-                *span,
-            )),
-            IrStmt::Stop => Ok((Stmt::Stop, *span)),
-            IrStmt::Label(_) => unreachable!(),
-        })
-        .collect();
-
-    result.map(|vec| {
-        let (stmts, span) = vec.iter().cloned().unzip();
-        Code {
-            stmts,
-            span,
-            code_lines,
-        }
-    })
-}
-
-fn parse_line(line: &str) -> Result<IrStmt, String> {
-    let no_register = || "No register provided".to_string();
-    let no_label_or_line_number = || "No label or line number provided".to_string();
-    let display_err = |parse_err: ParseIntError| parse_err.to_string();
-
-    let mut iter = line.split_whitespace();
-    let first = iter.next().expect("Empty lines filtered out");
-
-    Ok(match first {
-        "INC" => {
-            let register = iter
-                .next()
-                .ok_or_else(no_register)?
-                .parse()
-                .map_err(display_err)?;
-            IrStmt::Inc(register)
-        }
-        "DEC" => {
-            let register = iter
-                .next()
-                .ok_or_else(no_register)?
-                .parse()
-                .map_err(display_err)?;
-            IrStmt::Dec(register)
-        }
-        "IS_ZERO" => {
-            let register = iter
-                .next()
-                .ok_or_else(no_register)?
-                .parse()
-                .map_err(display_err)?;
-            let jump_target = iter.next().ok_or_else(no_label_or_line_number)?;
-            if let Ok(line_number) = jump_target.parse::<usize>() {
-                IrStmt::IsZeroLine(register, LineNumber(line_number))
-            } else {
-                IrStmt::IsZeroLabel(register, jump_target)
-            }
-        }
-        "JUMP" => {
-            let jump_target = iter.next().ok_or_else(no_label_or_line_number)?;
-            if let Ok(line_number) = jump_target.parse::<usize>() {
-                IrStmt::JumpLine(LineNumber(line_number))
-            } else {
-                IrStmt::JumpLabel(jump_target)
-            }
-        }
-        "STOP" => IrStmt::Stop,
-        stmt => {
-            if stmt.starts_with('.') {
-                IrStmt::Label(&stmt[1..])
-            } else {
-                return Err(format!("Illegal instruction: '{}'", stmt));
-            }
-        }
-    })
-}
-
-impl std::fmt::Display for Stmt {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Stmt::Inc(r) => write!(f, "INC {}", r)?,
-            Stmt::Dec(r) => write!(f, "DEC {}", r)?,
-            Stmt::IsZero(r, line) => write!(f, "IS_ZERO {} {}", r, line)?,
-            Stmt::Jump(r) => write!(f, "JUMP {}", r)?,
-            Stmt::Stop => write!(f, "STOP")?,
-        }
-        Ok(())
-    }
-}

test.m8

@@ -1,20 +1,7 @@
-.test
 INC 1
-.test
+JUMP 7
 INC 2
-.test
+STOP
 INC 3
-.test
-INC 4
-.test
-INC 5
-.test
-INC 6
-.test
-INC 7
-.test
-INC 8
-.test
-INC 9
-.test
-INC 10
+
+JUMP 4