115 lines
3.8 KiB
Java
115 lines
3.8 KiB
Java
package parser;
|
|
|
|
import org.antlr.v4.runtime.Token;
|
|
import org.antlr.v4.runtime.Vocabulary;
|
|
import parser.grammar.Grammar;
|
|
import parser.grammar.LL1GrammarAnalyzer;
|
|
import util.ast.AST;
|
|
import util.ast.Node;
|
|
|
|
import java.io.IOException;
|
|
import java.nio.file.Path;
|
|
import java.util.ArrayDeque;
|
|
import java.util.Deque;
|
|
import java.util.List;
|
|
|
|
import static util.tools.Logger.log;
|
|
|
|
public class LL1Parser {
|
|
|
|
private final ILL1ParsingTable parsetable;
|
|
|
|
public LL1Parser(ILL1ParsingTable parsetable) {
|
|
this.parsetable = parsetable;
|
|
}
|
|
|
|
public static LL1Parser fromGrammar(Path path) throws IOException {
|
|
return LL1Parser.fromGrammar(Grammar.fromFile(path));
|
|
}
|
|
|
|
public static LL1Parser fromGrammar(Grammar grammar) {
|
|
LL1GrammarAnalyzer analyzer = new LL1GrammarAnalyzer(grammar);
|
|
return new LL1Parser(analyzer.getTable());
|
|
}
|
|
|
|
public AST parse(List<? extends Token> token, Vocabulary voc) {
|
|
Node root = new Node(this.parsetable.getStartSymbol());
|
|
AST tree = new AST(root);
|
|
Deque<Node> stack = new ArrayDeque<>();
|
|
stack.push(root);
|
|
|
|
int inputPosition = 0;
|
|
|
|
log("\nParsing:");
|
|
log("Input: " + token + "\n");
|
|
|
|
// Parsing
|
|
while (!stack.isEmpty()) {
|
|
final String top = stack.peek().getName();
|
|
|
|
final String currentTokenSym;
|
|
if (inputPosition >= token.size()) {
|
|
// Wenn auf dem Stack mehr Nichtterminale liegen als Terminale in der Eingabe vorhanden sind
|
|
// Die Eingabe wurde komplett konsumiert
|
|
|
|
currentTokenSym = "$"; // EOF
|
|
} else {
|
|
// Es sind noch Eingabesymbole vorhanden
|
|
|
|
currentTokenSym = voc.getSymbolicName(token.get(inputPosition).getType());
|
|
}
|
|
|
|
final String prod = this.parsetable.get(top, currentTokenSym);
|
|
|
|
if (top.equals(this.parsetable.getEpsilon())) {
|
|
// Wenn auf dem Stack das Epsilonsymbol liegt
|
|
|
|
stack.pop();
|
|
} else if (top.equals(currentTokenSym)) {
|
|
// Wenn auf dem Stack ein Terminal liegt (dieses muss mit der Eingabe übereinstimmen)
|
|
|
|
stack.pop();
|
|
inputPosition++;
|
|
} else if (this.parsetable.getTerminals().contains(top)) {
|
|
// Wenn das Terminal auf dem Stack nicht mit der aktuellen Eingabe übereinstimmt
|
|
|
|
throw new MyParseException("Invalid terminal on stack: " + top, tree);
|
|
} else if (prod == null) {
|
|
// Wenn es für das aktuelle Terminal und das Nichtterminal auf dem Stack keine Regel gibt
|
|
|
|
throw new MyParseException("No prod. for nonterminal " + top + ", terminal " + currentTokenSym, tree);
|
|
} else {
|
|
// Wenn das Nichtterminal auf dem Stack durch (s)eine Produktion ersetzt werden kann
|
|
// Hier wird auch der AST aufgebaut
|
|
|
|
log("Used: " + top + " -> " + prod);
|
|
Node pop = stack.pop();
|
|
|
|
final String[] split = prod.split(" ");
|
|
|
|
for (int i = split.length - 1; i >= 0; i--) {
|
|
Node node = new Node(split[i]);
|
|
|
|
if (inputPosition + i < token.size()) {
|
|
// Die Schleife geht in der Eingabe weiter
|
|
Token currentTok = token.get(inputPosition + i);
|
|
|
|
// Die Token mit semantischem Inhalt auswählen
|
|
if ("IDENTIFIER".equals(split[i]) || split[i].endsWith("_LIT")) {
|
|
node.setValue(currentTok.getText());
|
|
}
|
|
}
|
|
|
|
stack.push(node);
|
|
pop.addChild(node);
|
|
}
|
|
}
|
|
}
|
|
|
|
log("\nParsed AST:\n" + tree);
|
|
log("-".repeat(100) + "\n");
|
|
|
|
return tree;
|
|
}
|
|
}
|