From e291ccb936429d3fc3b021ce56c4f9b8b72e75d2 Mon Sep 17 00:00:00 2001
From: ghostlyzsh <pokeball.181818@gmail.com>
Date: Thu, 1 Aug 2024 01:55:56 -0500
Subject: [PATCH] logical or and logical and

---
 kabel/grammar.ebnf  |  2 +-
 kabel/src/lexer.rs  | 24 ++++++++++++++++++++++++
 kabel/src/parser.rs | 40 +++++++++++++++++++++++++++++++++++++++-
 3 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/kabel/grammar.ebnf b/kabel/grammar.ebnf
index 7997b6c4dc4d09ba2455fee2632fba5b8a92041b..dcee8e1dadee005aa99e14ae96dc043da4a06618 100644
--- a/kabel/grammar.ebnf
+++ b/kabel/grammar.ebnf
@@ -14,11 +14,11 @@ declaration = "var" , identifier , "=" , expression ;
 
 assignment = { identifier , "=" , } logical_or ;
 
+(* implemented *)
 logical_or = logical_and { , "||" , logical_and } ;
 
 logical_and = equality { , "&&" , equality } ;
 
-(* implemented *)
 equality = comparison { , ( "==" | "!=" ) , comparison } ;
 
 comparison = term { , ( ">" | "<" | ">=" | "<=" ) , term } ;
diff --git a/kabel/src/lexer.rs b/kabel/src/lexer.rs
index 69d1bbf98e571cf19a7981a4a4aaea4f45f7c157..4cdc4ee0528c33f6c408b47676f2eac4e2b1ed6b 100644
--- a/kabel/src/lexer.rs
+++ b/kabel/src/lexer.rs
@@ -59,6 +59,26 @@ impl Lexer {
                 self.output.push(token!(self, TokenType::RightParen));
                 self.start = self.current;
             }
+            b'|' => {
+                if self.peek() == b'|' {
+                    self.read_char();
+                    self.output.push(token!(self, TokenType::OrOr));
+                    self.start = self.current;
+                } else {
+                    self.output.push(token!(self, TokenType::Or));
+                    self.start = self.current;
+                }
+            }
+            b'&' => {
+                if self.peek() == b'&' {
+                    self.read_char();
+                    self.output.push(token!(self, TokenType::AndAnd));
+                    self.start = self.current;
+                } else {
+                    self.output.push(token!(self, TokenType::And));
+                    self.start = self.current;
+                }
+            }
             b'=' => {
                 if self.peek() == b'=' {
                     self.read_char();
@@ -214,6 +234,10 @@ pub enum TokenType {
     GreaterEqual,
     Less,
     LessEqual,
+    And,
+    AndAnd,
+    Or,
+    OrOr,
 
     Ident(String),
     Str(String),
diff --git a/kabel/src/parser.rs b/kabel/src/parser.rs
index e509643df9bbc299d2b3c0c0669b854a890d7f1b..e2d21fcf0a81dc06bc003bdfae5ab032ec89863f 100644
--- a/kabel/src/parser.rs
+++ b/kabel/src/parser.rs
@@ -45,10 +45,46 @@ impl Parser {
     }
 
     pub fn expression(&mut self) -> Result<AST, KabelError> {
-        let equality = self.equality()?;
+        let equality = self.logical_or()?;
         Ok(equality)
     }
 
+    pub fn logical_or(&mut self) -> Result<AST, KabelError> {
+        let mut left = self.logical_and()?;
+
+        while self.current < self.input.len()
+            && self.peek()?.token_type == TokenType::OrOr {
+            self.read_token()?;
+            let right = self.logical_and()?;
+            left = AST {
+                ast_type: ASTType::Binary(Box::new(left.clone()), BinOp::Or, Box::new(right.clone())),
+                start: left.start,
+                end: right.end,
+                line: left.line,
+                column: left.column,
+            };
+        }
+
+        Ok(left)
+    }
+    pub fn logical_and(&mut self) -> Result<AST, KabelError> {
+        let mut left = self.equality()?;
+
+        while self.current < self.input.len()
+            && self.peek()?.token_type == TokenType::AndAnd {
+            self.read_token()?;
+            let right = self.equality()?;
+            left = AST {
+                ast_type: ASTType::Binary(Box::new(left.clone()), BinOp::And, Box::new(right.clone())),
+                start: left.start,
+                end: right.end,
+                line: left.line,
+                column: left.column,
+            };
+        }
+
+        Ok(left)
+    }
     pub fn equality(&mut self) -> Result<AST, KabelError> {
         let mut left = self.comparison()?;
 
@@ -400,6 +436,8 @@ pub enum BinOp {
     Ge,
     Ls,
     Le,
+    Or,
+    And,
 }
 
 #[derive(Debug, Clone, Copy)]