✨ Parser working for the new grammar

Author: igorkulman

Playground.playground/Contents.swift

@@ -15,6 +15,7 @@ lexer.getNextToken()
 
 let program =
 """
+PROGRAM Part10AST;
 BEGIN
     BEGIN
         number := 2;

SwiftPascalInterpreter/SwiftPascalInterpreter/Extensions/AST+Extensions.swift

@@ -39,6 +39,8 @@ extension AST: Equatable {
             return leftDeclarations == rightDeclarations && leftCompound == rightCompound
         case let (.variableDeclaration(name: leftName, type: leftType), .variableDeclaration(name: rightName, type: rightType)):
             return leftName == rightName && leftType == rightType
+        case let (.program(name: leftName, block: leftBlock), .program(name: rightName, block: rightBlock)):
+            return leftName == rightName && leftBlock == rightBlock
         default:
             return false
         }
@@ -115,6 +117,8 @@ extension AST {
             return []
         case .type:
             return []
+        case let .program(_, block):
+            return [block]
         }
     }
 
@@ -140,6 +144,8 @@ extension AST {
             return "\(name): \(type.description)"
         case let .type(type):
             return type.description
+        case let .program(name, _):
+            return name
         }
     }
 

SwiftPascalInterpreter/SwiftPascalInterpreter/Model/AST.swift

@@ -37,4 +37,5 @@ public enum AST {
     indirect case block(declarations: [AST], compound: AST)
     indirect case variableDeclaration(name: String, type: AST)
     case type(Type)
+    indirect case program(name: String, block: AST)
 }

SwiftPascalInterpreter/SwiftPascalInterpreter/Parser.swift

@@ -41,12 +41,19 @@ public class Parser {
     /**
      Rule:
 
-     program : compound_statement DOT
+     program : PROGRAM variable SEMI block DOT
      */
     private func program() -> AST {
-        let node = compoundStatement()
+        eat(.program)
+        guard case let .id(name) = currentToken else {
+            fatalError("Program must have a name")
+        }
+        eat(.id(name))
+        eat(.semi)
+        let blockNode = block()
+        let programNode = AST.program(name: name, block: blockNode)
         eat(.dot)
-        return node
+        return programNode
     }
 
     /**
@@ -213,22 +220,22 @@ public class Parser {
     /**
      Rule:
 
-     term: factor ((MUL | DIV) factor)*
+     term : factor ((MUL | INTEGER_DIV | FLOAT_DIV) factor)*
      */
     private func term() -> AST {
         var node = factor()
 
-        while [.mult, .floatDiv, .integerDiv].contains(currentToken) {
+        while [.mult, .integerDiv, .floatDiv].contains(currentToken) {
             let token = currentToken
             if token == .mult {
                 eat(.mult)
                 node = .binaryOperation(left: node, operation: .mult, right: factor())
-            } else if token == .floatDiv {
-                eat(.floatDiv)
-                node = .binaryOperation(left: node, operation: .floatDiv, right: factor())
             } else if token == .integerDiv {
                 eat(.integerDiv)
                 node = .binaryOperation(left: node, operation: .integerDiv, right: factor())
+            } else if token == .floatDiv {
+                eat(.floatDiv)
+                node = .binaryOperation(left: node, operation: .floatDiv, right: factor())
             }
         }
 
@@ -253,9 +260,10 @@ public class Parser {
     /**
      Rule:
 
-     factor : PLUS  factor
+     factor : PLUS factor
      | MINUS factor
-     | INTEGER
+     | INTEGER_CONST
+     | REAL_CONST
      | LPAREN expr RPAREN
      | variable
      */
@@ -271,6 +279,9 @@ public class Parser {
         case let .integerConst(value):
             eat(.integerConst(value))
             return .number(value)
+        case let .realConst(value):
+            eat(.realConst(value))
+            return .number(Int(value.rounded(.toNearestOrEven))) //TODO: proper real types
         case .lparen:
             eat(.lparen)
             let result = expr()

SwiftPascalInterpreter/SwiftPascalInterpreterTests/LexerTests.swift

@@ -233,7 +233,7 @@ class LexerTests: XCTestCase {
         if case let .realConst(value) = lexer.getNextToken() {
             XCTAssert(abs(3.14 - value) < 0.01)
         } else {
-            XCTFail()
+            XCTFail("Given value differes from expected 3.14")
         }
         XCTAssert(lexer.getNextToken() == .eof)
     }

SwiftPascalInterpreter/SwiftPascalInterpreterTests/ParserTests.swift

@@ -12,19 +12,28 @@ import XCTest
 
 class ParserTests: XCTestCase {
     func testBasicCompoundStatement() {
+        let program =
+        """
+        PROGRAM Part10AST;
+        BEGIN
+        a := 2
+        END.
+        """
+
         let a = AST.variable("a")
         let two = AST.number(2)
         let assignment = AST.assignment(left: a, right: two)
-        let empty = AST.noOp
-        let node = AST.compound(children: [assignment, empty])
-        let parser = Parser("BEGIN a := 2; END.")
+        let block = AST.block(declarations: [], compound: AST.compound(children: [assignment]))
+        let node = AST.program(name: "Part10AST", block: block)
+        let parser = Parser(program)
         let result = parser.parse()
         XCTAssert(result == node)
     }
 
     func testMoreComplexExpression() {
         let program =
             """
+            PROGRAM Part10AST;
             BEGIN
                 BEGIN
                     number := 2;
@@ -45,13 +54,15 @@ class ParserTests: XCTestCase {
         let a = AST.variable("a")
         let aAssignment = AST.assignment(left: a, right: AST.binaryOperation(left: number, operation: .plus, right: two))
         let compound = AST.compound(children: [AST.assignment(left: number, right: two), aAssignment, empty])
-        let node = AST.compound(children: [compound, xAssignment, empty])
+        let block = AST.block(declarations: [], compound: AST.compound(children: [compound, xAssignment, empty]))
+        let node = AST.program(name: "Part10AST", block: block)
         XCTAssert(result == node)
     }
 
     func testEvenMoreComplexExpression() {
         let program =
             """
+            PROGRAM Part10AST;
             BEGIN
                 BEGIN
                     number := 2;
@@ -75,7 +86,7 @@ class ParserTests: XCTestCase {
         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 node = AST.compound(children: [compound, xAssignment, empty])
+        let node = AST.program(name: "Part10AST", block: AST.block(declarations: [], compound: AST.compound(children: [compound, xAssignment, empty])))
         XCTAssert(result == node)
     }
 }