🚧 adding procedure symbols to symbol table

Author: igorkulman

PascalInterpreter/PascalInterpreter.xcodeproj/project.pbxproj

@@ -174,10 +174,10 @@
 		F300A0E01FDDB74700E5894D /* Semantic analyzer */ = {
 			isa = PBXGroup;
 			children = (
-				F300A0E11FDDB74700E5894D /* Symbol+Extensions.swift */,
+				F300A0E41FDDB74700E5894D /* SemanticAnalyzer.swift */,
 				F300A0E21FDDB74700E5894D /* Symbol.swift */,
+				F300A0E11FDDB74700E5894D /* Symbol+Extensions.swift */,
 				F300A0E31FDDB74700E5894D /* SymbolTable.swift */,
-				F300A0E41FDDB74700E5894D /* SemanticAnalyzer.swift */,
 			);
 			path = "Semantic analyzer";
 			sourceTree = "<group>";

PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift

@@ -61,7 +61,7 @@ public class Interpreter {
                 fatalError("Assignment left side is not a variable")
             }
 
-            guard let symbol = symbolTable.lookup(name), case let .variable(name: _, type: type) = symbol else {
+            guard let symbol = symbolTable.lookup(name), case let .variable(name: _, type: .builtIn(type)) = symbol else {
                 fatalError("Variable \(name) not in the symbol table")
             }
 
@@ -84,7 +84,7 @@ public class Interpreter {
                 return nil
             }
         case let .variable(name):
-            guard let symbol = symbolTable.lookup(name), case let .variable(name: _, type: type) = symbol else {
+            guard let symbol = symbolTable.lookup(name), case let .variable(name: _, type: .builtIn(type)) = symbol else {
                 fatalError("Variable \(name) not in the symbol table")
             }
 

PascalInterpreter/PascalInterpreter/Semantic analyzer/SemanticAnalyzer.swift

@@ -55,7 +55,7 @@ public class SemanticAnalyzer {
                 fatalError("Duplicate identifier '\(name)' found")
             }
 
-            guard let resolved = symbolTable.lookup(type.description), case let .builtIn(symbolType) = resolved else {
+            guard let symbolType = symbolTable.lookup(type.description) else {
                 fatalError("Type not found '\(type.description)'")
             }
 
@@ -65,9 +65,19 @@ public class SemanticAnalyzer {
             visit(node: left)
         case .type:
             break
-        case .procedure:
-            // TODO: local scope
-            break
+        case let .procedure(name: name, params: params, block: _):
+            var parameters: [Symbol] = []
+            for param in params {
+                guard case let .param(name: name, type: .type(type)) = param else {
+                    fatalError("Only built int type parameters supported in procedure, got \(param)")
+                }
+                guard let symbol = symbolTable.lookup(type.description) else {
+                    fatalError("Type not found '\(type.description)'")
+                }
+                parameters.append(.variable(name: name, type: symbol))
+            }
+            let symbol = Symbol.procedure(name: name, params: parameters)
+            symbolTable.insert(symbol)
         case .param:
             break
         }

PascalInterpreter/PascalInterpreter/Semantic analyzer/Symbol+Extensions.swift

@@ -10,6 +10,10 @@ import Foundation
 
 extension BuiltInType: CustomStringConvertible {
     public var description: String {
+        return "<BuiltinTypeSymbol(name='\(self.name)')>"
+    }
+
+    public var name: String {
         switch self {
         case .integer:
             return "INTEGER"
@@ -25,7 +29,9 @@ extension Symbol: CustomStringConvertible {
         case let .builtIn(type):
             return type.description
         case let .variable(name: name, type: type):
-            return "<\(name):\(type)>"
+            return "<VarSymbol(name='\(name)', type='\(type.name)')>"
+        case let .procedure(name: name, params: params):
+            return "<ProcedureSymbol(name=\(name), parameters=[\(params.reduce("", { $0.description + "," + $1.description }))]>"
         }
     }
 }
@@ -43,3 +49,16 @@ extension Symbol: Equatable {
     }
 
 }
+
+extension Symbol {
+    public var name: String {
+        switch self {
+        case let .builtIn(type):
+            return type.name
+        case .procedure(name: let name, params: _):
+            return name
+        case .variable(name: let name, type: _):
+            return name
+        }
+    }
+}

PascalInterpreter/PascalInterpreter/Semantic analyzer/Symbol.swift

@@ -13,7 +13,8 @@ public enum BuiltInType {
     case real
 }
 
-public enum Symbol {
+public indirect enum Symbol {
     case builtIn(BuiltInType)
-    case variable(name: String, type: BuiltInType)
+    case variable(name: String, type: Symbol)
+    case procedure(name: String, params: [Symbol])
 }

PascalInterpreter/PascalInterpreter/Semantic analyzer/SymbolTable.swift

@@ -18,18 +18,12 @@ public class ScopedSymbolTable {
         self.name = name
         self.level = level
 
-        let integer = Symbol.builtIn(.integer)
-        let real = Symbol.builtIn(.real)
-        symbols[integer.description] = integer
-        symbols[real.description] = real
+        insert(.builtIn(.integer))
+        insert(.builtIn(.real))
     }
 
     func insert(_ symbol: Symbol) {
-        guard case let .variable(name: name, type: _) = symbol else {
-            fatalError("Cannot insert built in type \(symbol), only variables")
-        }
-
-        symbols[name] = symbol
+        symbols[symbol.name] = symbol
     }
 
     func lookup(_ name: String) -> Symbol? {
@@ -68,6 +62,12 @@ extension ScopedSymbolTable: CustomStringConvertible {
                 return false
             case (.variable, .variable):
                 return lhs.key < rhs.key
+            case (.procedure, .procedure):
+                return lhs.key < rhs.key
+            case (.procedure, _):
+                return false
+            case (_, .procedure):
+                return true
             }
         }) {
             lines.append("\(pair.key.padding(toLength: 7, withPad: " ", startingAt: 0)): \(pair.value)")