From 419781cfb68f7163b901ca76fe08650c9bfe7a50 Mon Sep 17 00:00:00 2001 From: jonathandturner Date: Tue, 1 Mar 2016 09:40:48 -0500 Subject: [PATCH] Fill out support for operators --- src/engine.rs | 263 ++++++++++++++++++++++++++++++++------ src/fn_register.rs | 46 ++++++- src/main.rs | 85 +------------ src/ops.rs | 308 --------------------------------------------- src/parser.rs | 68 ++++++++-- 5 files changed, 331 insertions(+), 439 deletions(-) delete mode 100644 src/ops.rs diff --git a/src/engine.rs b/src/engine.rs index 5e5cfb0e..6308522e 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -6,14 +6,16 @@ use std::fmt; use parser::{lex, parse, Expr, Stmt }; use fn_register::FnRegister; -use ops::{add_boxes, sub_boxes, mult_boxes, div_boxes}; +//use ops::{add_boxes, sub_boxes, mult_boxes, div_boxes}; + +use std::ops::{Add, Sub, Mul, Div}; +use std::cmp::{Ord, Eq}; #[derive(Debug)] pub enum EvalError { FunctionNotFound, FunctionArgMismatch, FunctionCallNotSupported, - TypeMismatchForOperands, IfGuardMismatch, VariableNotFound } @@ -23,8 +25,7 @@ impl Error for EvalError { match *self { EvalError::FunctionNotFound => "Function not found", EvalError::FunctionArgMismatch => "Function argument types do not match", - EvalError::FunctionCallNotSupported => "Function call with > 1 argument not supported", - EvalError::TypeMismatchForOperands => "Operand types incompatible with operator", + EvalError::FunctionCallNotSupported => "Function call with > 2 argument not supported", EvalError::IfGuardMismatch => "If guards expect boolean expression", EvalError::VariableNotFound => "Variable not found", } @@ -41,7 +42,56 @@ impl fmt::Display for EvalError { } } +fn add(x: T, y: T) -> ::Output { + x + y +} + +fn sub(x: T, y: T) -> ::Output { + x - y +} + +fn mul(x: T, y: T) -> ::Output { + x * y +} + +fn div(x: T, y: T) -> ::Output { + x / y +} + +fn lt(x: T, y: T) -> bool { + x < y +} + +fn lte(x: T, y: T) -> bool { + x <= y +} + +fn gt(x: T, y: T) -> bool { + x > y +} + +fn gte(x: T, y: T) -> bool { + x >= y +} + +fn eq(x: T, y: T) -> bool { + x == y +} + +fn ne(x: T, y: T) -> bool { + x != y +} + +fn and(x: bool, y: bool) -> bool { + x && y +} + +fn or(x: bool, y: bool) -> bool { + x || y +} + pub struct Engine { + pub fns_arity_2: HashMap, &mut Box)->Result, EvalError>>>>, pub fns_arity_1: HashMap)->Result, EvalError>>>>, pub fns_arity_0: HashMapResult, EvalError>>>>, pub scope: Vec<(String, Box)> @@ -80,6 +130,22 @@ impl Engine { } } + pub fn call_fn_2_arg(&self, name: &str, arg1: &mut Box, arg2: &mut Box) -> Result, EvalError> { + match self.fns_arity_2.get(name) { + Some(vf) => { + for f in vf { + let invoke = f(arg1, arg2); + match invoke { + Ok(v) => return Ok(v), + _ => () + } + }; + Err(EvalError::FunctionArgMismatch) + } + None => Err(EvalError::FunctionNotFound) + } + } + fn register_type(&mut self) { fn clone_helper(t:T)->T { t.clone() }; @@ -139,30 +205,16 @@ impl Engine { self.call_fn_1_arg(&fn_name, &mut arg) } + else if args.len() == 2 { + let mut arg1 = try!(self.eval_expr(&args[0])); + let mut arg2 = try!(self.eval_expr(&args[1])); + + self.call_fn_2_arg(&fn_name, &mut arg1, &mut arg2) + } else { Err(EvalError::FunctionCallNotSupported) } } - Expr::Plus(ref a, ref b) => { - let arg1 = try!(self.eval_expr(a)); - let arg2 = try!(self.eval_expr(b)); - add_boxes(arg1, arg2) - } - Expr::Minus(ref a, ref b) => { - let arg1 = try!(self.eval_expr(a)); - let arg2 = try!(self.eval_expr(b)); - sub_boxes(arg1, arg2) - } - Expr::Multiply(ref a, ref b) => { - let arg1 = try!(self.eval_expr(a)); - let arg2 = try!(self.eval_expr(b)); - mult_boxes(arg1, arg2) - } - Expr::Divide(ref a, ref b) => { - let arg1 = try!(self.eval_expr(a)); - let arg2 = try!(self.eval_expr(b)); - div_boxes(arg1, arg2) - } Expr::True => { Ok(Box::new(true)) } @@ -254,20 +306,161 @@ impl Engine { } } + pub fn register_default_lib(engine: &mut Engine) { + engine.register_type::(); + engine.register_type::(); + engine.register_type::(); + engine.register_type::(); + engine.register_type::(); + engine.register_type::(); + engine.register_type::(); + engine.register_type::(); + engine.register_type::(); + + macro_rules! reg_op { + ($engine:expr, $x:expr, $op:expr, $( $y:ty ),*) => ( + $( + ($op as fn(x: $y, y: $y)->$y).register($engine, $x); + )* + ) + } + + macro_rules! reg_cmp { + ($engine:expr, $x:expr, $op:expr, $( $y:ty ),*) => ( + $( + ($op as fn(x: $y, y: $y)->bool).register($engine, $x); + )* + ) + } + + reg_op!(engine, "+", add, i32, i64, u32, u64, f32, f64); + reg_op!(engine, "-", sub, i32, i64, u32, u64, f32, f64); + reg_op!(engine, "*", mul, i32, i64, u32, u64, f32, f64); + reg_op!(engine, "/", div, i32, i64, u32, u64, f32, f64); + + reg_cmp!(engine, "<", lt, i32, i64, u32, u64); + reg_cmp!(engine, "<=", lte, i32, i64, u32, u64); + reg_cmp!(engine, ">", gt, i32, i64, u32, u64); + reg_cmp!(engine, ">=", gte, i32, i64, u32, u64); + reg_cmp!(engine, "==", eq, i32, i64, u32, u64); + reg_cmp!(engine, "!=", ne, i32, i64, u32, u64); + + reg_op!(engine, "||", or, bool); + reg_op!(engine, "&&", and, bool); + } + pub fn new() -> Engine { - let mut output = Engine { fns_arity_0: HashMap::new(), fns_arity_1: HashMap::new(), scope: Vec::new() }; + let mut engine = Engine { + fns_arity_0: HashMap::new(), + fns_arity_1: HashMap::new(), + fns_arity_2: HashMap::new(), + scope: Vec::new() + }; - output.register_type::(); - output.register_type::(); - output.register_type::(); - output.register_type::(); - output.register_type::(); - output.register_type::(); - output.register_type::(); - output.register_type::(); - output.register_type::(); + Engine::register_default_lib(&mut engine); - output + engine } } + +#[test] +fn test_number_literal() { + let mut engine = Engine::new(); + + if let Ok(result) = engine.eval("65".to_string()).unwrap().downcast::() { + assert_eq!(*result, 65); + } + else { + assert!(false); + } +} + +#[test] +fn test_addition() { + let mut engine = Engine::new(); + + if let Ok(result) = engine.eval("60 + 5".to_string()).unwrap().downcast::() { + assert_eq!(*result, 65); + } + else { + assert!(false); + } +} + +#[test] +fn test_bool_op() { + let mut engine = Engine::new(); + + if let Ok(result) = engine.eval("true && (false || true)".to_string()).unwrap().downcast::() { + assert_eq!(*result, true); + } + else { + assert!(false); + } + + if let Ok(result) = engine.eval("false && (false || true)".to_string()).unwrap().downcast::() { + assert_eq!(*result, false); + } + else { + assert!(false); + } +} + +#[test] +fn test_op_prec() { + let mut engine = Engine::new(); + + if let Ok(result) = engine.eval("var x = 0; if x == 10 || true { x = 1} x".to_string()).unwrap().downcast::() { + assert_eq!(*result, 1); + } + else { + assert!(false); + } +} + +#[test] +fn test_if() { + let mut engine = Engine::new(); + + if let Ok(result) = engine.eval("if true { 55 }".to_string()).unwrap().downcast::() { + assert_eq!(*result, 55); + } + else { + assert!(false); + } +} + +#[test] +fn test_var_scope() { + let mut engine = Engine::new(); + + if let Ok(_) = engine.eval("var x = 4 + 5".to_string()) { } else { assert!(false); } + + if let Ok(result) = engine.eval("x".to_string()).unwrap().downcast::() { + assert_eq!(*result, 9); + } + else { + assert!(false); + } + + if let Ok(_) = engine.eval("x = x + 1; x = x + 2;".to_string()) { } else { assert!(false); } + + if let Ok(result) = engine.eval("x".to_string()).unwrap().downcast::() { + assert_eq!(*result, 12); + } + else { + assert!(false); + } + + if let Ok(_) = engine.eval("{var x = 3}".to_string()) { } else { assert!(false); } + + if let Ok(result) = engine.eval("x".to_string()).unwrap().downcast::() { + assert_eq!(*result, 12); + } + else { + assert!(false); + } +} + + diff --git a/src/fn_register.rs b/src/fn_register.rs index 4cfcad9c..9f6f8f0e 100644 --- a/src/fn_register.rs +++ b/src/fn_register.rs @@ -7,7 +7,47 @@ pub trait FnRegister { fn register(self, engine: &mut Engine, name: &str); } -impl FnRegister for fn(&mut T)->U { +impl FnRegister for fn(&mut T, U)->V { + fn register(self, engine: &mut Engine, name: &str) { + let wrapped : Box, &mut Box)->Result, EvalError>> = + Box::new( + move |x: &mut Box, y: &mut Box| { + let inside1 = (*x).downcast_mut() as Option<&mut T>; + let inside2 = (*y).downcast_mut() as Option<&mut U>; + + match (inside1, inside2) { + (Some(b), Some(c)) => Ok(Box::new(self(b, c.clone())) as Box), + _ => Err(EvalError::FunctionArgMismatch) + } + } + ); + + let ent = engine.fns_arity_2.entry(name.to_string()).or_insert(Vec::new()); + (*ent).push(wrapped); + } +} + +impl FnRegister for fn(T, U)->V { + fn register(self, engine: &mut Engine, name: &str) { + let wrapped : Box, &mut Box)->Result, EvalError>> = + Box::new( + move |x: &mut Box, y: &mut Box| { + let inside1 = (*x).downcast_mut() as Option<&mut T>; + let inside2 = (*y).downcast_mut() as Option<&mut U>; + + match (inside1, inside2) { + (Some(b), Some(c)) => Ok(Box::new(self(b.clone(), c.clone())) as Box), + _ => Err(EvalError::FunctionArgMismatch) + } + } + ); + + let ent = engine.fns_arity_2.entry(name.to_string()).or_insert(Vec::new()); + (*ent).push(wrapped); + } +} + +impl FnRegister for fn(&mut T)->U { fn register(self, engine: &mut Engine, name: &str) { let wrapped : Box)->Result, EvalError>> = Box::new( @@ -26,7 +66,7 @@ impl FnRegister for fn(&mut T)->U { } } -impl FnRegister for fn(T)->U { +impl FnRegister for fn(T)->U { fn register(self, engine: &mut Engine, name: &str) { let wrapped : Box)->Result, EvalError>> = Box::new( @@ -44,7 +84,7 @@ impl FnRegister for fn(T)->U { } } -impl FnRegister for fn()->T { +impl FnRegister for fn()->T { fn register(self, engine: &mut Engine, name: &str) { let wrapped : BoxResult, EvalError>> = Box::new( diff --git a/src/main.rs b/src/main.rs index 67407853..42339040 100644 --- a/src/main.rs +++ b/src/main.rs @@ -9,8 +9,6 @@ use engine::Engine; mod fn_register; use fn_register::FnRegister; -mod ops; - mod parser; // Todo (in no particular order): @@ -18,8 +16,7 @@ mod parser; // * Doc some examples // * Refactor identifer to not require inlining of clone lookup in engine // * Remove empty box values? -// * Method/dot access -// * Comparison ops +// * Methods /* fn simple_fn(x: i32) -> bool { x == 1 } @@ -90,86 +87,6 @@ fn engine_test() { } */ -#[test] -fn test_number_literal() { - let mut engine = Engine::new(); - - if let Ok(result) = engine.eval("65".to_string()).unwrap().downcast::() { - assert_eq!(*result, 65); - } - else { - assert!(false); - } -} - -#[test] -fn test_addition() { - let mut engine = Engine::new(); - - if let Ok(result) = engine.eval("60 + 5".to_string()).unwrap().downcast::() { - assert_eq!(*result, 65); - } - else { - assert!(false); - } -} - -#[test] -fn test_boolean() { - let mut engine = Engine::new(); - - if let Ok(result) = engine.eval("true".to_string()).unwrap().downcast::() { - assert_eq!(*result, true); - } - else { - assert!(false); - } -} - -#[test] -fn test_if() { - let mut engine = Engine::new(); - - if let Ok(result) = engine.eval("if true { 55 }".to_string()).unwrap().downcast::() { - assert_eq!(*result, 55); - } - else { - assert!(false); - } -} - -#[test] -fn test_var_scope() { - let mut engine = Engine::new(); - - if let Ok(_) = engine.eval("var x = 4 + 5".to_string()) { } else { assert!(false); } - - if let Ok(result) = engine.eval("x".to_string()).unwrap().downcast::() { - assert_eq!(*result, 9); - } - else { - assert!(false); - } - - if let Ok(_) = engine.eval("x = x + 1; x = x + 2;".to_string()) { } else { assert!(false); } - - if let Ok(result) = engine.eval("x".to_string()).unwrap().downcast::() { - assert_eq!(*result, 12); - } - else { - assert!(false); - } - - if let Ok(_) = engine.eval("{var x = 3}".to_string()) { } else { assert!(false); } - - if let Ok(result) = engine.eval("x".to_string()).unwrap().downcast::() { - assert_eq!(*result, 12); - } - else { - assert!(false); - } -} - fn showit(x: &mut T) -> () { println!("{}", x) } diff --git a/src/ops.rs b/src/ops.rs deleted file mode 100644 index 11f95abd..00000000 --- a/src/ops.rs +++ /dev/null @@ -1,308 +0,0 @@ -use std::any::Any; -use std::boxed::Box; - -use engine::{EvalError}; - -pub fn add_boxes(arg1: Box, arg2: Box) -> Result, EvalError> { - match arg1.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 + *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 + *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 + *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 + *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 + *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 + *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(_) => { - return Err(EvalError::TypeMismatchForOperands) - } - } - } - } - } - } - } - } - } - } - } - } -} - -pub fn sub_boxes(arg1: Box, arg2: Box) -> Result, EvalError> { - match arg1.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 - *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 - *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 - *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 - *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 - *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 - *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(_) => { - return Err(EvalError::TypeMismatchForOperands) - } - } - } - } - } - } - } - } - } - } - } - } -} - -pub fn mult_boxes(arg1: Box, arg2: Box) -> Result, EvalError> { - match arg1.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 * *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 * *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 * *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 * *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 * *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 * *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(_) => { - return Err(EvalError::TypeMismatchForOperands) - } - } - } - } - } - } - } - } - } - } - } - } -} - -pub fn div_boxes(arg1: Box, arg2: Box) -> Result, EvalError> { - match arg1.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 / *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 / *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 / *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 / *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 / *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(arg1_again) => { - match arg1_again.downcast::() { - Ok(v1) => { - if let Ok(v2) = arg2.downcast::() { - return Ok(Box::new(*v1 / *v2)) - } - else { - return Err(EvalError::TypeMismatchForOperands) - } - }, - Err(_) => { - return Err(EvalError::TypeMismatchForOperands) - } - } - } - } - } - } - } - } - } - } - } - } -} diff --git a/src/parser.rs b/src/parser.rs index 77f6190e..210ec5e1 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -46,13 +46,12 @@ pub enum Stmt { If(Box, Box), While(Box, Box), Var(Strin Block(Box>), Expr(Box) } #[derive(Debug)] -pub enum Expr { IntConst(i32), Identifier(String), Plus(Box, Box), Minus(Box, Box), - Multiply(Box, Box), Divide(Box, Box), Call(String, Box>), - Assignment(Box, Box), True, False } +pub enum Expr { IntConst(i32), Identifier(String), Call(String, Box>), Assignment(Box, Box), True, False } #[derive(Debug)] pub enum Token { Int(i32), Id(String), LCurly, RCurly, LParen, RParen, LSquare, RSquare, - Plus, Minus, Multiply, Divide, Semicolon, Colon, Comma, Equals, True, False, Var, If, While } + Plus, Minus, Multiply, Divide, Semicolon, Colon, Comma, Equals, True, False, Var, If, While, + LessThan, GreaterThan, Bang, LessThanEqual, GreaterThanEqual, EqualTo, NotEqualTo, Pipe, Or, Ampersand, And } pub struct TokenIterator<'a> { char_stream: Peekable> @@ -128,7 +127,42 @@ impl<'a> Iterator for TokenIterator<'a> { ';' => { return Some(Token::Semicolon); }, ':' => { return Some(Token::Colon); }, ',' => { return Some(Token::Comma); }, - '=' => { return Some(Token::Equals); }, + '=' => { + match self.char_stream.peek() { + Some(&'=') => {self.char_stream.next(); return Some(Token::EqualTo); }, + _ => { return Some(Token::Equals); } + } + }, + '<' => { + match self.char_stream.peek() { + Some(&'=') => {self.char_stream.next(); return Some(Token::LessThanEqual); }, + _ => { return Some(Token::LessThan); } + } + } + '>' => { + match self.char_stream.peek() { + Some(&'=') => {self.char_stream.next(); return Some(Token::GreaterThanEqual); }, + _ => { return Some(Token::GreaterThan); } + } + }, + '!' => { + match self.char_stream.peek() { + Some(&'=') => {self.char_stream.next(); return Some(Token::NotEqualTo); }, + _ => { return Some(Token::Bang); } + } + }, + '|' => { + match self.char_stream.peek() { + Some(&'|') => {self.char_stream.next(); return Some(Token::Or); }, + _ => { return Some(Token::Pipe); } + } + }, + '&' => { + match self.char_stream.peek() { + Some(&'&') => {self.char_stream.next(); return Some(Token::And); }, + _ => { return Some(Token::Ampersand); } + } + }, ' ' | '\n' | '\r' => (), _ => return None } @@ -145,6 +179,14 @@ pub fn lex<'a>(input: &'a String) -> TokenIterator<'a> { fn get_precedence(token: &Token) -> i32 { match *token { Token::Equals => 10, + Token::Or => 11, + Token::And => 12, + Token::LessThan => 15, + Token::LessThanEqual => 15, + Token::GreaterThan => 15, + Token::GreaterThanEqual => 15, + Token::EqualTo => 15, + Token::NotEqualTo => 15, Token::Plus => 20, Token::Minus => 20, Token::Multiply => 40, @@ -238,11 +280,19 @@ fn parse_binop<'a>(input: &mut Peekable>, prec: i32, lhs: Expr } lhs_curr = match op_token { - Token::Plus => Expr::Plus(Box::new(lhs_curr), Box::new(rhs)), - Token::Minus => Expr::Minus(Box::new(lhs_curr), Box::new(rhs)), - Token::Multiply => Expr::Multiply(Box::new(lhs_curr), Box::new(rhs)), - Token::Divide => Expr::Divide(Box::new(lhs_curr), Box::new(rhs)), + Token::Plus => Expr::Call("+".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::Minus => Expr::Call("-".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::Multiply => Expr::Call("*".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::Divide => Expr::Call("/".to_string(), Box::new(vec![lhs_curr, rhs])), Token::Equals => Expr::Assignment(Box::new(lhs_curr), Box::new(rhs)), + Token::EqualTo => Expr::Call("==".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::NotEqualTo => Expr::Call("!=".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::LessThan => Expr::Call("<".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::LessThanEqual => Expr::Call("<=".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::GreaterThan => Expr::Call(">".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::GreaterThanEqual => Expr::Call(">=".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::Or => Expr::Call("||".to_string(), Box::new(vec![lhs_curr, rhs])), + Token::And => Expr::Call("&&".to_string(), Box::new(vec![lhs_curr, rhs])), _ => return Err(ParseError::UnknownOperator) }; }