feat(parser): Parse bit ops

shiika-lang · Nov 17, 2019 · 3bda8b6 · 3bda8b6
1 parent 37c44e1
commit 3bda8b6
Show file tree

Hide file tree

Showing 3 changed files with 48 additions and 14 deletions.
diff --git a/src/parser/expression_parser.rs b/src/parser/expression_parser.rs
@@ -303,13 +303,7 @@ impl<'a> Parser<'a> {
 
     fn parse_relational_expr(&mut self) -> Result<AstExpression, Error> {
         self.lv += 1; self.debug_log("parse_relational_expr");
-        //TODO:
-        //  parse_relational_expr
-        //  parse_bitwise_or
-        //  parse_bitwise_and
-        //  parse_bitwise_shift
-        //  parse_additive_expr
-        let mut expr = self.parse_additive_expr()?; // additive (> >= < <=) additive
+        let mut expr = self.parse_bitwise_or()?; // additive (> >= < <=) additive
         let mut nesting = false;
         loop {
             let op = match self.next_nonspace_token() {
@@ -322,7 +316,7 @@ impl<'a> Parser<'a> {
             self.skip_ws();
             self.consume_token();
             self.skip_wsn();
-            let right = self.parse_additive_expr()?;
+            let right = self.parse_bitwise_or()?;
 
             if nesting {
                 if let AstExpressionBody::MethodCall { arg_exprs, .. } = &expr.body {
@@ -340,6 +334,32 @@ impl<'a> Parser<'a> {
         Ok(expr)
     }
 
+    fn parse_bitwise_or(&mut self) -> Result<AstExpression, Error> {
+        let mut symbols = HashMap::new();
+        symbols.insert(Token::BitOr, "|");
+        symbols.insert(Token::BitOr, "^");
+        self.parse_binary_operator("parse_bitwise_or",
+                                   Parser::parse_bitwise_and,
+                                   symbols)
+    }
+
+    fn parse_bitwise_and(&mut self) -> Result<AstExpression, Error> {
+        let mut symbols = HashMap::new();
+        symbols.insert(Token::BitAnd, "&");
+        self.parse_binary_operator("parse_bitwise_and",
+                                   Parser::parse_bitwise_shift,
+                                   symbols)
+    }
+
+    fn parse_bitwise_shift(&mut self) -> Result<AstExpression, Error> {
+        let mut symbols = HashMap::new();
+        symbols.insert(Token::BitLShift, "<<");
+        symbols.insert(Token::BitRShift, ">>");
+        self.parse_binary_operator("parse_bitwise_shift",
+                                   Parser::parse_additive_expr,
+                                   symbols)
+    }
+
     fn parse_additive_expr(&mut self) -> Result<AstExpression, Error> {
         let mut symbols = HashMap::new();
         symbols.insert(Token::BinaryPlus, "+");

diff --git a/src/parser/lexer.rs b/src/parser/lexer.rs
@@ -358,6 +358,10 @@ impl<'a> Lexer<'a> {
                     next_cur.proceed(self.src);
                     (Token::LessEq, LexerState::ExprBegin)
                 }
+                else if c2 == Some('<') {
+                    next_cur.proceed(self.src);
+                    (Token::BitLShift, LexerState::ExprBegin)
+                }
                 else {
                     (Token::LessThan, LexerState::ExprBegin)
                 }
@@ -367,6 +371,10 @@ impl<'a> Lexer<'a> {
                     next_cur.proceed(self.src);
                     (Token::GraterEq, LexerState::ExprBegin)
                 }
+                else if c2 == Some('>') {
+                    next_cur.proceed(self.src);
+                    (Token::BitRShift, LexerState::ExprBegin)
+                }
                 else {
                     (Token::GraterThan, LexerState::ExprBegin)
                 }
@@ -391,7 +399,7 @@ impl<'a> Lexer<'a> {
                     (Token::AndAnd, LexerState::ExprBegin)
                 }
                 else {
-                    (Token::And, LexerState::ExprBegin)
+                    (Token::BitAnd, LexerState::ExprBegin)
                 }
             },
             '|' => {
@@ -400,7 +408,7 @@ impl<'a> Lexer<'a> {
                     (Token::OrOr, LexerState::ExprBegin)
                 }
                 else {
-                    (Token::Or, LexerState::ExprBegin)
+                    (Token::BitOr, LexerState::ExprBegin)
                 }
             },
             c => {

diff --git a/src/parser/token.rs b/src/parser/token.rs
@@ -37,10 +37,13 @@ pub enum Token {
     Comma,        //  , 
     Colon,        //  :      
     ColonColon,   //  ::
-    And,          //  &
     AndAnd,       //  &&
-    Or,           //  |
     OrOr,         //  ||
+    BitAnd,       //  &
+    BitOr,        //  |
+    BitXor,       //  ^
+    BitLShift,    //  <<
+    BitRShift,    //  >>
     // Keywords
     KwClass,
     KwEnd,
@@ -106,10 +109,13 @@ impl Token {
             Token::Comma => false,        //  , 
             Token::Colon => true,         //  :      
             Token::ColonColon => true,    //  ::
-            Token::And => true,           //  &
             Token::AndAnd => false,       //  &&
-            Token::Or => false,           //  |
             Token::OrOr => false,         //  ||
+            Token::BitAnd => false,       //  &
+            Token::BitOr => false,        //  |
+            Token::BitXor => false,       //  ^
+            Token::BitLShift => false,    //  <<
+            Token::BitRShift => false,    //  >>
             // Keywords
             Token::KwClass => false,
             Token::KwEnd => false,