✨ properly reading array values

Author: igorkulman

PascalInterpreter/PascalInterpreter/FatalError.swift

@@ -11,9 +11,9 @@ import Foundation
 /**
  Taken from https://medium.com/@marcosantadev/how-to-test-fatalerror-in-swift-e1be9ff11a29
  */
-func fatalError(_ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Never {
+/*func fatalError(_ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Never {
     FatalErrorUtil.fatalErrorClosure(message(), file, line)
-}
+}*/
 
 struct FatalErrorUtil {
 

PascalInterpreter/PascalInterpreter/Interpreter/Interpreter.swift

@@ -109,19 +109,33 @@ public class Interpreter {
             fatalError("No call stack frame")
         }
 
-        if let expression = assignment.index, case let .number(.integer(index)) = eval(node: expression) {
+        switch assignment.left {
+        case let array as ArrayVariable:
+            guard case let .number(.integer(index)) = eval(node: array.index) else {
+                fatalError("Cannot use non-Integer index with array '\(array.name)'")
+            }
             currentFrame.set(variable: assignment.left.name, value: eval(node: assignment.right), index: index)
-        } else {
+        default:
             currentFrame.set(variable: assignment.left.name, value: eval(node: assignment.right))
         }
+
         return .none
     }
 
     func eval(variable: Variable) -> Value {
         guard let currentFrame = callStack.peek() else {
             fatalError("No call stack frame")
         }
-        return currentFrame.get(variable: variable.name)
+
+        switch variable {
+        case let array as ArrayVariable:
+            guard case let .number(.integer(index)) = eval(node: array.index) else {
+                fatalError("Cannot use non-Integer index with array '\(array.name)'")
+            }
+            return currentFrame.get(variable: array.name, index: index)
+        default:
+            return currentFrame.get(variable: variable.name)
+        }
     }
 
     func eval(block: Block) -> Value {

PascalInterpreter/PascalInterpreter/Lexer/Lexer.swift

@@ -18,6 +18,8 @@ public class Lexer {
     private let text: String
     private var currentPosition: Int
     private var currentCharacter: Character?
+    private var isStringStart = false
+    private var wasStringLast = false
 
     // MARK: - Constants
 
@@ -150,13 +152,11 @@ public class Lexer {
     }
 
     private func string() -> Token {
-        advance()
         var lexem = ""
         while let character = currentCharacter, character != "'" {
             lexem += String(character)
             advance()
         }
-        advance()
         return .constant(.string(lexem))
     }
 
@@ -171,6 +171,20 @@ public class Lexer {
 
         while let currentCharacter = currentCharacter {
 
+            if wasStringLast {
+                wasStringLast = false
+                if currentCharacter == "'" {
+                    advance()
+                }
+                return .apostrophe
+            }
+
+            if isStringStart {
+                wasStringLast = true
+                isStringStart = false
+                return string()
+            }
+
             if CharacterSet.whitespacesAndNewlines.contains(currentCharacter.unicodeScalars.first!) {
                 skipWhitestace()
                 continue
@@ -183,7 +197,9 @@ public class Lexer {
             }
 
             if currentCharacter == "'" {
-                return string()
+                advance()
+                isStringStart = !isStringStart
+                return .apostrophe
             }
 
             // if the character is a digit, convert it to int, create an integer token and move position

PascalInterpreter/PascalInterpreter/Parser/AST.swift

@@ -77,12 +77,10 @@ class Compound: AST {
 class Assignment: AST {
     let left: Variable
     let right: AST
-    let index: AST?
 
-    init(left: Variable, right: AST, index: AST? = nil) {
+    init(left: Variable, right: AST) {
         self.left = left
         self.right = right
-        self.index = index
     }
 }
 
@@ -94,6 +92,15 @@ class Variable: AST {
     }
 }
 
+class ArrayVariable: Variable {
+    let index: AST
+
+    init(name: String, index: AST) {
+        self.index = index
+        super.init(name: name)
+    }
+}
+
 class NoOp: AST {
 }
 

PascalInterpreter/PascalInterpreter/Parser/Parser.swift

@@ -476,7 +476,7 @@ public class Parser {
             eat(.bracket(.right))
             eat(.assign)
             let right = expr()
-            return Assignment(left: left, right: right, index: indexExpression)
+            return Assignment(left: left, right: right)
         }
         eat(.assign)
         let right = expr()
@@ -547,6 +547,12 @@ public class Parser {
         switch currentToken {
         case let .id(value):
             eat(.id(value))
+            if currentToken == .bracket(.left) {
+                eat(.bracket(.left))
+                let index = expr()
+                eat(.bracket(.right))
+                return ArrayVariable(name: value, index: index)
+            }
             return Variable(name: value)
         default:
             fatalError("Syntax error, expected variable, found \(currentToken)")
@@ -585,8 +591,13 @@ public class Parser {
             let result = expr()
             eat(.parenthesis(.right))
             return result
-        case let .constant(.string(value)):
+        case .apostrophe:
+            eat(.apostrophe)
+            guard case let .constant(.string(value)) = currentToken else {
+                fatalError("Expected string literal after '")
+            }
             eat(.constant(.string(value)))
+            eat(.apostrophe)
             return value
         case let .constant(.boolean(value)):
             eat(.constant(.boolean(value)))

PascalInterpreter/PascalInterpreterTests/InterpreterTests.swift

@@ -260,14 +260,15 @@ class InterpreterTests: XCTestCase {
             begin
                 data[i] := i;
             end;
+            writeln(data[2]);
             end.
             """
 
         let interpeter = Interpreter(program)
         interpeter.interpret()
         let (scalars, arrays) = interpeter.getState()
         XCTAssert(scalars == [:])
-        XCTAssert(arrays.count==1)
+        XCTAssert(arrays.count == 1)
         XCTAssert(arrays["DATA"]! == [Value.number(.integer(1)), Value.number(.integer(2)), Value.number(.integer(3)), Value.number(.integer(4)), Value.number(.integer(5))])
     }
 }

PascalInterpreter/PascalInterpreterTests/LexerTests.swift

@@ -408,7 +408,7 @@ class LexerTests: XCTestCase {
     }
 
     func testDataTypes() {
-        let lexer = Lexer("a: Integer; b: Real; c: Boolean; c:= true; c:=false; d:= 'Test string'")
+        let lexer = Lexer("a: Integer; b: Real; c: Boolean; c:= true; c:=false; d:= 'Test string'; 'Another'")
         XCTAssert(lexer.getNextToken() == .id("a"))
         XCTAssert(lexer.getNextToken() == .colon)
         XCTAssert(lexer.getNextToken() == .type(.integer))
@@ -431,7 +431,13 @@ class LexerTests: XCTestCase {
         XCTAssert(lexer.getNextToken() == .semi)
         XCTAssert(lexer.getNextToken() == .id("d"))
         XCTAssert(lexer.getNextToken() == .assign)
+        XCTAssert(lexer.getNextToken() == .apostrophe)
         XCTAssert(lexer.getNextToken() == .constant(.string("Test string")))
+        XCTAssert(lexer.getNextToken() == .apostrophe)
+        XCTAssert(lexer.getNextToken() == .semi)
+        XCTAssert(lexer.getNextToken() == .apostrophe)
+        XCTAssert(lexer.getNextToken() == .constant(.string("Another")))
+        XCTAssert(lexer.getNextToken() == .apostrophe)
         XCTAssert(lexer.getNextToken() == .eof)
     }