✨ adding support for unary operations

Author: igorkulman

SwiftPascalInterpreter/SwiftPascalInterpreter/AST.swift

@@ -10,5 +10,6 @@ import Foundation
 
 public enum AST {
     case number(Int)
+    indirect case unaryOperation(operation: Operation, child: AST)
     indirect case binaryOperation(left: AST, operation: Operation, right: AST)
 }

SwiftPascalInterpreter/SwiftPascalInterpreter/Extensions.swift

@@ -121,6 +121,8 @@ extension AST: CustomStringConvertible {
             switch node {
             case let .number(value):
                 return ("\(value)", nil, nil)
+            case let .unaryOperation(operation: operation, child: child):
+                return ("u\(operation.shortDescription)", child, nil)
             case let .binaryOperation(left: left, operation: operation, right: right):
                 return ("\(operation.shortDescription)", left, right)
             }
@@ -133,6 +135,8 @@ extension AST: Equatable {
         switch (lhs, rhs) {
         case let (.number(left), .number(right)):
             return left == right
+        case let (.unaryOperation(operation: leftOperation, child: leftChild), .unaryOperation(operation: rightOperation, child: rightChild)):
+            return leftOperation == rightOperation && leftChild == rightChild
         case let (.binaryOperation(left: leftLeft, operation: leftOperation, right: leftRight), .binaryOperation(left: rightLeft, operation: rightOperation, right: rightRight)):
             return leftLeft == rightLeft && leftOperation == rightOperation && leftRight == rightRight
         default:

SwiftPascalInterpreter/SwiftPascalInterpreter/Interpreter.swift

@@ -24,6 +24,15 @@ public class Interpreter {
         switch node {
         case let .number(value):
             return value
+        case let .unaryOperation(operation: operation, child: child):
+            switch operation {
+            case .plus:
+                return +visit(child)
+            case .minus:
+                return -visit(child)
+            default:
+                fatalError("Unsupported unary operation \(operation)")
+            }
         case let .binaryOperation(left: left, operation: operation, right: right):
             switch operation {
             case .plus:

SwiftPascalInterpreter/SwiftPascalInterpreter/Notations.swift

@@ -31,6 +31,8 @@ public class RPN: Notation {
         switch node {
         case let .number(value):
             return "\(value)"
+        case let .unaryOperation(operation: operation, child: child):
+            return "\(visit(child)) \(operation.shortDescription)"
         case let .binaryOperation(left: left, operation: operation, right: right):
             return "\(visit(left)) \(visit(right)) \(operation.shortDescription)"
         }
@@ -56,6 +58,8 @@ public class LISPNotation: Notation {
         switch node {
         case let .number(value):
             return "\(value)"
+        case let .unaryOperation(operation: operation, child: child):
+            return "(\(operation.shortDescription) \(visit(child)))"
         case let .binaryOperation(left: left, operation: operation, right: right):
             return "(\(operation.shortDescription) \(visit(left)) \(visit(right)))"
         }

SwiftPascalInterpreter/SwiftPascalInterpreter/Parser.swift

@@ -46,6 +46,12 @@ public class Parser {
             let result = expr()
             eat(.parenthesis(.right))
             return result
+        case .operation(.plus):
+            eat(.operation(.plus))
+            return .unaryOperation(operation: .plus, child: factor())
+        case .operation(.minus):
+            eat(.operation(.minus))
+            return .unaryOperation(operation: .minus, child: factor())
         default:
             fatalError("Syntax error")
         }
@@ -78,7 +84,7 @@ public class Parser {
 
      expr   : term (PLUS | MINUS) term)*
      term   : factor ((MUL | DIV) factor)*
-     factor : INTEGER | LPAREN factor RPAREN
+     factor : (PLUS | MINUS) factor | INTEGER | LPAREN factor RPAREN
 
      Returns: AST node
      */

SwiftPascalInterpreter/SwiftPascalInterpreterTests/InterpreterTests.swift

@@ -30,4 +30,10 @@ class InterpreterTests: XCTestCase {
         XCTAssert(Interpreter("7 + 3 * (10 / (12 / (3 + 1) - 1)) / (2 + 3) - 5 - 3 + (8)").eval() == 10)
         XCTAssert(Interpreter("7 + (((3 + 2)))").eval() == 12)
     }
+
+    func testUnaryOperations() {
+        let interpeter = Interpreter("5 - - -2")
+        let result = interpeter.eval()
+        XCTAssert(result == 3)
+    }
 }

SwiftPascalInterpreter/SwiftPascalInterpreterTests/LexerTests.swift

@@ -155,4 +155,15 @@ class LexerTests: XCTestCase {
         XCTAssert(lexer.getNextToken() == .parenthesis(.right))
         XCTAssert(lexer.getNextToken() == .eof)
     }
+
+    func testUnaryOperators() {
+        let lexer = Lexer("5 - - - 2")
+
+        XCTAssert(lexer.getNextToken() == .integer(5))
+        XCTAssert(lexer.getNextToken() == .operation(.minus))
+        XCTAssert(lexer.getNextToken() == .operation(.minus))
+        XCTAssert(lexer.getNextToken() == .operation(.minus))
+        XCTAssert(lexer.getNextToken() == .integer(2))
+        XCTAssert(lexer.getNextToken() == .eof)
+    }
 }

SwiftPascalInterpreter/SwiftPascalInterpreterTests/ParserTests.swift

@@ -56,4 +56,15 @@ class ParserTests: XCTestCase {
         let result = parser.expr()
         XCTAssert(result == node)
     }
+
+    func testUnaryOperatorNodesNodes() {
+        let five = AST.number(5)
+        let two = AST.number(2)
+        let un1 = AST.unaryOperation(operation: .minus, child: two)
+        let un2 = AST.unaryOperation(operation: .minus, child: un1)
+        let node = AST.binaryOperation(left: five, operation: .minus, right: un2)
+        let parser = Parser("5 - - - 2")
+        let result = parser.expr()
+        XCTAssert(result == node)
+    }
 }