Ajout des If, des opérateurs logiques et des boucles While

src/parser.rs

@@ -1,8 +1,9 @@
-use crate::expr::{Assign, Binary, Expr, Grouping, Unary, Variable};
+use crate::expr::{Assign, Binary, Expr, Grouping, Unary, Variable, Logical};
+use crate::expr::Expr::LogicalExpr;
 use crate::expr::Literal::{LiteralBool, LiteralNumber, LiteralString};
 use crate::token::Token;
 use crate::token_type::TokenType;
-use crate::stmt::{BlockStatement, ExpressionStatement, PrintStatement, Statement, VarStatement};
+use crate::stmt::{BlockStatement, ExpressionStatement, PrintStatement, Statement, VarStatement, IfStatement, WhileStatement};
 
 pub struct Parser {
     tokens: Vec<Token>,
@@ -96,8 +97,40 @@ impl Parser {
         self.assignment()
     }
 
+    fn or(&mut self) -> Result<Expr, ParseError> {
+        let mut expr = self.and()?;
+
+        while self.match_token(&[TokenType::Or]) {
+            let operator = self.previous();
+            let right = self.and()?;
+            expr = Expr::LogicalExpr(Logical{
+                left: Box::new(expr),
+                operator,
+                right: Box::new(right)
+            });
+        }
+
+        Ok(expr)
+    }
+
+    fn and(&mut self) -> Result<Expr, ParseError> {
+        let mut expr = self.equality()?;
+
+        while self.match_token(&[TokenType::And]) {
+            let operator = self.previous();
+            let right = self.equality()?;
+            expr = Expr::LogicalExpr(Logical{
+                left: Box::new(expr),
+                operator,
+                right: Box::new(right)
+            });
+        }
+
+        Ok(expr)
+    }
+
     fn assignment(&mut self) -> Result<Expr, ParseError> {
-        let expr = self.equality()?;
+        let expr = self.or()?;
 
         if self.match_token(&[TokenType::Equal]) {
             let value = Box::new(self.assignment()?);       // l'assignation a une associativité par la droite
@@ -126,7 +159,7 @@ impl Parser {
             });
         }
 
-        return Ok(expr);
+        Ok(expr)
     }
 
     fn comparison(&mut self) -> Result<Expr, ParseError> {
@@ -224,10 +257,18 @@ impl Parser {
     }
 
     fn statement(&mut self) -> Result<Statement, ParseError> {
+        if self.match_token(&[TokenType::If]) {
+            return self.if_statement();
+        }
+
         if self.match_token(&[TokenType::Print]) {
             return self.print_statement();
         }
 
+        if self.match_token(&[TokenType::While]) {
+            return self.while_statement();
+        }
+
         if self.match_token(&[TokenType::LeftBrace]) {
             return self.block_statement();
         }
@@ -257,6 +298,28 @@ impl Parser {
         }
     }
 
+    fn while_statement(&mut self) -> Result<Statement, ParseError> {
+        self.consume(&TokenType::LeftParen, String::from("( attendu"))?;
+        let condition = self.expression()?;
+        self.consume(&TokenType::RightParen, String::from(") attendu"))?;
+        let body = self.statement()?;
+
+        Ok(Statement::While(WhileStatement{ condition, body: Box::new(body) }))
+    }
+
+    fn if_statement(&mut self) -> Result<Statement, ParseError> {
+        self.consume(&TokenType::LeftParen, String::from("( attendu"))?;
+        let expr = self.expression()?;
+        self.consume(&TokenType::RightParen, String::from(") attendu"))?;
+        let then_stmt = self.statement()?;
+        if self.match_token(&[TokenType::Else]) {
+            let else_stmt = self.statement()?;
+            Ok(Statement::If(IfStatement{ expr, statement_then: Box::new(then_stmt), statement_else: Some(Box::new(else_stmt))}))
+        } else {
+            Ok(Statement::If(IfStatement{ expr, statement_then: Box::new(then_stmt), statement_else: None}))
+        }
+    }
+
     fn expr_statement(&mut self) -> Result<Statement, ParseError> {
         match self.expression() {
             Ok(e) => {