Merge pull request #16 from igorkulman/functions

Functions

Author: igorkulman

Images/playground.png

@@ -14,13 +14,20 @@ class Frame {
     var booleanMemory: [String: Bool] = [:]
     let scope: ScopedSymbolTable
     let previousFrame: Frame?
+    var returnValue: Value?
 
     init(scope: ScopedSymbolTable, previousFrame: Frame?) {
         self.scope = scope
         self.previousFrame = previousFrame
     }
 
     func set(variable: String, value: Value) {
+        // setting function return value
+        if variable == scope.name && scope.level > 1 {
+            returnValue = value
+            return
+        }
+
         // variable define in current scole (procedure declataion, etc)
         if let symbol = scope.lookup(variable, currentScopeOnly: true),
             let variableSymbol = symbol as? VariableSymbol,

PascalInterpreter/PascalInterpreter/Interpreter/Frame.swift

@@ -38,7 +38,7 @@ public class Interpreter {
             return eval(block: block)
         case let program as Program:
             return eval(program: program)
-        case let call as ProcedureCall:
+        case let call as FunctionCall:
             return eval(call: call)
         case let condition as Condition:
             return eval(condition: condition)
@@ -122,14 +122,14 @@ public class Interpreter {
         return eval(node: program.block)
     }
 
-    func eval(call: ProcedureCall) -> Value? {
+    func eval(call: FunctionCall) -> Value? {
         let current = callStack.peek()!
         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)
+        let result = callFunction(function: call.name, params: call.actualParameters, frame: frame)
         callStack.pop()
-        return nil
+        return result
     }
 
     func eval(condition: Condition) -> Value {
@@ -164,9 +164,9 @@ public class Interpreter {
         }
     }
 
-    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)'")
+    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)'")
         }
 
         if procedureSymbol.params.count > 0 {
@@ -180,6 +180,7 @@ public class Interpreter {
         }
 
         eval(node: procedureSymbol.body.block)
+        return frame.returnValue
     }
 
     public func interpret() {

PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift

@@ -35,7 +35,8 @@ public class Lexer {
         "FALSE": .constant(.boolean(false)),
         "IF": .`if`,
         "ELSE": .`else`,
-        "THEN": .then
+        "THEN": .then,
+        "FUNCTION": .function
     ]
 
     public init(_ text: String) {

PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift

@@ -55,6 +55,8 @@ extension Token: Equatable {
             return true
         case (.greaterThan, .greaterThan):
             return true
+        case (.function, .function):
+            return true
         default:
             return false
         }
@@ -177,6 +179,8 @@ extension Token: CustomStringConvertible {
             return "LT"
         case .greaterThan:
             return "GT"
+        case .function:
+            return "FUNCTION"
         }
     }
 }

PascalInterpreter/PascalInterpreter/Lexer/Token+Extensions.swift

@@ -56,4 +56,5 @@ public enum Token {
     case equals
     case lessThan
     case greaterThan
+    case function
 }

PascalInterpreter/PascalInterpreter/Lexer/Token.swift

