✨ support for operations with real numbers

Author: igorkulman

SwiftPascalInterpreter/SwiftPascalInterpreter/Extensions/AST+Extensions.swift

@@ -11,7 +11,9 @@ import Foundation
 extension AST: Equatable {
     public static func == (lhs: AST, rhs: AST) -> Bool {
         switch (lhs, rhs) {
-        case let (.number(left), .number(right)):
+        case let (.number(.integer(left)), .number(.integer(right))):
+            return left == right
+        case let (.number(.real(left)), .number(.real(right))):
             return left == right
         case let (.unaryOperation(operation: leftOperation, child: leftChild),
                   .unaryOperation(operation: rightOperation, child: rightChild)):
@@ -69,6 +71,17 @@ extension Type: CustomStringConvertible {
     }
 }
 
+extension Number: CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case let .integer(value):
+            return "INTEGER(\(value))"
+        case let .real(value):
+            return "REAL(\(value))"
+        }
+    }
+}
+
 extension BinaryOperation: CustomStringConvertible {
     public var description: String {
         switch self {
@@ -158,3 +171,68 @@ extension AST {
 
     public func printTree() { print(treeLines().joined(separator: "\n")) }
 }
+
+infix operator ‖: MultiplicationPrecedence
+
+extension Number {
+    static func + (left: Number, right: Number) -> Number {
+        switch (left, right) {
+        case let (.integer(left), .integer(right)):
+            return .integer(left + right)
+        case let (.real(left), .real(right)):
+            return .real(left + right)
+        case let (.integer(left), .real(right)):
+            return .real(Double(left) + right)
+        case let (.real(left), .integer(right)):
+            return .real(left + Double(right))
+        }
+    }
+
+    static func - (left: Number, right: Number) -> Number {
+        switch (left, right) {
+        case let (.integer(left), .integer(right)):
+            return .integer(left - right)
+        case let (.real(left), .real(right)):
+            return .real(left - right)
+        case let (.integer(left), .real(right)):
+            return .real(Double(left) - right)
+        case let (.real(left), .integer(right)):
+            return .real(left - Double(right))
+        }
+    }
+
+    static func * (left: Number, right: Number) -> Number {
+        switch (left, right) {
+        case let (.integer(left), .integer(right)):
+            return .integer(left * right)
+        case let (.real(left), .real(right)):
+            return .real(left * right)
+        case let (.integer(left), .real(right)):
+            return .real(Double(left) * right)
+        case let (.real(left), .integer(right)):
+            return .real(left * Double(right))
+        }
+    }
+
+    static func / (left: Number, right: Number) -> Number {
+        switch (left, right) {
+        case let (.integer(left), .integer(right)):
+            return .real(Double(left) / Double(right))
+        case let (.real(left), .real(right)):
+            return .real(left / right)
+        case let (.integer(left), .real(right)):
+            return .real(Double(left) / right)
+        case let (.real(left), .integer(right)):
+            return .real(left / Double(right))
+        }
+    }
+
+    static func ‖ (left: Number, right: Number) -> Number {
+        switch (left, right) {
+        case let (.integer(left), .integer(right)):
+            return .integer(left / right)
+        default:
+            fatalError("Integer division DIV can only be applied to two integers")
+        }
+    }
+}

SwiftPascalInterpreter/SwiftPascalInterpreter/Interpreter.swift

@@ -10,28 +10,39 @@ import Foundation
 
 public class Interpreter {
     private let parser: Parser
-    private var globalScope: [String: Int] = [:]
+    private var globalIntegers: [String: Int] = [:]
+    private var globalReals: [String: Double] = [:]
 
     public init(_ text: String) {
         parser = Parser(text)
     }
 
-    @discardableResult private func visit(_ node: AST) -> Int? {
+    @discardableResult private func eval(_ node: AST) -> Number? {
         switch node {
         case let .number(value):
             return value
         case let .unaryOperation(operation: operation, child: child):
-            guard let result = visit(child) else {
+            guard let result = eval(child) else {
                 fatalError("Cannot use unary \(operation) on non number")
             }
             switch operation {
             case .plus:
-                return +result
+                switch result {
+                case let .integer(value):
+                    return .integer(+value)
+                case let .real(value):
+                    return .real(+value)
+                }
             case .minus:
-                return -result
+                switch result {
+                case let .integer(value):
+                    return .integer(-value)
+                case let .real(value):
+                    return .real(-value)
+                }
             }
         case let .binaryOperation(left: left, operation: operation, right: right):
-            guard let leftResult = visit(left), let rightResult = visit(right) else {
+            guard let leftResult = eval(left), let rightResult = eval(right) else {
                 fatalError("Cannot use binary \(operation) on non numbers")
             }
             switch operation {
@@ -42,54 +53,88 @@ public class Interpreter {
             case .mult:
                 return leftResult * rightResult
             case .integerDiv:
-                return leftResult / rightResult
+                return leftResult ‖ rightResult
             case .floatDiv:
                 return leftResult / rightResult
             }
         case let .compound(children):
             for chid in children {
-                visit(chid)
+                eval(chid)
             }
             return nil
         case let .assignment(left, right):
             switch left {
             case let .variable(name):
-                globalScope[name] = visit(right)!
+                if globalIntegers.keys.contains(name) {
+                    guard let result = eval(right) else {
+                        fatalError("Cannot assign empty value to variable \(name)")
+                    }
+                    switch result {
+                    case let .integer(value):
+                        globalIntegers[name] = value
+                    case .real:
+                        fatalError("Cannot assign real value to Int variable \(name)")
+                    }
+                }
+                if globalReals.keys.contains(name) {
+                    guard let result = eval(right) else {
+                        fatalError("Cannot assign empty value to variable \(name)")
+                    }
+                    switch result {
+                    case let .integer(value):
+                        globalReals[name] = Double(value)
+                    case let .real(value):
+                        globalReals[name] = value
+                    }
+                }
                 return nil
             default:
                 fatalError("Assignment left side is not a variable")
             }
         case let .variable(name):
-            guard let value = globalScope[name] else {
-                fatalError("Variable \(name) not found")
+            if let value = globalIntegers[name] {
+                return .integer(value)
             }
-            return value
+            if let value = globalReals[name] {
+                return .real(value)
+            }
+            fatalError("Variable \(name) not declared")
         case .noOp:
             return nil
-        case .block(let declarations, let compound):
+        case let .block(declarations, compound):
             for declaration in declarations {
-                visit(declaration)
+                eval(declaration)
+            }
+            return eval(compound)
+        case let .variableDeclaration(name: variable, type: variableType):
+            guard case let .variable(name) = variable, case let .type(type) = variableType else {
+                fatalError("Invalid variable declaration")
+            }
+            switch type {
+            case .integer:
+                globalIntegers[name] = 0
+            case .real:
+                globalReals[name] = 0
             }
-            return visit(compound)
-        case .variableDeclaration:
             return nil
         case .type:
             return nil
         case let .program(_, block):
-            return visit(block)
+            return eval(block)
         }
     }
 
     public func interpret() {
         let tree = parser.parse()
-        visit(tree)
+        eval(tree)
     }
 
-    func getState() -> [String: Int] {
-        return globalScope
+    func getState() -> ([String: Int], [String: Double]) {
+        return (globalIntegers, globalReals)
     }
 
     public func printState() {
-        print(globalScope)
+        print("Int: \(globalIntegers)")
+        print("Real: \(globalReals)")
     }
 }

SwiftPascalInterpreter/SwiftPascalInterpreter/Model/AST.swift

@@ -26,8 +26,13 @@ public enum Type {
     case real
 }
 
+public enum Number {
+    case integer(Int)
+    case real(Double)
+}
+
 public enum AST {
-    case number(Int)
+    case number(Number)
     indirect case unaryOperation(operation: UnaryOperation, child: AST)
     indirect case binaryOperation(left: AST, operation: BinaryOperation, right: AST)
     indirect case compound(children: [AST])

SwiftPascalInterpreter/SwiftPascalInterpreter/Parser.swift

@@ -280,10 +280,10 @@ public class Parser {
             return .unaryOperation(operation: .minus, child: factor())
         case let .integerConst(value):
             eat(.integerConst(value))
-            return .number(value)
+            return .number(.integer(value))
         case let .realConst(value):
             eat(.realConst(value))
-            return .number(Int(value.rounded(.toNearestOrEven))) //TODO: proper real types
+            return .number(.real(value))
         case .lparen:
             eat(.lparen)
             let result = expr()

SwiftPascalInterpreter/SwiftPascalInterpreterTests/InterpreterTests.swift

@@ -16,26 +16,31 @@ class InterpreterTests: XCTestCase {
         let program =
         """
         PROGRAM Part10AST;
+        VAR
+            a: INTEGER;
         BEGIN
             a := 2
         END.
         """
 
         let interpeter = Interpreter(program)
         interpeter.interpret()
-        let state = interpeter.getState()
-        XCTAssert(state == ["a": 2])
+        let (integerState, realState) = interpeter.getState()
+        XCTAssert(integerState == ["a": 2])
+        XCTAssert(realState == [:])
     }
 
     func testMoreComplexProgram() {
         let program =
             """
             PROGRAM Part10AST;
+            VAR
+                 a, number, b, c: INTEGER;
             BEGIN
                 BEGIN
                     number := 2;
                     a := number;
-                    b := 10 * a + 10 * number / 4;
+                    b := 10 * a + 10 * number DIV 4;
                     c := a - - b
                 END;
                 x := 11;
@@ -44,8 +49,9 @@ class InterpreterTests: XCTestCase {
 
         let interpeter = Interpreter(program)
         interpeter.interpret()
-        let state = interpeter.getState()
-        XCTAssert(state == ["b": 25, "number": 2, "a": 2, "x": 11, "c": 27])
+        let (integerState, realState) = interpeter.getState()
+        XCTAssert(integerState == ["b": 25, "number": 2, "a": 2, "x": 11, "c": 27])
+        XCTAssert(realState == [:])
     }
 
     func testProgramWithDeclarations() {
@@ -65,7 +71,7 @@ class InterpreterTests: XCTestCase {
 
         let interpeter = Interpreter(program)
         interpeter.interpret()
-        let state = interpeter.getState()
-        XCTAssert(state == ["b": 25, "y": 5, "a": 2])
+        let (integerState, realState) = interpeter.getState()
+        //XCTAssert((integerState, realState) == ["b": 25, "y": 5, "a": 2])
     }
 }

SwiftPascalInterpreter/SwiftPascalInterpreterTests/ParserTests.swift

@@ -21,7 +21,7 @@ class ParserTests: XCTestCase {
             """
 
         let a = AST.variable("a")
-        let two = AST.number(2)
+        let two = AST.number(.integer(2))
         let assignment = AST.assignment(left: a, right: two)
         let block = AST.block(declarations: [], compound: AST.compound(children: [assignment]))
         let node = AST.program(name: "Part10AST", block: block)
@@ -46,10 +46,10 @@ class ParserTests: XCTestCase {
         let parser = Parser(program)
         let result = parser.parse()
         let empty = AST.noOp
-        let eleven = AST.number(11)
+        let eleven = AST.number(.integer(11))
         let x = AST.variable("x")
         let xAssignment = AST.assignment(left: x, right: eleven)
-        let two = AST.number(2)
+        let two = AST.number(.integer(2))
         let number = AST.variable("number")
         let a = AST.variable("a")
         let aAssignment = AST.assignment(left: a, right: AST.binaryOperation(left: number, operation: .plus, right: two))
@@ -76,14 +76,14 @@ class ParserTests: XCTestCase {
         let parser = Parser(program)
         let result = parser.parse()
         let empty = AST.noOp
-        let eleven = AST.number(11)
+        let eleven = AST.number(.integer(11))
         let x = AST.variable("x")
         let xAssignment = AST.assignment(left: x, right: eleven)
-        let two = AST.number(2)
+        let two = AST.number(.integer(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 division = AST.binaryOperation(left: AST.binaryOperation(left: AST.number(.integer(10)), operation: .mult, right: number), operation: .floatDiv, right: AST.number(.integer(4)))
+        let plus = AST.binaryOperation(left: AST.binaryOperation(left: AST.number(.integer(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.program(name: "Part10AST", block: AST.block(declarations: [], compound: AST.compound(children: [compound, xAssignment, empty])))
@@ -110,14 +110,14 @@ class ParserTests: XCTestCase {
         let parser = Parser(program)
         let result = parser.parse()
         let empty = AST.noOp
-        let eleven = AST.number(11)
+        let eleven = AST.number(.integer(11))
         let x = AST.variable("x")
         let xAssignment = AST.assignment(left: x, right: eleven)
-        let two = AST.number(2)
+        let two = AST.number(.integer(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 division = AST.binaryOperation(left: AST.binaryOperation(left: AST.number(.integer(10)), operation: .mult, right: number), operation: .floatDiv, right: AST.number(.integer(4)))
+        let plus = AST.binaryOperation(left: AST.binaryOperation(left: AST.number(.integer(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))