|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use NFAState | |
---|---|
org.antlr.analysis | |
org.antlr.grammar.v2 | |
org.antlr.tool |
Uses of NFAState in org.antlr.analysis |
---|
Fields in org.antlr.analysis declared as NFAState | |
---|---|
NFAState |
DFA.decisionNFAStartState
From what NFAState did we create the DFA? |
NFAState |
RuleClosureTransition.followState
What node to begin computations following ref to rule |
NFAState |
NFAContext.invokingState
The NFA state that invoked another rule's start state is recorded on the rule invocation context stack. |
NFAState |
StateCluster.left
|
NFAState |
StateCluster.right
|
Fields in org.antlr.analysis with type parameters of type NFAState | |
---|---|
java.util.Map<NFAState,LookaheadSet> |
LL1Analyzer.FIRSTCache
|
protected java.util.Set<NFAState> |
LL1Analyzer.lookBusy
Used during LOOK to detect computation cycles |
Methods in org.antlr.analysis that return NFAState | |
---|---|
NFAState |
DFA.getNFADecisionStartState()
|
NFAState |
NFA.getState(int s)
|
Methods in org.antlr.analysis with parameters of type NFAState | |
---|---|
protected int |
LL1Analyzer._detectConfoundingPredicates(NFAState s,
Rule enclosingRule,
boolean chaseFollowTransitions)
|
protected LookaheadSet |
LL1Analyzer._FIRST(NFAState s,
boolean chaseFollowTransitions)
|
protected SemanticContext |
LL1Analyzer._getPredicates(NFAState s,
NFAState altStartState)
|
NFAConfiguration |
DFAState.addNFAConfiguration(NFAState state,
int alt,
NFAContext context,
SemanticContext semanticContext)
|
void |
DFAState.addNFAConfiguration(NFAState state,
NFAConfiguration c)
Add an NFA configuration to this DFA node. |
void |
NFA.addState(NFAState state)
|
void |
NFAToDFAConverter.closure(NFAState p,
int alt,
NFAContext context,
SemanticContext semanticContext,
DFAState d,
boolean collectPredicates)
Where can we get from NFA state p traversing only epsilon transitions? Add new NFA states + context to DFA state d. |
boolean |
LL1Analyzer.detectConfoundingPredicates(NFAState s)
Is there a non-syn-pred predicate visible from s that is not in the rule enclosing s? This accounts for most predicate situations and lets ANTLR do a simple LL(1)+pred computation. |
LookaheadSet |
LL1Analyzer.FIRST(NFAState s)
From an NFA state, s, find the set of all labels reachable from s. |
protected boolean |
DecisionProbe.getNFAPath(NFAState s,
int labelIndex,
java.util.List labels,
java.util.List path)
Given a sample input sequence, you usually would like to know the path taken through the NFA. |
SemanticContext |
LL1Analyzer.getPredicates(NFAState altStartState)
Return predicate expression found via epsilon edges from s. |
protected SemanticContext.Predicate |
LL1DFA.getSynPredForAlt(NFAState decisionStartState,
int alt)
|
LookaheadSet |
LL1Analyzer.LOOK(NFAState s)
|
Constructors in org.antlr.analysis with parameters of type NFAState | |
---|---|
DFA(int decisionNumber,
NFAState decisionStartState)
|
|
LL1DFA(int decisionNumber,
NFAState decisionStartState,
LookaheadSet[] altLook)
From list of lookahead sets (one per alt in decision), create an LL(1) DFA. |
|
LL1DFA(int decisionNumber,
NFAState decisionStartState,
MultiMap<IntervalSet,java.lang.Integer> edgeMap)
From a set of edgeset->list-of-alts mappings, create a DFA that uses syn preds for all |list-of-alts|>1. |
|
NFAContext(NFAContext parent,
NFAState invokingState)
|
|
RuleClosureTransition(Rule rule,
NFAState ruleStart,
NFAState followState)
|
|
StateCluster(NFAState left,
NFAState right)
|
Uses of NFAState in org.antlr.grammar.v2 |
---|
Methods in org.antlr.grammar.v2 with parameters of type NFAState | |
---|---|
protected void |
TreeToNFAConverter.addFollowTransition(java.lang.String ruleName,
NFAState following)
|
Uses of NFAState in org.antlr.tool |
---|
Fields in org.antlr.tool declared as NFAState | |
---|---|
NFAState |
GrammarAST.followingNFAState
Rule ref nodes, token refs, set, and NOT set refs need to track their location in the generated NFA so that local FOLLOW sets can be computed during code gen for automatic error recovery. |
NFAState |
GrammarAST.NFAStartState
What NFA start state was built from this node? |
NFAState |
GrammarAST.NFATreeDownState
This is used for TREE_BEGIN nodes to point into the NFA. |
NFAState |
Grammar.Decision.startState
|
NFAState |
Rule.startState
|
NFAState |
Rule.stopState
|
Fields in org.antlr.tool with type parameters of type NFAState | |
---|---|
protected java.util.Vector<NFAState> |
CompositeGrammar.numberToStateList
The NFA states in the NFA built from rules across grammars in composite. |
protected java.util.Set<NFAState> |
CompositeGrammar.refClosureBusy
Used during getRuleReferenceClosure to detect computation cycles |
Methods in org.antlr.tool that return NFAState | |
---|---|
NFAState |
Grammar.getDecisionNFAStartState(int decision)
|
NFAState |
GrammarAST.getNFAStartState()
|
NFAState |
Grammar.getNFAStateForAltOfDecision(NFAState decisionState,
int alt)
Get the ith alternative (1..n) from a decision; return null when an invalid alt is requested. |
NFAState |
Grammar.getRuleStartState(java.lang.String ruleName)
|
NFAState |
Grammar.getRuleStartState(java.lang.String scopeName,
java.lang.String ruleName)
|
NFAState |
Grammar.getRuleStopState(java.lang.String ruleName)
|
NFAState |
CompositeGrammar.getState(int s)
|
NFAState |
NFAFactory.newState()
|
Methods in org.antlr.tool with parameters of type NFAState | |
---|---|
void |
CompositeGrammar.addState(NFAState state)
|
int |
Grammar.assignDecisionNumber(NFAState state)
|
StateCluster |
NFAFactory.build_RuleRef(Rule refDef,
NFAState ruleStart)
For reference to rule r, build o-e->(r) o where (r) is the start of rule r and the trailing o is not linked to from rule ref state directly (it's done thru the transition(0) RuleClosureTransition. |
LookaheadSet |
Grammar.FIRST(NFAState s)
|
NFAState |
Grammar.getNFAStateForAltOfDecision(NFAState decisionState,
int alt)
Get the ith alternative (1..n) from a decision; return null when an invalid alt is requested. |
int |
Grammar.getNumberOfAltsForDecisionNFA(NFAState decisionState)
Decisions are linked together with transition(1). |
LookaheadSet |
Grammar.LOOK(NFAState s)
|
protected void |
Interpreter.parseEngine(java.lang.String startRule,
NFAState start,
NFAState stop,
IntStream input,
java.util.Stack ruleInvocationStack,
DebugEventListener actions,
java.util.List visitedStates)
Fill a list of all NFA states visited during the parse |
void |
Grammar.setDecisionNFA(int decision,
NFAState state)
|
void |
GrammarAST.setNFAStartState(NFAState nfaStartState)
|
protected boolean |
GrammarSanity.traceStatesLookingForLeftRecursion(NFAState s,
java.util.Set visitedStates,
java.util.List<java.util.Set<Rule>> listOfRecursiveCycles)
From state s, look for any transition to a rule that is currently being traced. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |