christoph/lecture-compilers
1
Fork 0
Code Actions Activity

adapt implementation to use grammar wrapper

Browse Source
This commit is contained in:
Christoph
2020-12-04 13:22:54 +01:00
parent 1ae77b2e51
commit 1b0dd064d7
5 changed files with 106 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/main/java/parser/LL1Parser.java
View File

@ -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);

32
src/main/java/parser/LL1ParsingTable.java
View File

@ -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 Set<String> terminals;
private final Set<String> nonterminals;
private final String epsilon;
private final Grammar grammar;
private final Map<Entry<String, String>, String> parsetable;
public LL1ParsingTable(Set<String> nonterminals,
Set<String> terminals,
String start,
String epsilon,
Map<Entry<String, String>, String> parsetable) {
this.start = start;
this.terminals = terminals;
this.nonterminals = nonterminals;
this.epsilon = epsilon;
public LL1ParsingTable(Grammar grammar, Map<Entry<String, String>, String> parsetable) {
this.grammar = grammar;
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();
}
}

72
src/main/java/parser/LL1GrammarAnalyzer.java → src/main/java/parser/grammar/LL1GrammarAnalyzer.java
View File

@ -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,
String start, String epsilon,
Map<String, List<String>> productions) {
public LL1GrammarAnalyzer(Grammar grammar) {
// Es muss zwingend in der Reihenfolge [Nullable < First < Follow < Table] initialisiert werden
this.nullable = this.initNullable(productions, epsilon);
this.first = this.initFirst(productions, terminals, nonterminals, epsilon);
this.follow = this.initFollow(productions, terminals, nonterminals, epsilon);
this.nullable = this.initNullable(grammar);
this.first = this.initFirst(grammar);
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,
Set<String> terminals, Set<String> nonterminals,
String epsilon) {
private Map<String, Set<String>> initFirst(Grammar grammar) {
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,
Set<String> terminals, Set<String> nonterminals,
String epsilon) {
private Map<String, Set<String>> initFollow(Grammar grammar) {
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,
Set<String> terminals, Set<String> nonterminals,
String start, String epsilon) {
private ILL1ParsingTable initParseTable(Grammar grammar) {
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() {

49
src/test/java/parser/LL1GrammarAnalyzerTest.java
View File

@ -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"};
String[] productions1 = {"b"};
Set<GrammarRule> rules = new HashSet<>();
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<>();
map.put("S", Arrays.asList(productions0));
map.put("E", Arrays.asList(productions1));
Grammar grammar = new Grammar(terminals, nonterminals,
startSymbol, epsilonSymbol,
rules);
LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(terminals, nonterminals,
startSymbol, epsilonSymbol,
map);
LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(grammar);
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"};
String[] production1 = {"+ T E2", "epsilon"};
String[] production2 = {"F T2"};
String[] production3 = {"* F T2", "epsilon"};
String[] production4 = {"( E )", "id"};
Set<GrammarRule> rules = new HashSet<>();
rules.add(new GrammarRule("E", "T", "E2"));
rules.add(new GrammarRule("E2", "+", "T", "E2"));
rules.add(new GrammarRule("E2", epsilonSymbol));
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<>();
map.put("E", Arrays.asList(production0));
map.put("E2", Arrays.asList(production1));
map.put("T", Arrays.asList(production2));
map.put("T2", Arrays.asList(production3));
map.put("F", Arrays.asList(production4));
Grammar grammar = new Grammar(terminals, nonterminals,
startSymbol, epsilonSymbol,
rules);
LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(terminals, nonterminals,
startSymbol, epsilonSymbol,
map);
LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(grammar);
assertThat(analyzer.getTable().get("F", "id")).isEqualTo("id");
}

13
src/test/java/parser/LL1ParserTest.java
View File

@ -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