Updated parser

src/main.rs

@@ -2,6 +2,7 @@ use std::io;
 use std::io::Write;
 //use std::io::Read;
 use std::sync::Arc;
+use std::collections::VecDeque;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use termcolor::{
@@ -59,6 +60,75 @@ fn prompt(
 	Ok(())
 }
 
+
+fn treefold(
+	mut exp: tokenize::Token, // Must be a group
+	check: fn(&tokenize::Token) -> bool,
+	op_type: u8,
+	new_token: fn(VecDeque<tokenize::Token>) -> tokenize::Token,
+) -> Result<tokenize::Token, ()> {
+
+	// Groups to process
+	let mut t_vec: VecDeque<&mut tokenize::Token> = VecDeque::with_capacity(32);
+	t_vec.push_back(&mut exp);
+
+	let mut out: Option<tokenize::Token> = None;
+
+	while t_vec.len() > 0 {
+
+		// The group we're currently working with
+		let g: &mut tokenize::Token = t_vec.pop_front().unwrap();
+		let g_inner: &mut VecDeque<tokenize::Token> = match g {
+			tokenize::Token::Group(ref mut x) => x,
+			_ => panic!()
+		};
+
+		let mut new: VecDeque<tokenize::Token> = VecDeque::with_capacity(8);
+
+		// Build new group array
+		while g_inner.len() > 0 {
+			let t: tokenize::Token = match g_inner.pop_front() {
+				Some(o) => o,
+				None => break
+			};
+
+			if check(&t) {
+				match op_type {
+					0 => {},
+					1 => {},
+					2 => {
+						let last: tokenize::Token = new.pop_back().unwrap();
+						let next: tokenize::Token = g_inner.pop_front().unwrap().clone();
+
+						let mut new_token_args: VecDeque<tokenize::Token> = VecDeque::with_capacity(2);
+						new_token_args.push_back(last);
+						new_token_args.push_back(next);
+						new.push_back(new_token(new_token_args));
+					},
+					_ => panic!()
+				};
+			} else {
+				new.push_back(t.clone());
+			}
+		}
+
+		*g_inner = new;
+	}
+	return Ok(exp);
+}
+
+
+fn is_mult(t: &tokenize::Token) -> bool {
+	match t {
+		tokenize::Token::Operator(s) => {s == "*"},
+		_ => false
+	}
+}
+
+fn new_mult(v: VecDeque<tokenize::Token>) -> tokenize::Token {
+	tokenize::Token::Mult(v)
+}
+
 fn main() -> Result<(), std::io::Error> {
 
 	let mut stdout = StandardStream::stdout(ColorChoice::Always);
@@ -78,7 +148,7 @@ fn main() -> Result<(), std::io::Error> {
 
 		// Tokenize input.
 		// Fail if we encounter invalid characters.
-		let tokens = match tokenize::tokenize(&input) {
+		let exp = match tokenize::tokenize(&input) {
 			Ok(v) => v,
 			Err(_) => {
 				continue;
@@ -91,8 +161,67 @@ fn main() -> Result<(), std::io::Error> {
 		stdout.reset()?;
 		write!(stdout, "Got {input}\n\n\n")?;
 
-		writeln!(stdout, "Tokenized: {tokens:#?}")?;
+		//writeln!(stdout, "Tokenized: {exp:#?}")?;
 
+
+		let q = treefold(
+			exp,
+			is_mult,
+			2,
+			new_mult
+		);
+		writeln!(stdout, "{q:#?}")?;
+
+
+		/*
+		// Groups to process
+		let mut t_vec: VecDeque<tokenize::Token> = VecDeque::with_capacity(32);
+		t_vec.push_back(exp);
+		
+		while t_vec.len() > 0 {
+			let g: tokenize::Token = t_vec.pop_front().unwrap();
+			let mut g_inner: Vec<tokenize::Token> = match g {
+				tokenize::Token::Group(x) => x,
+				_ => panic!()
+			};
+
+			let mut new: Vec<tokenize::Token> = Vec::with_capacity(8);
+
+			// Parse binary operators
+			for o in ["*", "/", "+", "-"] {
+				let mut i = g_inner.iter();
+				loop {
+					let t = match i.next() {
+						Some(o) => o,
+						None => break
+					};
+		
+					match t {
+						tokenize::Token::Operator(s) => {
+							if s == o {
+								let last = new.pop().unwrap();
+								let next = i.next().unwrap();
+	
+								new.push(tokenize::Token::Op(
+									String::from(s),
+									Box::new(last.clone()),
+									Box::new(next.clone())
+								))
+							} else {
+								new.push(t.clone());
+							}
+						},
+						_ => {
+							new.push(t.clone());
+						}
+					}
+				}
+				g_inner = new.clone();
+				new = Vec::with_capacity(8);
+			}
+			writeln!(stdout, "{:?}", g_inner)?;
+		}
+		*/
 	}
 
 	writeln!(stdout, "Exiting.")?;