Trzecia wersja interpretatora

Author: koder95

src/main/java/pl/koder95/interpreter/Interpreter.java

@@ -12,23 +12,33 @@ public interface Interpreter<C extends Context, R> {
      * @return kontekst używany podczas interpretacji wyrażeń terminalnych
      */
     C getContext();
+    
+    /**
+     * @return {@link Tokenizer tokenizer} używany przez {@link Parser parser} do budowy drzewa składni
+     */
+    Tokenizer getTokenizer();
+    /**
+     * @return {@link Parser parser}, który pobiera tokeny, aby stworzyć drzewo składniowe
+     */
+    Parser<C, R> getParser();
 
     /**
-     * Buduje drzewo abstrakcyjnej syntaktyki.
-     * @param expression wyrażenie
-     * @return wyrażenie terminalne najwyższego poziomu
+     * @return fabryka {@link java.util.Scanner skanerów}, które standardowo pomagają w przetwarzaniu danych wejściowych
      */
-    TerminalExpression<C,R> buildAbstractSyntaxTree(String expression);
+    ScannerFactory getScannerFactory();
 
     /**
      * Dokonuje interpretacji danych wejściowych korzystając z {@link Context kontekstu}. Dane najpierw są tokenizowane
      * i zamieniane na {@link NonTerminalExpression wyrażenia nieterminalne}, aby zbudować z nich drzewo abstrakcyjnej
      * syntaktyki (AST).
      *
+     * @param readable dane odczytywane przez tokenizer i zamieniane na postać terminalną
      * @return wynik interpretacji
      */
-    default R interpret(String expression) {
-        TerminalExpression<C, R> ast = buildAbstractSyntaxTree(expression);
+    default R interpret(Readable readable) {
+        Tokenizer tokenizer = getTokenizer();
+        tokenizer.useScanner(getScannerFactory().create(readable));
+        TerminalExpression<C, R> ast = getParser().buildAbstractSyntaxTree(tokenizer.enqueue());
         return ast.interpret(getContext());
     }
 }

src/main/java/pl/koder95/interpreter/Parser.java

@@ -0,0 +1,18 @@
+package pl.koder95.interpreter;
+
+import java.util.Queue;
+
+/**
+ * Interfejs dostarczający metodę, która buduje drzewo abstrakcyjnej syntaktyki.
+ * @param <C> typ {@link Context kontekstu} dla {@link TerminalExpression wyrażenia terminalnego}
+ * @param <R> typ obiektu zwracanego przez interpreter
+ */
+public interface Parser<C extends Context, R> {
+
+    /**
+     * Buduje drzewo abstrakcyjnej syntaktyki.
+     * @param tokens dane wejściowe poddane tokenizacji
+     * @return wyrażenie terminalne najwyższego poziomu
+     */
+    TerminalExpression<C, R> buildAbstractSyntaxTree(Queue<NonTerminalExpression<?>> tokens);
+}

src/main/java/pl/koder95/interpreter/ScannerFactory.java

@@ -0,0 +1,22 @@
+package pl.koder95.interpreter;
+
+import java.util.Scanner;
+
+/**
+ * Fabryka {@link Scanner skanerów}.
+ * Implementacja pozwala na określenie dowolnych właściwości skanera przed jego użyciem,
+ * takich jak {@link Scanner#delimiter() znak delimitera}. Domyślna implementacja tworzy
+ * skaner z domyślnymi właściwościami.
+ */
+public interface ScannerFactory {
+
+    /**
+     * Tworzy nową instancję skanera dostosowaną do konkretnych zastosowań.
+     *
+     * @param readable dane wejściowe możliwe do odczytania przez interfejs {@link Readable}
+     * @return nowa instancja {@link Scanner skanera}
+     */
+    default Scanner create(Readable readable) {
+        return new Scanner(readable);
+    }
+}

src/main/java/pl/koder95/interpreter/Tokenizer.java

@@ -0,0 +1,72 @@
+package pl.koder95.interpreter;
+
+import java.util.Queue;
+import java.util.Scanner;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * Definiuje sposób podziału danych wejściowych na tokeny.
+ * Standardowo korzysta ze {@link Scanner skanera}, aby dzielić i analizować ciąg odczytywanych wartości.
+ * Nic nie stoi na przeszkodzie, aby użyć innego sposobu. Wystarczy oprócz implementacji metody {@link #next()}
+ * nadpisać metodę {@link #hasNext()}.
+ */
+public abstract class Tokenizer {
+
+    private Scanner scanner;
+
+    /**
+     * Tworzy nową instancję tokenizera ustawiając skaner na wartość {@code null}.
+     * Dla poprawnego funkcjonowania należy wywołać metodę {@link #useScanner(Scanner)}.
+     */
+    public Tokenizer() {
+        this.scanner = null;
+    }
+
+    /**
+     * @param scanner skaner używany podczas procesu tokenizacji danych wejściowych
+     */
+    public void useScanner(Scanner scanner) {
+        this.scanner = scanner;
+    }
+
+    /**
+     * Metoda używana podczas procesu tworzenia tokenów w metodzie {@link #next()}.
+     * @return zwraca aktualnie ustawiony skaner
+     */
+    protected final Scanner getScanner() {
+        return scanner;
+    }
+
+    /**
+     * Umieszcza w kolejce wszystkie możliwe do odczytania tokeny.
+     * @param queue kolejka wyrażeń nieterminalnych (tokenów)
+     * @return {@code queue}
+     */
+    public final Queue<NonTerminalExpression<?>> enqueue(Queue<NonTerminalExpression<?>> queue) {
+        while (hasNext()) queue.add(next());
+        return queue;
+    }
+
+    /**
+     * Tworzy nową kolejkę wyrażeń nieterminalnych (tokenów) i umieszcza w niej odczytane tokeny z wejścia.
+     * @return nowa instancja kolejki {@link NonTerminalExpression wyrażeń nieterminalnych (tokenów)}
+     */
+    public Queue<NonTerminalExpression<?>> enqueue() {
+        return enqueue(new LinkedBlockingQueue<>());
+    }
+
+    /**
+     * Sprawdza, czy istnieje możliwość pobrania następnego tokenu.
+     * @return {@code true} – jeśli istnieje następny token, {@code false} w przeciwnym razie
+     */
+    public boolean hasNext() {
+        return scanner != null && scanner.hasNext();
+    }
+
+    /**
+     * Przetwarza dane wejściowe i zwraca je w postaci {@link NonTerminalExpression wyrażenia nieterminalnego},
+     * czyli tokenu.
+     * @return token typu {@link NonTerminalExpression}
+     */
+    public abstract NonTerminalExpression<?> next();
+}