Merge pull request #21 from igorkulman/while-loop

While loop

Author: igorkulman

PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift

@@ -48,6 +48,8 @@ public class Interpreter {
             return eval(ifElse: ifElse)
         case let repeatUntil as RepeatUntil:
             return eval(repeatUntil: repeatUntil)
+        case let whileLoop as While:
+            return eval(whileLoop: whileLoop)
         case let forLoop as For:
             return eval(forLoop: forLoop)
         default:
@@ -182,6 +184,14 @@ public class Interpreter {
         return .none
     }
 
+    func eval(whileLoop: While) -> Value {
+        while case .boolean(true) = eval(condition: whileLoop.condition) {
+            eval(node: whileLoop.statement)
+        }
+
+        return .none
+    }
+
     func eval(forLoop: For) -> Value {
         guard let currentFrame = callStack.peek() else {
             fatalError("No call stack frame")

PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift

@@ -43,6 +43,7 @@ public class Lexer {
         "FOR": .for,
         "TO": .to,
         "DO": .do,
+        "WHILE": .while,
     ]
 
     public init(_ text: String) {

PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift

@@ -69,6 +69,8 @@ extension Token: Equatable {
             return true
         case (.do, .do):
             return true
+        case (.while, .while):
+            return true
         default:
             return false
         }
@@ -211,6 +213,8 @@ extension Token: CustomStringConvertible {
             return "TO"
         case .do:
             return "DO"
+        case .while:
+            return "WHILE"
         }
     }
 }

PascalInterpreter/PascalInterpreter/Lexer/Token.swift

@@ -65,4 +65,5 @@ public enum Token {
     case `for`
     case to
     case `do`
+    case `while`
 }

PascalInterpreter/PascalInterpreter/Parser/AST+Extensions.swift

@@ -120,6 +120,8 @@ extension AST {
             return "REPEAT"
         case is For:
             return "FOR"
+        case is While:
+            return "WHILE"
         default:
             fatalError("Missed AST case \(self)")
         }
@@ -185,6 +187,8 @@ extension AST {
             return []
         case let repeatUntil as RepeatUntil:
             return [repeatUntil.condition, repeatUntil.statement]
+        case let whileLoop as While:
+            return [whileLoop.condition, whileLoop.statement]
         case let forLoop as For:
             return [forLoop.variable, forLoop.startValue, forLoop.endValue, forLoop.statement]
         default:

PascalInterpreter/PascalInterpreter/Parser/AST.swift

@@ -198,7 +198,22 @@ class IfElse: AST {
     }
 }
 
-class RepeatUntil: AST {
+protocol Loop: AST {
+    var statement: AST { get }
+    var condition: Condition { get }
+}
+
+class RepeatUntil: Loop {
+    let statement: AST
+    let condition: Condition
+
+    init(statement: AST, condition: Condition) {
+        self.statement = statement
+        self.condition = condition
+    }
+}
+
+class While: Loop {
     let statement: AST
     let condition: Condition
 

PascalInterpreter/PascalInterpreter/Parser/Parser.swift

@@ -279,6 +279,7 @@ public class Parser {
      | assignment_statement
      | repeat_until
      | for_loop
+     | while_loop
      | empty
      */
     private func statement() -> AST {
@@ -289,6 +290,8 @@ public class Parser {
             return ifElseStatement()
         case .repeat:
             return repeatUntilLoop()
+        case .while:
+            return whileLoop()
         case .for:
             return forLoop()
         case .id:
@@ -325,7 +328,20 @@ public class Parser {
 
     /**
      Rule:
-     
+
+     for_loop : WHILE condition DO statement
+     */
+    private func whileLoop() -> While {
+        eat(.while)
+        let condition = self.condition()
+        eat(.do)
+        let statement = self.statement()
+        return While(statement: statement, condition: condition)
+    }
+
+    /**
+     Rule:
+
      for_loop : FOR variable ASSIGN expression TO expression DO statement
      */
     private func forLoop() -> For {

PascalInterpreter/PascalInterpreter/Semantic analyzer/Visitor.swift

@@ -27,7 +27,7 @@ protocol Visitor: class {
     func visit(call: FunctionCall)
     func visit(condition: Condition)
     func visit(ifElse: IfElse)
-    func visit(repeatUntil: RepeatUntil)
+    func visit(loop: Loop)
     func visit(forLoop: For)
 }
 
@@ -68,8 +68,8 @@ extension Visitor {
             visit(condition: condition)
         case let ifElse as IfElse:
             visit(ifElse: ifElse)
-        case let repeatUntil as RepeatUntil:
-            visit(repeatUntil: repeatUntil)
+        case let loop as Loop:
+            visit(loop: loop)
         case let forLoop as For:
             visit(forLoop: forLoop)
         default:
@@ -163,9 +163,9 @@ extension Visitor {
         }
     }
 
-    func visit(repeatUntil: RepeatUntil) {
-        visit(node: repeatUntil.statement)
-        visit(node: repeatUntil.condition)
+    func visit(loop: Loop) {
+        visit(node: loop.statement)
+        visit(node: loop.condition)
     }
 
     func visit(forLoop: For) {

PascalInterpreter/PascalInterpreterTests/LexerTests.swift

@@ -465,4 +465,19 @@ class LexerTests: XCTestCase {
         XCTAssert(lexer.getNextToken() == .parenthesis(.right))
         XCTAssert(lexer.getNextToken() == .eof)
     }
+
+    func testWhileTokens() {
+        let lexer = Lexer("while x<5 do x:= x+1 ")
+        XCTAssert(lexer.getNextToken() == .while)
+        XCTAssert(lexer.getNextToken() == .id("x"))
+        XCTAssert(lexer.getNextToken() == .lessThan)
+        XCTAssert(lexer.getNextToken() == .constant(.integer(5)))
+        XCTAssert(lexer.getNextToken() == .do)
+        XCTAssert(lexer.getNextToken() == .id("x"))
+        XCTAssert(lexer.getNextToken() == .assign)
+        XCTAssert(lexer.getNextToken() == .id("x"))
+        XCTAssert(lexer.getNextToken() == .operation(.plus))
+        XCTAssert(lexer.getNextToken() == .constant(.integer(1)))
+        XCTAssert(lexer.getNextToken() == .eof)
+    }
 }

PascalInterpreter/PascalInterpreterTests/ParserTests.swift

@@ -469,4 +469,27 @@ class ParserTests: XCTestCase {
         let node = Program(name: "Main", block: block)
         XCTAssertEqual(result, node)
     }
+
+    func testProgramWithWhileLoop() {
+        let program =
+            """
+            program Main;
+            var x: integer;
+
+            begin
+            x:=0;
+            while x < 6 do
+                x:=x+1;
+            writeln(x);
+            end.  { Main }
+            """
+
+        let parser = Parser(program)
+        let result = parser.parse()
+        let xDec = VariableDeclaration(variable: Variable(name: "x"), type: VariableType(type: .integer))
+        let compound = Compound(children: [Assignment(left: Variable(name: "x"), right: Number.integer(0)), While(statement: Assignment(left: Variable(name: "x"), right: BinaryOperation(left: Variable(name: "x"), operation: BinaryOperationType.plus, right: Number.integer(1))), condition: Condition(type: .lessThan, leftSide: Variable(name: "x"), rightSide: Number.integer(6))), FunctionCall(name: "writeln", actualParameters: [Variable(name: "x")]), NoOp()])
+        let block = Block(declarations: [xDec], compound: compound)
+        let node = Program(name: "Main", block: block)
+        XCTAssertEqual(result, node)
+    }
 }