From 7f2a1d2de40c65f72b3073b064ec7890344f3b30 Mon Sep 17 00:00:00 2001 From: warburec <77669019+warburec@users.noreply.github.com> Date: Wed, 14 Oct 2026 22:22:58 +0100 Subject: [PATCH] FirstSetGenerator fix and cleanup More tests added FirstSetGenerator code cleaned and tweaked for fix EmptyToken equality method override --- src/main/java/grammar_objects/EmptyToken.java | 17 ++- src/main/java/grammar_objects/Token.java | 2 - .../helper_objects/FirstSetGenerator.java | 111 +++++++++-------- .../FirstSetGeneratorTests.java | 115 ++++++++++++++++++ 4 files changed, 194 insertions(+), 51 deletions(-) diff --git a/src/main/java/grammar_objects/EmptyToken.java b/src/main/java/grammar_objects/EmptyToken.java index 20c964f..ff43c61 100644 --- a/src/main/java/grammar_objects/EmptyToken.java +++ b/src/main/java/grammar_objects/EmptyToken.java @@ -1,7 +1,13 @@ package grammar_objects; -public class EmptyToken extends Token{ +import java.util.*; + +public class EmptyToken extends Token { + public static final Set EquivalentTokens = Set.of( + new Token("") + ); + public EmptyToken() { super(""); } @@ -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); + } + } diff --git a/src/main/java/grammar_objects/Token.java b/src/main/java/grammar_objects/Token.java index af308eb..48e8809 100644 --- a/src/main/java/grammar_objects/Token.java +++ b/src/main/java/grammar_objects/Token.java @@ -4,9 +4,7 @@ public class Token extends LexicalElement { private Integer lineNumber; private Integer columnNumber; - private Integer symbolNumber; - private PositionType positionType; /** diff --git a/src/main/java/helper_objects/FirstSetGenerator.java b/src/main/java/helper_objects/FirstSetGenerator.java index 888fff9..461ccdb 100644 --- a/src/main/java/helper_objects/FirstSetGenerator.java +++ b/src/main/java/helper_objects/FirstSetGenerator.java @@ -5,35 +5,46 @@ import grammar_objects.*; public class FirstSetGenerator { + private static Token EmptyToken = new EmptyToken(); public static HashMap> generate(Set productionRules, Set nonTerminals) { HashMap> firstTokenSets = new HashMap<>(); HashMap> firstNTSets = new HashMap<>(); - Token emptyToken = new Token(""); - for(NonTerminal nonTerminal : nonTerminals) { firstTokenSets.put(nonTerminal, new HashSet<>()); firstNTSets.put(nonTerminal, new HashSet<>()); } - Set emptyNonTerminals = findEmptyNonTerminals(productionRules, nonTerminals, emptyToken); + Set 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 findEmptyNonTerminals(Set productionRules, Set nonTerminals, Token emptyToken) { + private static Set findEmptyNonTerminals(Set productionRules, Set nonTerminals) { Set 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()); } } @@ -44,56 +55,60 @@ private static Set findEmptyNonTerminals(Set produc private static void findAllFirstElements( Set productionRules, HashMap> firstTokenSets, - HashMap> firstNTSets, - Token emptyToken, + HashMap> firstNTSets, Set 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> firstTokenSets, + HashMap> firstNTSets, + Set 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); } } @@ -137,8 +152,7 @@ private static void resolveCompleteSets( private static void resolveConnectedSets( HashMap> firstTokenSets, - HashMap> firstNTSets, - Token emptyToken + HashMap> firstNTSets ) { boolean changesMade = false; @@ -147,7 +161,7 @@ private static void resolveConnectedSets( for (NonTerminal nonTerminal : firstNTSets.keySet()) { for (NonTerminal nonTerminal2 : firstNTSets.get(nonTerminal)) { - Set tokensWithoutEmpty = removeEmpty(firstTokenSets.get(nonTerminal2), emptyToken); + Set tokensWithoutEmpty = removeEmpty(firstTokenSets.get(nonTerminal2)); if(firstTokenSets.get(nonTerminal).containsAll(tokensWithoutEmpty)) { continue; @@ -161,14 +175,15 @@ private static void resolveConnectedSets( } while (changesMade); } - private static Set removeEmpty(Set set, Token emptyToken) { + private static Set removeEmpty(Set set) { Set tokens = new HashSet<>(); for (Token token : set) { - if(!emptyToken.equals(token)) { + if(!EmptyToken.equals(token)) { tokens.add(token); } } + return tokens; } diff --git a/src/test/java/helper_objects/FirstSetGeneratorTests.java b/src/test/java/helper_objects/FirstSetGeneratorTests.java index 7d5790e..534c983 100644 --- a/src/test/java/helper_objects/FirstSetGeneratorTests.java +++ b/src/test/java/helper_objects/FirstSetGeneratorTests.java @@ -321,4 +321,119 @@ public void emptyTokenEdgeCaseRules() { assertEquals(expectedSets, actualSets); } + + @Test + public void emptyTokenRule() { + Set productionRules = new HashSet<>(); + productionRules.add(new ProductionRule( + new NonTerminal("s"), + new LexicalElement[] { + new Token("") + } + )); + + Set nonTerminals = new HashSet<>(); + nonTerminals.add(new NonTerminal("s")); + + + HashMap> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals); + + + HashMap> expectedSets = new HashMap<>(); + expectedSets.put( + new NonTerminal("s"), + Set.of( + new Token("") + )); + + assertEquals(expectedSets, actualSets); + } + + @Test + public void emptyTokenRule_explicitEmptyToken() { + Set productionRules = new HashSet<>(); + productionRules.add(new ProductionRule( + new NonTerminal("s"), + new LexicalElement[] { + new EmptyToken() + } + )); + + Set nonTerminals = new HashSet<>(); + nonTerminals.add(new NonTerminal("s")); + + + HashMap> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals); + + + HashMap> expectedSets = new HashMap<>(); + expectedSets.put( + new NonTerminal("s"), + Set.of( + new EmptyToken() + )); + + assertEquals(expectedSets, actualSets); + } + + @Test + public void ruleWithMultipleEmptyTokens() { + Set productionRules = new HashSet<>(); + productionRules.add(new ProductionRule( + new NonTerminal("s"), + new LexicalElement[] { + new EmptyToken(), + new Token("") + } + )); + + Set nonTerminals = new HashSet<>(); + nonTerminals.add(new NonTerminal("s")); + + + HashMap> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals); + + + HashMap> expectedSets = new HashMap<>(); + expectedSets.put( + new NonTerminal("s"), + Set.of( + new EmptyToken() + )); + + assertEquals(expectedSets, actualSets); + } + + @Test + public void selfReferentialRule() { + Set 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 nonTerminals = new HashSet<>(); + nonTerminals.add(new NonTerminal("s")); + + + HashMap> actualSets = FirstSetGenerator.generate(productionRules, nonTerminals); + + + HashMap> expectedSets = new HashMap<>(); + expectedSets.put( + new NonTerminal("s"), + Set.of( + new EmptyToken() + )); + + assertEquals(expectedSets, actualSets); + } }