christoph/lecture-compilers
1
Fork 0
Code Actions Activity

grammar update

Browse Source
This commit is contained in:
ChUrl
2020-12-15 16:24:01 +01:00
parent 921d735e69
commit 71c9348a3c
3 changed files with 81 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/test/java/parser/Demo.java
View File

@ -21,8 +21,8 @@ class Demo {
private Lexer initLexer(String program) { private Lexer initLexer(String program) {
try { try {
Path path = Paths.get(this.getClass().getClassLoader().getResource("examplePrograms/" + program).toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("examplePrograms/" + program).toURI());
String programCode = Files.readString(path, StandardCharsets.US_ASCII); final String programCode = Files.readString(path, StandardCharsets.US_ASCII);
return new StupsLexer(CharStreams.fromString(programCode)); return new StupsLexer(CharStreams.fromString(programCode));
} catch (Exception ignore) { } catch (Exception ignore) {
ignore.printStackTrace(); ignore.printStackTrace();
@ -33,24 +33,26 @@ class Demo {
@Test @Test
void demoClean() throws URISyntaxException, IOException { void demoClean() throws URISyntaxException, IOException {
Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI());
Grammar grammar = Grammar.fromFile(path); final Grammar grammar = Grammar.fromFile(path);
StupsParser stupsParser = StupsParser.fromGrammar(grammar); final StupsParser stupsParser = StupsParser.fromGrammar(grammar);
Lexer lex = this.initLexer("General.stups"); final Lexer lex = this.initLexer("General.stups");
AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary()); final AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary());
System.out.println(tree);
ASTCompacter.clean(tree, grammar); ASTCompacter.clean(tree, grammar);
System.out.println(tree);
} }
@Test @Test
void demoLeftPrecedence() throws URISyntaxException, IOException { void demoLeftPrecedence() throws URISyntaxException, IOException {
Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI());
Grammar grammar = Grammar.fromFile(path); final Grammar grammar = Grammar.fromFile(path);
StupsParser stupsParser = StupsParser.fromGrammar(grammar); final StupsParser stupsParser = StupsParser.fromGrammar(grammar);
Lexer lex = this.initLexer("General.stups"); final Lexer lex = this.initLexer("General.stups");
AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary()); final AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary());
ASTCompacter.clean(tree, grammar); ASTCompacter.clean(tree, grammar);
ASTBalancer.flip(tree); ASTBalancer.flip(tree);
@ -61,12 +63,12 @@ class Demo {
@Test @Test
void demoOperatorPrecedence() throws URISyntaxException, IOException { void demoOperatorPrecedence() throws URISyntaxException, IOException {
Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI());
Grammar grammar = Grammar.fromFile(path); final Grammar grammar = Grammar.fromFile(path);
StupsParser stupsParser = StupsParser.fromGrammar(grammar); final StupsParser stupsParser = StupsParser.fromGrammar(grammar);
Lexer lex = this.initLexer("General.stups"); final Lexer lex = this.initLexer("General.stups");
AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary()); final AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary());
ASTCompacter.clean(tree, grammar); ASTCompacter.clean(tree, grammar);
ASTBalancer.flip(tree); ASTBalancer.flip(tree);
@ -78,12 +80,12 @@ class Demo {
@Test @Test
void demoTypeCheck() throws URISyntaxException, IOException { void demoTypeCheck() throws URISyntaxException, IOException {
Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI());
Grammar grammar = Grammar.fromFile(path); final Grammar grammar = Grammar.fromFile(path);
StupsParser stupsParser = StupsParser.fromGrammar(grammar); final StupsParser stupsParser = StupsParser.fromGrammar(grammar);
Lexer lex = this.initLexer("General.stups"); final Lexer lex = this.initLexer("General.stups");
AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary()); final AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary());
tree.postprocess(grammar); tree.postprocess(grammar);
System.out.println("After Postprocessing:" + tree); System.out.println("After Postprocessing:" + tree);

67
src/test/java/parser/grammar/GrammarAnalyzerTest.java
View File

@ -24,23 +24,24 @@ class GrammarAnalyzerTest {
E -> b E -> b
*/ */
Set<String> nonterminals; final Set<String> nonterminals;
String[] narray = {"S", "E"}; final String[] narray = {"S", "E"};
nonterminals = new HashSet<>(Arrays.asList(narray)); nonterminals = new HashSet<>(Arrays.asList(narray));
Set<String> terminals; final Set<String> terminals;
String[] tarray = {"a", "b", "e", "i", "t"}; final String[] tarray = {"a", "b", "e", "i", "t"};
terminals = new HashSet<>(Arrays.asList(tarray)); terminals = new HashSet<>(Arrays.asList(tarray));
String startSymbol = "S"; final String startSymbol = "S";
String epsilonSymbol = "epsilon"; final String epsilonSymbol = "epsilon";
Set<GrammarRule> rules = new HashSet<>(); final Set<GrammarRule> rules = new HashSet<>();
rules.add(new GrammarRule("S", "a")); rules.add(new GrammarRule("S", "a"));
rules.add(new GrammarRule("S", "i", "E", "t", "S")); rules.add(new GrammarRule("S", "i", "E", "t", "S"));
rules.add(new GrammarRule("E", "b")); rules.add(new GrammarRule("E", "b"));
grammar0 = new Grammar(terminals, nonterminals, startSymbol, epsilonSymbol, null, null, rules); grammar0 = new Grammar(terminals, nonterminals, startSymbol, epsilonSymbol, null, null,
null, null, null, rules);
} }
@BeforeAll @BeforeAll
@ -49,18 +50,18 @@ class GrammarAnalyzerTest {
Folie 4b/32 Folie 4b/32
*/ */
Set<String> nonterminals; final Set<String> nonterminals;
String[] narray = {"E", "T", "E2", "T2", "F"}; final String[] narray = {"E", "T", "E2", "T2", "F"};
nonterminals = new HashSet<>(Arrays.asList(narray)); nonterminals = new HashSet<>(Arrays.asList(narray));
Set<String> terminals; final Set<String> terminals;
String[] tarray = {"id", "+", "*", "(", ")"}; final String[] tarray = {"id", "+", "*", "(", ")"};
terminals = new HashSet<>(Arrays.asList(tarray)); terminals = new HashSet<>(Arrays.asList(tarray));
String startSymbol = "E"; final String startSymbol = "E";
String epsilonSymbol = "epsilon"; final String epsilonSymbol = "epsilon";
Set<GrammarRule> rules = new HashSet<>(); final Set<GrammarRule> rules = new HashSet<>();
rules.add(new GrammarRule("E", "T", "E2")); rules.add(new GrammarRule("E", "T", "E2"));
rules.add(new GrammarRule("E2", "+", "T", "E2")); rules.add(new GrammarRule("E2", "+", "T", "E2"));
rules.add(new GrammarRule("E2", epsilonSymbol)); rules.add(new GrammarRule("E2", epsilonSymbol));
@ -70,7 +71,8 @@ class GrammarAnalyzerTest {
rules.add(new GrammarRule("F", "(", "E", ")")); rules.add(new GrammarRule("F", "(", "E", ")"));
rules.add(new GrammarRule("F", "id")); rules.add(new GrammarRule("F", "id"));
grammar1 = new Grammar(terminals, nonterminals, startSymbol, epsilonSymbol, null, null, rules); grammar1 = new Grammar(terminals, nonterminals, startSymbol, epsilonSymbol, null, null,
null, null, null, rules);
} }
@BeforeAll @BeforeAll
@ -84,18 +86,18 @@ class GrammarAnalyzerTest {
X -> a X -> a
*/ */
Set<String> nonterminals; final Set<String> nonterminals;
String[] narray = {"X", "Y", "Z"}; final String[] narray = {"X", "Y", "Z"};
nonterminals = new HashSet<>(Arrays.asList(narray)); nonterminals = new HashSet<>(Arrays.asList(narray));
Set<String> terminals; final Set<String> terminals;
String[] tarray = {"a", "c", "d"}; final String[] tarray = {"a", "c", "d"};
terminals = new HashSet<>(Arrays.asList(tarray)); terminals = new HashSet<>(Arrays.asList(tarray));
String startSymbol = "Z"; final String startSymbol = "Z";
String epsilonSymbol = "epsilon"; final String epsilonSymbol = "epsilon";
Set<GrammarRule> rules = new HashSet<>(); final Set<GrammarRule> rules = new HashSet<>();
rules.add(new GrammarRule("Z", "d")); rules.add(new GrammarRule("Z", "d"));
rules.add(new GrammarRule("Z", "X", "Y", "Z")); rules.add(new GrammarRule("Z", "X", "Y", "Z"));
rules.add(new GrammarRule("Y", epsilonSymbol)); rules.add(new GrammarRule("Y", epsilonSymbol));
@ -103,12 +105,13 @@ class GrammarAnalyzerTest {
rules.add(new GrammarRule("X", "Y")); rules.add(new GrammarRule("X", "Y"));
rules.add(new GrammarRule("X", "a")); rules.add(new GrammarRule("X", "a"));
grammar2 = new Grammar(terminals, nonterminals, startSymbol, epsilonSymbol, null, null, rules); grammar2 = new Grammar(terminals, nonterminals, startSymbol, epsilonSymbol, null, null,
null, null, null, rules);
} }
@Test @Test
void testFirstGrammar0() { void testFirstGrammar0() {
GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar0); final GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar0);
assertThat(analyzer.getFirst().get("S")).containsOnly("i", "a"); assertThat(analyzer.getFirst().get("S")).containsOnly("i", "a");
assertThat(analyzer.getFirst().get("E")).containsOnly("b"); assertThat(analyzer.getFirst().get("E")).containsOnly("b");
@ -116,7 +119,7 @@ class GrammarAnalyzerTest {
@Test @Test
void testFirstGrammar1() { void testFirstGrammar1() {
GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar1); final GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar1);
assertThat(analyzer.getFirst().get("E")).containsOnly("id", "("); assertThat(analyzer.getFirst().get("E")).containsOnly("id", "(");
assertThat(analyzer.getFirst().get("E2")).containsOnly("+", grammar1.getEpsilonSymbol()); assertThat(analyzer.getFirst().get("E2")).containsOnly("+", grammar1.getEpsilonSymbol());
@ -127,7 +130,7 @@ class GrammarAnalyzerTest {
@Test @Test
void testFirstGrammar2() { void testFirstGrammar2() {
GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar2); final GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar2);
assertThat(analyzer.getFirst().get("X")).containsOnly("c", "a", grammar2.getEpsilonSymbol()); assertThat(analyzer.getFirst().get("X")).containsOnly("c", "a", grammar2.getEpsilonSymbol());
assertThat(analyzer.getFirst().get("Y")).containsOnly("c", grammar2.getEpsilonSymbol()); assertThat(analyzer.getFirst().get("Y")).containsOnly("c", grammar2.getEpsilonSymbol());
@ -136,7 +139,7 @@ class GrammarAnalyzerTest {
@Test @Test
void testFollowGrammar0() { void testFollowGrammar0() {
GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar0); final GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar0);
assertThat(analyzer.getFollow().get("S")).containsOnly("$"); assertThat(analyzer.getFollow().get("S")).containsOnly("$");
assertThat(analyzer.getFollow().get("E")).containsOnly("t"); assertThat(analyzer.getFollow().get("E")).containsOnly("t");
@ -144,7 +147,7 @@ class GrammarAnalyzerTest {
@Test @Test
void testFollowGrammar1() { void testFollowGrammar1() {
GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar1); final GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar1);
assertThat(analyzer.getFollow().get("E")).containsOnly(")", "$"); assertThat(analyzer.getFollow().get("E")).containsOnly(")", "$");
assertThat(analyzer.getFollow().get("E2")).containsOnly(")", "$"); assertThat(analyzer.getFollow().get("E2")).containsOnly(")", "$");
@ -155,7 +158,7 @@ class GrammarAnalyzerTest {
@Test @Test
void testFollowGrammar2() { void testFollowGrammar2() {
GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar2); final GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar2);
assertThat(analyzer.getFollow().get("X")).containsOnly("a", "c", "d"); assertThat(analyzer.getFollow().get("X")).containsOnly("a", "c", "d");
assertThat(analyzer.getFollow().get("Y")).containsOnly("a", "c", "d"); assertThat(analyzer.getFollow().get("Y")).containsOnly("a", "c", "d");
@ -164,8 +167,8 @@ class GrammarAnalyzerTest {
@Test @Test
void testTableGrammar1() { void testTableGrammar1() {
GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar1); final GrammarAnalyzer analyzer = new GrammarAnalyzer(grammar1);
ParsingTable table = analyzer.getTable(); final ParsingTable table = analyzer.getTable();
assertThat(table.get("E", "id")).isEqualTo("T E2"); assertThat(table.get("E", "id")).isEqualTo("T E2");
assertThat(table.get("E", "(")).isEqualTo("T E2"); assertThat(table.get("E", "(")).isEqualTo("T E2");

44
src/test/java/parser/typechecker/SymbolTableTest.java → src/test/java/parser/typechecker/TypeTableTest.java
View File

@ -8,7 +8,7 @@ import parser.StupsParser;
import parser.ast.AST; import parser.ast.AST;
import parser.grammar.Grammar; import parser.grammar.Grammar;
import typechecker.SymbolAlreadyDefinedException; import typechecker.SymbolAlreadyDefinedException;
import typechecker.SymbolTable; import typechecker.TypeTable;
import java.io.IOException; import java.io.IOException;
import java.net.URISyntaxException; import java.net.URISyntaxException;
@ -20,12 +20,12 @@ import java.nio.file.Paths;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
class SymbolTableTest { class TypeTableTest {
private Lexer initLexer(String program) { private Lexer initLexer(String program) {
try { try {
Path path = Paths.get(this.getClass().getClassLoader().getResource("examplePrograms/" + program).toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("examplePrograms/" + program).toURI());
String programCode = Files.readString(path, StandardCharsets.US_ASCII); final String programCode = Files.readString(path, StandardCharsets.US_ASCII);
return new StupsLexer(CharStreams.fromString(programCode)); return new StupsLexer(CharStreams.fromString(programCode));
} catch (Exception ignore) { } catch (Exception ignore) {
ignore.printStackTrace(); ignore.printStackTrace();
@ -36,15 +36,15 @@ class SymbolTableTest {
@Test @Test
void testSingleSymbol() throws URISyntaxException, IOException { void testSingleSymbol() throws URISyntaxException, IOException {
Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI());
Grammar grammar = Grammar.fromFile(path); final Grammar grammar = Grammar.fromFile(path);
StupsParser stupsParser = StupsParser.fromGrammar(grammar); final StupsParser stupsParser = StupsParser.fromGrammar(grammar);
Lexer lex = this.initLexer("SingleSymbol.stups"); final Lexer lex = this.initLexer("SingleSymbol.stups");
AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary()); final AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary());
tree.postprocess(grammar); tree.postprocess(grammar);
SymbolTable table = SymbolTable.fromAST(tree); final TypeTable table = TypeTable.fromAST(tree);
assertThat(table.getSymbolType("i")).isEqualTo("INTEGER_TYPE"); assertThat(table.getSymbolType("i")).isEqualTo("INTEGER_TYPE");
assertThat(table.getSymbolCount()).isEqualTo(1); assertThat(table.getSymbolCount()).isEqualTo(1);
@ -52,15 +52,15 @@ class SymbolTableTest {
@Test @Test
void testMultipleSymbol() throws URISyntaxException, IOException { void testMultipleSymbol() throws URISyntaxException, IOException {
Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI());
Grammar grammar = Grammar.fromFile(path); final Grammar grammar = Grammar.fromFile(path);
StupsParser stupsParser = StupsParser.fromGrammar(grammar); final StupsParser stupsParser = StupsParser.fromGrammar(grammar);
Lexer lex = this.initLexer("MultipleSymbol.stups"); final Lexer lex = this.initLexer("MultipleSymbol.stups");
AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary()); final AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary());
tree.postprocess(grammar); tree.postprocess(grammar);
SymbolTable table = SymbolTable.fromAST(tree); final TypeTable table = TypeTable.fromAST(tree);
assertThat(table.getSymbolType("i")).isEqualTo("INTEGER_TYPE"); assertThat(table.getSymbolType("i")).isEqualTo("INTEGER_TYPE");
assertThat(table.getSymbolType("ii")).isEqualTo("INTEGER_TYPE"); assertThat(table.getSymbolType("ii")).isEqualTo("INTEGER_TYPE");
@ -73,14 +73,14 @@ class SymbolTableTest {
@Test @Test
void testExistingSymbol() throws URISyntaxException, IOException { void testExistingSymbol() throws URISyntaxException, IOException {
Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); final Path path = Paths.get(this.getClass().getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI());
Grammar grammar = Grammar.fromFile(path); final Grammar grammar = Grammar.fromFile(path);
StupsParser stupsParser = StupsParser.fromGrammar(grammar); final StupsParser stupsParser = StupsParser.fromGrammar(grammar);
Lexer lex = this.initLexer("ExistingSymbol.stups"); final Lexer lex = this.initLexer("ExistingSymbol.stups");
AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary()); final AST tree = stupsParser.parse(lex.getAllTokens(), lex.getVocabulary());
tree.postprocess(grammar); tree.postprocess(grammar);
assertThatThrownBy(() -> SymbolTable.fromAST(tree)).isInstanceOf(SymbolAlreadyDefinedException.class); assertThatThrownBy(() -> TypeTable.fromAST(tree)).isInstanceOf(SymbolAlreadyDefinedException.class);
} }
} }