♻️ simplifying the Parser

Author: igorkulman

SwiftPascalInterpreter/SwiftPascalInterpreter/Parser.swift

@@ -17,48 +17,34 @@ public class Parser {
         currentToken = lexer.getNextToken()
     }
 
-    private func eatInteger() {
-        switch currentToken {
-        case .integer:
-            currentToken = lexer.getNextToken()
-        default:
-            fatalError("Expected integer, got \(currentToken)")
-        }
-    }
-
-    private func eatOperation(_ operation: Operation) {
-        switch currentToken {
-        case .operation(operation):
-            currentToken = lexer.getNextToken()
-        default:
-            fatalError("Expected \(operation), got \(currentToken)")
-        }
-    }
+    /**
+     Compares the current token with the given token, if they match, the next token is read, otherwise an error is thrown
 
-    private func eatParenthesis(_ parenthesis: Parenthesis) {
-        switch currentToken {
-        case .parenthesis(parenthesis):
+     - Parameter token: Expected token
+     */
+    private func eat(_ token: Token) {
+        if currentToken == token {
             currentToken = lexer.getNextToken()
-        default:
-            fatalError("Expected \(parenthesis), got \(currentToken)")
+        } else {
+            fatalError("Syntax error, expected token, got \(currentToken)")
         }
     }
 
     /**
      Factor for the grammar described in the `expr` method
 
-     Returns: Int value
+     Returns: AST node
      */
     private func factor() -> AST {
         let token = currentToken
         switch token {
         case let .integer(value):
-            eatInteger()
+            eat(.integer(value))
             return .number(value)
         case .parenthesis(.left):
-            eatParenthesis(.left)
+            eat(.parenthesis(.left))
             let result = expr()
-            eatParenthesis(.right)
+            eat(.parenthesis(.right))
             return result
         default:
             fatalError("Syntax error")
@@ -68,18 +54,18 @@ public class Parser {
     /**
      Term for the grammar described in the `expr` method
 
-     Returns: Int value
+     Returns: AST node
      */
     private func term() -> AST {
         var node = factor()
 
         while [.operation(.mult), .operation(.div)].contains(currentToken) {
             let token = currentToken
             if token == .operation(.mult) {
-                eatOperation(.mult)
+                eat(.operation(.mult))
                 node = .binaryOperation(left: node, operation: .mult, right: factor())
             } else if token == .operation(.div) {
-                eatOperation(.div)
+                eat(.operation(.div))
                 node = .binaryOperation(left: node, operation: .div, right: factor())
             }
         }
@@ -94,7 +80,7 @@ public class Parser {
      term   : factor ((MUL | DIV) factor)*
      factor : INTEGER | LPAREN factor RPAREN
 
-     Returns: Int value
+     Returns: AST node
      */
     public func expr() -> AST {
 
@@ -103,10 +89,10 @@ public class Parser {
         while [.operation(.plus), .operation(.minus)].contains(currentToken) {
             let token = currentToken
             if token == .operation(.plus) {
-                eatOperation(.plus)
+                eat(.operation(.plus))
                 node = .binaryOperation(left: node, operation: .plus, right: term())
             } else if token == .operation(.minus) {
-                eatOperation(.minus)
+                eat(.operation(.minus))
                 node = .binaryOperation(left: node, operation: .minus, right: term())
             }
         }