igorkulman · igorkulman · Dec 20, 2017 · Dec 20, 2017 · Dec 20, 2017 · Dec 20, 2017
diff --git a/Examples/factorial.pas b/Examples/factorial.pas
@@ -3,7 +3,7 @@
 
 function Factorial(number: Integer): Integer;
 begin
-if (number > 1) then
+if number > 1 then
     Factorial := number * Factorial(number-1)
 else
     Factorial := 1

diff --git a/Examples/game.pas b/Examples/game.pas
@@ -0,0 +1,25 @@
+Program Game;
+Var       
+    target, guess: Integer;
+
+Begin 
+	guess  := 10;
+	target := random(guess);
+
+	Writeln('Guess a number between 0 and 10:'); 
+	Read(guess);
+
+	repeat		
+		if guess > target then
+		begin
+			Writeln('Too much, try again');
+			Read(guess);
+		end
+		else
+		begin
+			Writeln('Too low, try again');
+			Read(guess);
+		end
+	until target = guess;
+	Writeln('You won!')
+End.  
diff --git a/PascalInterpreter/PascalInterpreter/Interpreter/Interpreter+Standard.swift b/PascalInterpreter/PascalInterpreter/Interpreter/Interpreter+Standard.swift
@@ -23,11 +23,22 @@ extension Interpreter {
         case "READLN":
             read(params: params, frame: frame)
             return .none
+        case "RANDOM":
+            return random(params: params)
         default:
             fatalError("Implement built in procedure \(procedure)")
         }
     }
 
+    private func random(params: [AST]) -> Value {
+        guard params.count == 1, let first = params.first, case let .number(.integer(l)) = eval(node: first) else {
+            fatalError("Random called with invalid parameters")
+        }
+
+        let value = arc4random_uniform(UInt32(l))
+        return .number(.integer(Int(value)))
+    }
+
     private func write(params: [AST], newLine: Bool) {
         var s = ""
         for param in params {

diff --git a/PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift b/PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift
@@ -46,6 +46,8 @@ public class Interpreter {
             return eval(condition: condition)
         case let ifElse as IfElse:
             return eval(ifElse: ifElse)
+        case let repeatUntil as RepeatUntil:
+            return eval(repeatUntil: repeatUntil)
         default:
             return .none
         }
@@ -165,6 +167,18 @@ public class Interpreter {
         }
     }
 
+    func eval(repeatUntil: RepeatUntil) -> Value {
+        eval(node: repeatUntil.statement)
+        var value = eval(condition: repeatUntil.condition)
+
+        while case .boolean(false) = value {
+            eval(node: repeatUntil.statement)
+            value = eval(condition: repeatUntil.condition)
+        }
+
+        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)'")

diff --git a/PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift b/PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift
@@ -37,7 +37,9 @@ public class Lexer {
         "IF": .if,
         "ELSE": .else,
         "THEN": .then,
-        "FUNCTION": .function
+        "FUNCTION": .function,
+        "REPEAT": .repeat,
+        "UNTIL": .until
     ]
 
     public init(_ text: String) {

diff --git a/PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift b/PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift
@@ -59,6 +59,10 @@ extension Token: Equatable {
             return true
         case (.apostrophe, .apostrophe):
             return true
+        case (.repeat, .repeat):
+            return true
+        case (.until, .until):
+            return true
         default:
             return false
         }
@@ -191,6 +195,10 @@ extension Token: CustomStringConvertible {
             return "FUNCTION"
         case .apostrophe:
             return "APOSTROPHE"
+        case .repeat:
+            return "REPEAT"
+        case .until:
+            return "UNTIL"
         }
     }
 }
diff --git a/PascalInterpreter/PascalInterpreter/Lexer/Token.swift b/PascalInterpreter/PascalInterpreter/Lexer/Token.swift
@@ -60,4 +60,6 @@ public enum Token {
     case greaterThan
     case function
     case apostrophe
+    case `repeat`
+    case until
 }
