refactoring

src/main.rs

@@ -1,5 +1,5 @@
-mod db;
-mod stmt;
+mod parse;
+mod run;
 
 fn main() {
     println!(
@@ -9,5 +9,5 @@ Type 'help' for help
     "
     );
 
-    db::start(std::env::args().nth(1));
+    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,5 +1,5 @@
-use crate::stmt;
-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;
 
@@ -8,9 +8,9 @@ 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,
 }
 
@@ -25,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,
+        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 {
-                    self.pc = index - 1;
+                if self.registers[r.0] == 0 {
+                    self.pc = StmtIdx(index.0 - 1);
                 }
             }
-            Some(Stmt::Jump(index)) => self.pc = index - 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 {
@@ -57,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))
     }
 }
 
@@ -72,8 +75,8 @@ enum VmRunKind {
 enum VmInstruction {
     Step,
     Run(VmRunKind),
-    Break(usize),
-    Set(usize, usize),
+    Break(StmtIdx),
+    Set(Register, usize),
     Stop,
 }
 
@@ -94,9 +97,9 @@ fn read_and_run(path: &str) {
     let path = Path::new(path);
 
     match std::fs::read_to_string(path) {
-        Ok(content) => match stmt::parse(&content, filename(path)) {
+        Ok(content) => match parse::parse(&content, filename(path)) {
             Ok(stmts) => run(stmts),
-            Err(why) => eprintln!("error while parsing: {}.", why),
+            Err(why) => eprintln!("{}", why),
         },
         Err(why) => eprintln!("error while reading file: {}.", why),
     };
@@ -126,6 +129,10 @@ fn loading_input() -> LoadInstruction {
     }
 }
 
+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);
@@ -134,7 +141,7 @@ fn run(code: Code) {
         span: code.span,
         code_lines: code.code_lines,
         file_name: code.file_name,
-        pc: 0,
+        pc: StmtIdx(0),
         registers: vec![0; max_register_index + 1],
         breakpoints: vec![],
     };
@@ -174,7 +181,7 @@ fn run(code: Code) {
                     }
                 }
             }
-            VmInstruction::Set(r, value) => vm.registers[r] = value,
+            VmInstruction::Set(r, value) => vm.registers[r.0] = value,
         }
     }
     println!("Execution finished.");
@@ -228,19 +235,19 @@ fn debug_input(vm: &Vm) -> VmInstruction {
     }
 }
 
-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,
         })
@@ -258,7 +265,7 @@ fn print_registers(vm: &Vm) {
 fn print_program(vm: &Vm) {
     use std::cmp::min;
 
-    if let Some(span_pc) = vm.span.get(vm.pc) {
+    if let Some(span_pc) = vm.span.get(vm.pc.0) {
         println!("Program:");
 
         let lower = span_pc.0.saturating_sub(5);
@@ -284,7 +291,7 @@ fn print_breakpoints(vm: &Vm) {
     ",
         vm.breakpoints
             .iter()
-            .map(|p| p.to_string())
+            .map(|p| p.0.to_string())
             .collect::<Vec<String>>()
             .join(", ")
     );
@@ -327,7 +334,3 @@ fn get_input(prompt: Option<&str>) -> String {
     std::io::stdin().read_line(&mut input_buf).unwrap();
     input_buf.trim().to_owned()
 }
-
-fn filename(path: &Path) -> String {
-    path.file_stem().unwrap().to_str().unwrap().to_owned()
-}

src/stmt.rs

@@ -1,235 +0,0 @@
-use std::collections::HashMap;
-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>,
-    pub file_name: String,
-}
-
-enum IrStmt<'a> {
-    Inc(usize),
-    Dec(usize),
-    IsZeroLabel(usize, &'a str),
-    IsZeroLine(usize, LineNumber),
-    JumpLabel(&'a str),
-    JumpLine(LineNumber),
-    Label(&'a str),
-    Stop,
-    None,
-}
-
-pub fn parse(text: &str, file_name: String) -> 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() {
-        let result = parse_line(line);
-        match result {
-            Ok(IrStmt::Label(name)) => {
-                labels.insert(name, statement_number);
-            }
-            Ok(IrStmt::None) => {}
-            Ok(stmt) => {
-                statement_number += 1;
-                statements.push((stmt, Span(line_index)));
-            }
-            Err(msg) => {
-                return Err(format!(
-                    "error on line '{}': {}",
-                    Span(line_index).line_number(),
-                    msg
-                ))
-            }
-        }
-    }
-
-    let result: Result<Vec<(Stmt, Span)>, String> = 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,
-                    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!(),
-            IrStmt::None => unreachable!(),
-        })
-        .collect();
-
-    result.map(|vec| {
-        let (stmts, span) = vec.iter().cloned().unzip();
-        Code {
-            stmts,
-            span,
-            code_lines,
-            file_name,
-        }
-    })
-}
-
-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();
-    let first = match first {
-        Some(first) => first,
-        None => return Ok(IrStmt::None),
-    };
-
-    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 let Some(stripped) = stmt.strip_prefix('.') {
-                IrStmt::Label(stripped)
-            } else if stmt.starts_with('#') {
-                IrStmt::None
-            } else {
-                return Err(format!("Illegal instruction: '{}'", stmt));
-            }
-        }
-    })
-}

test.m8

@@ -1,6 +1,5 @@
-# hi
 INC 1
-JUMP 8
+JUMP 7
 INC 2
 STOP
 INC 3