add assembly dumping

Author: mlyoung101

src/emitter.rs

@@ -42,6 +42,9 @@ pub struct Program {
 
     /// Counts for each instruction type that was emitted
     instr_type_counts: HashMap<InstrType, u32>,
+
+    /// Current line, starting at 0
+    pub line: u32
 }
 
 impl Program {

src/main.rs

@@ -7,6 +7,10 @@
 use std::{fs::File, io::Read, path::PathBuf};
 
 use clap::{Parser, Subcommand};
+use color_eyre::{
+    Section, SectionExt,
+    owo_colors::{AnsiColors, OwoColorize},
+};
 use env_logger::{Builder, Env};
 
 use crate::{emitter::Program, parser::document, tokeniser::lex};
@@ -71,9 +75,27 @@ fn main() -> color_eyre::Result<()> {
             // add extra newline in case file doesn't have its own
             string += "\n";
 
+            let lines: Vec<String> = string.lines().map(|x| x.into()).collect();
+
             let mut tokens = lex(string.as_str());
             let mut prog = Program::default();
-            document(&mut tokens, &mut prog, relaxed)?;
+            let result = document(&mut tokens, &mut prog, relaxed);
+
+            match result {
+                Ok(_) => {}
+                Err(error) => {
+                    let index = prog.line;
+                    let line = match lines.get::<usize>(index as usize) {
+                        Some(l) => l,
+                        None => "error fetching context",
+                    };
+                    // TODO if we're not in --relaxed mode, suggest running --relaxed
+                    return Err(error.with_section(move || {
+                        format!("{} | {}", index, line)
+                            .header("Assembly context:".color(AnsiColors::Green))
+                    }));
+                }
+            }
         }
         Commands::Version {} => {
             println!(

src/parser.rs

@@ -490,16 +490,35 @@ pub fn document(
             prog.flush()?;
             // skip newline
             lexer.next();
+            prog.line += 1;
             continue;
         }
 
         // first try match a define
         // if a line starts with an ident, we assume they're trying to write a define
         if tok.is_ident() {
             lexer.next();
+
+            // in relaxed mode, they might have intended it to be a label
+            if relaxed && token(lexer)? != T::Equals {
+                // TODO we should actually check this is valid to do right
+                debug!("Trying to recover ident -> label in relaxed mode");
+                match tok {
+                    T::Ident(lab) => {
+                        prog.add_label(lab);
+                    }
+                    _ => {
+                        panic!("Internal error: Should have been an ident!");
+                    }
+                }
+                continue;
+            }
+
+            // normal non-relaxed mode
             // should be X = Y; check eq
             expect(&T::Equals, lexer)?;
             let num = num(lexer)?;
+            // TODO handle this
             continue;
         }