Added % operator

Author: cogiton

framec/src/frame_c/ast.rs

@@ -2734,6 +2734,8 @@ pub enum OperatorType {
     LogicalOr,
     LogicalXor,
     Negated,
+    Percent,
+    Unknown,
 }
 
 impl NodeElement for OperatorType {
@@ -2764,7 +2766,8 @@ impl OperatorType {
             TokenType::LogicalAnd => OperatorType::LogicalAnd,
             TokenType::PipePipe => OperatorType::LogicalOr,
             TokenType::LogicalXor => OperatorType::LogicalXor,
-            _ => panic!("Invalid token for operator."),
+            TokenType::Percent => OperatorType::Percent,
+            _ => OperatorType::Unknown,
         }
     }
 }

framec/src/frame_c/parser.rs

@@ -4949,7 +4949,7 @@ impl<'a> Parser<'a> {
         while self.match_token(&[TokenType::BangEqual, TokenType::EqualEqual]) {
             //           let line = self.previous().line;
             let operator_token = self.previous();
-            let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+            let op_type = self.get_operator_type(&operator_token.clone());
             let r_value = match self.comparison() {
                 Ok(Some(expr_type)) => expr_type,
                 Ok(None) => return Ok(None),
@@ -4988,7 +4988,7 @@ impl<'a> Parser<'a> {
             TokenType::LessEqual,
         ]) {
             let operator_token = self.previous();
-            let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+            let op_type = self.get_operator_type(&operator_token.clone());
             let r_value = match self.term() {
                 Ok(Some(expr_type)) => expr_type,
                 Ok(None) => return Ok(None),
@@ -5020,9 +5020,9 @@ impl<'a> Parser<'a> {
             Err(parse_error) => return Err(parse_error),
         };
 
-        while self.match_token(&[TokenType::Dash, TokenType::Plus]) {
+        while self.match_token(&[TokenType::Dash, TokenType::Plus, TokenType::Percent]) {
             let operator_token = self.previous().clone();
-            let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+            let op_type = self.get_operator_type(&operator_token.clone());
             let r_value = match self.factor() {
                 Ok(Some(expr_type)) => expr_type,
                 Ok(None) => {
@@ -5065,7 +5065,7 @@ impl<'a> Parser<'a> {
 
         while self.match_token(&[TokenType::ForwardSlash, TokenType::Star]) {
             let operator_token = self.previous();
-            let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+            let op_type = self.get_operator_type(&operator_token.clone());
             let r_value = match self.logical_xor() {
                 Ok(Some(expr_type)) => expr_type,
                 Ok(None) => return Ok(None),
@@ -5090,7 +5090,7 @@ impl<'a> Parser<'a> {
 
         while self.match_token(&[TokenType::LogicalXor]) {
             let operator_token = self.previous();
-            let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+            let op_type = self.get_operator_type(&operator_token.clone());
             let r_value = match self.logical_or() {
                 Ok(Some(expr_type)) => expr_type,
                 Ok(None) => return Ok(None),
@@ -5124,7 +5124,7 @@ impl<'a> Parser<'a> {
 
         while self.match_token(&[TokenType::PipePipe]) {
             let operator_token = self.previous();
-            let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+            let op_type = self.get_operator_type(&operator_token.clone());
             let r_value = match self.logical_and() {
                 Ok(Some(expr_type)) => expr_type,
                 Ok(None) => return Ok(None),
@@ -5158,7 +5158,7 @@ impl<'a> Parser<'a> {
 
         while self.match_token(&[TokenType::LogicalAnd]) {
             let operator_token = self.previous();
-            let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+            let op_type = self.get_operator_type(&operator_token.clone());
             let r_value = match self.unary_expression() {
                 Ok(Some(expr_type)) => expr_type,
                 Ok(None) => return Ok(None),
@@ -5331,7 +5331,7 @@ impl<'a> Parser<'a> {
     fn unary_expression(&mut self) -> Result<Option<ExprType>, ParseError> {
         if self.match_token(&[TokenType::Bang, TokenType::Dash]) {
             let token = self.previous();
-            let mut operator_type = OperatorType::get_operator_type(&token.token_type);
+            let mut operator_type = self.get_operator_type(&token.clone());
             if operator_type == OperatorType::Minus {
                 // change this so the code gen doesn't have a space between the - and ID
                 // -x rather than - x
@@ -8072,4 +8072,15 @@ impl<'a> Parser<'a> {
             Ok(())
         }
     }
+
+    // ------------------------------------------------------------------ */
+    pub fn get_operator_type(&mut self, operator_token: &Token) -> OperatorType {
+        let op_type = OperatorType::get_operator_type(&operator_token.token_type);
+        if op_type == OperatorType::Unknown {
+            let err_msg = &format!("Unknown operator {}", operator_token.lexeme);
+            self.error_at_current(err_msg);
+        }
+
+        op_type
+    }
 }

framec/src/frame_c/scanner.rs

@@ -388,6 +388,7 @@ impl Scanner {
                     self.add_token(TokenType::Dot);
                 }
             }
+            '%' => self.add_token(TokenType::Percent),
             ',' => self.add_token(TokenType::Comma),
             _ => {
                 if self.is_digit(c) {
@@ -708,6 +709,7 @@ pub enum TokenType {
     GreaterEqual, // >=
     LessEqual,    // <=
     LT,           // <
+    Percent,      // %
     // LTx2,                         // <<
     // LTx3,                         // <<<
     Ampersand,                    // &

framec/src/frame_c/visitors/python_visitor.rs

@@ -5380,6 +5380,8 @@ impl AstVisitor for PythonVisitor {
             OperatorType::LogicalAnd => self.add_code(" and "),
             OperatorType::LogicalOr => self.add_code(" or "),
             OperatorType::LogicalXor => self.add_code(" ^ "),
+            OperatorType::Percent => self.add_code(" % "),
+            OperatorType::Unknown => self.add_code(" <Unknown> "),
         }
     }
 
@@ -5402,6 +5404,8 @@ impl AstVisitor for PythonVisitor {
             OperatorType::LogicalAnd => output.push_str(" and "),
             OperatorType::LogicalOr => output.push_str(" or "),
             OperatorType::LogicalXor => output.push_str(" ^ "),
+            OperatorType::Percent => output.push_str(" % "),
+            OperatorType::Unknown => output.push_str(" <Unknown> "),
         }
     }
 }