diff --git a/PascalInterpreter/PascalInterpreter/Parser/AST+Extensions.swift b/PascalInterpreter/PascalInterpreter/Parser/AST+Extensions.swift
@@ -116,6 +116,8 @@ extension AST {
             return string
         case let boolean as Bool:
             return boolean ? "TRUE" : "FALSE"
+        case is RepeatUntil:
+            return "REPEAT"
         default:
             fatalError("Missed AST case \(self)")
         }
@@ -179,6 +181,8 @@ extension AST {
             return []
         case is Bool:
             return []
+        case let repeatUntil as RepeatUntil:
+            return [repeatUntil.condition, repeatUntil.statement]
         default:
             fatalError("Missed AST case \(self)")
         }

diff --git a/PascalInterpreter/PascalInterpreter/Parser/AST.swift b/PascalInterpreter/PascalInterpreter/Parser/AST.swift
@@ -197,3 +197,13 @@ class IfElse: AST {
         self.falseExpression = falseExpression
     }
 }
+
+class RepeatUntil: AST {
+    let statement: AST
+    let condition: Condition
+
+    init(statement: AST, condition: Condition) {
+        self.statement = statement
+        self.condition = condition
+    }
+}
diff --git a/PascalInterpreter/PascalInterpreter/Parser/Parser.swift b/PascalInterpreter/PascalInterpreter/Parser/Parser.swift
@@ -276,6 +276,7 @@ public class Parser {
      | procedure_call
      | if_else_statement
      | assignment_statement
+     | repeat_until
      | empty
      */
     private func statement() -> AST {
@@ -284,6 +285,8 @@ public class Parser {
             return compoundStatement()
         case .if:
             return ifElseStatement()
+        case .repeat:
+            return repeatUntilLoop()
         case .id:
             if nextToken == .parenthesis(.left) {
                 return functionCall()
@@ -295,6 +298,27 @@ public class Parser {
         }
     }
 
+    /**
+     Rule:
+
+     repeat_until : REPEAT statement UNTIL condition
+     */
+    private func repeatUntilLoop() -> RepeatUntil {
+        eat(.repeat)
+
+        var statements: [AST] = []
+
+        while currentToken != .until {
+            statements.append(statement())
+            if currentToken == .semi {
+                eat(.semi)
+            }
+        }
+        eat(.until)
+        let condition = self.condition()
+        return RepeatUntil(statement: statements.count == 1 ? statements[0] : Compound(children: statements), condition: condition)
+    }
+
     /**
      Rule:
 
@@ -346,9 +370,12 @@ public class Parser {
     /**
      Rule:
      condition: expr (= | < | >) expr
+     | LPAREN expr (= | < | >) expr RPAREN
      */
     private func condition() -> Condition {
-        eat(.parenthesis(.left))
+        if currentToken == .parenthesis(.left) {
+            eat(.parenthesis(.left))
+        }
         let left = expr()
         var type: ConditionType = .equals
         switch currentToken {
@@ -365,7 +392,9 @@ public class Parser {
             fatalError("Invalid condition type \(type)")
         }
         let right = expr()
-        eat(.parenthesis(.right))
+        if currentToken == .parenthesis(.right) {
+            eat(.parenthesis(.right))
+        }
         return Condition(type: type, leftSide: left, rightSide: right)
     }
 
@@ -483,10 +512,10 @@ public class Parser {
             let result = expr()
             eat(.parenthesis(.right))
             return result
-        case .constant(.string(let value)):
+        case let .constant(.string(value)):
             eat(.constant(.string(value)))
             return value
-        case .constant(.boolean(let value)):
+        case let .constant(.boolean(value)):
             eat(.constant(.boolean(value)))
             return value
         default:

diff --git a/PascalInterpreter/PascalInterpreter/Semantic analyzer/SymbolTable.swift b/PascalInterpreter/PascalInterpreter/Semantic analyzer/SymbolTable.swift
@@ -36,6 +36,7 @@ public class ScopedSymbolTable {
         symbols["WRITE"] = BuiltInProcedureSymbol(name: "WRITE", parameters: [], hasVariableParameters: true)
         symbols["READ"] = BuiltInProcedureSymbol(name: "READ", parameters: [], hasVariableParameters: true)
         symbols["READLN"] = BuiltInProcedureSymbol(name: "READLN", parameters: [], hasVariableParameters: true)
+        symbols["RANDOM"] = BuiltInProcedureSymbol(name: "RANDOM", parameters: [BuiltInTypeSymbol.integer], hasVariableParameters: false)
     }
 
     func insert(_ symbol: Symbol) {

diff --git a/PascalInterpreter/PascalInterpreter/Semantic analyzer/Visitor.swift b/PascalInterpreter/PascalInterpreter/Semantic analyzer/Visitor.swift
@@ -27,6 +27,7 @@ protocol Visitor: class {
     func visit(call: FunctionCall)
     func visit(condition: Condition)
     func visit(ifElse: IfElse)
+    func visit(repeatUntil: RepeatUntil)
 }
 
 extension Visitor {
@@ -66,6 +67,8 @@ extension Visitor {
             visit(condition: condition)
         case let ifElse as IfElse:
             visit(ifElse: ifElse)
+        case let repeatUntil as RepeatUntil:
+            visit(repeatUntil: repeatUntil)
         default:
             fatalError("Unsupported node type \(node)")
         }
@@ -160,4 +163,9 @@ extension Visitor {
             visit(node: falseExpression)
         }
     }
+
+    func visit(repeatUntil: RepeatUntil) {
+        visit(node: repeatUntil.statement)
+        visit(node: repeatUntil.condition)
+    }
 }
diff --git a/PascalInterpreter/PascalInterpreterTests/InterpreterTests.swift b/PascalInterpreter/PascalInterpreterTests/InterpreterTests.swift
@@ -144,7 +144,7 @@ class InterpreterTests: XCTestCase {
 
             function Factorial(number: Integer): Integer;
             begin
-            if (number > 1) then
+            if number > 1 then
                 Factorial := number * Factorial(number-1)
             else
                 Factorial := 1
@@ -172,7 +172,7 @@ class InterpreterTests: XCTestCase {
 
             function Factorial(number: Integer): Integer;
             begin
-            if (number > 1) then
+            if number > 1 then
                 Factorial := number * Factorial(number-1)
             else
                 Factorial := 1
@@ -195,13 +195,13 @@ class InterpreterTests: XCTestCase {
 
     func testProgramWithRecursiveFunctionsAndParameterTheSameName() {
         let program =
-        """
+            """
             program Main;
             var number, result: integer;
 
             function Factorial(number: Integer): Integer;
             begin
-            if (number > 1) then
+            if number > 1 then
                 Factorial := number * Factorial(number-1)
             else
                 Factorial := 1
@@ -221,4 +221,28 @@ class InterpreterTests: XCTestCase {
         XCTAssert(boolState == [:])
         XCTAssert(stringState == [:])
     }
+
+    func testProgramWithRepeatUntil() {
+        let program =
+            """
+            program Main;
+            var x: integer;
+
+            begin
+            x:=0;
+            repeat
+                x:=x+1;
+            until x = 6;
+            writeln(x);
+            end.  { Main }
+            """
+
+        let interpeter = Interpreter(program)
+        interpeter.interpret()
+        let (integerState, realState, boolState, stringState) = interpeter.getState()
+        XCTAssert(realState == [:])
+        XCTAssert(integerState == ["x": 6])
+        XCTAssert(boolState == [:])
+        XCTAssert(stringState == [:])
+    }
 }
diff --git a/PascalInterpreter/PascalInterpreterTests/LexerTests.swift b/PascalInterpreter/PascalInterpreterTests/LexerTests.swift
@@ -434,4 +434,19 @@ class LexerTests: XCTestCase {
         XCTAssert(lexer.getNextToken() == .constant(.string("Test string")))
         XCTAssert(lexer.getNextToken() == .eof)
     }
+
+    func testLoopTokens() {
+        let lexer = Lexer("repeat x:= x+1 until x=5")
+        XCTAssert(lexer.getNextToken() == .repeat)
+        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() == .until)
+        XCTAssert(lexer.getNextToken() == .id("x"))
+        XCTAssert(lexer.getNextToken() == .equals)
+        XCTAssert(lexer.getNextToken() == .constant(.integer(5)))
+        XCTAssert(lexer.getNextToken() == .eof)
+    }
 }