Chapter 9: Control Flow (#6)

jeschkies · web-flow · commit d1f8d67f65fa · 2019-11-26T12:33:32.000+01:00
This implements [chapter 9](http://craftinginterpreters.com/control-flow.html). Most code should be a straight forward translation. Rust's `Option` and `if let` makes it easy to handle the cases when there is an initializer or not in a loop.
diff --git a/README.md b/README.md
@@ -9,3 +9,4 @@ Each commit corresponds to one chapter in the book:
 * [Chapter 5: Representing Code](https://github.com/jeschkies/lox-rs/commit/0156a95b4bf448dbff9cb4341a2339b741a163ca)
 * [Chapter 6: Parsing Expressions](https://github.com/jeschkies/lox-rs/commit/9508c9d887a88540597d314520ae6aa045256e7d)
 * [Chapter 7: Evaluating Expressions](https://github.com/jeschkies/lox-rs/commit/fd90ef985c88832c9af6f193e0614e41dd13ef28)
+* [Chapter 8: Statements and State](https://github.com/jeschkies/lox-rs/commit/941cbba900acb5876dbe6031b24ef31ff81ca99e)
diff --git a/examples/loop.lox b/examples/loop.lox
@@ -0,0 +1,9 @@
+var a = 0;
+var b = 1;
+
+while (a < 10000) {
+  print a;
+  var temp = a;
+  a = b;
+  b = temp + b;
+}
diff --git a/examples/scope.lox b/examples/scope.lox
@@ -0,0 +1,20 @@
+var a = "global a";
+var b = "global b";
+var c = "global c";
+{
+  var a = "outer a";
+  var b = "outer b";
+  {
+    var a = "inner a";
+    print a;
+    print b;
+    print c;
+  }
+  print a;
+  print b;
+  print c;
+}
+print a;
+print b;
+print c;
+
diff --git a/examples/simple.lox b/examples/simple.lox
@@ -0,0 +1,3 @@
+print "one";
+print true;
+print 2 + 1;
diff --git a/src/interpreter.rs b/src/interpreter.rs
@@ -166,6 +166,26 @@ impl expr::Visitor<Object> for Interpreter {
         }
     }
 
+    fn visit_logical_expr(
+        &mut self,
+        left: &Expr,
+        operator: &Token,
+        right: &Expr,
+    ) -> Result<Object, Error> {
+        let l = self.evaluate(left)?;
+
+        if operator.tpe == TokenType::Or {
+            if self.is_truthy(&l) {
+                return Ok(l);
+            }
+        } else {
+            if !self.is_truthy(&l) {
+                return Ok(l);
+            }
+        }
+        self.evaluate(right)
+    }
+
     fn visit_unary_expr(&mut self, operator: &Token, right: &Expr) -> Result<Object, Error> {
         let right = self.evaluate(right)?;
 
@@ -204,6 +224,22 @@ impl stmt::Visitor<()> for Interpreter {
         Ok(())
     }
 
+    fn visit_if_stmt(
+        &mut self,
+        condition: &Expr,
+        else_branch: &Option<Stmt>,
+        then_branch: &Stmt,
+    ) -> Result<(), Error> {
+        let condition_value = self.evaluate(condition)?;
+        if self.is_truthy(&condition_value) {
+            self.execute(then_branch)?;
+        } else if let Some(other) = else_branch {
+            self.execute(other)?;
+        }
+
+        Ok(())
+    }
+
     fn visit_print_stmt(&mut self, expression: &Expr) -> Result<(), Error> {
         let value = self.evaluate(expression)?;
         println!("{}", self.stringify(value));
@@ -216,7 +252,19 @@ impl stmt::Visitor<()> for Interpreter {
             .map(|i| self.evaluate(i))
             .unwrap_or(Ok(Object::Null))?;
 
-        self.environment.borrow_mut().define(name.lexeme.clone(), value);
+        self.environment
+            .borrow_mut()
+            .define(name.lexeme.clone(), value);
+        Ok(())
+    }
+
+    fn visit_while_stmt(&mut self, condition: &Expr, body: &Stmt) -> Result<(), Error> {
+        let mut value = self.evaluate(condition)?;
+        while self.is_truthy(&value) {
+            self.execute(body)?;
+            value = self.evaluate(condition)?
+        }
+
         Ok(())
     }
 }
diff --git a/src/parser.rs b/src/parser.rs
@@ -55,8 +55,14 @@ impl<'t> Parser<'t> {
     }
 
     fn statement(&mut self) -> Result<Stmt, Error> {
-        if matches!(self, TokenType::Print) {
+        if matches!(self, TokenType::For) {
+            self.for_statement()
+        } else if matches!(self, TokenType::If) {
+            self.if_statement()
+        } else if matches!(self, TokenType::Print) {
             self.print_statement()
+        } else if matches!(self, TokenType::While) {
+            self.while_statement()
         } else if matches!(self, TokenType::LeftBrace) {
             Ok(Stmt::Block {
                 statements: self.block()?,
@@ -66,6 +72,75 @@ impl<'t> Parser<'t> {
         }
     }
 
+    fn for_statement(&mut self) -> Result<Stmt, Error> {
+        self.consume(TokenType::LeftParen, "Expect '(' after 'for'.")?;
+
+        let initializer = if matches!(self, TokenType::Semicolon) {
+            None
+        } else if matches!(self, TokenType::Var) {
+            Some(self.var_declaration()?)
+        } else {
+            Some(self.expression_statement()?)
+        };
+
+        let condition = if !self.check(TokenType::Semicolon) {
+            Some(self.expression()?)
+        } else {
+            None
+        };
+        self.consume(TokenType::Semicolon, "Expect ';' after loop condition.")?;
+
+        let increment = if !self.check(TokenType::RightParen) {
+            Some(self.expression()?)
+        } else {
+            None
+        };
+        self.consume(TokenType::RightParen, "Expect ')' after for clauses.")?;
+
+        let mut body = self.statement()?;
+
+        if let Some(inc) = increment {
+            let inc_stmt = Stmt::Expression { expression: inc };
+            body = Stmt::Block {
+                statements: vec![body, inc_stmt],
+            }
+        }
+
+        body = Stmt::While {
+            condition: condition.unwrap_or(Expr::Literal {
+                value: LiteralValue::Boolean(true),
+            }),
+            body: Box::new(body),
+        };
+
+        if let Some(init_stmt) = initializer {
+            body = Stmt::Block {
+                statements: vec![init_stmt, body],
+            }
+        }
+
+        Ok(body)
+    }
+
+    fn if_statement(&mut self) -> Result<Stmt, Error> {
+        self.consume(TokenType::LeftParen, "Expect '(' after 'if'.")?;
+        let condition = self.expression()?;
+        self.consume(TokenType::RightParen, "Expect ')' after if condition.")?;
+
+        let then_branch = Box::new(self.statement()?);
+        let else_branch = if matches!(self, TokenType::Else) {
+            Box::new(Some(self.statement()?))
+        } else {
+            Box::new(None)
+        };
+
+        Ok(Stmt::If {
+            condition,
+            else_branch,
+            then_branch,
+        })
+    }
+
     fn print_statement(&mut self) -> Result<Stmt, Error> {
         let value = self.expression()?;
         self.consume(TokenType::Semicolon, "Expect ';' after value.")?;
@@ -88,6 +163,14 @@ impl<'t> Parser<'t> {
         Ok(Stmt::Var { name, initializer })
     }
 
+    fn while_statement(&mut self) -> Result<Stmt, Error> {
+        self.consume(TokenType::LeftParen, "Expect '(' after 'while'.")?;
+        let condition = self.expression()?;
+        self.consume(TokenType::RightParen, "Expect ')' after condition.")?;
+        let body = Box::new(self.statement()?);
+        Ok(Stmt::While { condition, body })
+    }
+
     fn expression_statement(&mut self) -> Result<Stmt, Error> {
         let expr = self.expression()?;
         self.consume(TokenType::Semicolon, "Expect ';' after expression.")?;
@@ -106,7 +189,7 @@ impl<'t> Parser<'t> {
     }
 
     fn assignment(&mut self) -> Result<Expr, Error> {
-        let expr = self.equality()?;
+        let expr = self.or_()?;
 
         if matches!(self, TokenType::Equal) {
             let value = Box::new(self.assignment()?);
@@ -124,6 +207,38 @@ impl<'t> Parser<'t> {
         Ok(expr)
     }
 
+    fn or_(&mut self) -> Result<Expr, Error> {
+        let mut expr = self.and_()?;
+
+        while matches!(self, TokenType::Or) {
+            let operator: Token = (*self.previous()).clone();
+            let right: Expr = self.and_()?;
+            expr = Expr::Logical {
+                left: Box::new(expr),
+                operator: operator,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn and_(&mut self) -> Result<Expr, Error> {
+        let mut expr = self.equality()?;
+
+        while matches!(self, TokenType::And) {
+            let operator: Token = (*self.previous()).clone();
+            let right: Expr = self.equality()?;
+            expr = Expr::Logical {
+                left: Box::new(expr),
+                operator: operator,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
     fn equality(&mut self) -> Result<Expr, Error> {
         let mut expr = self.comparison()?;
 
diff --git a/src/syntax.rs b/src/syntax.rs
@@ -19,6 +19,11 @@ pub enum Expr {
     Literal {
         value: LiteralValue,
     },
+    Logical {
+        left: Box<Expr>,
+        operator: Token,
+        right: Box<Expr>,
+    },
     Unary {
         operator: Token,
         right: Box<Expr>,
@@ -64,6 +69,11 @@ impl Expr {
             } => visitor.visit_binary_expr(left, operator, right),
             Expr::Grouping { expression } => visitor.visit_grouping_expr(expression),
             Expr::Literal { value } => visitor.visit_literal_expr(value),
+            Expr::Logical {
+                left,
+                operator,
+                right,
+            } => visitor.visit_logical_expr(left, operator, right),
             Expr::Unary { operator, right } => visitor.visit_unary_expr(operator, right),
             Expr::Variable { name } => visitor.visit_variable_expr(name),
         }
@@ -91,6 +101,12 @@ pub mod expr {
         /// * `expression` - This is the *inner* expression of the grouping.
         fn visit_grouping_expr(&mut self, expression: &Expr) -> Result<R, Error>;
         fn visit_literal_expr(&self, value: &LiteralValue) -> Result<R, Error>;
+        fn visit_logical_expr(
+            &mut self,
+            left: &Expr,
+            operator: &Token,
+            right: &Expr,
+        ) -> Result<R, Error>;
         fn visit_unary_expr(&mut self, operator: &Token, right: &Expr) -> Result<R, Error>;
         fn visit_variable_expr(&mut self, name: &Token) -> Result<R, Error>;
     }
@@ -103,13 +119,22 @@ pub enum Stmt {
     Expression {
         expression: Expr,
     },
+    If {
+        condition: Expr,
+        else_branch: Box<Option<Stmt>>,
+        then_branch: Box<Stmt>,
+    },
     Print {
         expression: Expr,
     },
     Var {
         name: Token,
         initializer: Option<Expr>,
     },
+    While {
+        condition: Expr,
+        body: Box<Stmt>,
+    },
     Null, // TODO see how stmt is handled after synchronize
 }
 
@@ -118,8 +143,14 @@ impl Stmt {
         match self {
             Stmt::Block { statements } => visitor.visit_block_stmt(statements),
             Stmt::Expression { expression } => visitor.visit_expression_stmt(expression),
+            Stmt::If {
+                condition,
+                else_branch,
+                then_branch,
+            } => visitor.visit_if_stmt(condition, else_branch, then_branch),
             Stmt::Print { expression } => visitor.visit_print_stmt(expression),
             Stmt::Var { name, initializer } => visitor.visit_var_stmt(name, initializer),
+            Stmt::While { condition, body } => visitor.visit_while_stmt(condition, body),
             Stmt::Null => unimplemented!(),
         }
     }
@@ -135,11 +166,16 @@ pub mod stmt {
         //        fn visit_class_stmt(&self, Class stmt); TODO: Classes chapter
         fn visit_expression_stmt(&mut self, expression: &Expr) -> Result<R, Error>;
         //        fn visit_function_stmt(&self, Function stmt); TODO: Functions chapter
-        //        fn visit_if_stmt(&self, If stmt); TODO: Control Flows chapter
+        fn visit_if_stmt(
+            &mut self,
+            condition: &Expr,
+            else_branch: &Option<Stmt>,
+            then_branch: &Stmt,
+        ) -> Result<R, Error>;
         fn visit_print_stmt(&mut self, expression: &Expr) -> Result<R, Error>;
         //        fn visit_return_stmt(&self, Return stmt); TODO: Functions chapter
         fn visit_var_stmt(&mut self, name: &Token, initializer: &Option<Expr>) -> Result<R, Error>;
-        //        fn visit_while_stmt(&self, While stmt); TODO: Control Flows chapter
+        fn visit_while_stmt(&mut self, condition: &Expr, body: &Stmt) -> Result<R, Error>;
     }
 }
 
@@ -181,6 +217,15 @@ impl expr::Visitor<String> for AstPrinter {
         Ok(value.to_string()) // check for null
     }
 
+    fn visit_logical_expr(
+        &mut self,
+        left: &Expr,
+        operator: &Token,
+        right: &Expr,
+    ) -> Result<String, Error> {
+        self.parenthesize(operator.lexeme.clone(), vec![left, right])
+    }
+
     fn visit_unary_expr(&mut self, operator: &Token, right: &Expr) -> Result<String, Error> {
         self.parenthesize(operator.lexeme.clone(), vec![right])
     }

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+print "one";`
	`2`	`+print true;`
	`3`	`+print 2 + 1;`