@@ -100,11 +100,13 @@ extension AST {
             return "\(type.type)"
         case let program as Program:
             return program.name
+        case let function as Function:
+            return "\(function.name):\(function.returnType.type)"
         case let procedure as Procedure:
             return procedure.name
         case let param as Param:
             return "param(\(param.name))"
-        case let call as ProcedureCall:
+        case let call as FunctionCall:
             return "\(call.name)()"
         case is IfElse:
             return "IF"
@@ -144,6 +146,13 @@ extension AST {
             return []
         case let program as Program:
             return [program.block]
+        case let function as Function:
+            var nodes: [AST] = []
+            for param in function.params {
+                nodes.append(param)
+            }
+            nodes.append(function.block)
+            return nodes
         case let procedure as Procedure:
             var nodes: [AST] = []
             for param in procedure.params {
@@ -153,7 +162,7 @@ extension AST {
             return nodes
         case let param as Param:
             return [param.type]
-        case let call as ProcedureCall:
+        case let call as FunctionCall:
             return call.actualParameters
         case let ifelse as IfElse:
             if let falseExpression = ifelse.falseExpression {

PascalInterpreter/PascalInterpreter/Parser/AST+Extensions.swift

@@ -139,6 +139,15 @@ class Procedure: Declaration {
     }
 }
 
+class Function: Procedure {
+    let returnType: VariableType
+
+    init(name: String, params: [Param], block: Block, returnType: VariableType) {
+        self.returnType = returnType
+        super.init(name: name, params: params, block: block)
+    }
+}
+
 class Param: AST {
     let name: String
     let type: VariableType
@@ -149,7 +158,7 @@ class Param: AST {
     }
 }
 
-class ProcedureCall: AST {
+class FunctionCall: AST {
     let name: String
     let actualParameters: [AST]
 

PascalInterpreter/PascalInterpreter/Parser/AST.swift

@@ -81,6 +81,7 @@ public class Parser {
     /**
      declarations : VAR (variable_declaration SEMI)+
      | (PROCEDURE ID (LPAREN formal_parameter_list RPAREN)? SEMI block SEMI)*
+     | (FUNCTION ID (LPAREN formal_parameter_list RPAREN)? COLON type_spec SEMI block SEMI)*
      | empty
      */
     private func declarations() -> [Declaration] {
@@ -118,6 +119,30 @@ public class Parser {
             eat(.semi)
         }
 
+        while currentToken == .function {
+            eat(.function)
+            guard case let .id(name) = currentToken else {
+                fatalError("Function name expected, got \(currentToken)")
+            }
+            eat(.id(name))
+
+            var params: [Param] = []
+            if currentToken == .parenthesis(.left) {
+                eat(.parenthesis(.left))
+                params = formalParameterList()
+                eat(.parenthesis(.right))
+            }
+
+            eat(.colon)
+            let type = typeSpec()
+
+            eat(.semi)
+            let body = block()
+            let function = Function(name: name, params: params, block: body, returnType: type)
+            declarations.append(function)
+            eat(.semi)
+        }
+
         return declarations
     }
 
@@ -255,7 +280,7 @@ public class Parser {
             return ifElseStatement()
         case .id:
             if nextToken == .parenthesis(.left) {
-                return procedureCall()
+                return functionCall()
             } else {
                 return assignmentStatement()
             }
@@ -267,9 +292,9 @@ public class Parser {
     /**
      Rule:
 
-     procedure_call : id( (factor (factor,)* )* )
+     function_call : id LPAREN (factor (factor COLON)* )* RPAREN
      */
-    private func procedureCall() -> ProcedureCall {
+    private func functionCall() -> FunctionCall {
         guard case let .id(name) = currentToken else {
             fatalError("Procedure name expected, got \(currentToken)")
         }
@@ -291,7 +316,7 @@ public class Parser {
             eat(.parenthesis(.right))
         }
 
-        return ProcedureCall(name: name, actualParameters: parameters)
+        return FunctionCall(name: name, actualParameters: parameters)
     }
 
     /**
@@ -431,6 +456,7 @@ public class Parser {
      | REAL_CONST
      | LPAREN expr RPAREN
      | variable
+     | function_call
      */
     private func factor() -> AST {
         let token = currentToken
@@ -453,7 +479,11 @@ public class Parser {
             eat(.parenthesis(.right))
             return result
         default:
-            return variable()
+            if nextToken == .parenthesis(.left) {
+                return functionCall()
+            } else {
+                return variable()
+            }
         }
     }
 

PascalInterpreter/PascalInterpreter/Parser/Parser.swift

@@ -54,6 +54,10 @@ public class SemanticAnalyzer: Visitor {
         scope.insert(VariableSymbol(name: variableDeclaration.variable.name, type: symbolType))
     }
 
+    func visit(function: Function) {
+        visit(procedure: function)
+    }
+
     func visit(procedure: Procedure) {
         let scope = ScopedSymbolTable(name: procedure.name, level: (currentScope?.level ?? 0) + 1, enclosingScope: currentScope)
         scopes[scope.name] = scope
@@ -68,14 +72,24 @@ public class SemanticAnalyzer: Visitor {
             parameters.append(variable)
             scope.insert(variable)
         }
-        let proc = ProcedureSymbol(name: procedure.name, parameters: parameters, body: procedure)
-        scope.enclosingScope?.insert(proc)
+
+        switch procedure {
+        case let function as Function:
+            guard let symbol = scope.lookup(function.returnType.type.description) else {
+                fatalError("Type not found '\(function.returnType.type.description)'")
+            }
+            let fn = FunctionSymbol(name: procedure.name, parameters: parameters, body: procedure, returnType: symbol)
+            scope.enclosingScope?.insert(fn)
+        default:
+            let proc = ProcedureSymbol(name: procedure.name, parameters: parameters, body: procedure)
+            scope.enclosingScope?.insert(proc)
+        }
 
         visit(node: procedure.block)
         currentScope = currentScope?.enclosingScope
     }
 
-    func visit(call: ProcedureCall) {
+    func visit(call: FunctionCall) {
         guard let symbol = currentScope?.lookup(call.name), let procedure = symbol as? ProcedureSymbol else {
             fatalError("Symbol(procedure) not found '\(call.name)'")
         }