✨ working interpreter for the new grammar

Author: igorkulman

Playground.playground/Contents.swift

@@ -16,15 +16,15 @@ lexer.getNextToken()
 let program =
 """
 PROGRAM Part10AST;
-BEGIN
-    BEGIN
-        number := 2;
-        a := number;
-        b := 10 * a + 10 * number / 4;
-        c := a - - b
-    END;
-    x := 11;
-END.
+VAR
+   a, b : INTEGER;
+   y    : REAL;
+
+BEGIN {Part10AST}
+   a := 2;
+   b := 10 * a + 10 * a DIV 4;
+   y := 20 / 7 + 3.14;
+END.  {Part10AST}
 """
 
 let parser = Parser(program)

SwiftPascalInterpreter/SwiftPascalInterpreter/Extensions/AST+Extensions.swift

@@ -113,8 +113,8 @@ extension AST {
             var nodes = declarations
             nodes.append(compound)
             return nodes
-        case .variableDeclaration:
-            return []
+        case let .variableDeclaration(name: name, type: type):
+            return [name, type]
         case .type:
             return []
         case let .program(_, block):
@@ -140,8 +140,8 @@ extension AST {
             return ":="
         case .block:
             return "block"
-        case let .variableDeclaration(name, type):
-            return "\(name): \(type.description)"
+        case .variableDeclaration:
+            return "var"
         case let .type(type):
             return type.description
         case let .program(name, _):

SwiftPascalInterpreter/SwiftPascalInterpreter/Extensions/Token+Extensions.swift

@@ -53,6 +53,8 @@ extension Token: Equatable {
             return true
         case let (.integerConst(left), .integerConst(right)):
             return left == right
+        case let (.realConst(left), .realConst(right)):
+            return left == right
         default:
             return false
         }

SwiftPascalInterpreter/SwiftPascalInterpreter/Interpreter.swift

@@ -66,8 +66,17 @@ public class Interpreter {
             return value
         case .noOp:
             return nil
-        default:
+        case .block(let declarations, let compound):
+            for declaration in declarations {
+                visit(declaration)
+            }
+            return visit(compound)
+        case .variableDeclaration:
+            return nil
+        case .type:
             return nil
+        case let .program(_, block):
+            return visit(block)
         }
     }
 

SwiftPascalInterpreter/SwiftPascalInterpreter/Model/AST.swift

@@ -35,7 +35,7 @@ public enum AST {
     case variable(String)
     case noOp
     indirect case block(declarations: [AST], compound: AST)
-    indirect case variableDeclaration(name: String, type: AST)
+    indirect case variableDeclaration(name: AST, type: AST)
     case type(Type)
     indirect case program(name: String, block: AST)
 }

SwiftPascalInterpreter/SwiftPascalInterpreter/Parser.swift

@@ -108,7 +108,7 @@ public class Parser {
         eat(.colon)
 
         let type = typeSpec()
-        return variableNames.map({ .variableDeclaration(name: $0, type: type) })
+        return variableNames.map({ .variableDeclaration(name: .variable($0), type: type) })
     }
 
     /**
@@ -118,8 +118,10 @@ public class Parser {
     private func typeSpec() -> AST {
         switch currentToken {
         case .integer:
+            eat(.integer)
             return .type(.integer)
         case .real:
+            eat(.real)
             return .type(.real)
         default:
             fatalError("Expected type, got \(currentToken)")

SwiftPascalInterpreter/SwiftPascalInterpreterTests/InterpreterTests.swift

@@ -12,16 +12,25 @@ import Foundation
 import XCTest
 
 class InterpreterTests: XCTestCase {
-    func testSimpleDeclaration() {
-        let interpeter = Interpreter("BEGIN a := 2; END.")
+    func testSimpleProgram() {
+        let program =
+        """
+        PROGRAM Part10AST;
+        BEGIN
+            a := 2
+        END.
+        """
+
+        let interpeter = Interpreter(program)
         interpeter.interpret()
         let state = interpeter.getState()
         XCTAssert(state == ["a": 2])
     }
 
-    func testComplexDeclaration() {
+    func testMoreComplexProgram() {
         let program =
             """
+            PROGRAM Part10AST;
             BEGIN
                 BEGIN
                     number := 2;
@@ -38,4 +47,25 @@ class InterpreterTests: XCTestCase {
         let state = interpeter.getState()
         XCTAssert(state == ["b": 25, "number": 2, "a": 2, "x": 11, "c": 27])
     }
+
+    func testProgramWithDeclarations() {
+        let program =
+        """
+        PROGRAM Part10AST;
+        VAR
+            a, b : INTEGER;
+            y    : REAL;
+
+        BEGIN {Part10AST}
+            a := 2;
+            b := 10 * a + 10 * a DIV 4;
+            y := 20 / 7 + 3.14;
+        END.  {Part10AST}
+        """
+
+        let interpeter = Interpreter(program)
+        interpeter.interpret()
+        let state = interpeter.getState()
+        XCTAssert(state == ["b": 25, "number": 2, "a": 2, "x": 11, "c": 27])
+    }
 }

SwiftPascalInterpreter/SwiftPascalInterpreterTests/ParserTests.swift

@@ -13,12 +13,12 @@ import XCTest
 class ParserTests: XCTestCase {
     func testBasicCompoundStatement() {
         let program =
-        """
-        PROGRAM Part10AST;
-        BEGIN
-        a := 2
-        END.
-        """
+            """
+            PROGRAM Part10AST;
+            BEGIN
+                a := 2
+            END.
+            """
 
         let a = AST.variable("a")
         let two = AST.number(2)
@@ -89,4 +89,41 @@ class ParserTests: XCTestCase {
         let node = AST.program(name: "Part10AST", block: AST.block(declarations: [], compound: AST.compound(children: [compound, xAssignment, empty])))
         XCTAssert(result == node)
     }
+
+    func testProgramWithDeclarationsExpression() {
+        let program =
+            """
+            PROGRAM Part10AST;
+            VAR
+                a, b : INTEGER;
+                y    : REAL;
+            BEGIN
+                BEGIN
+                    number := 2;
+                    a := number;
+                    a := 10 * a + 10 * number / 4;
+                END;
+                x := 11;
+            END.
+            """
+
+        let parser = Parser(program)
+        let result = parser.parse()
+        let empty = AST.noOp
+        let eleven = AST.number(11)
+        let x = AST.variable("x")
+        let xAssignment = AST.assignment(left: x, right: eleven)
+        let two = AST.number(2)
+        let number = AST.variable("number")
+        let a = AST.variable("a")
+        let division = AST.binaryOperation(left: AST.binaryOperation(left: AST.number(10), operation: .mult, right: number), operation: .floatDiv, right: AST.number(4))
+        let plus = AST.binaryOperation(left: AST.binaryOperation(left: AST.number(10), operation: .mult, right: a), operation: .plus, right: division)
+        let aAssignment = AST.assignment(left: a, right: plus)
+        let compound = AST.compound(children: [AST.assignment(left: number, right: two), AST.assignment(left: a, right: number), aAssignment, empty])
+        let aDec = AST.variableDeclaration(name: AST.variable("a"), type: .type(.integer))
+        let bDec = AST.variableDeclaration(name: AST.variable("b"), type: .type(.integer))
+        let yDec = AST.variableDeclaration(name: AST.variable("y"), type: .type(.real))
+        let node = AST.program(name: "Part10AST", block: AST.block(declarations: [aDec, bDec, yDec], compound: AST.compound(children: [compound, xAssignment, empty])))
+        XCTAssert(result == node)
+    }
 }