org.antlr.v4.semantics

Class SymbolChecks

java.lang.Object

org.antlr.v4.semantics.SymbolChecks

public class SymbolChecks
extends Object

Check for symbol problems; no side-effects. Inefficient to walk rules and such multiple times, but I like isolating all error checking outside of code that actually defines symbols etc... Side-effect: strip away redef'd rules.

Field Summary

Fields

Modifier and Type	Field and Description
ErrorManager	errMgr
protected Set<String>	reservedNames

Constructor Summary

Constructors

Constructor and Description
SymbolChecks(Grammar g, SymbolCollector collector)

Method Summary

Modifier and Type	Method and Description
void	checkActionRedefinitions(List<GrammarAST> actions)
protected void	checkDeclarationRuleConflicts(Rule r, AttributeDict attributes, Set<String> ruleNames, ErrorType errorType)
void	checkForAttributeConflicts(Rule r)
void	checkForLabelConflict(Rule r, GrammarAST labelID)
void	checkForLabelConflicts(Collection<Rule> rules) Make sure a label doesn't conflict with another symbol.
void	checkForModeConflicts(Grammar g)
void	checkForQualifiedRuleIssues(Grammar g, List<GrammarAST> qualifiedRuleRefs)
void	checkForUnreachableTokens(Grammar g) Algorithm steps: 1.
protected void	checkLocalConflictingDeclarations(Rule r, AttributeDict attributes, AttributeDict referenceAttributes, ErrorType errorType)
protected void	checkReservedNames(Collection<Rule> rules)
void	checkRuleArgs(Grammar g, List<GrammarAST> rulerefs)
void	process()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

errMgr

public ErrorManager errMgr

reservedNames

protected final Set<String> reservedNames

Constructor Detail

SymbolChecks

public SymbolChecks(Grammar g,
                    SymbolCollector collector)

Method Detail

process

public void process()

checkActionRedefinitions

public void checkActionRedefinitions(List<GrammarAST> actions)

checkForLabelConflicts

public void checkForLabelConflicts(Collection<Rule> rules)

Make sure a label doesn't conflict with another symbol. Labels must not conflict with: rules, tokens, scope names, return values, parameters, and rule-scope dynamic attributes defined in surrounding rule. Also they must have same type for repeated defs.

checkForLabelConflict

public void checkForLabelConflict(Rule r,
                                  GrammarAST labelID)

checkForAttributeConflicts

public void checkForAttributeConflicts(Rule r)

checkDeclarationRuleConflicts

protected void checkDeclarationRuleConflicts(@NotNull
                                             Rule r,
                                             @Nullable
                                             AttributeDict attributes,
                                             @NotNull
                                             Set<String> ruleNames,
                                             @NotNull
                                             ErrorType errorType)

checkLocalConflictingDeclarations

protected void checkLocalConflictingDeclarations(@NotNull
                                                 Rule r,
                                                 @Nullable
                                                 AttributeDict attributes,
                                                 @Nullable
                                                 AttributeDict referenceAttributes,
                                                 @NotNull
                                                 ErrorType errorType)

checkReservedNames

protected void checkReservedNames(@NotNull
                                  Collection<Rule> rules)

checkForModeConflicts

public void checkForModeConflicts(Grammar g)

checkForUnreachableTokens

public void checkForUnreachableTokens(Grammar g)

Algorithm steps: 1. Collect all simple string literals (i.e. 'asdf', 'as' 'df', but not [a-z]+, 'a'..'z') for all lexer rules in each mode except of autogenerated tokens (getSingleTokenValues(org.antlr.v4.tool.Rule)) 2. Compare every string literal with each other (checkForOverlap(org.antlr.v4.tool.Grammar, org.antlr.v4.tool.Rule, org.antlr.v4.tool.Rule, java.util.List<java.lang.String>, java.util.List<java.lang.String>)) and throw TOKEN_UNREACHABLE warning if the same string found. Complexity: O(m * n^2 / 2), approximately equals to O(n^2) where m - number of modes, n - average number of lexer rules per mode. See also testUnreachableTokens unit test for details.

checkRuleArgs

public void checkRuleArgs(Grammar g,
                          List<GrammarAST> rulerefs)

checkForQualifiedRuleIssues

public void checkForQualifiedRuleIssues(Grammar g,
                                        List<GrammarAST> qualifiedRuleRefs)