refactor: reordered conditionals and removed public functions now parser is a librarytui

2 files changed, 27 insertions, 18 deletions

diff --git a/lmc-parser/src/lib.rs b/lmc-parser/src/lib.rs
index 7e72261..c7f8338 100644
--- a/lmc-parser/src/lib.rs
+++ b/lmc-parser/src/lib.rs
@@ -77,13 +77,13 @@ fn tokenise(lines: Vec<&str>) -> Vec<Token> {
             match word.to_uppercase().as_str() {
                 "LDA" => tokens.push(Token::Mnemonic(Mnemonic::Load)),
                 "STA" => tokens.push(Token::Mnemonic(Mnemonic::Save)),
-                "HLT" => tokens.push(Token::Mnemonic(Mnemonic::Halt)),
                 "ADD" => tokens.push(Token::Mnemonic(Mnemonic::Add)),
                 "SUB" => tokens.push(Token::Mnemonic(Mnemonic::Subtract)),
                 "DAT" => tokens.push(Token::Mnemonic(Mnemonic::Dat)),
                 "BRP" => tokens.push(Token::Mnemonic(Mnemonic::BranchPositive)),
                 "BRZ" => tokens.push(Token::Mnemonic(Mnemonic::BranchZero)),
                 "BRA" => tokens.push(Token::Mnemonic(Mnemonic::BranchAlways)),
+                "HLT" => tokens.push(Token::Mnemonic(Mnemonic::Halt)),
                 "INP" => tokens.push(Token::Mnemonic(Mnemonic::Input)),
                 "OUT" => tokens.push(Token::Mnemonic(Mnemonic::Output)),
                 "" => (),
@@ -133,14 +133,14 @@ fn syntax_analysis(tokens: &Vec<Token>) -> Result<(), ()> {
     for i in 0..tokens.len() {
         match &tokens[i] {
             Token::Mnemonic(mnemonic) => match mnemonic {
-                Mnemonic::Add
+                Mnemonic::Load
+                | Mnemonic::Save
+                | Mnemonic::Add
                 | Mnemonic::Subtract
-                | Mnemonic::BranchAlways
+                | Mnemonic::Dat
                 | Mnemonic::BranchPositive
                 | Mnemonic::BranchZero
-                | Mnemonic::Load
-                | Mnemonic::Save
-                | Mnemonic::Dat => {
+                | Mnemonic::BranchAlways => {
                     if i + 1 < tokens.len() {
                         match tokens[i + 1] {
                             Token::Parameter(_) => (),
@@ -157,14 +157,6 @@ fn syntax_analysis(tokens: &Vec<Token>) -> Result<(), ()> {
                     }
                 }
             },
-            Token::Label(_) => {
-                if i + 1 < tokens.len() {
-                    match tokens[i + 1] {
-                        Token::Mnemonic(_) => (),
-                        _ => return Err(()),
-                    }
-                }
-            }
             Token::Parameter(param) => {
                 match param {
                     Parameter::Label(label) => {
@@ -182,6 +174,14 @@ fn syntax_analysis(tokens: &Vec<Token>) -> Result<(), ()> {
                     }
                 }
             }
+            Token::Label(_) => {
+                if i + 1 < tokens.len() {
+                    match tokens[i + 1] {
+                        Token::Mnemonic(_) => (),
+                        _ => return Err(()),
+                    }
+                }
+            }
             Token::LineBreak => {
                 if i + 1 < tokens.len() {
                     match tokens[i + 1] {
@@ -232,9 +232,9 @@ fn translate_to_instructions(tokens: &Vec<Token>) -> Vec<Instruction> {
                 Mnemonic::Add => Instruction::Add(parameter),
                 Mnemonic::Subtract => Instruction::Subtract(parameter),
                 Mnemonic::Dat => Instruction::Dat(parameter),
-                Mnemonic::BranchAlways => Instruction::BranchAlways(parameter),
                 Mnemonic::BranchPositive => Instruction::BranchPositive(parameter),
                 Mnemonic::BranchZero => Instruction::BranchZero(parameter),
+                Mnemonic::BranchAlways => Instruction::BranchAlways(parameter),
                 Mnemonic::Halt => Instruction::Halt,
                 Mnemonic::Input => Instruction::Input,
                 Mnemonic::Output => Instruction::Output,
@@ -246,7 +246,7 @@ fn translate_to_instructions(tokens: &Vec<Token>) -> Vec<Instruction> {
     instructions
 }
 
-pub fn is_number(s: &str) -> bool {
+fn is_number(s: &str) -> bool {
     for c in s.chars() {
         if !c.is_numeric() {
             return false;
@@ -267,9 +267,9 @@ pub fn return_opcodes(instructions: &Vec<Instruction>) -> Vec<String> {
             Instruction::Add(param) => format!("ADD {:02}", param),
             Instruction::Subtract(param) => format!("SUB {:02}", param),
             Instruction::Dat(param) => format!("DAT {:02}", param),
-            Instruction::BranchAlways(param) => format!("BRA {:02}", param),
             Instruction::BranchPositive(param) => format!("BRP {:02}", param),
             Instruction::BranchZero(param) => format!("BRZ {:02}", param),
+            Instruction::BranchAlways(param) => format!("BRA {:02}", param),
             Instruction::Halt => "HLT".to_string(),
             Instruction::Input => "INP".to_string(),
             Instruction::Output => "OUT".to_string(),
diff --git a/src/app.rs b/src/app.rs
index c198a79..df99dba 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -2,7 +2,7 @@ use std::fs::read_to_string;
 use std::io;

 use std::time::{Duration, Instant};

 

-use lmc_parser::{Instruction, is_number};

+use lmc_parser::Instruction;

 

 use lmc_parser::{parse_string, return_opcodes};

 use ratatui::{

@@ -272,3 +272,12 @@ impl App {
         self.exit = true;

     }

 }

+

+fn is_number(s: &str) -> bool {

+    for c in s.chars() {

+        if !c.is_numeric() {

+            return false;

+        }

+    }

+    true

+}