src/assembler.rs

@@ -1,5 +0,0 @@
-use std::collections::HashMap;
-
-fn parse_label(line: String, line_i: i64) {
-    
-}

src/ast.rs

@@ -39,11 +39,24 @@ pub enum BinOp {
     Minus,
 }
 
+#[derive(Debug, Clone)]
+pub enum ValueNode {
+    Literal(Literal),
+    Operator(Operator),
+    Variable(String),
+}
+
 #[derive(Debug, Clone)]
 pub enum Literal {
     Int(i64),
 }
 
+#[derive(Debug, Clone)]
+pub enum Operator {
+    Add(Box<ValueNode>, Box<ValueNode>),
+    Sub(Box<ValueNode>, Box<ValueNode>),
+}
+
 #[derive(Debug, Clone)]
 pub struct AssemblerState {
     pub functions: HashMap<String, Function>,
@@ -454,7 +467,7 @@ C-OUT   RAM-IN        0xFF ; Store address after jump in ram
 }
 
 impl Node for Unary {
-    fn to_assembly(&self, _state: &mut AssemblerState) -> String {
+    fn to_assembly(&self, state: &mut AssemblerState) -> String {
         todo!()
     }
 }

src/main.rs

@@ -1,6 +1,5 @@
 mod ast;
 mod parse;
-mod assembler;
 mod tokeniser;
 
 fn main() {

src/parse.rs

@@ -1,7 +1,71 @@
+use std::collections::{HashMap, HashSet};
+
 use crate::ast::*;
 use crate::tokeniser::Keyword;
 use crate::tokeniser::Token;
 
+fn parse_math(tokens: &Vec<Token>) -> ValueNode {
+    let mut prioritizing_order: HashMap<i64, HashSet<Token>> = HashMap::new();
+    prioritizing_order.insert(0, HashSet::from([Token::Plus, Token::Minus]));
+
+    let mut ordered_binops: Vec<Token> = Vec::new();
+    let mut ordered_binops_indexes: Vec<usize> = Vec::new();
+
+    if tokens.len() == 1 {
+        return match &tokens[0] {
+            Token::Number(n) => ValueNode::Literal(Literal::Int(n.parse::<i64>().unwrap())),
+            Token::Identifier(identifier) => ValueNode::Variable(identifier.to_owned()),
+            _ => todo!(),
+        };
+    }
+
+    for j in prioritizing_order.keys() {
+        let mut i = 0;
+        let current_order_binops = prioritizing_order.get(j).unwrap();
+
+        while i < tokens.len() {
+            for binop in current_order_binops {
+                if &tokens[i] == binop {
+                    ordered_binops.push(binop.to_owned());
+                    ordered_binops_indexes.push(i);
+                }
+            }
+
+            i += 1;
+        }
+    }
+
+    let binop = ordered_binops.pop().unwrap();
+    let binop_index = ordered_binops_indexes.pop().unwrap();
+
+    let mut a: Vec<Token> = Vec::new();
+    let mut b: Vec<Token> = Vec::new();
+
+    let mut i = 0;
+    while i < tokens.len() {
+        if i < binop_index {
+            a.push(tokens[i].clone());
+        }
+        if i > binop_index {
+            b.push(tokens[i].clone());
+        }
+
+        i += 1;
+    }
+
+    return match binop {
+        Token::Plus => ValueNode::Operator(Operator::Add(
+            Box::new(parse_math(&a)),
+            Box::new(parse_math(&b)),
+        )),
+        Token::Minus => ValueNode::Operator(Operator::Sub(
+            Box::new(parse_math(&a)),
+            Box::new(parse_math(&b)),
+        )),
+        _ => todo!(),
+    };
+}
+
 fn parse_basic(tokens: &Vec<Token>, i: &mut usize) -> Expression {
     let literal = match &tokens[*i] {
         Token::Identifier(identifier) => Expression::Variable(identifier.to_owned()),