control flow

Author: lewis-weinberger

README.md

@@ -59,11 +59,12 @@ Following the order in the [book](https://craftinginterpreters.com/contents.html
 * [ ] Interpreter:
     * [x] Expressions
     * [x] Statements
-    * [ ] Control flow
+    * [x] Control flow
     * [ ] Functions
     * [ ] Variable binding
     * [ ] Classes
     * [ ] Inheritance
+* [ ] Tests
 
 ## License
 

examples/control.lox

@@ -0,0 +1,19 @@
+// control flow examples
+
+var i = 0;
+while (i < 10) {
+    if (i == 7)
+        print "7 (an auspicious number)";
+    else
+        print i;
+    i = i + 1;
+}
+
+print "Fibonacci sequence:";
+var a = 0;
+var temp;
+for (var b = 1; a < 10000; b = temp + b) {
+    print a;
+    temp = a;
+    a = b;
+}

src/ASTPrinter.st

@@ -53,7 +53,7 @@ Object subclass: ASTPrinter [
         | str |
         str := WriteStream on: String new.
 
-        str 
+        str
             nextPutAll: '(' , aName;
             nextPutAll: ' ' , (first accept: self).
         second ifNotNil: [ str nextPutAll: ' ' , (second accept: self) ].

src/Environment.st

@@ -65,9 +65,9 @@ Object subclass: Environment [
             values at: aName lexeme put: aValue.
             ^aValue.
         ].
-        
+
         enclosing ifNotNil: [ ^enclosing assign: aName value: aValue ].
-        
+
         ^RuntimeError
             error: aName
             message: 'Undefined variable ''' , aName lexeme , '''.'.

src/Expr.st

@@ -137,6 +137,53 @@ Expr subclass: ExprLiteral [
     ]
 ]
 
+Expr subclass: ExprLogical [
+    | left operator right |
+
+    ExprLogical class >> left: aLeft operator: anOperator right: aRight [
+        <category: 'instance creation'>
+        ^self new
+            left: aLeft;
+            operator: anOperator;
+            right: aRight;
+            yourself.
+    ]
+
+    left: aLeft [
+        <category: 'setter'>
+        left := aLeft.
+    ]
+
+    left [
+        <category: 'getter'>
+        ^left.
+    ]
+
+    operator: anOperator [
+        <category: 'setter'>
+        operator := anOperator.
+    ]
+
+    operator [
+        <category: 'getter'>
+        ^operator.
+    ]
+
+    right: aRight [
+        <category: 'setter'>
+        right := aRight.
+    ]
+
+    right [
+        <category: 'getter'>
+        ^right.
+    ]
+
+    accept: aVisitor [
+        ^aVisitor visitLogicalExpr: self.
+    ]
+]
+
 Expr subclass: ExprUnary [
     | operator right |
 
@@ -196,4 +243,4 @@ Expr subclass: ExprVariable [
     accept: aVisitor [
         ^aVisitor visitVariableExpr: self.
     ]
-]
+]

src/Interpreter.st

@@ -131,6 +131,20 @@ Object subclass: Interpreter [
         self evaluate: stmt expression.
     ]
 
+    visitIfStmt: stmt [
+        "Evaluate an if statement"
+
+        <category: 'evaluation'>
+        (self isTruthy: (self evaluate: stmt condition)) ifTrue: [
+            self execute: stmt thenBranch
+        ] ifFalse: [
+            stmt elseBranch ifNotNil: [
+                self execute: stmt elseBranch
+            ]
+        ].
+        ^nil.
+    ]
+
     visitPrintStmt: stmt [
         "Evaluate a print statement"
 
@@ -153,6 +167,16 @@ Object subclass: Interpreter [
         ^nil.
     ]
 
+    visitWhileStmt: stmt [
+        "Evaluate a while statement"
+
+        <category: 'evaluation'>
+        [ self isTruthy: (self evaluate: stmt condition) ] whileTrue: [
+            self execute: stmt body
+        ].
+        ^nil.
+    ]
+
     visitAssignExpr: expr [
         "Evaluate a variable assignment expression"
 
@@ -170,6 +194,22 @@ Object subclass: Interpreter [
         ^expr value.
     ]
 
+    visitLogicalExpr: expr [
+        "Evaluate a logical expression"
+
+        <category: 'evaluation'>
+        | left operator type|
+        left := self evaluate: expr left.
+        operator := expr operator.
+        type := operator type.
+        type = #Or ifTrue: [
+            (self isTruthy: left) ifTrue: [ ^left ]
+        ] ifFalse: [
+            (self isTruthy: left) ifFalse: [ ^left ]
+        ].
+        ^self evaluate: expr right.
+    ]
+
     visitGroupingExpr: expr [
         "Evaluate a grouping expression"
 
@@ -185,13 +225,13 @@ Object subclass: Interpreter [
         right := self evaluate: expr right.
         operator := expr operator.
         type := operator type.
-        
+
         type = #Bang ifTrue: [ ^self isTruthy: right not ].
         type = #Minus ifTrue: [
             self checkNumber: operator operand: right.
             ^right negated
         ].
-        
+
         "Unreachable"
         ^nil
     ]
@@ -237,13 +277,13 @@ Object subclass: Interpreter [
         ].
         type = #Plus ifTrue: [
             ((left respondsTo: #+) & (right respondsTo: #+)) ifTrue: [
-                ^left + right 
+                ^left + right
             ].
 
             ((left respondsTo: #,) & (right respondsTo: #,)) ifTrue: [
-                ^left , right 
+                ^left , right
             ].
-            
+
             ^RuntimeError
                 error: expr operator
                 message: 'Operands must be two numbers or two strings.'
@@ -256,8 +296,8 @@ Object subclass: Interpreter [
             self checkNumber: operator left: left right: right.
             ^left * right
         ].
-        
+
         "Unreachable"
-        ^nil 
+        ^nil
     ]
 ]

src/Parser.st

@@ -113,7 +113,7 @@ the Lox programming language.'>
         ].
         ^false.
     ]
-    
+
     parse [
         "Parse the source tokens into a list of statements"
 
@@ -152,11 +152,73 @@ the Lox programming language.'>
         "Grammar rule for a statement"
 
         <category: 'rule'>
+        (self match: #(#For)) ifTrue: [ ^self forStatement ].
+        (self match: #(#If)) ifTrue: [ ^self ifStatement ].
         (self match: #(#Print)) ifTrue: [ ^self printStatement ].
+        (self match: #(#While)) ifTrue: [ ^self whileStatement ].
         (self match: #(#LeftBrace)) ifTrue: [ ^StmtBlock statements: self block ].
         ^self expressionStatement.
     ]
 
+    forStatement [
+        "Grammar rule for desugaring a for statement"
+
+        <category: 'rule'>
+        | ini cond incr body stmts |
+        self consume: #LeftParen expect: 'Expect ''('' after ''for''.'.
+
+        (self match: #(#Semicolon)) ifTrue: [ ini := nil ].
+        (self match: #(#Var)) ifTrue: [ 
+            ini := self varDeclaration
+        ] ifFalse: [
+            ini := self expressionStatement
+        ].
+
+        cond := nil.
+        (self check: #Semicolon) ifFalse: [ cond := self expression ].
+        self consume: #Semicolon expect: 'Expect '';'' after loop condition.'.
+
+        incr := nil.
+        (self check: #RightParen) ifFalse: [ incr := self expression ].
+        self consume: #RightParen expect: 'Expect '')'' after for clauses.'.
+        body := self statement.
+
+        incr ifNotNil: [
+            stmts := OrderedCollection new.
+            stmts
+                add: body;
+                add: (StmtExpression expression: incr).
+            body := StmtBlock statements: stmts
+        ].
+
+        cond ifNil: [ cond := ExprLiteral value: true ].
+        body := StmtWhile condition: cond body: body.
+
+        ini ifNotNil: [
+            stmts := OrderedCollection new.
+            stmts
+                add: ini;
+                add: body.
+            body := StmtBlock statements: stmts
+        ].
+
+        ^body.
+    ]
+
+    ifStatement [
+        "Grammar rule for an if statement"
+
+        <category: 'rule'>
+        | cond then else |
+        self consume: #LeftParen expect: 'Expect ''('' after ''if''.'.
+        cond := self expression.
+        self consume: #RightParen expect: 'Expect '')'' after if condition.'.
+        then := self statement.
+        else := nil.
+        (self match: #(#Else)) ifTrue: [ else := self statement ].
+        ^StmtIf condition: cond thenBranch: then elseBranch: else.
+    ]
+
     printStatement [
         "Grammar rule for a print statement"
 
@@ -167,6 +229,18 @@ the Lox programming language.'>
         ^StmtPrint expression: value.
     ]
 
+    whileStatement [
+        "Grammar rule for a while statement"
+
+        <category: 'rule'>
+        | cond body |
+        self consume: #LeftParen expect: 'Expect ''('' after ''while''.'.
+        cond := self expression.
+        self consume: #RightParen expect: 'Expect '')'' after condition.'.
+        body := self statement.
+        ^StmtWhile condition: cond body: body.
+    ]
+
     expressionStatement [
         "Grammar rule for an expression statement"
 
@@ -202,7 +276,7 @@ the Lox programming language.'>
 
         <category: 'rule'>
         | expr equals value name |
-        expr := self equality.
+        expr := self or.
 
         (self match: #(#Equal)) ifTrue: [
             equals := self previous.
@@ -219,6 +293,36 @@ the Lox programming language.'>
         ^expr.
     ]
 
+    or [
+        "Grammar rule for an or expression"
+
+        <category: 'rule'>
+        | expr operator right |
+        expr := self and.
+
+        [ self match: #(#Or) ] whileTrue: [
+            operator := self previous.
+            right := self and.
+            expr := ExprLogical left: expr operator: operator right: right
+        ].
+        ^expr.
+    ]
+
+    and [
+        "Grammar rule for an and expression"
+
+        <category: 'rule'>
+        | expr operator right |
+        expr := self equality.
+
+        [ self match: #(#And) ] whileTrue: [
+            operator := self previous.
+            right := self equality.
+            expr := ExprLogical left: expr operator: operator right: right
+        ].
+        ^expr.
+    ]
+
     equality [
         "Grammar rule for an equality"
 
@@ -296,7 +400,7 @@ the Lox programming language.'>
         (self match: #(#False)) ifTrue: [ ^ExprLiteral value: false ].
         (self match: #(#True)) ifTrue: [ ^ExprLiteral value: true ].
         (self match: #(#Nil)) ifTrue: [ ^ExprLiteral value: nil ].
-        
+
         (self match: #(#Number #String)) ifTrue: [
             ^ExprLiteral value: (self previous literal)
         ].
@@ -310,7 +414,7 @@ the Lox programming language.'>
             self consume: #RightParen expect: 'Expect '')'' after expression'.
             ^ExprGrouping expression: expr
         ].
-        
+
         ^ParseError error: (self peek) message: 'Expected expression'.
     ]
 ]