Fix improper handling of Loc on newline

src/env.rs

@@ -192,7 +192,7 @@ impl Env {
                         }
                         _ => unimplemented!(),
                     })?;
-            Ok(u32::from_str_radix(&with(i, imm, regs).0.to_string(), 2).unwrap())
+            Ok(u32::from_str_radix(dbg!(&with(i, imm, regs).0.to_string()), 2).unwrap())
         } else {
             unreachable!()
         }

src/instructions.rs

@@ -111,7 +111,7 @@ pub mod kind {
     impl Display for Pseudo {
         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
             // (pseudo) padded on either side with - to make it 32 characters
-            write!(f, "{:-^32}", "(pseudo)")
+            write!(f, "{:0^32}", 0)
         }
     }
     impl Display for R {
@@ -253,7 +253,10 @@ pub fn instruction(op: &str) -> (Kind, Vec<Arg>) {
         "nop" => (Kind::Pseudo(Pseudo {}), vec![]),
 
         // Move
-        "li" => (Kind::Pseudo(Pseudo {}), vec![Arg::Register(0), Arg::Immediate]),
+        "li" => (
+            Kind::Pseudo(Pseudo {}),
+            vec![Arg::Register(0), Arg::Immediate],
+        ),
         "lui" => (
             Kind::U(U {
                 imm: to_bits(0),

src/parser.rs

@@ -1,7 +1,6 @@
 /// TODO: Strings, Symbols
 use crate::{env::Env, err::SyntaxErr};
 use itertools::Itertools;
-use rayon::prelude::*;
 
 #[derive(Debug, Clone)]
 pub enum Token {
@@ -57,14 +56,12 @@ pub struct Loc {
     pub end: usize,
 }
 
-fn parse_line(env: &Env, input: &str, line: usize, loc: &mut Loc) -> Result<Vec<(Token, Loc)>, ParseErr> {
+fn parse_line(env: &Env, input: &str, loc: &mut Loc) -> Result<Vec<(Token, Loc)>, ParseErr> {
     let mut tokens: Vec<(Token, Loc)> = Vec::new();
     let mut chars = input.chars().peekable();
 
     use Token::*;
 
-    loc.line = line;
-
     while let Some(c) = chars.next() {
         let token = match c {
             '\t' | ' ' => Spacing,
@@ -89,7 +86,7 @@ fn parse_line(env: &Env, input: &str, line: usize, loc: &mut Loc) -> Result<Vec<
                     return Err((
                         SyntaxErr::UnexpectedChar,
                         Loc {
-                            line,
+                            line: loc.line,
                             start: loc.end + 1,
                             end: loc.end + 1,
                         },
@@ -103,7 +100,7 @@ fn parse_line(env: &Env, input: &str, line: usize, loc: &mut Loc) -> Result<Vec<
                 while let Some('0'..='9') = chars.peek() {
                     num.push(chars.next().unwrap());
                 }
-                Immediate(num.parse().unwrap())
+                Immediate(num.parse::<i32>().unwrap() as u32)
             }
             '(' => {
                 let start = loc.start + 2;
@@ -134,7 +131,11 @@ fn parse_line(env: &Env, input: &str, line: usize, loc: &mut Loc) -> Result<Vec<
                 if !env.is_valid_register(reg) {
                     return Err((
                         SyntaxErr::MemoryInvalidRegister,
-                        Loc { line, start, end },
+                        Loc {
+                            line: loc.line,
+                            start,
+                            end,
+                        },
                         tokens.clone(),
                         None,
                     ));
@@ -185,10 +186,13 @@ fn parse_line(env: &Env, input: &str, line: usize, loc: &mut Loc) -> Result<Vec<
             _ => return Err((SyntaxErr::UnexpectedChar, loc.clone(), tokens.clone(), None)),
         };
         tokens.push((token, loc.clone()));
-        loc.end += 1; // Newline
+        loc.end += 1;
         loc.start = loc.end;
     }
 
+    loc.end += 1; // Newline
+    loc.start = loc.end;
+
     let tokens = tokens
         .into_iter()
         .filter(|(token, _)| !matches!(token, Token::Spacing))
@@ -261,14 +265,16 @@ pub fn parse(env: &Env, input: &str) -> Result<Vec<(Token, Loc)>, Vec<ParseErr>>
     let parsed_lines = input
         .lines()
         .enumerate()
-        .map(|(i, line)| parse_line(env, line, i + 1, &mut loc))
+        .map(|(i, line)| {
+            loc.line = i + 1;
+            parse_line(env, line, &mut loc)
+        })
         .collect::<Vec<_>>();
 
-    let (ok, err): (Vec<_>, Vec<_>) = parsed_lines.into_iter()
+    let (ok, err): (Vec<_>, Vec<_>) = parsed_lines
+        .into_iter()
         .partition(|line| matches!(line, Ok(_)));
 
-    dbg!(err.clone());
-
     if err.is_empty() {
         Ok(ok.into_iter().flat_map(|line| line.unwrap()).collect())
     } else {

test.s

@@ -1,4 +1,9 @@
-a:
-    a0 addi a0 zero 1
-    addi a1 zero 2
-    a0 add a2 a1 a0
+    li a0 5
+    li a1 1
+
+factorial:
+    beqz a0 end
+    mul a1 a1 a0
+    addi a0 a0 -1
+    bneqz factorial
+end: