adapt implementation to use grammar wrapper

src/main/java/parser/LL1Parser.java

@@ -1,5 +1,7 @@
 package parser;
 
+import parser.grammar.Grammar;
+import parser.grammar.LL1GrammarAnalyzer;
 import util.ast.AST;
 import util.ast.Node;
 
@@ -15,6 +17,11 @@ public class LL1Parser {
         this.parsetable = parsetable;
     }
 
+    public static LL1Parser fromGrammar(Grammar grammar) {
+        LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(grammar);
+        return new LL1Parser(analyzer.getTable());
+    }
+
     public boolean parse(List<String> token) {
         Node root = new Node(this.parsetable.getStartSymbol());
         AST tree = new AST(root);

src/main/java/parser/LL1ParsingTable.java

@@ -1,5 +1,8 @@
 package parser;
 
+import parser.grammar.Grammar;
+import parser.grammar.LL1GrammarAnalyzer;
+
 import java.util.AbstractMap.SimpleEntry;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -7,24 +10,19 @@ import java.util.Set;
 
 public class LL1ParsingTable implements ILL1ParsingTable {
 
-    private final String start;
+    private final Grammar grammar;
-    private final Set<String> terminals;
-    private final Set<String> nonterminals;
-    private final String epsilon;
     private final Map<Entry<String, String>, String> parsetable;
 
-    public LL1ParsingTable(Set<String> nonterminals,
+    public LL1ParsingTable(Grammar grammar, Map<Entry<String, String>, String> parsetable) {
-                           Set<String> terminals,
+        this.grammar = grammar;
-                           String start,
-                           String epsilon,
-                           Map<Entry<String, String>, String> parsetable) {
-        this.start = start;
-        this.terminals = terminals;
-        this.nonterminals = nonterminals;
-        this.epsilon = epsilon;
         this.parsetable = parsetable;
     }
 
+    public static ILL1ParsingTable fromGrammar(Grammar grammar) {
+        LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(grammar);
+        return analyzer.getTable();
+    }
+
     @Override
     public String get(String nonterminal, String terminal) {
         return this.parsetable.get(new SimpleEntry<>(nonterminal, terminal));
@@ -32,21 +30,21 @@ public class LL1ParsingTable implements ILL1ParsingTable {
 
     @Override
     public String getStartSymbol() {
-        return this.start;
+        return this.grammar.getStartSymbol();
     }
 
     @Override
     public Set<String> getNonterminals() {
-        return this.nonterminals;
+        return this.grammar.getNonterminals();
     }
 
     @Override
     public Set<String> getTerminals() {
-        return this.terminals;
+        return this.grammar.getTerminals();
     }
 
     @Override
     public String getEpsilon() {
-        return this.epsilon;
+        return this.grammar.getEpsilonSymbol();
     }
 }

src/main/java/parser/grammar/LL1GrammarAnalyzer.java

@@ -1,10 +1,12 @@
-package parser;
+package parser.grammar;
+
+import parser.ILL1ParsingTable;
+import parser.LL1ParsingTable;
 
 import java.util.AbstractMap;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
@@ -16,26 +18,41 @@ public class LL1GrammarAnalyzer {
 
     private final ILL1ParsingTable table;
 
-    public LL1GrammarAnalyzer(Set<String> terminals, Set<String> nonterminals,
+    public LL1GrammarAnalyzer(Grammar grammar) {
-                              String start, String epsilon,
-                              Map<String, List<String>> productions) {
 
         // Es muss zwingend in der Reihenfolge [Nullable < First < Follow < Table] initialisiert werden
-        this.nullable = this.initNullable(productions, epsilon);
+        this.nullable = this.initNullable(grammar);
-        this.first = this.initFirst(productions, terminals, nonterminals, epsilon);
+        this.first = this.initFirst(grammar);
-        this.follow = this.initFollow(productions, terminals, nonterminals, epsilon);
+        this.follow = this.initFollow(grammar);
 
-        this.table = this.initParseTable(productions, terminals, nonterminals, start, epsilon);
+        this.table = this.initParseTable(grammar);
     }
 
-    private Set<String> initNullable(Map<String, List<String>> productions, String epsilon) {
+    private Map<String, Set<String>> getProductionMap(Grammar grammar) {
+        Map<String, Set<String>> productionOut = new HashMap<>();
+
+        for (GrammarRule rule : grammar.getRules()) {
+            if (!productionOut.containsKey(rule.getLeftside())) {
+                productionOut.put(rule.getLeftside(), new HashSet<>());
+            }
+
+            productionOut.get(rule.getLeftside()).add(rule.getRightside());
+        }
+
+        return productionOut;
+    }
+
+    private Set<String> initNullable(Grammar grammar) {
         Set<String> nullableOut = new HashSet<>();
         boolean change;
 
+        final String epsilon = grammar.getEpsilonSymbol();
+        final Map<String, Set<String>> productions = this.getProductionMap(grammar);
+
         do {
             change = false;
 
-            for (Map.Entry<String, List<String>> prods : productions.entrySet()) {
+            for (Map.Entry<String, Set<String>> prods : productions.entrySet()) {
                 // Für jedes Nichtterminal
 
                 final String leftX = prods.getKey();
@@ -82,12 +99,15 @@ public class LL1GrammarAnalyzer {
         return true;
     }
 
-    private Map<String, Set<String>> initFirst(Map<String, List<String>> productions,
+    private Map<String, Set<String>> initFirst(Grammar grammar) {
-                                               Set<String> terminals, Set<String> nonterminals,
-                                               String epsilon) {
         Map<String, Set<String>> firstOut = new HashMap<>();
         boolean change;
 
+        final Set<String> terminals = grammar.getTerminals();
+        final Set<String> nonterminals = grammar.getNonterminals();
+        final String epsilon = grammar.getEpsilonSymbol();
+        final Map<String, Set<String>> productions = this.getProductionMap(grammar);
+
         for (String sym : nonterminals) {
             // Alle Nichtterminale mit leeren Sets initialisieren
 
@@ -103,7 +123,7 @@ public class LL1GrammarAnalyzer {
         do {
             change = false;
 
-            for (Map.Entry<String, List<String>> prods : productions.entrySet()) {
+            for (Map.Entry<String, Set<String>> prods : productions.entrySet()) {
                 // Für jedes Nichtterminal
 
                 final String leftX = prods.getKey();
@@ -169,12 +189,15 @@ public class LL1GrammarAnalyzer {
         return firstOut;
     }
 
-    private Map<String, Set<String>> initFollow(Map<String, List<String>> productions,
+    private Map<String, Set<String>> initFollow(Grammar grammar) {
-                                                Set<String> terminals, Set<String> nonterminals,
-                                                String epsilon) {
         Map<String, Set<String>> followOut = new HashMap<>();
         boolean change;
 
+        final Set<String> terminals = grammar.getTerminals();
+        final Set<String> nonterminals = grammar.getNonterminals();
+        final String epsilon = grammar.getEpsilonSymbol();
+        final Map<String, Set<String>> productions = this.getProductionMap(grammar);
+
         for (String sym : terminals) {
             // Alle Nichtterminale mit leeren Sets initialisieren
 
@@ -189,7 +212,7 @@ public class LL1GrammarAnalyzer {
         do {
             change = false;
 
-            for (Map.Entry<String, List<String>> prods : productions.entrySet()) {
+            for (Map.Entry<String, Set<String>> prods : productions.entrySet()) {
                 // Für jedes Nichtterminal
 
                 final String leftX = prods.getKey();
@@ -266,11 +289,14 @@ public class LL1GrammarAnalyzer {
         return this.follow.get(sym);
     }
 
-    private ILL1ParsingTable initParseTable(Map<String, List<String>> productions,
+    private ILL1ParsingTable initParseTable(Grammar grammar) {
-                                            Set<String> terminals, Set<String> nonterminals,
-                                            String start, String epsilon) {
         Map<Map.Entry<String, String>, String> parseTableOut = new HashMap<>();
 
+        final Set<String> terminals = grammar.getTerminals();
+        final Set<String> nonterminals = grammar.getNonterminals();
+        final String epsilon = grammar.getEpsilonSymbol();
+        final Map<String, Set<String>> productions = this.getProductionMap(grammar);
+
         for (String leftX : nonterminals) {
             // Für alle Nichtterminale (Zeilen der Tabelle)
 
@@ -299,7 +325,7 @@ public class LL1GrammarAnalyzer {
             }
         }
 
-        return new LL1ParsingTable(nonterminals, terminals, start, epsilon, parseTableOut);
+        return new LL1ParsingTable(grammar, parseTableOut);
     }
 
     public Set<String> getNullable() {

src/test/java/parser/LL1GrammarAnalyzerTest.java

@@ -1,12 +1,12 @@
 package parser;
 
 import org.junit.jupiter.api.Test;
+import parser.grammar.Grammar;
+import parser.grammar.GrammarRule;
+import parser.grammar.LL1GrammarAnalyzer;
 
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -32,16 +32,16 @@ class LL1GrammarAnalyzerTest {
         String startSymbol = "S";
         String epsilonSymbol = "epsilon";
 
-        String[] productions0 = {"a", "i E t S"};
+        Set<GrammarRule> rules = new HashSet<>();
-        String[] productions1 = {"b"};
+        rules.add(new GrammarRule("S", "a"));
+        rules.add(new GrammarRule("S", "i", "E", "t", "S"));
+        rules.add(new GrammarRule("E", "b"));
 
-        Map<String, List<String>> map = new HashMap<>();
+        Grammar grammar = new Grammar(terminals, nonterminals,
-        map.put("S", Arrays.asList(productions0));
+                                      startSymbol, epsilonSymbol,
-        map.put("E", Arrays.asList(productions1));
+                                      rules);
 
-        LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(terminals, nonterminals,
+        LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(grammar);
-                                                             startSymbol, epsilonSymbol,
-                                                             map);
 
         assertThat(analyzer.getTable().get("S", "a")).isEqualTo("a");
         assertThat(analyzer.getTable().get("S", "i")).isEqualTo("i E t S");
@@ -65,22 +65,21 @@ class LL1GrammarAnalyzerTest {
         String startSymbol = "E";
         String epsilonSymbol = "epsilon";
 
-        String[] production0 = {"T E2"};
+        Set<GrammarRule> rules = new HashSet<>();
-        String[] production1 = {"+ T E2", "epsilon"};
+        rules.add(new GrammarRule("E", "T", "E2"));
-        String[] production2 = {"F T2"};
+        rules.add(new GrammarRule("E2", "+", "T", "E2"));
-        String[] production3 = {"* F T2", "epsilon"};
+        rules.add(new GrammarRule("E2", epsilonSymbol));
-        String[] production4 = {"( E )", "id"};
+        rules.add(new GrammarRule("T", "F", "T2"));
+        rules.add(new GrammarRule("T2", "*", "F", "T2"));
+        rules.add(new GrammarRule("T2", epsilonSymbol));
+        rules.add(new GrammarRule("F", "(", "E", ")"));
+        rules.add(new GrammarRule("F", "id"));
 
-        Map<String, List<String>> map = new HashMap<>();
+        Grammar grammar = new Grammar(terminals, nonterminals,
-        map.put("E", Arrays.asList(production0));
+                                      startSymbol, epsilonSymbol,
-        map.put("E2", Arrays.asList(production1));
+                                      rules);
-        map.put("T", Arrays.asList(production2));
-        map.put("T2", Arrays.asList(production3));
-        map.put("F", Arrays.asList(production4));
 
-        LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(terminals, nonterminals,
+        LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(grammar);
-                                                             startSymbol, epsilonSymbol,
-                                                             map);
 
         assertThat(analyzer.getTable().get("F", "id")).isEqualTo("id");
     }

src/test/java/parser/LL1ParserTest.java

@@ -2,6 +2,7 @@ package parser;
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import parser.grammar.Grammar;
 
 import java.util.AbstractMap.SimpleEntry;
 import java.util.Arrays;
@@ -50,7 +51,11 @@ class LL1ParserTest {
         String production2 = "b";
         map.put(new SimpleEntry<>("E", "b"), production2);
 
-        return new LL1ParsingTable(nonterminals, terminals, startSymbol, epsilonSymbol, map);
+        Grammar grammar = new Grammar(terminals, nonterminals,
+                                      startSymbol, epsilonSymbol,
+                                      null);
+
+        return new LL1ParsingTable(grammar, map);
     }
 
     private static ILL1ParsingTable initTable1() {
@@ -97,7 +102,11 @@ class LL1ParserTest {
         String production12 = "( E )";
         map.put(new SimpleEntry<>("F", "("), production12);
 
-        return new LL1ParsingTable(nonterminals, terminals, startSymbol, epsilonSymbol, map);
+        Grammar grammar = new Grammar(terminals, nonterminals,
+                                      startSymbol, epsilonSymbol,
+                                      null);
+
+        return new LL1ParsingTable(grammar, map);
     }
 
     @Test