🚧 basic recursion

Author: igorkulman

PascalInterpreter/PascalInterpreter.xcodeproj/project.pbxproj

@@ -9,7 +9,7 @@
 /* Begin PBXBuildFile section */
 		F300A0A51FDDB63F00E5894D /* PascalInterpreter.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F300A09B1FDDB63F00E5894D /* PascalInterpreter.framework */; };
 		F300A0AC1FDDB63F00E5894D /* PascalInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = F300A09E1FDDB63F00E5894D /* PascalInterpreter.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		F300A0C71FDDB6BE00E5894D /* Result.swift in Sources */ = {isa = PBXBuildFile; fileRef = F300A0C41FDDB6BD00E5894D /* Result.swift */; };
+		F300A0C71FDDB6BE00E5894D /* Value.swift in Sources */ = {isa = PBXBuildFile; fileRef = F300A0C41FDDB6BD00E5894D /* Value.swift */; };
 		F300A0C81FDDB6BE00E5894D /* Arithmetics.swift in Sources */ = {isa = PBXBuildFile; fileRef = F300A0C51FDDB6BE00E5894D /* Arithmetics.swift */; };
 		F300A0C91FDDB6BE00E5894D /* Interpreter.swift in Sources */ = {isa = PBXBuildFile; fileRef = F300A0C61FDDB6BE00E5894D /* Interpreter.swift */; };
 		F300A0D11FDDB6E400E5894D /* Lexer.swift in Sources */ = {isa = PBXBuildFile; fileRef = F300A0CE1FDDB6E300E5894D /* Lexer.swift */; };
@@ -50,7 +50,7 @@
 		F300A09F1FDDB63F00E5894D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		F300A0A41FDDB63F00E5894D /* PascalInterpreterTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = PascalInterpreterTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		F300A0AB1FDDB63F00E5894D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		F300A0C41FDDB6BD00E5894D /* Result.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Result.swift; sourceTree = "<group>"; };
+		F300A0C41FDDB6BD00E5894D /* Value.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Value.swift; sourceTree = "<group>"; };
 		F300A0C51FDDB6BE00E5894D /* Arithmetics.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Arithmetics.swift; sourceTree = "<group>"; };
 		F300A0C61FDDB6BE00E5894D /* Interpreter.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Interpreter.swift; sourceTree = "<group>"; };
 		F300A0CE1FDDB6E300E5894D /* Lexer.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Lexer.swift; sourceTree = "<group>"; };
@@ -142,7 +142,7 @@
 				F300A0C51FDDB6BE00E5894D /* Arithmetics.swift */,
 				F3EF28CF1FE12EBF001F36AB /* Frame.swift */,
 				F300A0C61FDDB6BE00E5894D /* Interpreter.swift */,
-				F300A0C41FDDB6BD00E5894D /* Result.swift */,
+				F300A0C41FDDB6BD00E5894D /* Value.swift */,
 				F3EF28D11FE12F4D001F36AB /* Stack.swift */,
 			);
 			path = Interpreter;
@@ -347,7 +347,7 @@
 			files = (
 				F300A0C91FDDB6BE00E5894D /* Interpreter.swift in Sources */,
 				F3EF28D01FE12EBF001F36AB /* Frame.swift in Sources */,
-				F300A0C71FDDB6BE00E5894D /* Result.swift in Sources */,
+				F300A0C71FDDB6BE00E5894D /* Value.swift in Sources */,
 				F3EF28D21FE12F4D001F36AB /* Stack.swift in Sources */,
 				F300A0E71FDDB74800E5894D /* SymbolTable.swift in Sources */,
 				F300A0D81FDDB6F400E5894D /* AST+Extensions.swift in Sources */,

PascalInterpreter/PascalInterpreter/FatalError.swift

@@ -11,9 +11,9 @@ import Foundation
 /**
  Taken from https://medium.com/@marcosantadev/how-to-test-fatalerror-in-swift-e1be9ff11a29
  */
-func fatalError(_ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Never {
+/*func fatalError(_ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Never {
     FatalErrorUtil.fatalErrorClosure(message(), file, line)
-}
+}*/
 
 struct FatalErrorUtil {
 

PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift

@@ -40,6 +40,10 @@ public class Interpreter {
             return eval(program: program)
         case let call as ProcedureCall:
             return eval(call: call)
+        case let condition as Condition:
+            return eval(condition: condition)
+        case let ifElse as IfElse:
+            return eval(ifElse: ifElse)
         default:
             return nil
         }
@@ -56,28 +60,28 @@ public class Interpreter {
 
         switch unaryOperation.operation {
         case .plus:
-            return  .number(+result)
+            return .number(+result)
         case .minus:
-            return  .number(-result)
+            return .number(-result)
         }
     }
     func eval(binaryOperation: BinaryOperation) -> Value? {
-        guard let leftValue = eval(node: binaryOperation.left), case let  .number(leftResult) = leftValue,
+        guard let leftValue = eval(node: binaryOperation.left), case let .number(leftResult) = leftValue,
             let rightValue = eval(node: binaryOperation.right), case let .number(rightResult) = rightValue else {
             fatalError("Cannot use binary \(binaryOperation.operation) on non numbers")
         }
 
         switch binaryOperation.operation {
         case .plus:
-            return  .number(leftResult + rightResult)
+            return .number(leftResult + rightResult)
         case .minus:
-            return  .number(leftResult - rightResult)
+            return .number(leftResult - rightResult)
         case .mult:
-            return  .number(leftResult * rightResult)
+            return .number(leftResult * rightResult)
         case .integerDiv:
-            return  .number(leftResult ‖ rightResult)
+            return .number(leftResult ‖ rightResult)
         case .floatDiv:
-            return  .number(leftResult / rightResult)
+            return .number(leftResult / rightResult)
         }
     }
 
@@ -101,7 +105,6 @@ public class Interpreter {
         guard let currentFrame = callStack.peek() else {
             fatalError("No call stack frame")
         }
-
         return currentFrame.get(variable: variable.name)
     }
 
@@ -121,13 +124,39 @@ public class Interpreter {
 
     func eval(call: ProcedureCall) -> Value? {
         let current = callStack.peek()!
-        let frame = Frame(scope: scopes[call.name]!, previousFrame: current)
+        let newScope = current.scope.level == 1 ? scopes[call.name]! : ScopedSymbolTable(name: call.name, level: scopes[call.name]!.level+1, enclosingScope: scopes[call.name]!)
+        let frame = Frame(scope: newScope, previousFrame: current)
         callStack.push(frame)
         callProcedure(procedure: call.name, params: call.actualParameters, frame: frame)
         callStack.pop()
         return nil
     }
 
+    func eval(condition: Condition) -> Value {
+        let left = eval(node: condition.leftSide)
+        let right = eval(node: condition.rightSide)
+
+        guard let leftResult = left, let rightResult = right else {
+            fatalError("Invalid condition \(left) = \(right)")
+        }
+
+        return .boolean(leftResult == rightResult)
+    }
+
+    func eval(ifElse: IfElse) -> Value? {
+        guard case let .boolean(value) = eval(condition: ifElse.condition) else {
+            fatalError("Condition not boolean")
+        }
+
+        if value {
+            return eval(node: ifElse.trueExpression)
+        } else if let falseExpression = ifElse.falseExpression {
+            return eval(node: falseExpression)
+        } else {
+            return nil
+        }
+    }
+
     private func callProcedure(procedure: String, params: [AST], frame: Frame) {
         guard let symbol = frame.scope.lookup(procedure), let procedureSymbol = symbol as? ProcedureSymbol else {
             fatalError("Symbol(procedure) not found '\(procedure)'")

PascalInterpreter/PascalInterpreter/Interpreter/Result.swift

@@ -0,0 +1,28 @@
+//
+//  Result.swift
+//  SwiftPascalInterpreter
+//
+//  Created by Igor Kulman on 10/12/2017.
+//  Copyright © 2017 Igor Kulman. All rights reserved.
+//
+
+import Foundation
+
+enum Value {
+    case number(Number)
+    case boolean(Bool)
+}
+
+extension Value: Equatable {
+    static func ==(lhs: Value, rhs: Value) -> Bool {
+        switch (lhs, rhs) {
+        case let (.number(left), .number(right)):
+            return left == right
+        case let (.boolean(left), .boolean(right)):
+            return left == right
+        default:
+            return false
+        }
+    }
+
+}

PascalInterpreter/PascalInterpreter/Interpreter/Value.swift

@@ -32,7 +32,10 @@ public class Lexer {
         "END": .end,
         "PROCEDURE": .procedure,
         "TRUE": .constant(.boolean(true)),
-        "FALSE": .constant(.boolean(false))
+        "FALSE": .constant(.boolean(false)),
+        "IF": .`if`,
+        "ELSE": .`else`,
+        "THEN": .then
     ]
 
     public init(_ text: String) {
@@ -223,6 +226,11 @@ public class Lexer {
                 return .parenthesis(.right)
             }
 
+            if currentCharacter == "=" {
+                advance()
+                return .equals
+            }
+
             fatalError("Unrecognized character \(currentCharacter) at position \(currentPosition)")
         }
 

PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift

@@ -43,6 +43,14 @@ extension Token: Equatable {
             return left == right
         case (.procedure, .procedure):
             return true
+        case (.if, .if):
+            return true
+        case (.else, .else):
+            return true
+        case (.equals, .equals):
+            return true
+        case (.then, .then):
+            return true
         default:
             return false
         }
@@ -56,6 +64,8 @@ extension Constant: Equatable {
             return left == right
         case let (.real(left), .real(right)):
             return left == right
+        case let (.boolean(left), .boolean(right)):
+            return left == right
         default:
             return false
         }
@@ -151,6 +161,14 @@ extension Token: CustomStringConvertible {
             return constant.description
         case .procedure:
             return "PROCEDURE"
+        case .`if`:
+            return "IF"
+        case .`else`:
+            return "ELSE"
+        case .then:
+            return "THEN"
+        case .equals:
+            return "EQUALS"
         }
     }
 }

PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift

@@ -50,4 +50,8 @@ public enum Token {
     case type(Type)
     case constant(Constant)
     case procedure
+    case `if`
+    case `else`
+    case then
+    case equals
 }

PascalInterpreter/PascalInterpreter/Lexer/Token.swift

@@ -30,6 +30,21 @@ extension Number: CustomStringConvertible {
     }
 }
 
+extension Number: Equatable {
+    public static func == (lhs: Number, rhs: Number) -> Bool {
+        switch (lhs, rhs) {
+        case let (.integer(left), .integer(right)):
+            return left == right
+        case let (.real(left), .real(right)):
+            return left == right
+        case let (.real(left), .integer(right)):
+            return left == Double(right)
+        case let (.integer(left), .real(right)):
+            return Double(left) == right
+        }
+    }
+}
+
 extension BinaryOperationType: CustomStringConvertible {
     public var description: String {
         switch self {
@@ -78,6 +93,10 @@ extension AST {
             return "param(\(param.name))"
         case let call as ProcedureCall:
             return "\(call.name)()"
+        case is IfElse:
+            return "IF"
+        case is Condition:
+            return "="
         default:
             fatalError("Missed AST case \(self)")
         }
@@ -123,6 +142,13 @@ extension AST {
             return [param.type]
         case let call as ProcedureCall:
             return call.actualParameters
+        case let ifelse as IfElse:
+            if let falseExpression = ifelse.falseExpression {
+                return [ifelse.condition, ifelse.trueExpression, falseExpression]
+            }
+            return [ifelse.condition, ifelse.trueExpression]
+        case let condition as Condition:
+            return [condition.leftSide, condition.rightSide]
         default:
             fatalError("Missed AST case \(self)")
         }

PascalInterpreter/PascalInterpreter/Parser/AST+Extensions.swift

@@ -152,3 +152,25 @@ class ProcedureCall: AST {
         self.actualParameters = actualParameters
     }
 }
+
+class Condition: AST {
+    let leftSide: AST
+    let rightSide: AST
+
+    init(leftSide: AST, rightSide: AST) {
+        self.leftSide = leftSide
+        self.rightSide = rightSide
+    }
+}
+
+class IfElse: AST {
+    let condition: Condition
+    let trueExpression: AST
+    let falseExpression: AST?
+
+    init(condition: Condition, trueExpression: AST, falseExpression: AST?) {
+        self.condition = condition
+        self.trueExpression = trueExpression
+        self.falseExpression = falseExpression
+    }
+}