| java.lang.Object
 antlr.LLkAnalyzer
| Method Summary | |
| public Lookahead | FOLLOW(int k, RuleEndElement end)
Compute the lookahead set of whatever follows references to
the rule associated witht the FOLLOW block. | | protected boolean | altUsesWildcardDefault(Alternative alt)
Return true if someone used the '.' wildcard default idiom.
Either #(. | | public boolean | deterministic(AlternativeBlock blk)
Is this block of alternatives LL(k)? Fill in alternative cache for this block. | | public boolean | deterministic(OneOrMoreBlock blk)
Is (...)+ block LL(1)? Fill in alternative cache for this block. | | public boolean | deterministic(ZeroOrMoreBlock blk)
Is (...)* block LL(1)? Fill in alternative cache for this block. | | public boolean | deterministicImpliedPath(BlockWithImpliedExitPath blk)
| | public Lookahead | look(int k, ActionElement action)
| | public Lookahead | look(int k, AlternativeBlock blk)
| | public Lookahead | look(int k, BlockEndElement end)
Compute what follows this place-holder node and possibly
what begins the associated loop unless the
node is locked.
if we hit the end of a loop, we have to include
what tokens can begin the loop as well. | | public Lookahead | look(int k, CharLiteralElement atom)
Return this char as the lookahead if k=1.
### Doesn't work for ( 'a' 'b' | 'a' ~'b' ) yet!!!
If the atom has the not flag on, then
create the set complement of the tokenType
which is the set of all characters referenced
in the grammar with this char turned off.
Also remove characters from the set that
are currently allocated for predicting
previous alternatives. | | public Lookahead | look(int k, CharRangeElement r)
| | public Lookahead | look(int k, GrammarAtom atom)
| | public Lookahead | look(int k, OneOrMoreBlock blk)
The lookahead of a (...)+ block is the combined lookahead of
all alternatives and, if an empty path is found, the lookahead
of what follows the block. | | public Lookahead | look(int k, RuleBlock blk)
Combine the lookahead computed for each alternative.
Lock the node so that no other computation may come back
on itself--infinite loop. | | public Lookahead | look(int k, RuleEndElement end)
If not locked or noFOLLOW set, compute FOLLOW of a rule.
TJP says 8/12/99: not true anymore:
Lexical rules never compute follow. | | public Lookahead | look(int k, RuleRefElement rr)
Compute the lookahead contributed by a rule reference.
When computing ruleref lookahead, we don't want the FOLLOW
computation done if an empty path exists for the rule.
The FOLLOW is too loose of a set...we want only to
include the "local" FOLLOW or what can follow this
particular ref to the node. | | public Lookahead | look(int k, StringLiteralElement atom)
| | public Lookahead | look(int k, SynPredBlock blk)
The lookahead of a (...)=> block is the lookahead of
what follows the block. | | public Lookahead | look(int k, TokenRangeElement r)
| | public Lookahead | look(int k, TreeElement t)
| | public Lookahead | look(int k, WildcardElement wc)
| | public Lookahead | look(int k, ZeroOrMoreBlock blk)
The (...)* element is the combined lookahead of the alternatives and what can
follow the loop. | | public Lookahead | look(int k, String rule)
Compute the combined lookahead for all productions of a rule.
If the lookahead returns with epsilon, at least one epsilon
path exists (one that consumes no tokens). | | public static boolean | lookaheadEquivForApproxAndFullAnalysis(Lookahead[] bset, int k)
If the first k-1 sets are singleton sets, the appoximate
lookahead analysis is equivalent to full lookahead analysis. | | public void | setGrammar(Grammar g)
| | public boolean | subruleCanBeInverted(AlternativeBlock blk, boolean forLexer)
|
| DEBUG_ANALYZER | | public boolean DEBUG_ANALYZER(Code) | | |
| lexicalAnalysis | | protected boolean lexicalAnalysis(Code) | | |
| LLkAnalyzer | | public LLkAnalyzer(Tool tool_)(Code) | | Create an LLk analyzer
|
| FOLLOW | | public Lookahead FOLLOW(int k, RuleEndElement end)(Code) | | Compute the lookahead set of whatever follows references to
the rule associated witht the FOLLOW block.
|
| altUsesWildcardDefault | | protected boolean altUsesWildcardDefault(Alternative alt)(Code) | | Return true if someone used the '.' wildcard default idiom.
Either #(. children) or '.' as an alt by itself.
|
| deterministic | | public boolean deterministic(AlternativeBlock blk)(Code) | | Is this block of alternatives LL(k)? Fill in alternative cache for this block.
true if the block is deterministic |
| deterministic | | public boolean deterministic(OneOrMoreBlock blk)(Code) | | Is (...)+ block LL(1)? Fill in alternative cache for this block.
true if the block is deterministic |
| deterministic | | public boolean deterministic(ZeroOrMoreBlock blk)(Code) | | Is (...)* block LL(1)? Fill in alternative cache for this block.
true if the block is deterministic |
| deterministicImpliedPath | | public boolean deterministicImpliedPath(BlockWithImpliedExitPath blk)(Code) | | Is this (...)* or (...)+ block LL(k)?
true if the block is deterministic |
| look | | public Lookahead look(int k, BlockEndElement end)(Code) | | Compute what follows this place-holder node and possibly
what begins the associated loop unless the
node is locked.
if we hit the end of a loop, we have to include
what tokens can begin the loop as well. If the start
node is locked, then we simply found an empty path
through this subrule while analyzing it. If the
start node is not locked, then this node was hit
during a FOLLOW operation and the FIRST of this
block must be included in that lookahead computation.
|
| look | | public Lookahead look(int k, CharLiteralElement atom)(Code) | | Return this char as the lookahead if k=1.
### Doesn't work for ( 'a' 'b' | 'a' ~'b' ) yet!!!
If the atom has the not flag on, then
create the set complement of the tokenType
which is the set of all characters referenced
in the grammar with this char turned off.
Also remove characters from the set that
are currently allocated for predicting
previous alternatives. This avoids ambiguity
messages and is more properly what is meant.
( 'a' | ~'a' ) implies that the ~'a' is the
"else" clause.
NOTE: we do NOT include exit path in
the exclusion set. E.g.,
( 'a' | ~'a' )* 'b'
should exit upon seeing a 'b' during the loop.
|
| look | | public Lookahead look(int k, OneOrMoreBlock blk)(Code) | | The lookahead of a (...)+ block is the combined lookahead of
all alternatives and, if an empty path is found, the lookahead
of what follows the block.
|
| look | | public Lookahead look(int k, RuleBlock blk)(Code) | | Combine the lookahead computed for each alternative.
Lock the node so that no other computation may come back
on itself--infinite loop. This also implies infinite left-recursion
in the grammar (or an error in this algorithm ;)).
|
| look | | public Lookahead look(int k, RuleEndElement end)(Code) | | If not locked or noFOLLOW set, compute FOLLOW of a rule.
TJP says 8/12/99: not true anymore:
Lexical rules never compute follow. They set epsilon and
the code generator gens code to check for any character.
The code generator must remove the tokens used to predict
any previous alts in the same block.
When the last node of a rule is reached and noFOLLOW,
it implies that a "local" FOLLOW will be computed
after this call. I.e.,
a : b A;
b : B | ;
c : b C;
Here, when computing the look of rule b from rule a,
we want only {B,EPSILON_TYPE} so that look(b A) will
be {B,A} not {B,A,C}.
if the end block is not locked and the FOLLOW is
wanted, the algorithm must compute the lookahead
of what follows references to this rule. If
end block is locked, FOLLOW will return an empty set
with a cycle to the rule associated with this end block.
|
| look | | public Lookahead look(int k, RuleRefElement rr)(Code) | | Compute the lookahead contributed by a rule reference.
When computing ruleref lookahead, we don't want the FOLLOW
computation done if an empty path exists for the rule.
The FOLLOW is too loose of a set...we want only to
include the "local" FOLLOW or what can follow this
particular ref to the node. In other words, we use
context information to reduce the complexity of the
analysis and strengthen the parser.
The noFOLLOW flag is used as a means of restricting
the FOLLOW to a "local" FOLLOW. This variable is
orthogonal to the lock variable that prevents
infinite recursion. noFOLLOW does not care about what k is.
|
| look | | public Lookahead look(int k, SynPredBlock blk)(Code) | | The lookahead of a (...)=> block is the lookahead of
what follows the block. By definition, the syntactic
predicate block defies static analysis (you want to try it
out at run-time). The LOOK of (a)=>A B is A for LL(1)
### is this even called?
|
| look | | public Lookahead look(int k, ZeroOrMoreBlock blk)(Code) | | The (...)* element is the combined lookahead of the alternatives and what can
follow the loop.
|
| look | | public Lookahead look(int k, String rule)(Code) | | Compute the combined lookahead for all productions of a rule.
If the lookahead returns with epsilon, at least one epsilon
path exists (one that consumes no tokens). The noFOLLOW
flag being set for this endruleblk, indicates that the
a rule ref invoked this rule.
Currently only look(RuleRef) calls this. There is no need
for the code generator to call this.
|
| lookaheadEquivForApproxAndFullAnalysis | | public static boolean lookaheadEquivForApproxAndFullAnalysis(Lookahead[] bset, int k)(Code) | | If the first k-1 sets are singleton sets, the appoximate
lookahead analysis is equivalent to full lookahead analysis.
|
| setGrammar | | public void setGrammar(Grammar g)(Code) | | Set the grammar for the analyzer
|
|
|