Merge pull request #18 from igorkulman/repeat-until

Repeat until

Author: igorkulman

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

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.  

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 {

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)'")

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) {

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"
         }
     }
 }

PascalInterpreter/PascalInterpreter/Lexer/Token.swift

@@ -60,4 +60,6 @@ public enum Token {
     case greaterThan
     case function
     case apostrophe
+    case `repeat`
+    case until
 }

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)")
         }

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
+    }
+}

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: