🚧 adding Boolean support, support for evaluating method parameters

igorkulman · igorkulman · commit f5c71d29e80b · 2017-12-15T11:40:37.000+01:00
diff --git a/PascalInterpreter/PascalInterpreter/Interpreter/Frame.swift b/PascalInterpreter/PascalInterpreter/Interpreter/Frame.swift
@@ -11,6 +11,7 @@ import Foundation
 class Frame {
     var integerMemory: [String: Int] = [:]
     var realMemory: [String: Double] = [:]
+    var booleanMemory: [String: Bool] = [:]
     let scope: ScopedSymbolTable
     let previousFrame: Frame?
 
@@ -19,7 +20,7 @@ class Frame {
         self.previousFrame = previousFrame
     }
 
-    func set(variable: String, value: Number) {
+    func set(variable: String, value: Value) {
         // variable define in current scole (procedure declataion, etc)
         if let symbol = scope.lookup(variable, currentScopeOnly: true),
             let variableSymbol = symbol as? VariableSymbol,
@@ -28,17 +29,34 @@ class Frame {
             switch type {
             case .integer:
                 switch value {
-                case .integer(let value):
-                    integerMemory[variable] = value
-                case .real:
-                    fatalError("Cannot assign Real value to Int variable \(variable)")
+                case let .number(number):
+                    switch number {
+                    case let .integer(value):
+                        integerMemory[variable] = value
+                    case .real:
+                        fatalError("Cannot assign Real value to Int variable \(variable)")
+                    }
+                case .boolean:
+                    fatalError("Cannot assign Boolean value to Int variable \(variable)")
                 }
             case .real:
                 switch value {
-                case .integer(let value):
-                    realMemory[variable] = Double(value)
-                case .real(let value):
-                    realMemory[variable] = value
+                case let .number(number):
+                    switch number {
+                    case let .integer(value):
+                        realMemory[variable] = Double(value)
+                    case let .real(value):
+                        realMemory[variable] = value
+                    }
+                case .boolean:
+                    fatalError("Cannot assign Boolean value to Real variable \(variable)")
+                }
+            case .boolean:
+                switch value {
+                case let .boolean(boolean):
+                    booleanMemory[variable] = boolean
+                default:
+                    fatalError("Cannot assign \(value) value to Boolean variable \(variable)")
                 }
             }
             return
@@ -48,17 +66,19 @@ class Frame {
         previousFrame!.set(variable: variable, value: value)
     }
 
-    func get(variable: String) -> Number {
+    func get(variable: String) -> Value {
         // variable define in current scole (procedure declataion, etc)
         if let symbol = scope.lookup(variable, currentScopeOnly: true),
             let variableSymbol = symbol as? VariableSymbol,
             let type = variableSymbol.type as? BuiltInTypeSymbol {
 
             switch type {
             case .integer:
-                return .integer(integerMemory[variable]!)
+                return .number(.integer(integerMemory[variable]!))
             case .real:
-                return .real(realMemory[variable]!)
+                return .number(.real(realMemory[variable]!))
+            case .boolean:
+                return .boolean(booleanMemory[variable]!)
             }
         }
 
diff --git a/PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift b/PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift
@@ -20,7 +20,7 @@ public class Interpreter {
         scopes = semanticAnalyzer.analyze(node: tree)
     }
 
-    @discardableResult private func eval(node: AST) -> Number? {
+    @discardableResult private func eval(node: AST) -> Value? {
         switch node {
         case let number as Number:
             return eval(number: number)
@@ -45,49 +45,50 @@ public class Interpreter {
         }
     }
 
-    func eval(number: Number) -> Number? {
-        return number
+    func eval(number: Number) -> Value? {
+        return .number(number)
     }
 
-    func eval(unaryOperation: UnaryOperation) -> Number? {
-        guard let result = eval(node: unaryOperation.operand) else {
+    func eval(unaryOperation: UnaryOperation) -> Value? {
+        guard let value = eval(node: unaryOperation.operand), case let .number(result) = value else {
             fatalError("Cannot use unary \(unaryOperation.operation) on non number")
         }
 
         switch unaryOperation.operation {
         case .plus:
-            return +result
+            return  .number(+result)
         case .minus:
-            return -result
+            return  .number(-result)
         }
     }
-    func eval(binaryOperation: BinaryOperation) -> Number? {
-        guard let leftResult = eval(node: binaryOperation.left), let rightResult = eval(node: binaryOperation.right) else {
+    func eval(binaryOperation: BinaryOperation) -> Value? {
+        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 leftResult + rightResult
+            return  .number(leftResult + rightResult)
         case .minus:
-            return leftResult - rightResult
+            return  .number(leftResult - rightResult)
         case .mult:
-            return leftResult * rightResult
+            return  .number(leftResult * rightResult)
         case .integerDiv:
-            return leftResult ‖ rightResult
+            return  .number(leftResult ‖ rightResult)
         case .floatDiv:
-            return leftResult / rightResult
+            return  .number(leftResult / rightResult)
         }
     }
 
-    func eval(compound: Compound) -> Number? {
+    func eval(compound: Compound) -> Value? {
         for child in compound.children {
             eval(node: child)
         }
         return nil
     }
 
-    func eval(assignment: Assignment) -> Number? {
+    func eval(assignment: Assignment) -> Value? {
         guard let currentFrame = callStack.peek() else {
             fatalError("No call stack frame")
         }
@@ -96,29 +97,29 @@ public class Interpreter {
         return nil
     }
 
-    func eval(variable: Variable) -> Number? {
+    func eval(variable: Variable) -> Value? {
         guard let currentFrame = callStack.peek() else {
             fatalError("No call stack frame")
         }
 
         return currentFrame.get(variable: variable.name)
     }
 
-    func eval(block: Block) -> Number? {
+    func eval(block: Block) -> Value? {
         for declaration in block.declarations {
             eval(node: declaration)
         }
 
         return eval(node: block.compound)
     }
 
-    func eval(program: Program) -> Number? {
+    func eval(program: Program) -> Value? {
         let frame = Frame(scope: scopes["global"]!, previousFrame: nil)
         callStack.push(frame)
         return eval(node: program.block)
     }
 
-    func eval(call: ProcedureCall) -> Number? {
+    func eval(call: ProcedureCall) -> Value? {
         let current = callStack.peek()!
         let frame = Frame(scope: scopes[call.name]!, previousFrame: current)
         callStack.push(frame)
@@ -127,15 +128,18 @@ public class Interpreter {
         return nil
     }
 
-    private func callProcedure(procedure: String, params: [Number], frame: Frame) {
+    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)'")
         }
 
         if procedureSymbol.params.count > 0 {
 
             for i in 0 ... procedureSymbol.params.count - 1 {
-                frame.set(variable: procedureSymbol.params[i].name, value: params[i])
+                guard let evaluated = eval(node: params[i]) else {
+                    fatalError("Cannot assing empty value")
+                }
+                frame.set(variable: procedureSymbol.params[i].name, value: evaluated)
             }
         }
 
diff --git a/PascalInterpreter/PascalInterpreter/Interpreter/Result.swift b/PascalInterpreter/PascalInterpreter/Interpreter/Result.swift
@@ -8,7 +8,7 @@
 
 import Foundation
 
-enum Result {
-    case none
+enum Value {
     case number(Number)
+    case boolean(Bool)
 }
diff --git a/PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift b/PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift
@@ -27,9 +27,12 @@ public class Lexer {
         "DIV": .operation(.integerDiv),
         "INTEGER": .type(.integer),
         "REAL": .type(.real),
+        "BOOLEAN": .type(.boolean),
         "BEGIN": .begin,
         "END": .end,
-        "PROCEDURE": .procedure
+        "PROCEDURE": .procedure,
+        "TRUE": .constant(.boolean(true)),
+        "FALSE": .constant(.boolean(false))
     ]
 
     public init(_ text: String) {
diff --git a/PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift b/PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift
@@ -86,6 +86,8 @@ extension Type: CustomStringConvertible {
             return "INTEGER"
         case .real:
             return "REAL"
+        case .boolean:
+            return "BOOLEAN"
         }
     }
 }
@@ -108,6 +110,8 @@ extension Constant: CustomStringConvertible {
             return "INTEGER_CONST(\(value))"
         case let .real(value):
             return "REAL_CONST(\(value))"
+        case let .boolean(value):
+            return "BOOLEAN_CONST(\(value))"
         }
     }
 }
diff --git a/PascalInterpreter/PascalInterpreter/Lexer/Token.swift b/PascalInterpreter/PascalInterpreter/Lexer/Token.swift
@@ -24,11 +24,13 @@ public enum Parenthesis {
 public enum Constant {
     case integer(Int)
     case real(Double)
+    case boolean(Bool)
 }
 
 public enum Type {
     case integer
     case real
+    case boolean
 }
 
 public enum Token {
diff --git a/PascalInterpreter/PascalInterpreter/Parser/AST.swift b/PascalInterpreter/PascalInterpreter/Parser/AST.swift
@@ -25,6 +25,7 @@ public enum Number: AST {
     case integer(Int)
     case real(Double)
 }
+
 public protocol AST {
 }
 
@@ -144,9 +145,9 @@ class Param: AST {
 
 class ProcedureCall: AST {
     let name: String
-    let actualParameters: [Number]
+    let actualParameters: [AST]
 
-    init(name: String, actualParameters: [Number]) {
+    init(name: String, actualParameters: [AST]) {
         self.name = name
         self.actualParameters = actualParameters
     }
diff --git a/PascalInterpreter/PascalInterpreter/Semantic analyzer/SemanticAnalyzer.swift b/PascalInterpreter/PascalInterpreter/Semantic analyzer/SemanticAnalyzer.swift
@@ -89,21 +89,9 @@ public class SemanticAnalyzer: Visitor {
         }
 
         for i in 0 ... procedure.params.count - 1 {
-            guard let variableSymbol = procedure.params[i] as? VariableSymbol, let type = variableSymbol.type as? BuiltInTypeSymbol else {
+            guard let variableSymbol = procedure.params[i] as? VariableSymbol, variableSymbol.type is BuiltInTypeSymbol else {
                 fatalError("Procedure declared with wrong parameters '\(call.name)'")
             }
-
-            switch type {
-            case .integer:
-                switch call.actualParameters[i] {
-                case .integer:
-                    break
-                case .real:
-                    fatalError("Cannot assing Real to Integer parameter in procedure call '\(call.name)'")
-                }
-            case .real:
-                break
-            }
         }
     }
 }
diff --git a/PascalInterpreter/PascalInterpreter/Semantic analyzer/Symbol.swift b/PascalInterpreter/PascalInterpreter/Semantic analyzer/Symbol.swift
@@ -15,13 +15,16 @@ protocol Symbol {
 public enum BuiltInTypeSymbol: Symbol {
     case integer
     case real
+    case boolean
 
     var name: String {
         switch self {
         case .integer:
             return "INTEGER"
         case .real:
             return "REAL"
+        case .boolean:
+            return "BOOLEAN"
         }
     }
 }
diff --git a/PascalInterpreter/PascalInterpreter/Semantic analyzer/SymbolTable.swift b/PascalInterpreter/PascalInterpreter/Semantic analyzer/SymbolTable.swift
@@ -22,6 +22,7 @@ public class ScopedSymbolTable {
 
         insert(BuiltInTypeSymbol.integer)
         insert(BuiltInTypeSymbol.real)
+        insert(BuiltInTypeSymbol.boolean)
     }
 
     func insert(_ symbol: Symbol) {
diff --git a/Playground.playground/Sources/Extensions.swift b/Playground.playground/Sources/Extensions.swift

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public class Interpreter {`
`20`	`20`	`scopes = semanticAnalyzer.analyze(node: tree)`
`21`	`21`	`}`
`22`	`22`
`23`		`- @discardableResult private func eval(node: AST) -> Number? {`
	`23`	`+ @discardableResult private func eval(node: AST) -> Value? {`
`24`	`24`	`switch node {`
`25`	`25`	`case let number as Number:`
`26`	`26`	`return eval(number: number)`
`@@ -45,49 +45,50 @@ public class Interpreter {`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`48`		`- func eval(number: Number) -> Number? {`
`49`		`- return number`
	`48`	`+ func eval(number: Number) -> Value? {`
	`49`	`+ return .number(number)`
`50`	`50`	`}`
`51`	`51`
`52`		`- func eval(unaryOperation: UnaryOperation) -> Number? {`
`53`		`- guard let result = eval(node: unaryOperation.operand) else {`
	`52`	`+ func eval(unaryOperation: UnaryOperation) -> Value? {`
	`53`	`+ guard let value = eval(node: unaryOperation.operand), case let .number(result) = value else {`
`54`	`54`	`fatalError("Cannot use unary \(unaryOperation.operation) on non number")`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`switch unaryOperation.operation {`
`58`	`58`	`case .plus:`
`59`		`- return +result`
	`59`	`+ return .number(+result)`
`60`	`60`	`case .minus:`
`61`		`- return -result`
	`61`	`+ return .number(-result)`
`62`	`62`	`}`
`63`	`63`	`}`
`64`		`- func eval(binaryOperation: BinaryOperation) -> Number? {`
`65`		`- guard let leftResult = eval(node: binaryOperation.left), let rightResult = eval(node: binaryOperation.right) else {`
	`64`	`+ func eval(binaryOperation: BinaryOperation) -> Value? {`
	`65`	`+ guard let leftValue = eval(node: binaryOperation.left), case let .number(leftResult) = leftValue,`
	`66`	`+ let rightValue = eval(node: binaryOperation.right), case let .number(rightResult) = rightValue else {`
`66`	`67`	`fatalError("Cannot use binary \(binaryOperation.operation) on non numbers")`
`67`	`68`	`}`
`68`	`69`
`69`	`70`	`switch binaryOperation.operation {`
`70`	`71`	`case .plus:`
`71`		`- return leftResult + rightResult`
	`72`	`+ return .number(leftResult + rightResult)`
`72`	`73`	`case .minus:`
`73`		`- return leftResult - rightResult`
	`74`	`+ return .number(leftResult - rightResult)`
`74`	`75`	`case .mult:`
`75`		`- return leftResult * rightResult`
	`76`	`+ return .number(leftResult * rightResult)`
`76`	`77`	`case .integerDiv:`
`77`		`- return leftResult ‖ rightResult`
	`78`	`+ return .number(leftResult ‖ rightResult)`
`78`	`79`	`case .floatDiv:`
`79`		`- return leftResult / rightResult`
	`80`	`+ return .number(leftResult / rightResult)`
`80`	`81`	`}`
`81`	`82`	`}`
`82`	`83`
`83`		`- func eval(compound: Compound) -> Number? {`
	`84`	`+ func eval(compound: Compound) -> Value? {`
`84`	`85`	`for child in compound.children {`
`85`	`86`	`eval(node: child)`
`86`	`87`	`}`
`87`	`88`	`return nil`
`88`	`89`	`}`
`89`	`90`
`90`		`- func eval(assignment: Assignment) -> Number? {`
	`91`	`+ func eval(assignment: Assignment) -> Value? {`
`91`	`92`	`guard let currentFrame = callStack.peek() else {`
`92`	`93`	`fatalError("No call stack frame")`
`93`	`94`	`}`
`@@ -96,29 +97,29 @@ public class Interpreter {`
`96`	`97`	`return nil`
`97`	`98`	`}`
`98`	`99`
`99`		`- func eval(variable: Variable) -> Number? {`
	`100`	`+ func eval(variable: Variable) -> Value? {`
`100`	`101`	`guard let currentFrame = callStack.peek() else {`
`101`	`102`	`fatalError("No call stack frame")`
`102`	`103`	`}`
`103`	`104`
`104`	`105`	`return currentFrame.get(variable: variable.name)`
`105`	`106`	`}`
`106`	`107`
`107`		`- func eval(block: Block) -> Number? {`
	`108`	`+ func eval(block: Block) -> Value? {`
`108`	`109`	`for declaration in block.declarations {`
`109`	`110`	`eval(node: declaration)`
`110`	`111`	`}`
`111`	`112`
`112`	`113`	`return eval(node: block.compound)`
`113`	`114`	`}`
`114`	`115`
`115`		`- func eval(program: Program) -> Number? {`
	`116`	`+ func eval(program: Program) -> Value? {`
`116`	`117`	`let frame = Frame(scope: scopes["global"]!, previousFrame: nil)`
`117`	`118`	`callStack.push(frame)`
`118`	`119`	`return eval(node: program.block)`
`119`	`120`	`}`
`120`	`121`
`121`		`- func eval(call: ProcedureCall) -> Number? {`
	`122`	`+ func eval(call: ProcedureCall) -> Value? {`
`122`	`123`	`let current = callStack.peek()!`
`123`	`124`	`let frame = Frame(scope: scopes[call.name]!, previousFrame: current)`
`124`	`125`	`callStack.push(frame)`
`@@ -127,15 +128,18 @@ public class Interpreter {`
`127`	`128`	`return nil`
`128`	`129`	`}`
`129`	`130`
`130`		`- private func callProcedure(procedure: String, params: [Number], frame: Frame) {`
	`131`	`+ private func callProcedure(procedure: String, params: [AST], frame: Frame) {`
`131`	`132`	`guard let symbol = frame.scope.lookup(procedure), let procedureSymbol = symbol as? ProcedureSymbol else {`
`132`	`133`	`fatalError("Symbol(procedure) not found '\(procedure)'")`
`133`	`134`	`}`
`134`	`135`
`135`	`136`	`if procedureSymbol.params.count > 0 {`
`136`	`137`
`137`	`138`	`for i in 0 ... procedureSymbol.params.count - 1 {`
`138`		`- frame.set(variable: procedureSymbol.params[i].name, value: params[i])`
	`139`	`+ guard let evaluated = eval(node: params[i]) else {`
	`140`	`+ fatalError("Cannot assing empty value")`
	`141`	`+ }`
	`142`	`+ frame.set(variable: procedureSymbol.params[i].name, value: evaluated)`
`139`	`143`	`}`
`140`	`144`	`}`
`141`	`145`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`
`9`	`9`	`import Foundation`
`10`	`10`
`11`		`-enum Result {`
`12`		`- case none`
	`11`	`+enum Value {`
`13`	`12`	`case number(Number)`
	`13`	`+ case boolean(Bool)`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,8 @@ extension Type: CustomStringConvertible {`
`86`	`86`	`return "INTEGER"`
`87`	`87`	`case .real:`
`88`	`88`	`return "REAL"`
	`89`	`+ case .boolean:`
	`90`	`+ return "BOOLEAN"`
`89`	`91`	`}`
`90`	`92`	`}`
`91`	`93`	`}`
`@@ -108,6 +110,8 @@ extension Constant: CustomStringConvertible {`
`108`	`110`	`return "INTEGER_CONST(\(value))"`
`109`	`111`	`case let .real(value):`
`110`	`112`	`return "REAL_CONST(\(value))"`
	`113`	`+ case let .boolean(value):`
	`114`	`+ return "BOOLEAN_CONST(\(value))"`
`111`	`115`	`}`
`112`	`116`	`}`
`113`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,13 @@ public enum Parenthesis {`
`24`	`24`	`public enum Constant {`
`25`	`25`	`case integer(Int)`
`26`	`26`	`case real(Double)`
	`27`	`+ case boolean(Bool)`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`public enum Type {`
`30`	`31`	`case integer`
`31`	`32`	`case real`
	`33`	`+ case boolean`
`32`	`34`	`}`
`33`	`35`
`34`	`36`	`public enum Token {`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ public enum Number: AST {`
`25`	`25`	`case integer(Int)`
`26`	`26`	`case real(Double)`
`27`	`27`	`}`
	`28`	`+`
`28`	`29`	`public protocol AST {`
`29`	`30`	`}`
`30`	`31`
`@@ -144,9 +145,9 @@ class Param: AST {`
`144`	`145`
`145`	`146`	`class ProcedureCall: AST {`
`146`	`147`	`let name: String`
`147`		`- let actualParameters: [Number]`
	`148`	`+ let actualParameters: [AST]`
`148`	`149`
`149`		`- init(name: String, actualParameters: [Number]) {`
	`150`	`+ init(name: String, actualParameters: [AST]) {`
`150`	`151`	`self.name = name`
`151`	`152`	`self.actualParameters = actualParameters`
`152`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,21 +89,9 @@ public class SemanticAnalyzer: Visitor {`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`for i in 0 ... procedure.params.count - 1 {`
`92`		`- guard let variableSymbol = procedure.params[i] as? VariableSymbol, let type = variableSymbol.type as? BuiltInTypeSymbol else {`
	`92`	`+ guard let variableSymbol = procedure.params[i] as? VariableSymbol, variableSymbol.type is BuiltInTypeSymbol else {`
`93`	`93`	`fatalError("Procedure declared with wrong parameters '\(call.name)'")`
`94`	`94`	`}`
`95`		`-`
`96`		`- switch type {`
`97`		`- case .integer:`
`98`		`- switch call.actualParameters[i] {`
`99`		`- case .integer:`
`100`		`- break`
`101`		`- case .real:`
`102`		`- fatalError("Cannot assing Real to Integer parameter in procedure call '\(call.name)'")`
`103`		`- }`
`104`		`- case .real:`
`105`		`- break`
`106`		`- }`
`107`	`95`	`}`
`108`	`96`	`}`
`109`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,16 @@ protocol Symbol {`
`15`	`15`	`public enum BuiltInTypeSymbol: Symbol {`
`16`	`16`	`case integer`
`17`	`17`	`case real`
	`18`	`+ case boolean`
`18`	`19`
`19`	`20`	`var name: String {`
`20`	`21`	`switch self {`
`21`	`22`	`case .integer:`
`22`	`23`	`return "INTEGER"`
`23`	`24`	`case .real:`
`24`	`25`	`return "REAL"`
	`26`	`+ case .boolean:`
	`27`	`+ return "BOOLEAN"`
`25`	`28`	`}`
`26`	`29`	`}`
`27`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ public class ScopedSymbolTable {`
`22`	`22`
`23`	`23`	`insert(BuiltInTypeSymbol.integer)`
`24`	`24`	`insert(BuiltInTypeSymbol.real)`
	`25`	`+ insert(BuiltInTypeSymbol.boolean)`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`func insert(_ symbol: Symbol) {`