✨ For loops

Author: igorkulman

PascalInterpreter/PascalInterpreter/Interpreter/Frame.swift

@@ -22,6 +22,24 @@ class Frame {
         self.previousFrame = previousFrame
     }
 
+    func remove(variable: String) {
+        if let symbol = scope.lookup(variable, currentScopeOnly: true),
+            let variableSymbol = symbol as? VariableSymbol,
+            let type = variableSymbol.type as? BuiltInTypeSymbol {
+
+            switch type {
+            case .integer:
+                integerMemory.removeValue(forKey: variable)
+            case .real:
+                realMemory.removeValue(forKey: variable)
+            case .boolean:
+                booleanMemory.removeValue(forKey: variable)
+            case .string:
+                stringMemory.removeValue(forKey: variable)
+            }
+        }
+    }
+
     func set(variable: String, value: Value) {
         // setting function return value
         if variable == scope.name && scope.level > 1 {

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 forLoop as For:
+            return eval(forLoop: forLoop)
         default:
             return .none
         }
@@ -73,6 +75,7 @@ public class Interpreter {
             return .number(-result)
         }
     }
+
     func eval(binaryOperation: BinaryOperation) -> Value {
         guard case let .number(leftResult) = eval(node: binaryOperation.left), case let .number(rightResult) = eval(node: binaryOperation.right) else {
             fatalError("Cannot use binary \(binaryOperation.operation) on non numbers")
@@ -179,6 +182,24 @@ public class Interpreter {
         return .none
     }
 
+    func eval(forLoop: For) -> Value {
+        guard let currentFrame = callStack.peek() else {
+            fatalError("No call stack frame")
+        }
+
+        guard case let .number(.integer(start)) = eval(node: forLoop.startValue), case let .number(.integer(end)) = eval(node: forLoop.endValue) else {
+            fatalError("Cannot do a for loop on non integer values")
+        }
+
+        for i in start ... end {
+            currentFrame.set(variable: forLoop.variable.name, value: .number(.integer(i)))
+            eval(node: forLoop.statement)
+        }
+        currentFrame.remove(variable: forLoop.variable.name)
+
+        return .none
+    }
+
     private func callFunction(function: String, params: [AST], frame: Frame) -> Value {
         guard let symbol = frame.scope.lookup(function), let procedureSymbol = symbol as? ProcedureSymbol else {
             fatalError("Symbol(procedure) not found '\(function)'")

PascalInterpreter/PascalInterpreter/Interpreter/Value.swift

@@ -28,5 +28,4 @@ extension Value: Equatable {
             return false
         }
     }
-
 }

PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift

@@ -39,7 +39,10 @@ public class Lexer {
         "THEN": .then,
         "FUNCTION": .function,
         "REPEAT": .repeat,
-        "UNTIL": .until
+        "UNTIL": .until,
+        "FOR": .for,
+        "TO": .to,
+        "DO": .do,
     ]
 
     public init(_ text: String) {

PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift

@@ -63,6 +63,12 @@ extension Token: Equatable {
             return true
         case (.until, .until):
             return true
+        case (.for, .for):
+            return true
+        case (.to, .to):
+            return true
+        case (.do, .do):
+            return true
         default:
             return false
         }
@@ -199,6 +205,12 @@ extension Token: CustomStringConvertible {
             return "REPEAT"
         case .until:
             return "UNTIL"
+        case .for:
+            return "FOR"
+        case .to:
+            return "TO"
+        case .do:
+            return "DO"
         }
     }
 }

PascalInterpreter/PascalInterpreter/Lexer/Token.swift

@@ -62,4 +62,7 @@ public enum Token {
     case apostrophe
     case `repeat`
     case until
+    case `for`
+    case to
+    case `do`
 }

PascalInterpreter/PascalInterpreter/Parser/AST+Extensions.swift

@@ -118,6 +118,8 @@ extension AST {
             return boolean ? "TRUE" : "FALSE"
         case is RepeatUntil:
             return "REPEAT"
+        case is For:
+            return "FOR"
         default:
             fatalError("Missed AST case \(self)")
         }
@@ -183,6 +185,8 @@ extension AST {
             return []
         case let repeatUntil as RepeatUntil:
             return [repeatUntil.condition, repeatUntil.statement]
+        case let forLoop as For:
+            return [forLoop.variable, forLoop.startValue, forLoop.endValue, forLoop.statement]
         default:
             fatalError("Missed AST case \(self)")
         }

PascalInterpreter/PascalInterpreter/Parser/AST.swift

@@ -207,3 +207,17 @@ class RepeatUntil: AST {
         self.condition = condition
     }
 }
+
+class For: AST {
+    let statement: AST
+    let variable: Variable
+    let startValue: AST
+    let endValue: AST
+
+    init(statement: AST, variable: Variable, startValue: AST, endValue: AST) {
+        self.statement = statement
+        self.variable = variable
+        self.startValue = startValue
+        self.endValue = endValue
+    }
+}

PascalInterpreter/PascalInterpreter/Parser/Parser.swift

@@ -18,6 +18,7 @@ public class Parser {
     private var currentToken: Token {
         return tokens[tokenIndex]
     }
+
     private var nextToken: Token {
         return tokens[tokenIndex + 1]
     }
@@ -277,6 +278,7 @@ public class Parser {
      | if_else_statement
      | assignment_statement
      | repeat_until
+     | for_loop
      | empty
      */
     private func statement() -> AST {
@@ -287,6 +289,8 @@ public class Parser {
             return ifElseStatement()
         case .repeat:
             return repeatUntilLoop()
+        case .for:
+            return forLoop()
         case .id:
             if nextToken == .parenthesis(.left) {
                 return functionCall()
@@ -319,6 +323,18 @@ public class Parser {
         return RepeatUntil(statement: statements.count == 1 ? statements[0] : Compound(children: statements), condition: condition)
     }
 
+    private func forLoop() -> For {
+        eat(.for)
+        let variable = self.variable()
+        eat(.assign)
+        let start = expr()
+        eat(.to)
+        let end = expr()
+        eat(.do)
+        let statement = self.statement()
+        return For(statement: statement, variable: variable, startValue: start, endValue: end)
+    }
+
     /**
      Rule:
 

PascalInterpreter/PascalInterpreter/Semantic analyzer/SemanticAnalyzer.swift

@@ -13,7 +13,6 @@ public class SemanticAnalyzer: Visitor {
     private var scopes: [String: ScopedSymbolTable] = [:]
 
     public init() {
-
     }
 
     public func analyze(node: AST) -> [String: ScopedSymbolTable] {
@@ -104,8 +103,7 @@ public class SemanticAnalyzer: Visitor {
         }
     }
 
-    private func checkBuiltInProcedure(call: FunctionCall, procedure: BuiltInProcedureSymbol) {
-
+    private func checkBuiltInProcedure(call _: FunctionCall, procedure _: BuiltInProcedureSymbol) {
     }
 
     private func checkFunction(call: FunctionCall, procedure: ProcedureSymbol) {
@@ -137,4 +135,12 @@ public class SemanticAnalyzer: Visitor {
             }
         }
     }
+
+    func visit(forLoop: For) {
+        currentScope?.insert(VariableSymbol(name: forLoop.variable.name, type: currentScope!.lookup("INTEGER")!))
+
+        visit(node: forLoop.startValue)
+        visit(node: forLoop.endValue)
+        visit(node: forLoop.statement)
+    }
 }