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() {