Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
17 changes: 16 additions & 1 deletion src/main/java/grammar_objects/EmptyToken.java
Original file line number Diff line number Diff line change
@@ -1,7 +1,13 @@
package grammar_objects;

public class EmptyToken extends Token{
import java.util.*;

public class EmptyToken extends Token {

public static final Set<Token> EquivalentTokens = Set.of(
new Token("")
);

public EmptyToken() {
super("");
}
Expand All @@ -10,4 +16,13 @@ public EmptyToken() {
public String toString() {
return "ε";
}

@Override
public boolean equals(Object obj) {
if (!(obj instanceof Token)) { return false; }

Token otherToken = (Token) obj;
return EquivalentTokens.contains(otherToken);
}

}
2 changes: 0 additions & 2 deletions src/main/java/grammar_objects/Token.java
Original file line number Diff line number Diff line change
Expand Up @@ -4,9 +4,7 @@ public class Token extends LexicalElement {

private Integer lineNumber;
private Integer columnNumber;

private Integer symbolNumber;

private PositionType positionType;

/**
Expand Down
111 changes: 63 additions & 48 deletions src/main/java/helper_objects/FirstSetGenerator.java
Original file line number Diff line number Diff line change
Expand Up @@ -5,35 +5,46 @@
import grammar_objects.*;

public class FirstSetGenerator {
private static Token EmptyToken = new EmptyToken();

public static HashMap<NonTerminal, Set<Token>> generate(Set<ProductionRule> productionRules, Set<NonTerminal> nonTerminals) {
HashMap<NonTerminal, Set<Token>> firstTokenSets = new HashMap<>();
HashMap<NonTerminal, Set<NonTerminal>> firstNTSets = new HashMap<>();

Token emptyToken = new Token("");

for(NonTerminal nonTerminal : nonTerminals) {
firstTokenSets.put(nonTerminal, new HashSet<>());
firstNTSets.put(nonTerminal, new HashSet<>());
}

Set<NonTerminal> emptyNonTerminals = findEmptyNonTerminals(productionRules, nonTerminals, emptyToken);
Set<NonTerminal> emptyNonTerminals = findEmptyNonTerminals(productionRules, nonTerminals);

findAllFirstElements(productionRules, firstTokenSets, firstNTSets, emptyToken, emptyNonTerminals);
findAllFirstElements(productionRules, firstTokenSets, firstNTSets, emptyNonTerminals);

resolveCompleteSets(firstTokenSets, firstNTSets);
resolveConnectedSets(firstTokenSets, firstNTSets, emptyToken);
resolveConnectedSets(firstTokenSets, firstNTSets);

return firstTokenSets;
}

private static Set<NonTerminal> findEmptyNonTerminals(Set<ProductionRule> productionRules, Set<NonTerminal> nonTerminals, Token emptyToken) {
private static Set<NonTerminal> findEmptyNonTerminals(Set<ProductionRule> productionRules, Set<NonTerminal> nonTerminals) {
Set<NonTerminal> emptyNonTerminals = new HashSet<>();

for (ProductionRule rule : productionRules) {
if(rule.productionSequence().length == 0 ||
(rule.productionSequence().length == 1 && rule.getFirstElement().equals(emptyToken))
) {
if (rule.productionSequence().length == 0) {
emptyNonTerminals.add(rule.nonTerminal());
continue;
}

boolean isEmpty = true;

for (LexicalElement element : rule.productionSequence()) {
if (!EmptyToken.equals(element)) {
isEmpty = false;
break;
}
}

if (isEmpty) {
emptyNonTerminals.add(rule.nonTerminal());
}
}
Expand All @@ -44,56 +55,60 @@ private static Set<NonTerminal> findEmptyNonTerminals(Set<ProductionRule> produc
private static void findAllFirstElements(
Set<ProductionRule> productionRules,
HashMap<NonTerminal, Set<Token>> firstTokenSets,
HashMap<NonTerminal, Set<NonTerminal>> firstNTSets,
Token emptyToken,
HashMap<NonTerminal, Set<NonTerminal>> firstNTSets,
Set<NonTerminal> emptyNonTerminals
) {
for(ProductionRule rule : productionRules) {
if(rule.productionSequence().length == 0 ||
(rule.productionSequence().length == 1 && rule.getFirstElement().equals(emptyToken))
) {
firstTokenSets.get(rule.nonTerminal()).add((Token)emptyToken);
continue;
}
findFirstElementsForRule(
rule.nonTerminal(),
rule.productionSequence(),
firstTokenSets,
firstNTSets,
emptyNonTerminals
);
}
}

boolean foundNonEmpty = false;
int index = -1;
LexicalElement element = rule.getFirstElement();
private static void findFirstElementsForRule(
NonTerminal ruleNonTerminal,
LexicalElement[] productionSequence,
HashMap<NonTerminal, Set<Token>> firstTokenSets,
HashMap<NonTerminal, Set<NonTerminal>> firstNTSets,
Set<NonTerminal> emptyNonTerminals
) {
boolean isEmpty = true;

while(index < rule.productionSequence().length) {
index += 1;
element = rule.productionSequence()[index];
for(LexicalElement element : productionSequence) {
if(element instanceof Token) {
if(EmptyToken.equals(element)) {
firstTokenSets.get(ruleNonTerminal).add(EmptyToken);
continue;
}

if(element instanceof Token) {
if(emptyToken.equals(element)) {
firstTokenSets.get(ruleNonTerminal).add((Token)element);
return;
}
else {
if(ruleNonTerminal.equals(element)) {
if (emptyNonTerminals.contains((NonTerminal)element)) {
continue;
}

firstTokenSets.get(rule.nonTerminal()).add((Token)element);

foundNonEmpty = true;
isEmpty = false;
break;
}
else {
if(rule.nonTerminal().equals(element)) {
foundNonEmpty = true;
break;
}

firstNTSets.get(rule.nonTerminal()).add((NonTerminal)element);
firstNTSets.get(ruleNonTerminal).add((NonTerminal)element);

if(!emptyNonTerminals.contains((NonTerminal)element)) {
foundNonEmpty = true;
break;
}
if(!emptyNonTerminals.contains((NonTerminal)element)) {
isEmpty = false;
return;
}
}
}

if(!foundNonEmpty) {
if(emptyNonTerminals.contains((NonTerminal)element)) {
firstTokenSets.get(rule.nonTerminal()).add(emptyToken);
}
}
if(isEmpty) {
firstTokenSets.get(ruleNonTerminal).add(EmptyToken);
}
}

Expand Down Expand Up @@ -137,8 +152,7 @@ private static void resolveCompleteSets(

private static void resolveConnectedSets(
HashMap<NonTerminal, Set<Token>> firstTokenSets,
HashMap<NonTerminal, Set<NonTerminal>> firstNTSets,
Token emptyToken
HashMap<NonTerminal, Set<NonTerminal>> firstNTSets
) {
boolean changesMade = false;

Expand All @@ -147,7 +161,7 @@ private static void resolveConnectedSets(

for (NonTerminal nonTerminal : firstNTSets.keySet()) {
for (NonTerminal nonTerminal2 : firstNTSets.get(nonTerminal)) {
Set<Token> tokensWithoutEmpty = removeEmpty(firstTokenSets.get(nonTerminal2), emptyToken);
Set<Token> tokensWithoutEmpty = removeEmpty(firstTokenSets.get(nonTerminal2));

if(firstTokenSets.get(nonTerminal).containsAll(tokensWithoutEmpty)) {
continue;
Expand All @@ -161,14 +175,15 @@ private static void resolveConnectedSets(
} while (changesMade);
}

private static Set<Token> removeEmpty(Set<Token> set, Token emptyToken) {
private static Set<Token> removeEmpty(Set<Token> set) {
Set<Token> tokens = new HashSet<>();

for (Token token : set) {
if(!emptyToken.equals(token)) {
if(!EmptyToken.equals(token)) {
tokens.add(token);
}
}

return tokens;
}

Expand Down
115 changes: 115 additions & 0 deletions src/test/java/helper_objects/FirstSetGeneratorTests.java
Original file line number Diff line number Diff line change
Expand Up @@ -321,4 +321,119 @@ public void emptyTokenEdgeCaseRules() {

assertEquals(expectedSets, actualSets);
}

@Test
public void emptyTokenRule() {
Set<ProductionRule> productionRules = new HashSet<>();
productionRules.add(new ProductionRule(
new NonTerminal("s"),
new LexicalElement[] {
new Token("")
}
));

Set<NonTerminal> nonTerminals = new HashSet<>();
nonTerminals.add(new NonTerminal("s"));


HashMap<NonTerminal, Set<Token>> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals);


HashMap<NonTerminal, Set<Token>> expectedSets = new HashMap<>();
expectedSets.put(
new NonTerminal("s"),
Set.of(
new Token("")
));

assertEquals(expectedSets, actualSets);
}

@Test
public void emptyTokenRule_explicitEmptyToken() {
Set<ProductionRule> productionRules = new HashSet<>();
productionRules.add(new ProductionRule(
new NonTerminal("s"),
new LexicalElement[] {
new EmptyToken()
}
));

Set<NonTerminal> nonTerminals = new HashSet<>();
nonTerminals.add(new NonTerminal("s"));


HashMap<NonTerminal, Set<Token>> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals);


HashMap<NonTerminal, Set<Token>> expectedSets = new HashMap<>();
expectedSets.put(
new NonTerminal("s"),
Set.of(
new EmptyToken()
));

assertEquals(expectedSets, actualSets);
}

@Test
public void ruleWithMultipleEmptyTokens() {
Set<ProductionRule> productionRules = new HashSet<>();
productionRules.add(new ProductionRule(
new NonTerminal("s"),
new LexicalElement[] {
new EmptyToken(),
new Token("")
}
));

Set<NonTerminal> nonTerminals = new HashSet<>();
nonTerminals.add(new NonTerminal("s"));


HashMap<NonTerminal, Set<Token>> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals);


HashMap<NonTerminal, Set<Token>> expectedSets = new HashMap<>();
expectedSets.put(
new NonTerminal("s"),
Set.of(
new EmptyToken()
));

assertEquals(expectedSets, actualSets);
}

@Test
public void selfReferentialRule() {
Set<ProductionRule> productionRules = new HashSet<>();
productionRules.add(new ProductionRule(
new NonTerminal("s"),
new LexicalElement[] {
new NonTerminal("s")
}
));
productionRules.add(new ProductionRule(
new NonTerminal("s"),
new LexicalElement[] {
new EmptyToken()
}
));

Set<NonTerminal> nonTerminals = new HashSet<>();
nonTerminals.add(new NonTerminal("s"));


HashMap<NonTerminal, Set<Token>> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals);


HashMap<NonTerminal, Set<Token>> expectedSets = new HashMap<>();
expectedSets.put(
new NonTerminal("s"),
Set.of(
new EmptyToken()
));

assertEquals(expectedSets, actualSets);
}
}
Loading