✨ Lexer support for while loops

Author: igorkulman

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

@@ -325,7 +325,7 @@ public class Parser {
 
     /**
      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)
+    }
 }

README.md

@@ -14,7 +14,7 @@ Simple Swift interpreter for the Pascal language inspired by the [Let’s Build
 * function calls
 * procedure calls
 * recursion
-* loops (for, repet until)
+* loops (for, repet until, while)
 * logical conditions (if)
 * standard Pascal functions (writeln, write, readln, read, random)