org.antlr.tool
Class GrammarSanity

java.lang.Object
  extended by org.antlr.tool.GrammarSanity

public class GrammarSanity
extends java.lang.Object

Factor out routines that check sanity of rules, alts, grammars, etc..


Field Summary
protected  Grammar grammar
           
 
Constructor Summary
GrammarSanity(Grammar grammar)
           
 
Method Summary
protected  void addRulesToCycle(java.lang.String targetRuleName, java.lang.String enclosingRuleName, java.util.List listOfRecursiveCycles)
          enclosingRuleName calls targetRuleName, find the cycle containing the target and add the caller.
 java.util.List checkAllRulesForLeftRecursion()
          Check all rules for infinite left recursion before analysis.
 void checkRuleReference(GrammarAST refAST, GrammarAST argsAST, java.lang.String currentRuleName)
           
 void ensureAltIsSimpleNodeOrTree(GrammarAST altAST, GrammarAST elementAST, int outerAltNum)
          Rules in tree grammar that use -> rewrites and are spitting out templates via output=template and then use rewrite=true must only use -> on alts that are simple nodes or trees or single rule refs that match either nodes or trees.
protected  boolean isNextNonActionElementEOA(GrammarAST t)
           
protected  boolean isValidSimpleElementNode(GrammarAST t)
           
protected  boolean traceStatesLookingForLeftRecursion(NFAState s, java.util.Set visitedStates, java.util.List listOfRecursiveCycles)
          From state s, look for any transition to a rule that is currently being traced.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

grammar

protected Grammar grammar
Constructor Detail

GrammarSanity

public GrammarSanity(Grammar grammar)
Method Detail

checkAllRulesForLeftRecursion

public java.util.List checkAllRulesForLeftRecursion()
Check all rules for infinite left recursion before analysis. Return list of troublesome rule cycles. This method has two side-effects: it notifies the error manager that we have problems and it sets the list of recursive rules that we should ignore during analysis. Return type: List>.


traceStatesLookingForLeftRecursion

protected boolean traceStatesLookingForLeftRecursion(NFAState s,
                                                     java.util.Set visitedStates,
                                                     java.util.List listOfRecursiveCycles)
From state s, look for any transition to a rule that is currently being traced. When tracing r, visitedDuringRecursionCheck has r initially. If you reach an accept state, return but notify the invoking rule that it is nullable, which implies that invoking rule must look at follow transition for that invoking state. The visitedStates tracks visited states within a single rule so we can avoid epsilon-loop-induced infinite recursion here. Keep filling the cycles in listOfRecursiveCycles and also, as a side-effect, set leftRecursiveRules.


addRulesToCycle

protected void addRulesToCycle(java.lang.String targetRuleName,
                               java.lang.String enclosingRuleName,
                               java.util.List listOfRecursiveCycles)
enclosingRuleName calls targetRuleName, find the cycle containing the target and add the caller. Find the cycle containing the caller and add the target. If no cycles contain either, then create a new cycle. listOfRecursiveCycles is List> that holds a list of cycles (sets of rule names).


checkRuleReference

public void checkRuleReference(GrammarAST refAST,
                               GrammarAST argsAST,
                               java.lang.String currentRuleName)

ensureAltIsSimpleNodeOrTree

public void ensureAltIsSimpleNodeOrTree(GrammarAST altAST,
                                        GrammarAST elementAST,
                                        int outerAltNum)
Rules in tree grammar that use -> rewrites and are spitting out templates via output=template and then use rewrite=true must only use -> on alts that are simple nodes or trees or single rule refs that match either nodes or trees. The altAST is the ALT node for an ALT. Verify that its first child is simple. Must be either ( ALT ^( A B ) ) or ( ALT A ) or other element. Ignore predicates in front and labels.


isValidSimpleElementNode

protected boolean isValidSimpleElementNode(GrammarAST t)

isNextNonActionElementEOA

protected boolean isNextNonActionElementEOA(GrammarAST t)