And Or expressions

2 files changed, 37 insertions, 1 deletions

diff --git a/src/parse/ast/nodes.rs b/src/parse/ast/nodes.rs
index bffaea3..2bf3f17 100644
--- a/src/parse/ast/nodes.rs
+++ b/src/parse/ast/nodes.rs
@@ -14,6 +14,8 @@ pub enum BinaryOperator {
     Gte,
     Lt,
     Lte,
+    And,
+    Or,
     Assign,
     ConstAssign,
     Dot,
@@ -32,6 +34,8 @@ impl BinaryOperator {
             OpGt => Self::Gt,
             OpLte => Self::Lte,
             OpGte => Self::Gte,
+            OpAnd => Self::And,
+            OpOr => Self::Or,
             Assign => Self::Assign,
             ConstAssign => Self::ConstAssign,
             Dot => Self::Dot,
diff --git a/src/parse/parser.rs b/src/parse/parser.rs
index a882f35..6b0a785 100644
--- a/src/parse/parser.rs
+++ b/src/parse/parser.rs
@@ -87,7 +87,7 @@ impl<T: Iterator<Item = Token>> Parser<T> {
 
     fn assignment_expression(&mut self) -> Result<Expression> {
         // Parse any expressions as l-values for now.
-        let left = self.equality_expression()?;
+        let left = self.or_expression()?;
 
         if let Some(op) = consume_if!(self, Assign | ConstAssign) {
             let right = self.assignment_expression()?;
@@ -102,6 +102,38 @@ impl<T: Iterator<Item = Token>> Parser<T> {
         }
     }
 
+    fn or_expression(&mut self) -> Result<Expression> {
+        let mut left = self.and_expression()?;
+
+        while let Some(op) = consume_if!(self, OpAnd) {
+            let right = self.and_expression()?;
+
+            left = Expression::Binary {
+                left: Box::new(left),
+                op: BinaryOperator::from_token(op),
+                right: Box::new(right),
+            };
+        }
+
+        Ok(left)
+    }
+
+    fn and_expression(&mut self) -> Result<Expression> {
+        let mut left = self.equality_expression()?;
+
+        while let Some(op) = consume_if!(self, OpOr) {
+            let right = self.equality_expression()?;
+
+            left = Expression::Binary {
+                left: Box::new(left),
+                op: BinaryOperator::from_token(op),
+                right: Box::new(right),
+            };
+        }
+
+        Ok(left)
+    }
+
     fn equality_expression(&mut self) -> Result<Expression> {
         let mut left = self.comparison_expression()?;