a Interval
a MismatchedRangeException
abortedDFA AnalysisTimeoutException
abortedDFA NonLLStarDecisionException
abortedDueToMultipleRecursiveAlts DFAState
If we detect recursion on more than one alt, decision is non-LL(*),
but try to isolate it to only those states whose closure operations
detect recursion.
abortedDueToRecursionOverflow DFAState
If a closure operation finds that we tried to invoke the same
rule too many times (stack would grow beyond a threshold), it
marks the state has aborted and notifies the DecisionProbe.
AbstractInputEditor org.antlr.gunit.swingui
AbstractInputEditor() AbstractInputEditor
AbstractTest org.antlr.gunit
AbstractTest() AbstractTest
accept DFA
ACCEPT ImageFactory
accept(File, String) ParserLoader.ClassFilenameFilter
accept DFA
acceptState State
An accept state is an end of rule state for lexers and
parser grammar rules.
acceptStateReachable DFAState
The NFA->DFA algorithm may terminate leaving some states
without a path to an accept state, implying that upon certain
input, the decision is not deterministic--no decision about
predicting a unique alternative can be made.
ack() DebugEventSocketProxy
ack() RemoteDebugEventSocketListener
ACTION Label
action() ANTLRParser
Match stuff like @parser::members {int i;}
ACTION ANTLRTokenTypes
action(AST) ANTLRTreePrinter
ACTION ANTLRTreePrinterTokenTypes
ACTION AssignTokenTypesWalkerTokenTypes
ACTION CodeGenTreeWalkerTokenTypes
action(AST) DefineGrammarItemsWalker
ACTION DefineGrammarItemsWalkerTokenTypes
ACTION TreeToNFAConverterTokenTypes
action() Barrier
What to do when everyone reaches barrier
ACTION(TokenRewriteStream, CommonTree) Strip
ACTION_CHAR_LITERAL ANTLRTokenTypes
ACTION_CHAR_LITERAL ANTLRTreePrinterTokenTypes
ACTION_CHAR_LITERAL AssignTokenTypesWalkerTokenTypes
ACTION_CHAR_LITERAL CodeGenTreeWalkerTokenTypes
ACTION_CHAR_LITERAL DefineGrammarItemsWalkerTokenTypes
ACTION_CHAR_LITERAL TreeToNFAConverterTokenTypes
ACTION_ESC ANTLRTokenTypes
ACTION_ESC ANTLRTreePrinterTokenTypes
ACTION_ESC AssignTokenTypesWalkerTokenTypes
ACTION_ESC CodeGenTreeWalkerTokenTypes
ACTION_ESC DefineGrammarItemsWalkerTokenTypes
ACTION_ESC TreeToNFAConverterTokenTypes
ACTION_STRING_LITERAL ANTLRTokenTypes
ACTION_STRING_LITERAL ANTLRTreePrinterTokenTypes
ACTION_STRING_LITERAL AssignTokenTypesWalkerTokenTypes
ACTION_STRING_LITERAL CodeGenTreeWalkerTokenTypes
ACTION_STRING_LITERAL DefineGrammarItemsWalkerTokenTypes
ACTION_STRING_LITERAL TreeToNFAConverterTokenTypes
actionAST ActionLabel
ActionLabel org.antlr.analysis
ActionLabel(GrammarAST) ActionLabel
actionPerformed(ActionEvent) TestCaseEditController.OutputResultEditor
actionReferencesLabel Grammar.LabelElementPair
Has an action referenced the label? Set by ActionAnalysis.g
Currently only set for rule labels.
actions() ANTLRParser
actions(AST) ANTLRTreePrinter
actions(AST) DefineGrammarItemsWalker
actions Grammar
Map a scope to a map of name:action pairs.
actions Rule
Map a name to an action for this rule.
actionScopeName() ANTLRParser
Sometimes the scope names will collide with keywords; allow them as
ids for action scopes.
ActionScriptTarget org.antlr.codegen
ActionScriptTarget() ActionScriptTarget
actual AbstractTest
ACyclicDFACodeGenerator org.antlr.codegen
ACyclicDFACodeGenerator(CodeGenerator) ACyclicDFACodeGenerator
acyclicDFAGenerator CodeGenerator
I have factored out the generation of acyclic DFAs to separate class
adaptor DebugEventSocketProxy
Almost certainly the recognizer will have adaptor set, but
we don't know how to cast it (Parser or TreeParser) to get
the adaptor field.
adaptor DebugTreeAdaptor
adaptor DebugTreeNodeStream
adaptor RewriteRuleElementStream
adaptor TreeIterator
adaptor TreePatternParser
adaptor TreeVisitor
adaptor TreeWizard
add(Label) Label
ADD ImageFactory
add(int) BitSet
or this element into this set (grow as necessary to accommodate)
add(int) IntArrayList
add(int) IntervalSet
Add a single element to the set.
add(int, int) IntervalSet
Add interval; i.e., add all integers from a to b to set.
add(Interval) IntervalSet
add(int) IntSet
Add an element to the set
add(Object) OrderedHashSet
Add a value to list; keep in hashtable for consistency also;
Key is object itself.
add(int) BitSet
or this element into this set (grow as necessary to accommodate)
add(T) FastQueue
add(int) IntArray
add(Object) RewriteRuleElementStream
addActionListener(ActionListener) AbstractInputEditor
addAll(IntSet) BitSet
addAll(int[]) BitSet
addAll(Iterable) BitSet
addAll(IntSet) IntervalSet
addAll(IntSet) IntSet
Add all elements from incoming set to this set.
addArtificialMatchTokensRule(GrammarAST, List<String>, List<String>, boolean) Grammar
Parse a rule we add artificially that is a list of the other lexer
rules like this: "Tokens : ID | INT | SEMI ;" nextToken() will invoke
this to set the current token.
addAttribute(String, String) AttributeScope
addAttributes(String, int) AttributeScope
From a chunk of text holding the definitions of the attributes,
pull them apart and create an Attribute for each one.
addChild(Object, Object) BlankDebugEventListener
addChild(Object, Object) DebugEventHub
addChild(Object, Object) DebugEventListener
Make childID a child of rootID.
addChild(Object, Object) DebugEventRepeater
addChild(Object, Object) DebugEventSocketProxy
addChild(Object, Object) DebugTreeAdaptor
addChild(Object, Token) DebugTreeAdaptor
addChild(Object, Object) TraceDebugEventListener
addChild(Tree) BaseTree
Add t as child of this node.
addChild(Object, Object) BaseTreeAdaptor
Add a child to the tree t.
addChild(Tree) Tree
Add t as a child to this node.
addChild(Object, Object) TreeAdaptor
Add a child to the tree t.
addChild(CompositeGrammarTree) CompositeGrammarTree
addChildren(List) BaseTree
Add all elements of kids list as children of this node
addDelegateGrammar(Grammar) Grammar
add new delegate to composite tree
addDFAStateToWorkList(DFAState) NFAToDFAConverter
Add a new DFA state to the DFA if not already present.
addEdge(Object, Object) Graph
addEdge(Graph.Node) Graph.Node
ADDFILE ImageFactory
addFollowTransition(String, NFAState) TreeToNFAConverter
addGrammar(Grammar, Grammar) CompositeGrammar
Add delegate grammar as child of delegator
addGrammarFile(String) Tool
addListener(DebugEventListener) DebugEventHub
Add another listener to broadcast events too.
addNavigationNode(int) BufferedTreeNodeStream
As we flatten the tree, we use UP, DOWN nodes to represent
the tree structure.
addNFAConfiguration(NFAState, NFAConfiguration) DFAState
Add an NFA configuration to this DFA node.
addNFAConfiguration(NFAState, int, NFAContext, SemanticContext) DFAState
addPredicateTransitions(DFAState) NFAToDFAConverter
for each NFA config in d, look for "predicate required" sign set
during nondeterminism resolution.
addReachableLabel(Label) DFAState
Add label uniquely and disjointly; intersection with
another set or int/char forces breaking up the set(s).
addRule(Rule) TestSuite
addRulesToCycle(Rule, Rule, List<Set<Rule>>) GrammarSanity
enclosingRuleName calls targetRuleName, find the cycle containing
the target and add the caller.
addRuleTestSuite(gUnitTestSuite) GrammarInfo
addState(DFAState) DFA
Add a new DFA state to this DFA if not already present.
addState(NFAState) NFA
addState(NFAState) CompositeGrammar
addTestCase(gUnitTestInput, AbstractTest) gUnitTestSuite
addTestCase(TestCase) Rule
addTestCase(ITestCaseInput, ITestCaseOutput) TestSuiteAdapter
addTransition(Transition) DFAState
addTransition(DFAState, Label) DFAState
Add a transition from this state to target with label.
addTransition(Transition) NFAState
addTransition(DFAState, Label, DFAState, Map) NFAToDFAConverter
Add a transition from state d to targetState with label in normal case.
addTransition(Transition) State
adjacent(Interval) Interval
Are two intervals adjacent such as 0..41 and 42..42?
alias(GrammarAST, GrammarAST) AssignTokenTypesWalker
alias(GrammarAST, GrammarAST) AssignTokenTypesBehavior
aliases AssignTokenTypesBehavior
aliasesReverseIndex AssignTokenTypesBehavior
aliasTokenIDsAndLiterals(Grammar) AssignTokenTypesWalker
aliasTokenIDsAndLiterals(Grammar) AssignTokenTypesBehavior
allDecisionDFACreated Grammar
allDecisionDFAHaveBeenCreated() Grammar
alreadyParsedRule(IntStream, int) BaseRecognizer
Has this rule already parsed input at the current index in the
input stream? Return the stop token index or MEMO_RULE_UNKNOWN.
alt NFAConfiguration
What alt is predicted by this configuration
ALT ANTLRTokenTypes
ALT ANTLRTreePrinterTokenTypes
ALT AssignTokenTypesWalkerTokenTypes
ALT CodeGenTreeWalkerTokenTypes
ALT DefineGrammarItemsWalkerTokenTypes
ALT TreeToNFAConverterTokenTypes
alt(GrammarAST) GrammarSerializerFoo
alt RecursionOverflowMessage
altBuf GrammarSerializerFoo
alternative() ANTLRParser
alternative(AST) ANTLRTreePrinter
alternative(AST) AssignTokenTypesWalker
alternative(AST) CodeGenTreeWalker
alternative(AST) DefineGrammarItemsWalker
alternative(AST) TreeToNFAConverter
altList(Map) ANTLRParser
altReferencesRule(String, GrammarAST, GrammarAST, int) Grammar
Track a rule reference within an outermost alt of a rule.
altReferencesTokenID(String, GrammarAST, int) Grammar
Track a token reference within an outermost alt of a rule.
alts GrammarUnreachableAltsMessage
altsWithProblem DecisionProbe
The overall list of alts within the decision that have at least one
conflicting input sequence.
altsWithRecursion NonRegularDecisionMessage
altsWithRewrites Rule
Track which alts have rewrite rules associated with them.
altToAcceptState DFA
We only want one accept state per predicted alt; track here
altToLocations GrammarInsufficientPredicatesMessage
altToRuleRefMap Rule
Each alt has a Map>; range 1..numberOfAlts
So, if there are 3 expr refs in a rule's alt number 2, you'll have
altToRuleRef[2].get("expr").size()==3.
altToTokenRefMap Rule
Each alt has a Map>; range 1..numberOfAlts.
AMPERSAND ANTLRTokenTypes
AMPERSAND ANTLRTreePrinterTokenTypes
AMPERSAND AssignTokenTypesWalkerTokenTypes
AMPERSAND CodeGenTreeWalkerTokenTypes
AMPERSAND DefineGrammarItemsWalkerTokenTypes
AMPERSAND TreeToNFAConverterTokenTypes
analysisAborted(DecisionProbe) ErrorManager
analysisOverflowed() DecisionProbe
Took too long to analyze a DFA
AnalysisRecursionOverflowException org.antlr.analysis
An NFA configuration context stack overflowed.
AnalysisRecursionOverflowException(DFAState, NFAConfiguration) AnalysisRecursionOverflowException
analysisTimedOut() DecisionProbe
Did the analysis complete it's work?
analysisTimedOut() DFA
AnalysisTimeoutException org.antlr.analysis
Analysis took too long; bail out of entire DFA construction.
AnalysisTimeoutException(DFA) AnalysisTimeoutException
and(SemanticContext, SemanticContext) SemanticContext
and(IntSet) BitSet
and(IntSet) IntervalSet
Return a new set with the intersection of this set with other.
and(IntSet) IntSet
Return the intersection of this set with the argument, creating
a new set.
andInPlace(BitSet) BitSet
Antlr3ErrorLog org.antlr.mojo.antlr3
The Maven plexus container gives us a Log logging provider
which we can use to install an error listener for the ANTLR
tool to report errors by.
Antlr3ErrorLog(Log) Antlr3ErrorLog
Instantiate an ANTLR ErrorListner that communicates any messages
it receives to the Maven error sink.
Antlr3Mojo org.antlr.mojo.antlr3
Goal that picks up all the ANTLR grammars in a project and moves those that
are required for generation of the compilable sources into the location
that we use to compile them, such as target/generated-sources/antlr3 ...
Antlr3Mojo() Antlr3Mojo
ANTLR_ARTIFACT_NAME GUnitExecuteMojo
ANTLR_GROUP_ID GUnitExecuteMojo
ANTLR_RUNTIME_ARTIFACT_NAME GUnitExecuteMojo
ANTLRErrorListener org.antlr.tool
Defines behavior of object able to handle error messages from ANTLR including
both tool errors like "can't write file" and grammar ambiguity warnings.
ANTLRFileStream org.antlr.runtime
This is a char buffer stream that is loaded from a file
all at once when you construct the object.
ANTLRFileStream(String) ANTLRFileStream
ANTLRFileStream(String, String) ANTLRFileStream
ANTLRInputStream org.antlr.runtime
A kind of ReaderStream that pulls from an InputStream.
ANTLRInputStream() ANTLRInputStream
ANTLRInputStream(InputStream) ANTLRInputStream
ANTLRInputStream(InputStream, int) ANTLRInputStream
ANTLRInputStream(InputStream, String) ANTLRInputStream
ANTLRInputStream(InputStream, int, String) ANTLRInputStream
ANTLRInputStream(InputStream, int, int, String) ANTLRInputStream
ANTLRLexer org.antlr.grammar.v2
ANTLRLexer(InputStream) ANTLRLexer
ANTLRLexer(Reader) ANTLRLexer
ANTLRLexer(InputBuffer) ANTLRLexer
ANTLRLexer(LexerSharedInputState) ANTLRLexer
ANTLRLiteralCharValueEscape Grammar
Given a char, we need to be able to show as an ANTLR literal.
ANTLRLiteralEscapedCharValue Grammar
When converting ANTLR char and string literals, here is the
value set of escape chars.
ANTLRParser org.antlr.grammar.v2
Read in an ANTLR grammar and build an AST.
ANTLRParser(TokenBuffer, int) ANTLRParser
ANTLRParser(TokenBuffer) ANTLRParser
ANTLRParser(TokenStream, int) ANTLRParser
ANTLRParser(TokenStream) ANTLRParser
ANTLRParser(ParserSharedInputState) ANTLRParser
ANTLRReaderStream org.antlr.runtime
Vacuum all input from a Reader and then treat it like a StringStream.
ANTLRReaderStream() ANTLRReaderStream
ANTLRReaderStream(Reader) ANTLRReaderStream
ANTLRReaderStream(Reader, int) ANTLRReaderStream
ANTLRReaderStream(Reader, int, int) ANTLRReaderStream
antlrSettings Tool
ANTLRStringStream org.antlr.runtime
A pretty quick CharStream that pulls all data from an array
directly.
ANTLRStringStream() ANTLRStringStream
ANTLRStringStream(String) ANTLRStringStream
Copy data in string to a local char array
ANTLRStringStream(char[], int) ANTLRStringStream
This is the preferred constructor as no data is copied
ANTLRTokenTypes org.antlr.grammar.v2
ANTLRTreePrinter org.antlr.grammar.v2
Print out a grammar (no pretty printing).
ANTLRTreePrinter() ANTLRTreePrinter
ANTLRTreePrinterTokenTypes org.antlr.grammar.v2
ANTLRWORKS_DIR Stats
appendUnitTestResult(String) GrammarInfo
applyOnce(Object, TreeFilter.fptr) TreeFilter
applyOnce(Object, TreeRewriter.fptr) TreeRewriter
applyRepeatedly(Object, TreeRewriter.fptr) TreeRewriter
approximateLineInfo RecognitionException
If you are parsing a tree node stream, you will encounter som
imaginary nodes w/o line/col info.
ARG ANTLRTokenTypes
ARG ANTLRTreePrinterTokenTypes
ARG AssignTokenTypesWalkerTokenTypes
ARG CodeGenTreeWalkerTokenTypes
ARG DefineGrammarItemsWalkerTokenTypes
ARG TreeToNFAConverterTokenTypes
ARG TreePatternLexer
arg Message
arg2 Message
ARG_ACTION ANTLRTokenTypes
ARG_ACTION ANTLRTreePrinterTokenTypes
ARG_ACTION AssignTokenTypesWalkerTokenTypes
ARG_ACTION CodeGenTreeWalkerTokenTypes
ARG_ACTION DefineGrammarItemsWalkerTokenTypes
ARG_ACTION TreeToNFAConverterTokenTypes
argActionAST Rule
For convenience, track the argument def AST action node if any
ARGLIST ANTLRTokenTypes
ARGLIST ANTLRTreePrinterTokenTypes
ARGLIST AssignTokenTypesWalkerTokenTypes
ARGLIST CodeGenTreeWalkerTokenTypes
ARGLIST DefineGrammarItemsWalkerTokenTypes
ARGLIST TreeToNFAConverterTokenTypes
args Strip
arrowhead DOTGenerator
ARTIFICIAL_TOKENS_RULENAME Grammar
assertTrue(boolean, String) ErrorManager
ASSIGN ANTLRTokenTypes
ASSIGN ANTLRTreePrinterTokenTypes
ASSIGN AssignTokenTypesWalkerTokenTypes
ASSIGN CodeGenTreeWalkerTokenTypes
ASSIGN DefineGrammarItemsWalkerTokenTypes
ASSIGN TreeToNFAConverterTokenTypes
assignDecisionNumber(NFAState) Grammar
assignStringTypes(Grammar) AssignTokenTypesWalker
assignStringTypes(Grammar) AssignTokenTypesBehavior
assignTokenIDTypes(Grammar) AssignTokenTypesWalker
assignTokenIDTypes(Grammar) AssignTokenTypesBehavior
assignTokenTypes() CompositeGrammar
AssignTokenTypesBehavior org.antlr.tool
Move all of the functionality from assign.types.g grammar file.
AssignTokenTypesBehavior() AssignTokenTypesBehavior
AssignTokenTypesWalker org.antlr.grammar.v2
[Warning: TJP says that this is probably out of date as of 11/19/2005,
but since it's probably still useful, I'll leave in.
AssignTokenTypesWalker() AssignTokenTypesWalker
AssignTokenTypesWalkerTokenTypes org.antlr.grammar.v2
associatedASTNode NFAState
Associate this NFAState with the corresponding GrammarAST node
from which this node was created.
ast_suffix(AST) ANTLRTreePrinter
ast_suffix(AST) AssignTokenTypesWalker
ast_suffix(AST) CodeGenTreeWalker
ast_suffix(AST) DefineGrammarItemsWalker
ast_suffix(AST) TreeToNFAConverter
atLeastOneBacktrackOption Grammar
At least one backtrack=true in rule or decision or grammar.
atLeastOneConfigurationHasAPredicate DFAState
atLeastOneRuleMemoizes Grammar
At least one rule has memoize=true
atom() ANTLRParser
atom(AST) ANTLRTreePrinter
atom(AST) AssignTokenTypesWalker
atom(AST, GrammarAST, GrammarAST, GrammarAST) CodeGenTreeWalker
atom(AST, GrammarAST) DefineGrammarItemsWalker
atom(AST, String) TreeToNFAConverter
atom_or_notatom(AST) TreeToNFAConverter
atTreeRoot ANTLRParser
Attribute org.antlr.tool
Track the names of attributes define in arg lists, return values,
scope blocks etc...
Attribute(String) Attribute
Attribute(String, String) Attribute
attributes AttributeScope
The list of Attribute objects
AttributeScope org.antlr.tool
Track the attributes within a scope.
AttributeScope(String, Token) AttributeScope
AttributeScope(Grammar, String, Token) AttributeScope
attrScope() ANTLRParser
attrScope(AST) ANTLRTreePrinter
attrScope(AST) AssignTokenTypesWalker
attrScope(AST) CodeGenTreeWalker
attrScope(AST) DefineGrammarItemsWalker
attrScope(AST) TreeToNFAConverter
attrScopes() ANTLRParser
AUTO_GENERATED_TOKEN_NAME_PREFIX Grammar
avg(int[]) Stats
Compute the sample mean
b Interval
b MismatchedRangeException
BACKTRACK_SEMPRED ANTLRTokenTypes
BACKTRACK_SEMPRED ANTLRTreePrinterTokenTypes
BACKTRACK_SEMPRED AssignTokenTypesWalkerTokenTypes
BACKTRACK_SEMPRED CodeGenTreeWalkerTokenTypes
BACKTRACK_SEMPRED DefineGrammarItemsWalkerTokenTypes
BACKTRACK_SEMPRED TreeToNFAConverterTokenTypes
backtracking RecognizerSharedState
If 0, no backtracking is going on.
BANG ANTLRTokenTypes
BANG ANTLRTreePrinterTokenTypes
BANG AssignTokenTypesWalkerTokenTypes
BANG CodeGenTreeWalkerTokenTypes
BANG DefineGrammarItemsWalkerTokenTypes
BANG TreeToNFAConverterTokenTypes
Barrier org.antlr.misc
A very simple barrier wait.
Barrier(int) Barrier
BaseRecognizer org.antlr.runtime
A generic recognizer that can handle recognizers generated from
lexer, parser, and tree grammars.
BaseRecognizer() BaseRecognizer
BaseRecognizer(RecognizerSharedState) BaseRecognizer
baseTemplates CodeGenerator
The basic output templates without AST or templates stuff; this will be
the templates loaded for the language such as Java.stg *and* the Dbg
stuff if turned on.
BaseTree org.antlr.runtime.tree
A generic tree implementation with no payload.
BaseTree() BaseTree
BaseTree(Tree) BaseTree
Create a new node from an existing node does nothing for BaseTree
as there are no fields other than the children list, which cannot
be copied as the children are not considered part of this node.
BaseTreeAdaptor org.antlr.runtime.tree
A TreeAdaptor that works with any Tree implementation.
BaseTreeAdaptor() BaseTreeAdaptor
becomeRoot(Object, Object) BlankDebugEventListener
becomeRoot(Object, Object) DebugEventHub
becomeRoot(Object, Object) DebugEventListener
Make a node the new root of an existing root.
becomeRoot(Object, Object) DebugEventRepeater
becomeRoot(Object, Object) DebugEventSocketProxy
becomeRoot(Object, Object) DebugTreeAdaptor
becomeRoot(Token, Object) DebugTreeAdaptor
becomeRoot(Object, Object) TraceDebugEventListener
becomeRoot(Object, Object) BaseTreeAdaptor
If oldRoot is a nil root, just copy or move the children to newRoot.
becomeRoot(Token, Object) BaseTreeAdaptor
becomeRoot(Object, Object) TreeAdaptor
If oldRoot is a nil root, just copy or move the children to newRoot.
becomeRoot(Token, Object) TreeAdaptor
Create a node for newRoot make it the root of oldRoot.
BEGIN TreePatternLexer
beginBacktrack(int) BlankDebugEventListener
beginBacktrack(int) DebugEventHub
beginBacktrack(int) DebugEventListener
beginBacktrack(int) DebugEventRepeater
beginBacktrack(int) DebugEventSocketProxy
beginBacktrack(int) DebugParser
beginBacktrack(int) DebugTreeParser
beginBacktrack(int) Profiler
Track backtracking decisions.
beginResync() BaseRecognizer
A hook to listen in on the token consumption during error recovery.
beginResync() BlankDebugEventListener
beginResync() DebugEventHub
beginResync() DebugEventListener
Indicates the recognizer is about to consume tokens to resynchronize
the parser.
beginResync() DebugEventRepeater
beginResync() DebugEventSocketProxy
beginResync() DebugParser
beginResync() DebugTreeParser
BITS BitSet
bits BitSet
The actual data bits
BITS BitSet
bits BitSet
The actual data bits
BitSet org.antlr.misc
A BitSet to replace java.util.BitSet.
BitSet() BitSet
Construct a bitset of size one word (64 bits)
BitSet(long[]) BitSet
Construction from a static array of longs
BitSet(int) BitSet
Construct a bitset given the size
BitSet org.antlr.runtime
A stripped-down version of org.antlr.misc.BitSet that is just
good enough to handle runtime requirements such as FOLLOW sets
for automatic error recovery.
BitSet() BitSet
Construct a bitset of size one word (64 bits)
BitSet(long[]) BitSet
Construction from a static array of longs
BitSet(List) BitSet
Construction from a list of integers
BitSet(int) BitSet
Construct a bitset given the size
BlankDebugEventListener org.antlr.runtime.debug
A blank listener that does nothing; useful for real classes so
they don't have to have lots of blank methods and are less
sensitive to updates to debug interface.
BlankDebugEventListener() BlankDebugEventListener
block() ANTLRParser
Build #(BLOCK ( #(ALT ...) EOB )+ )
BLOCK ANTLRTokenTypes
block(AST, boolean) ANTLRTreePrinter
BLOCK ANTLRTreePrinterTokenTypes
block(AST) AssignTokenTypesWalker
BLOCK AssignTokenTypesWalkerTokenTypes
block(AST, String, DFA) CodeGenTreeWalker
BLOCK CodeGenTreeWalkerTokenTypes
block(AST) DefineGrammarItemsWalker
BLOCK DefineGrammarItemsWalkerTokenTypes
block(AST) TreeToNFAConverter
BLOCK TreeToNFAConverterTokenTypes
block(int) GrammarSerializerFoo
BLOCK_START NFAState
blockAction(AST) DefineGrammarItemsWalker
blockAST Grammar.Decision
blockLevel DefineGrammarItemsWalker
blockLevel TreeToNFAConverter
blockNestingLevel CodeGenTreeWalker
blockOptions GrammarAST
If this is a BLOCK node, track options here
blocksWithSemPreds Grammar
Track decisions with syn preds specified for reporting.
blocksWithSynPreds Grammar
Track decisions with syn preds specified for reporting.
BooleanTest org.antlr.gunit
BooleanTest(boolean) BooleanTest
bottomup() TreeFilter
bottomup() TreeRewriter
btnOpenGrammar WorkSpaceView
buf ANTLRTreePrinter
BufferedTreeNodeStream org.antlr.runtime.tree
A buffered stream of tree nodes.
BufferedTreeNodeStream(Object) BufferedTreeNodeStream
BufferedTreeNodeStream(TreeAdaptor, Object) BufferedTreeNodeStream
BufferedTreeNodeStream(TreeAdaptor, Object, int) BufferedTreeNodeStream
BufferedTreeNodeStream.StreamIterator org.antlr.runtime.tree
BufferedTreeNodeStream.StreamIterator() BufferedTreeNodeStream.StreamIterator
build_AB(StateCluster, StateCluster) NFAFactory
From A B build A-e->B (that is, build an epsilon arc from right
of A to left of B).
build_Action(GrammarAST) NFAFactory
Build what amounts to an epsilon transition with an action.
build_AlternativeBlock(List) NFAFactory
From A|B|..|Z alternative block build
o->o-A->o->o (last NFAState is blockEndNFAState pointed to by all alts)
| ^
o->o-B->o--|
| |
...
build_AlternativeBlockFromSet(StateCluster) NFAFactory
From a set ('a'|'b') build
o->o-'a'..'b'->o->o (last NFAState is blockEndNFAState pointed to by all alts)
build_Aoptional(StateCluster) NFAFactory
From (A)? build either:
o--A->o
| ^
o---->|
or, if A is a block, just add an empty alt to the end of the block
build_Aplus(StateCluster) NFAFactory
From (A)+ build
|---| (Transition 2 from A.right points at alt 1)
v | (follow of loop is Transition 1)
o->o-A-o->o
Meaning that the last NFAState in A points back to A's left Transition NFAState
and we add a new begin/end NFAState.
build_Astar(StateCluster) NFAFactory
From (A)* build
|---|
v |
o->o-A-o--o (Transition 2 from block end points at alt 1; follow is Transition 1)
| ^
o---------| (optional branch is 2nd alt of optional block containing A+)
Meaning that the last (end) NFAState in A points back to A's
left side NFAState and we add 3 new NFAStates (the
optional branch is built just like an optional subrule).
build_Atom(int, GrammarAST) NFAFactory
From label A build Graph o-A->o
build_Atom(GrammarAST) NFAFactory
build_CharLiteralAtom(GrammarAST) NFAFactory
From char 'c' build StateCluster o-intValue(c)->o
build_CharRange(String, String) NFAFactory
From char 'c' build StateCluster o-intValue(c)->o
can include unicode spec likes '$' later.
build_EOFStates(List) NFAFactory
add an EOF transition to any rule end NFAState that points to nothing
(i.e., for all those rules not invoked by another rule).
build_Epsilon() NFAFactory
From an empty alternative build StateCluster o-e->o
build_Range(int, int) NFAFactory
Can only complement block of simple alts; can complement build_Set()
result, that is.
build_RuleRef(Rule, NFAState) NFAFactory
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.
build_SemanticPredicate(GrammarAST) NFAFactory
Build what amounts to an epsilon transition with a semantic
predicate action.
build_Set(IntSet, GrammarAST) NFAFactory
From set build single edge graph o->o-set->o.
build_StringLiteralAtom(GrammarAST) NFAFactory
For a non-lexer, just build a simple token reference atom.
build_Wildcard(GrammarAST) NFAFactory
Build an atom with all possible values in its label
build_WildcardTree(GrammarAST) NFAFactory
Build a subrule matching ^(.
buildAST() Grammar
BuildDependencyGenerator org.antlr.tool
Given a grammar file, show the dependencies on .tokens etc...
BuildDependencyGenerator(Tool, String) BuildDependencyGenerator
buildNFA() Grammar
buildRequired(String) Tool
Checks to see if the list of outputFiles all exist, and have
last-modified timestamps which are later than the last-modified
timestamp of all the grammar files involved in build the output
(imports must be checked).
buildTemplate() Grammar
buildTokenTypeASTClassMap() ANTLRParser
builtFromString Grammar
We need a way to detect when a lexer grammar is autogenerated from
another grammar or we are just sending in a string representing a
grammar.
BYPASS NFAState
c RecognitionException
The current char when an error occurred.
c TreePatternLexer
Current char
cachedHashCode DFAState
Build up the hash code for this state as NFA configurations
are added as it's monotonically increasing list of configurations.
cachedHashCode NFAContext
Computing the hashCode is very expensive and closureBusy()
uses it to track when it's seen a state|ctx before to avoid
infinite loops.
cachedUniquelyPredicatedAlt DFAState
calls BufferedTreeNodeStream
Stack of indexes used for push/pop calls
calls CommonTreeNodeStream
Stack of indexes used for push/pop calls
callSiteStates RecursionOverflowMessage
canGenerateSwitch(DFAState) CodeGenerator
You can generate a switch rather than if-then-else for a DFA state
if there are no semantic predicates and the number of edge label
values is small enough; e.g., don't generate a switch for a state
containing an edge label such as 20..52330 (the resulting byte codes
would overflow the method 65k limit probably).
canInlineDecision() DFA
capacity() IntArrayList
caretUpdate(CaretEvent) TestCaseEditController.InputMultiEditor
caretUpdate(CaretEvent) TestCaseEditController.InputStringEditor
caretUpdate(CaretEvent) TestCaseEditController.OutputAstEditor
catOpText(Object, Object) TokenRewriteStream
changeFirstCapital(String) JUnitCodeGen
channel ClassicToken
channel CommonToken
channel CommonTokenStream
Skip tokens on any channel but this one; this is how we skip whitespace...
channel RecognizerSharedState
The channel number for the current token
channelOverrideMap CommonTokenStream
Map to override some Tokens' channel numbers
CHAR_LABEL Grammar
CHAR_LITERAL ANTLRTokenTypes
CHAR_LITERAL ANTLRTreePrinterTokenTypes
CHAR_LITERAL AssignTokenTypesWalkerTokenTypes
CHAR_LITERAL CodeGenTreeWalkerTokenTypes
CHAR_LITERAL DefineGrammarItemsWalkerTokenTypes
CHAR_LITERAL TreeToNFAConverterTokenTypes
CHAR_RANGE ANTLRTokenTypes
CHAR_RANGE ANTLRTreePrinterTokenTypes
CHAR_RANGE AssignTokenTypesWalkerTokenTypes
CHAR_RANGE CodeGenTreeWalkerTokenTypes
CHAR_RANGE DefineGrammarItemsWalkerTokenTypes
CHAR_RANGE TreeToNFAConverterTokenTypes
charAlias AssignTokenTypesWalker
charAlias2 AssignTokenTypesWalker
charLabels Rule
A list of all LabelElementPair attached to single char literals like x='a'
charLiteral(GrammarAST) GrammarSerializerFoo
charPos RemoteDebugEventSocketListener.ProxyTree
charPositionInLine ANTLRStringStream
The index of the character relative to the beginning of the line 0..n-1
charPositionInLine ClassicToken
charPositionInLine CommonToken
charPositionInLine RecognitionException
charSet(AST) AssignTokenTypesWalker
CHARSET AssignTokenTypesWalkerTokenTypes
charSetElement(AST) AssignTokenTypesWalker
CharStream org.antlr.runtime
A source of characters for an ANTLR lexer
CharStreamState org.antlr.runtime
When walking ahead with cyclic DFA or for syntactic predicates,
we need to record the state of the input stream (char index,
line, etc...) so that we can rewind the state after scanning ahead.
CharStreamState() CharStreamState
charVocabulary Grammar
TODO: hook this to the charVocabulary option
checkAllRulesForLeftRecursion() Grammar
checkAllRulesForLeftRecursion() GrammarSanity
Check all rules for infinite left recursion before analysis.
checkAllRulesForUselessLabels() Grammar
Remove all labels on rule refs whose target rules have no return value.
checkConflicts() NameSpaceChecker
checkForGlobalScopeTokenConflict(AttributeScope) NameSpaceChecker
checkForLabelConflict(Rule, Token) NameSpaceChecker
Make sure a label doesn't conflict with another symbol.
checkForLabelTypeMismatch(Rule, Token, int) NameSpaceChecker
If type of previous label differs from new label's type, that's an error.
checkForRuleArgumentAndReturnValueConflicts(Rule) NameSpaceChecker
checkForRuleDefinitionProblems(Rule) NameSpaceChecker
checkForRuleScopeAttributeConflict(Rule, Attribute) NameSpaceChecker
Check for collision of a rule-scope dynamic attribute with:
arg, return value, rule name itself.
checkNameSpaceAndActions() Grammar
ANALYZE ACTIONS, LOOKING FOR LABEL AND ATTR REFS, sanity check
checkRuleReference(GrammarAST, GrammarAST, GrammarAST, String) Grammar
checkRuleReference(GrammarAST, GrammarAST, GrammarAST, String) GrammarSanity
childIndex CommonTree
What index is this node in the child list? Range: 0..n-1
children BaseTree
children CompositeGrammarTree
chooseWhereCyclicDFAsGo(Tool, CodeGenerator, Grammar, StringTemplate, StringTemplate) ActionScriptTarget
chooseWhereCyclicDFAsGo(Tool, CodeGenerator, Grammar, StringTemplate, StringTemplate) CSharp2Target
chooseWhereCyclicDFAsGo(Tool, CodeGenerator, Grammar, StringTemplate, StringTemplate) CSharpTarget
chooseWhereCyclicDFAsGo(Tool, CodeGenerator, Grammar, StringTemplate, StringTemplate) CTarget
chooseWhereCyclicDFAsGo(Tool, CodeGenerator, Grammar, StringTemplate, StringTemplate) DelphiTarget
chooseWhereCyclicDFAsGo(Tool, CodeGenerator, Grammar, StringTemplate, StringTemplate) JavaTarget
classForName(String) gUnitExecutor
ClassicToken org.antlr.runtime
A Token object like we'd use in ANTLR 2.x; has an actual string created
and associated with this object.
ClassicToken(int) ClassicToken
ClassicToken(Token) ClassicToken
ClassicToken(int, String) ClassicToken
ClassicToken(int, String, int) ClassicToken
classpathTemplateRootDirectoryName CodeGenerator
cleanup(GrammarAST) ANTLRParser
clear() BitSet
clear(int) BitSet
clear() OrderedHashSet
clear() FastQueue
clear() IntArray
clone() Label
clone() BitSet
clone() IntArrayList
clone() BitSet
close() GrammarSerializerFoo
CLOSE_ELEMENT_OPTION ANTLRTokenTypes
CLOSE_ELEMENT_OPTION ANTLRTreePrinterTokenTypes
CLOSE_ELEMENT_OPTION AssignTokenTypesWalkerTokenTypes
CLOSE_ELEMENT_OPTION CodeGenTreeWalkerTokenTypes
CLOSE_ELEMENT_OPTION DefineGrammarItemsWalkerTokenTypes
CLOSE_ELEMENT_OPTION TreeToNFAConverterTokenTypes
closeConnection() RemoteDebugEventSocketListener
closure(DFAState) NFAToDFAConverter
For all NFA states (configurations) merged in d,
compute the epsilon closure; that is, find all NFA states reachable
from the NFA states in d via purely epsilon transitions.
closure(NFAState, int, NFAContext, SemanticContext, DFAState, boolean) NFAToDFAConverter
Where can we get from NFA state p traversing only epsilon transitions?
Add new NFA states + context to DFA state d.
CLOSURE ANTLRTokenTypes
CLOSURE ANTLRTreePrinterTokenTypes
CLOSURE AssignTokenTypesWalkerTokenTypes
CLOSURE CodeGenTreeWalkerTokenTypes
CLOSURE DefineGrammarItemsWalkerTokenTypes
CLOSURE TreeToNFAConverterTokenTypes
closureBusy DFAState
Used to prevent the closure operation from looping to itself and
hence looping forever.
closureIsBusy(DFAState, NFAConfiguration) NFAToDFAConverter
A closure operation should abort if that computation has already
been done or a computation with a conflicting context has already
been done.
code GrammarAST
if this is a TOKEN_REF or RULE_REF node, this is the code StringTemplate
generated for this node.
CodeGenerator org.antlr.codegen
ANTLR's code generator.
CodeGenerator(Tool, Grammar, String) CodeGenerator
CodeGenTreeWalker org.antlr.grammar.v2
Walk a grammar and generate code by gradually building up
a bigger and bigger StringTemplate.
CodeGenTreeWalker() CodeGenTreeWalker
CodeGenTreeWalkerTokenTypes org.antlr.grammar.v2
COLLAPSE_ALL_PARALLEL_EDGES DFAOptimizer
COLON ANTLRTokenTypes
COLON ANTLRTreePrinterTokenTypes
COLON AssignTokenTypesWalkerTokenTypes
COLON CodeGenTreeWalkerTokenTypes
COLON DefineGrammarItemsWalkerTokenTypes
COLON TreeToNFAConverterTokenTypes
COLON TreePatternLexer
column Message
COMBINED Grammar
COMBINED_GRAMMAR ANTLRTokenTypes
COMBINED_GRAMMAR ANTLRTreePrinterTokenTypes
COMBINED_GRAMMAR AssignTokenTypesWalkerTokenTypes
COMBINED_GRAMMAR CodeGenTreeWalkerTokenTypes
COMBINED_GRAMMAR DefineGrammarItemsWalkerTokenTypes
COMBINED_GRAMMAR TreeToNFAConverterTokenTypes
combineFollows(boolean) BaseRecognizer
COMMA ANTLRTokenTypes
COMMA ANTLRTreePrinterTokenTypes
COMMA AssignTokenTypesWalkerTokenTypes
COMMA CodeGenTreeWalkerTokenTypes
COMMA DefineGrammarItemsWalkerTokenTypes
COMMA TreeToNFAConverterTokenTypes
commence() BlankDebugEventListener
commence() DebugEventHub
commence() DebugEventListener
Announce that parsing has begun.
commence() DebugEventRepeater
commence() DebugEventSocketProxy
COMMENT ANTLRTokenTypes
COMMENT ANTLRTreePrinterTokenTypes
COMMENT AssignTokenTypesWalkerTokenTypes
COMMENT CodeGenTreeWalkerTokenTypes
COMMENT DefineGrammarItemsWalkerTokenTypes
COMMENT TreeToNFAConverterTokenTypes
CommonErrorNode org.antlr.runtime.tree
A node representing erroneous token range in token stream
CommonErrorNode(TokenStream, Token, Token, RecognitionException) CommonErrorNode
CommonToken org.antlr.runtime
CommonToken(int) CommonToken
CommonToken(CharStream, int, int, int, int) CommonToken
CommonToken(int, String) CommonToken
CommonToken(Token) CommonToken
CommonTokenStream org.antlr.runtime
The most common stream of tokens is one where every token is buffered up
and tokens are prefiltered for a certain channel (the parser will only
see these tokens and cannot change the filter channel number during the
parse).
CommonTokenStream() CommonTokenStream
CommonTokenStream(TokenSource) CommonTokenStream
CommonTokenStream(TokenSource, int) CommonTokenStream
CommonTree org.antlr.runtime.tree
A tree node that is wrapper for a Token object.
CommonTree() CommonTree
CommonTree(CommonTree) CommonTree
CommonTree(Token) CommonTree
CommonTreeAdaptor org.antlr.runtime.tree
A TreeAdaptor that works with any Tree implementation.
CommonTreeAdaptor() CommonTreeAdaptor
CommonTreeNodeStream org.antlr.runtime.tree
CommonTreeNodeStream(Object) CommonTreeNodeStream
CommonTreeNodeStream(TreeAdaptor, Object) CommonTreeNodeStream
comp AbstractInputEditor
compareTo(Object) Label
compareTo(Object) Transition
compile() JUnitCodeGen
compileToBuffer(String, String, String) JUnitCodeGen
complement() BitSet
complement(IntSet) BitSet
complement(int, int) IntervalSet
complement(IntSet) IntervalSet
Given the set of possible values (rather than, say UNICODE or MAXINT),
return a new set containing all elements in vocabulary, but not in
this.
complement(IntSet) IntSet
complement(IntSet) Grammar
For lexer grammars, return everything in unicode not in set.
complement(int) Grammar
complete NFA
COMPLETE_SET IntervalSet
composite Grammar
If this grammar is part of a larger composite grammar via delegate
statement, then this points at the composite.
CompositeGrammar org.antlr.tool
A tree of component (delegate) grammars.
CompositeGrammar() CompositeGrammar
CompositeGrammar(Grammar) CompositeGrammar
CompositeGrammarTree org.antlr.tool
A tree of grammars
CompositeGrammarTree(Grammar) CompositeGrammarTree
compositeTreeNode Grammar
A pointer back into grammar tree.
computeContextSensitiveRuleFOLLOW() BaseRecognizer
Compute the context-sensitive FOLLOW set for current rule.
computeErrorRecoverySet() BaseRecognizer
computeStartState() NFAToDFAConverter
From this first NFA state of a decision, create a DFA.
computeTokenNameFromLiteral(int, String) Grammar
given a token type and the text of the literal, come up with a
decent token type label.
computeTokenTypes(String[]) TreeWizard
Compute a Map that is an inverted index of
tokenNames (which maps int token types to names).
computingStartState NFAToDFAConverter
configurationsWithLabeledEdges DFAState
conflictsWith(NFAContext) NFAContext
Two contexts conflict() if they are equals() or one is a stack suffix
of the other.
constantValue SemanticContext.Predicate
sometimes predicates are known to be true or false; we need
a way to represent this without resorting to a target language
value like true or TRUE.
consume() ANTLRStringStream
consume() CommonTokenStream
Move the input pointer to the next incoming token.
consume() DebugTokenStream
consume() DebugTreeNodeStream
consume() IntStream
consume() LookaheadStream
Make sure we have at least one element to remove, even if EOF
consume() BufferedTreeNodeStream
consume() TreePatternLexer
consumeHiddenToken(Token) BlankDebugEventListener
consumeHiddenToken(Token) DebugEventHub
consumeHiddenToken(Token) DebugEventListener
An off-channel input token was consumed.
consumeHiddenToken(Token) DebugEventRepeater
consumeHiddenToken(Token) DebugEventSocketProxy
consumeHiddenToken(Token) ParseTreeBuilder
consumeHiddenToken(Token) Profiler
consumeInitialHiddenTokens() DebugTokenStream
consumeNode(Object) BlankDebugEventListener
consumeNode(Object) DebugEventHub
consumeNode(Object) DebugEventListener
Input for a tree parser is an AST, but we know nothing for sure
about a node except its type and text (obtained from the adaptor).
consumeNode(Object) DebugEventRepeater
consumeNode(Object) DebugEventSocketProxy
consumeNode(Object) TraceDebugEventListener
consumeToken(Token) BlankDebugEventListener
consumeToken(Token) DebugEventHub
consumeToken(Token) DebugEventListener
An input token was consumed; matched by any kind of element.
consumeToken(Token) DebugEventRepeater
consumeToken(Token) DebugEventSocketProxy
consumeToken(Token) ParseTreeBuilder
consumeToken(Token) Profiler
consumeUntil(IntStream, int) BaseRecognizer
consumeUntil(IntStream, BitSet) BaseRecognizer
Consume tokens until one matches the given token set
contains(int) IntArrayList
context NFAConfiguration
What is the stack of rule invocations that got us to state?
contextTrees NFAToDFAConverter
While converting NFA, we must track states that
reference other rule's NFAs so we know what to do
at the end of a rule.
conversionStartTime DFA
Track absolute time of the conversion so we can have a failsafe:
if it takes too long, then terminate.
convert() NFAToDFAConverter
convertPreservedChars(String) TestCase
convertToAcceptState(DFAState, int) NFAToDFAConverter
convertToEOTAcceptState(DFAState) NFAToDFAConverter
Walk the configurations of this DFA state d looking for the
configuration, c, that has a transition on EOT.
COOKIE SerializedGrammar
count Barrier
countAltsForBlock(AST) ANTLRTreePrinter
countAltsForRule(AST) DefineGrammarItemsWalker
CPPTarget org.antlr.codegen
CPPTarget() CPPTarget
create(int, int) Interval
Interval objects are used readonly so share all with the
same single value a==b up to some max size.
create(Token) DebugTreeAdaptor
create(int, Token) DebugTreeAdaptor
create(int, Token, String) DebugTreeAdaptor
create(int, String) DebugTreeAdaptor
create(Object) ParseTreeBuilder
What kind of node to create.
create(int, Token) BaseTreeAdaptor
create(int, Token, String) BaseTreeAdaptor
create(int, String) BaseTreeAdaptor
create(Token) CommonTreeAdaptor
create(Token) TreeAdaptor
Create a tree node from Token object; for CommonTree type trees,
then the token just becomes the payload.
create(int, Token) TreeAdaptor
Create a new node derived from a token, with a new token type.
create(int, Token, String) TreeAdaptor
Same as create(tokenType,fromToken) except set the text too.
create(int, String) TreeAdaptor
Create a new node derived from a token, with a new token type.
create(String) TreeWizard
Create a tree or node from the indicated tree pattern that closely
follows ANTLR tree grammar tree element syntax:
(root child1 ...
create(Token) TreeWizard.TreePatternTreeAdaptor
createAstOutput(String) TestSuiteAdapter
createBlockFromDupAlt(GrammarAST) ANTLRParser
Create a copy of the alt and make it into a BLOCK; all actions,
labels, tree operators, rewrites are removed.
createBoolOutput(boolean) TestSuiteAdapter
createChildrenList() BaseTree
Override in a subclass to change the impl of children list
createDecision(int) Grammar
createEOTAndEOFTables(DFAState) DFA
Set up the EOT and EOF tables; we cannot put -1 min/max values so
we need another way to test that in the DFA transition function.
createFileInput(String) TestSuiteAdapter
createLL_1_LookaheadDFA(int) Grammar
createLookaheadDFA(int, boolean) Grammar
createLookaheadDFAs() Grammar
For each decision in this grammar, compute a single DFA using the
NFA states associated with the decision.
createLookaheadDFAs(boolean) Grammar
createMinMaxTables(DFAState) DFA
createMultiInput(String) TestSuiteAdapter
createNFAs() CompositeGrammar
createNode(Object) BlankDebugEventListener
createNode(Object, Token) BlankDebugEventListener
createNode(Object) DebugEventHub
createNode(Object, Token) DebugEventHub
createNode(Object) DebugEventListener
Announce a new node built from token elements such as type etc...
createNode(Object, Token) DebugEventListener
Announce a new node built from an existing token.
createNode(Object) DebugEventRepeater
createNode(Object, Token) DebugEventRepeater
createNode(Object) DebugEventSocketProxy
createNode(Object, Token) DebugEventSocketProxy
createNode(Object) TraceDebugEventListener
createNode(Object, Token) TraceDebugEventListener
createParameterScope(String, Token) Grammar
createReturnOutput(String) TestSuiteAdapter
createReturnScope(String, Token) Grammar
createRuleScope(String, Token) Grammar
createRuleStartAndStopNFAStates() Grammar
Define all the rule begin/end NFAStates to solve forward reference
issues.
creates Interval
createSimpleRuleAST(String, GrammarAST, boolean) ANTLRParser
createSpecialTable(DFAState) DFA
createStateTables(CodeGenerator) DFA
createStdOutput(String) TestSuiteAdapter
createStringInput(String) TestSuiteAdapter
createSynSemPredFromBlock(GrammarAST, int) ANTLRParser
createTestSuite(File) TestSuiteFactory
Factory method: create a testsuite from ANTLR grammar.
createToken(int, String) BaseTreeAdaptor
Tell me how to create a token for use with imaginary token nodes.
createToken(Token) BaseTreeAdaptor
Tell me how to create a token for use with imaginary token nodes.
createToken(int, String) CommonTreeAdaptor
Tell me how to create a token for use with imaginary token nodes.
createToken(Token) CommonTreeAdaptor
Tell me how to create a token for use with imaginary token nodes.
createTransitionTableEntryForState(DFAState) DFA
createUniqueLabel(String) CodeGenerator
Create a label to track a token / rule reference's result.
CSharp2Target org.antlr.codegen
CSharp2Target() CSharp2Target
CSharpTarget org.antlr.codegen
CSharpTarget() CSharpTarget
CTarget org.antlr.codegen
CTarget() CTarget
ctx SemanticContext.NOT
currentAltHasASTRewrite CodeGenTreeWalker
currentBlockAST ANTLRParser
currentBlockST CodeGenTreeWalker
currentRewriteBlock DefineGrammarItemsWalker
currentRewriteRule DefineGrammarItemsWalker
currentRuleName ANTLRParser
currentRuleName AssignTokenTypesWalker
currentRuleName CodeGenTreeWalker
currentRuleName DefineGrammarItemsWalker
currentRuleName TreeToNFAConverter
cursor RewriteRuleElementStream
Cursor 0..n-1.
cycles LeftRecursionCyclesMessage
cyclic DFA
Are there any loops in this DFA?
Computed by doesStateReachAcceptState()
danglingState(DecisionProbe, DFAState) ErrorManager
danglingStates DecisionProbe
The set of states w/o emanating edges and w/o resolving sem preds.
data ANTLRStringStream
The data being scanned
data FastQueue
dynamically-sized buffer of elements
data IntArray
dbg DebugParser
Who to notify when events in the parser occur.
dbg DebugTokenStream
dbg DebugTreeAdaptor
dbg DebugTreeNodeStream
dbg DebugTreeParser
Who to notify when events in the parser occur.
dealWithTreeFilterMode() Grammar
debug NFAToDFAConverter
debug CodeGenerator
Generate debugging event method calls
debug Antlr3Mojo
If set to true, then the code generated by the ANTLR code generator will
be set to debug mode.
debug DFA
debug RandomPhrase
DebugEventHub org.antlr.runtime.debug
Broadcast debug events to multiple listeners.
DebugEventHub(DebugEventListener) DebugEventHub
DebugEventHub(DebugEventListener, DebugEventListener) DebugEventHub
DebugEventListener org.antlr.runtime.debug
All debugging events that a recognizer can trigger.
DebugEventRepeater org.antlr.runtime.debug
A simple event repeater (proxy) that delegates all functionality to the
listener sent into the ctor.
DebugEventRepeater(DebugEventListener) DebugEventRepeater
DebugEventSocketProxy org.antlr.runtime.debug
A proxy debug event listener that forwards events over a socket to
a debugger (or any other listener) using a simple text-based protocol;
one event per line.
DebugEventSocketProxy(BaseRecognizer, TreeAdaptor) DebugEventSocketProxy
DebugEventSocketProxy(BaseRecognizer, int, TreeAdaptor) DebugEventSocketProxy
DebugParser org.antlr.runtime.debug
DebugParser(TokenStream, DebugEventListener, RecognizerSharedState) DebugParser
Create a normal parser except wrap the token stream in a debug
proxy that fires consume events.
DebugParser(TokenStream, RecognizerSharedState) DebugParser
DebugParser(TokenStream, DebugEventListener) DebugParser
DebugTokenStream org.antlr.runtime.debug
DebugTokenStream(TokenStream, DebugEventListener) DebugTokenStream
DebugTreeAdaptor org.antlr.runtime.debug
A TreeAdaptor proxy that fires debugging events to a DebugEventListener
delegate and uses the TreeAdaptor delegate to do the actual work.
DebugTreeAdaptor(DebugEventListener, TreeAdaptor) DebugTreeAdaptor
DebugTreeNodeStream org.antlr.runtime.debug
Debug any tree node stream.
DebugTreeNodeStream(TreeNodeStream, DebugEventListener) DebugTreeNodeStream
DebugTreeParser org.antlr.runtime.debug
DebugTreeParser(TreeNodeStream, DebugEventListener, RecognizerSharedState) DebugTreeParser
Create a normal parser except wrap the token stream in a debug
proxy that fires consume events.
DebugTreeParser(TreeNodeStream, RecognizerSharedState) DebugTreeParser
DebugTreeParser(TreeNodeStream, DebugEventListener) DebugTreeParser
decision Grammar.Decision
decisionCount Grammar
Be able to assign a number to every decision in grammar;
decisions in 1..n
decisionLevel Profiler
decisionMaxCyclicLookaheads Profiler
decisionMaxFixedLookaheads Profiler
decisionMaxSynPredLookaheads Profiler
decisionNFAStartState DFA
From what NFAState did we create the DFA?
decisionNumber DFA
This DFA is being built for which decision?
decisionNumber NFAState
What's its decision number from 1..n?
decisionNumber DFA
decisionNumber EarlyExitException
decisionNumber NoViableAltException
DecisionProbe org.antlr.analysis
Collection of information about what is wrong with a decision as
discovered while building the DFA predictor.
DecisionProbe(DFA) DecisionProbe
decisionStateType NFAState
Subrules (...)* and (...)+ have more than one decision point in
the NFA created for them.
decisionsWhoseDFAsUsesSemPreds Grammar
Track decisions that actually use the syn preds in the DFA.
decisionsWhoseDFAsUsesSynPreds Grammar
Track decisions that actually use the syn preds in the DFA.
decl Attribute
The entire declaration such as "String foo;"
decodeReportData(String) Profiler
decodeReportData(String) GrammarReport
DEFAULT_CHANNEL Token
All tokens go to the parser (unless skip() is called in that rule)
on a particular "channel".
DEFAULT_DEBUGGER_PORT DebugEventSocketProxy
DEFAULT_INITIAL_BUFFER_SIZE BufferedTreeNodeStream
DEFAULT_INITIAL_BUFFER_SIZE CommonTreeNodeStream
DEFAULT_PROGRAM_NAME TokenRewriteStream
DEFAULT_TOKEN_CHANNEL BaseRecognizer
defaultBlockOptions Grammar
What are the default options for a subrule?
defaultLexerBlockOptions Grammar
defaultNodeOption(GrammarAST) ANTLRParser
defaultOptions Grammar
defaultTokenOption Grammar
defineGlobalScope(String, Token) Grammar
DefineGrammarItemsWalker org.antlr.grammar.v2
DefineGrammarItemsWalker() DefineGrammarItemsWalker
DefineGrammarItemsWalkerTokenTypes org.antlr.grammar.v2
defineGrammarSymbols() CompositeGrammar
defineGrammarSymbols() Grammar
defineLabel(Rule, Token, GrammarAST, int) Grammar
Define a label defined in a rule r; check the validity then ask the
Rule object to actually define it.
defineLabel(Token, GrammarAST, int) Rule
defineLexerRuleForAliasedStringLiteral(String, String, int) Grammar
If someone does PLUS='+' in the parser, must make sure we get
"PLUS : '+' ;" in lexer not "T73 : '+';"
defineLexerRuleForStringLiteral(String, int) Grammar
defineLexerRuleFoundInParser(Token, GrammarAST) Grammar
defineNamedAction(GrammarAST, String, GrammarAST, GrammarAST) Grammar
Given @scope::name {action} define it for this grammar.
defineNamedAction(GrammarAST, GrammarAST, GrammarAST) Rule
Given @scope::name {action} define it for this grammar.
defineRule(Token, String, Map, GrammarAST, GrammarAST, int) Grammar
Define a new rule.
defineRuleListLabel(String, Token, GrammarAST) Grammar
defineRuleRefLabel(String, Token, GrammarAST) Grammar
defineStringLiteralsFromDelegates() AssignTokenTypesWalker
defineSyntacticPredicate(GrammarAST, String) Grammar
Define a new predicate and get back its name for use in building
a semantic predicate reference to the syn pred.
defineToken(String, int) Grammar
Define a token at a particular token type value.
defineTokenListLabel(String, Token, GrammarAST) Grammar
defineTokenNamesAndLiteralsInGrammar(Grammar) AssignTokenTypesWalker
defineTokenNamesAndLiteralsInGrammar(Grammar) AssignTokenTypesBehavior
defineTokenRefLabel(String, Token, GrammarAST) Grammar
defineTokens(Grammar) AssignTokenTypesWalker
defineTokens(Grammar) AssignTokenTypesBehavior
defineWildcardTreeLabel(String, Token, GrammarAST) Grammar
defineWildcardTreeListLabel(String, Token, GrammarAST) Grammar
delegatedRuleReferences Grammar
The list of all rules referenced in this grammar, not defined here,
and defined in a delegate grammar.
delegateGrammar() ANTLRParser
delegateGrammars() ANTLRParser
delegateGrammars(AST) ANTLRTreePrinter
delegateGrammars(AST) AssignTokenTypesWalker
delegateGrammars(AST) DefineGrammarItemsWalker
delegateGrammarTreeRoot CompositeGrammar
DELETE ImageFactory
delete(int) TokenRewriteStream
delete(int, int) TokenRewriteStream
delete(Token) TokenRewriteStream
delete(Token, Token) TokenRewriteStream
delete(String, int, int) TokenRewriteStream
delete(String, Token, Token) TokenRewriteStream
deleteChild(Object, int) DebugTreeAdaptor
deleteChild(int) BaseTree
deleteChild(Object, int) BaseTreeAdaptor
deleteChild(int) Tree
deleteChild(Object, int) TreeAdaptor
Remove ith child and shift children down from right.
deleteProgram() TokenRewriteStream
deleteProgram(String) TokenRewriteStream
Reset the program so that no instructions exist
deleteTempLexer Tool
DelphiTarget org.antlr.codegen
DelphiTarget() DelphiTarget
derivedFromToken AttributeScope
This scope is associated with which input token (for error handling)?
description DFA
The printable grammar fragment associated with this DFA
description NFAState
During debugging and for nondeterminism warnings, it's useful
to know what relationship this node has to the original grammar.
deserializeNode(String[], int) RemoteDebugEventSocketListener
deserializeToken(String[], int) RemoteDebugEventSocketListener
DETECT_PRED_EOR LL1Analyzer
0 if we hit end of rule and invoker should keep going (epsilon)
DETECT_PRED_FOUND LL1Analyzer
1 if we found a nonautobacktracking pred
DETECT_PRED_NOT_FOUND LL1Analyzer
2 if we didn't find such a pred
detectConfoundingPredicates(NFAState) LL1Analyzer
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.
dfa DecisionProbe
DFA org.antlr.analysis
A DFA (converted from a grammar's NFA).
DFA() DFA
DFA(int, NFAState) DFA
dfa DFAState
We are part of what DFA? Use this ref to get access to the
context trees for an alt.
dfa NFAToDFAConverter
We are converting which DFA?
dfa Antlr3Mojo
If set to true then the ANTLR tool will generate a description of the DFA
for each decision in the grammar in
Dot format
DFA org.antlr.runtime
A DFA implemented as a set of transition tables.
DFA() DFA
dfa Grammar.Decision
DFACreationWallClockTimeInMS Grammar
How long in ms did it take to build DFAs for this grammar?
If this grammar is a combined grammar, it only records time for
the parser grammar component.
DFAOptimizer org.antlr.analysis
A module to perform optimizations on DFAs.
DFAOptimizer(Grammar) DFAOptimizer
DFAState org.antlr.analysis
A DFA state represents a set of possible NFA configurations.
DFAState(DFA) DFAState
DFS(Graph.Node, Set<Graph.Node>, ArrayList<Object>) Graph
differenceNotProperlyContained(Interval) Interval
Return the interval with elements from this not in other;
other must not be totally enclosed (properly contained)
within this, which would result in two disjoint intervals
instead of the single one returned by this method.
DIGIT ANTLRTokenTypes
DIGIT ANTLRTreePrinterTokenTypes
DIGIT AssignTokenTypesWalkerTokenTypes
DIGIT CodeGenTreeWalkerTokenTypes
DIGIT DefineGrammarItemsWalkerTokenTypes
DIGIT TreeToNFAConverterTokenTypes
dirty RewriteRuleElementStream
Once a node / subtree has been used in a stream, it must be dup'd
from then on.
discardOffChannelTokens CommonTokenStream
By default, track all incoming tokens
discardOffChannelTokens(boolean) CommonTokenStream
discardSet CommonTokenStream
Set; discard any tokens with this type
discardTokenType(int) CommonTokenStream
disjoint(Interval) Interval
Are both ranges disjoint? I.e., no overlap?
dispatch(String) RemoteDebugEventSocketListener
displayRecognitionError(String[], RecognitionException) BaseRecognizer
DOC_COMMENT ANTLRTokenTypes
DOC_COMMENT ANTLRTreePrinterTokenTypes
DOC_COMMENT AssignTokenTypesWalkerTokenTypes
DOC_COMMENT CodeGenTreeWalkerTokenTypes
DOC_COMMENT DefineGrammarItemsWalkerTokenTypes
DOC_COMMENT TreeToNFAConverterTokenTypes
doesStateReachAcceptState(DFAState) DFA
figure out if this state eventually reaches an accept state and
modify the instance variable 'reduced' to indicate if we find
at least one state that cannot reach an accept state.
DOLLAR ANTLRTokenTypes
DOLLAR ANTLRTreePrinterTokenTypes
DOLLAR AssignTokenTypesWalkerTokenTypes
DOLLAR CodeGenTreeWalkerTokenTypes
DOLLAR DefineGrammarItemsWalkerTokenTypes
DOLLAR TreeToNFAConverterTokenTypes
doNotAttemptAnalysis() ErrorManager
doNotAttemptCodeGen() ErrorManager
doNotCopyOptionsToLexer Grammar
DOT ANTLRTokenTypes
DOT ANTLRTreePrinterTokenTypes
DOT AssignTokenTypesWalkerTokenTypes
DOT CodeGenTreeWalkerTokenTypes
DOT DefineGrammarItemsWalkerTokenTypes
DOT TreeToNFAConverterTokenTypes
DOT TreePatternLexer
dotBlock(AST) DefineGrammarItemsWalker
DOTGenerator org.antlr.tool
The DOT (part of graphviz) generation aspect.
DOTGenerator(Grammar) DOTGenerator
This aspect is associated with a grammar
dotLoop(AST) DefineGrammarItemsWalker
Track the .* and .+ idioms and make them nongreedy by default.
DOTTreeGenerator org.antlr.runtime.tree
A utility class to generate DOT diagrams (graphviz) from
arbitrary trees.
DOTTreeGenerator() DOTTreeGenerator
DOUBLE_ANGLE_STRING_LITERAL ANTLRTokenTypes
DOUBLE_ANGLE_STRING_LITERAL ANTLRTreePrinterTokenTypes
DOUBLE_ANGLE_STRING_LITERAL AssignTokenTypesWalkerTokenTypes
DOUBLE_ANGLE_STRING_LITERAL CodeGenTreeWalkerTokenTypes
DOUBLE_ANGLE_STRING_LITERAL DefineGrammarItemsWalkerTokenTypes
DOUBLE_ANGLE_STRING_LITERAL TreeToNFAConverterTokenTypes
DOUBLE_QUOTE_STRING_LITERAL ANTLRTokenTypes
DOUBLE_QUOTE_STRING_LITERAL ANTLRTreePrinterTokenTypes
DOUBLE_QUOTE_STRING_LITERAL AssignTokenTypesWalkerTokenTypes
DOUBLE_QUOTE_STRING_LITERAL CodeGenTreeWalkerTokenTypes
DOUBLE_QUOTE_STRING_LITERAL DefineGrammarItemsWalkerTokenTypes
DOUBLE_QUOTE_STRING_LITERAL TreeToNFAConverterTokenTypes
DOWN Label
DOWN Token
imaginary tree navigation type; traverse "get child" link
down BufferedTreeNodeStream
down TreeIterator
DOWN TreeParser
downup(Object) TreeFilter
downup(Object) TreeRewriter
downup(Object, boolean) TreeRewriter
dup(Object) RewriteRuleElementStream
When constructing trees, sometimes we need to dup a token or AST
subtree.
dup(Object) RewriteRuleNodeStream
dup(Object) RewriteRuleSubtreeStream
dup(Object) RewriteRuleTokenStream
dup(AST) GrammarAST
dupListNoActions(GrammarAST, GrammarAST) GrammarAST
Duplicate tree including siblings of root.
dupNode(Object) DebugTreeAdaptor
dupNode() RemoteDebugEventSocketListener.ProxyTree
dupNode() CommonTree
dupNode(Object) CommonTreeAdaptor
Duplicate a node.
dupNode() ParseTree
dupNode() Tree
dupNode(Object) TreeAdaptor
Duplicate a single tree node.
dupTree(Object) DebugTreeAdaptor
dupTree(Object) BaseTreeAdaptor
dupTree(Object, Object) BaseTreeAdaptor
This is generic in the sense that it will work with any kind of
tree (not just Tree interface).
dupTree(Object) TreeAdaptor
Duplicate tree recursively, using dupNode() for each node
dupTreeNoActions(GrammarAST, GrammarAST) GrammarAST
Duplicate a tree, assuming this is a root node of a tree--
duplicate that node and what's below; ignore siblings of root node.
e Message
EarlyExitException org.antlr.runtime
The recognizer did not match anything for a (..)+ loop.
EarlyExitException() EarlyExitException
Used for remote debugger deserialization
EarlyExitException(int, IntStream) EarlyExitException
ebnf() ANTLRParser
matches ENBF blocks (and sets via block rule)
ebnf(AST) ANTLRTreePrinter
ebnf(AST) AssignTokenTypesWalker
ebnf(AST) CodeGenTreeWalker
ebnf(AST) DefineGrammarItemsWalker
ebnf(AST) TreeToNFAConverter
ebnfSuffix(GrammarAST, boolean) ANTLRParser
edgeTransitionClass DFA
The unique edge transition class number; every time we see a new
set of edges emanating from a state, we number it so we can reuse
if it's every seen again for another state.
edgeTransitionClassMap DFA
Map an edge transition table to a unique set number; ordered so
we can push into the output template as an ordered list of sets
and then ref them from within the transition[][] table.
EDIT16 ImageFactory
element() ANTLRParser
element(AST) ANTLRTreePrinter
element(AST) AssignTokenTypesWalker
element(AST, GrammarAST, GrammarAST) CodeGenTreeWalker
element(AST) DefineGrammarItemsWalker
element(AST) TreeToNFAConverter
element(int) IntArrayList
element_action(AST) CodeGenTreeWalker
elementDescription RewriteCardinalityException
elementDescription RewriteRuleElementStream
The element or stream description; usually has name of the token or
rule reference that this list tracks.
elementNoOptionSpec() ANTLRParser
elementOption(GrammarAST) ANTLRParser
elementOptions(GrammarAST) ANTLRParser
elementRef Grammar.LabelElementPair
elements IntArrayList
elements() IntArrayList
elements OrderedHashSet
Track the elements as they are added to the set
elements() OrderedHashSet
Return the List holding list of table elements.
elements RewriteRuleElementStream
The list of tokens or subtrees we are tracking
emit(Token) Lexer
Currently does not support multiple emits per nextToken invocation
for efficiency reasons.
emit() Lexer
The standard method called to automatically emit a token at the
outermost lexical rule.
EMIT_TEMPLATE_DELIMITERS CodeGenerator
emitErrorMessage(String) BaseRecognizer
Override this method to change where error messages go
emitSingleError ErrorManager
Only one error can be emitted for any entry in this table.
EMPTY_SEMANTIC_CONTEXT SemanticContext
Create a default value for the semantic context shared among all
NFAConfigurations that do not have an actual semantic context.
enclosingRule NFAState
What rule do we live in?
enclosingRuleName GrammarAST
encodeIntAsCharEscape(int) ActionScriptTarget
ActionScript doesn't support Unicode String literals that are considered "illegal"
or are in the surrogate pair ranges.
encodeIntAsCharEscape(int) CSharp2Target
encodeIntAsCharEscape(int) CSharpTarget
encodeIntAsCharEscape(int) DelphiTarget
encodeIntAsCharEscape(int) JavaScriptTarget
Convert an int to a JavaScript Unicode character literal.
encodeIntAsCharEscape(int) Perl5Target
encodeIntAsCharEscape(int) Target
END TreePatternLexer
endAlt() GrammarSerializerFoo
endBacktrack(int, boolean) BlankDebugEventListener
endBacktrack(int, boolean) DebugEventHub
endBacktrack(int, boolean) DebugEventListener
endBacktrack(int, boolean) DebugEventRepeater
endBacktrack(int, boolean) DebugEventSocketProxy
endBacktrack(int, boolean) DebugParser
endBacktrack(int, boolean) DebugTreeParser
endBacktrack(int, boolean) Profiler
Successful or not, track how much lookahead synpreds use
endOfBlockStateNumber NFAState
Jean Bovet needs in the GUI to know which state pairs correspond
to the start/stop of a block.
endResync() BaseRecognizer
endResync() BlankDebugEventListener
endResync() DebugEventHub
endResync() DebugEventListener
Indicates that the recognizer has finished consuming tokens in order
to resychronize.
endResync() DebugEventRepeater
endResync() DebugEventSocketProxy
endResync() DebugParser
endResync() DebugTreeParser
endRule() TestSuiteAdapter
endRule() GrammarSerializerFoo
ensureAltIsSimpleNodeOrTree(GrammarAST, GrammarAST, int) GrammarSanity
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.
ensureCapacity(int) IntArrayList
ensureCapacity(int) IntArray
enterAlt(int) BlankDebugEventListener
enterAlt(int) DebugEventHub
enterAlt(int) DebugEventListener
Because rules can have lots of alternatives, it is very useful to
know which alt you are entering.
enterAlt(int) DebugEventRepeater
enterAlt(int) DebugEventSocketProxy
enterDecision(int) BlankDebugEventListener
enterDecision(int) DebugEventHub
enterDecision(int) DebugEventListener
Every decision, fixed k or arbitrary, has an enter/exit event
so that a GUI can easily track what LT/consume events are
associated with prediction.
enterDecision(int) DebugEventRepeater
enterDecision(int) DebugEventSocketProxy
enterDecision(int) ParseTreeBuilder
Backtracking or cyclic DFA, don't want to add nodes to tree
enterDecision(int) Profiler
enterRule(String, String) BlankDebugEventListener
enterRule(String, String) DebugEventHub
enterRule(String, String) DebugEventListener
The parser has just entered a rule.
enterRule(String, String) DebugEventRepeater
enterRule(String, String) DebugEventSocketProxy
enterRule(String, String) ParseTreeBuilder
enterRule(String, String) Profiler
enterRule(String) TraceDebugEventListener
enterRule(String) Tracer
enterSubRule(int) BlankDebugEventListener
enterSubRule(int) DebugEventHub
enterSubRule(int) DebugEventListener
Track entry into any (...) subrule other EBNF construct
enterSubRule(int) DebugEventRepeater
enterSubRule(int) DebugEventSocketProxy
enterSubRule(int) TraceDebugEventListener
EOA ANTLRTokenTypes
EOA ANTLRTreePrinterTokenTypes
EOA AssignTokenTypesWalkerTokenTypes
EOA CodeGenTreeWalkerTokenTypes
EOA DefineGrammarItemsWalkerTokenTypes
EOA TreeToNFAConverterTokenTypes
EOB ANTLRTokenTypes
EOB ANTLRTreePrinterTokenTypes
EOB AssignTokenTypesWalkerTokenTypes
EOB CodeGenTreeWalkerTokenTypes
EOB DefineGrammarItemsWalkerTokenTypes
EOB TreeToNFAConverterTokenTypes
eof DFA
EOF Label
EOF ANTLRTokenTypes
EOF ANTLRTreePrinterTokenTypes
EOF AssignTokenTypesWalkerTokenTypes
EOF CodeGenTreeWalkerTokenTypes
EOF DefineGrammarItemsWalkerTokenTypes
EOF TreeToNFAConverterTokenTypes
EOF CharStream
eof DFA
eof LookaheadStream
Returned by nextElement upon end of stream; we add to buffer also
EOF Token
eof BufferedTreeNodeStream
eof TreeIterator
EOF TreePatternLexer
EOF GrammarSpelunker.Scanner
EOF_TOKEN Token
eofElementIndex LookaheadStream
Set to buffer index of eof when nextElement returns eof
EOR ANTLRTokenTypes
EOR ANTLRTreePrinterTokenTypes
EOR AssignTokenTypesWalkerTokenTypes
EOR CodeGenTreeWalkerTokenTypes
EOR DefineGrammarItemsWalkerTokenTypes
EOR TreeToNFAConverterTokenTypes
EOR_TOKEN_TYPE Label
End of rule token type; imaginary token type used only for
local, partial FOLLOW sets to indicate that the local FOLLOW
hit the end of rule.
EOR_TOKEN_TYPE Token
EORNode Rule
eot DFA
EOT Label
End of Token is like EOF for lexer rules.
eot DFA
EOTTargetState NFAState
Is this state the sole target of an EOT transition?
EPSILON Label
EPSILON ANTLRTokenTypes
EPSILON ANTLRTreePrinterTokenTypes
EPSILON AssignTokenTypesWalkerTokenTypes
EPSILON CodeGenTreeWalkerTokenTypes
EPSILON DefineGrammarItemsWalkerTokenTypes
EPSILON TreeToNFAConverterTokenTypes
EPSILON_PAYLOAD ParseTreeBuilder
EPSILON_STR Label
epsilonNode() ParseTreeBuilder
equals(Object) DFAState
Two DFAStates are equal if their NFA configuration sets are the
same.
equals(Object) Label
equals(Object) LookaheadSet
equals(Object) NFAConfiguration
An NFA configuration is equal to another if both have
the same state, the predict the same alternative, and
syntactic/semantic contexts are the same.
equals(Object) NFAContext
Two contexts are equals() if both have
same call stack; walk upwards to the root.
equals(Object) PredicateLabel
equals(Object) SemanticContext.NOT
equals(Object) SemanticContext.Predicate
Two predicates are the same if they are literally the same
text rather than same node in the grammar's AST.
equals(Object) Transition
equals(Object) BitSet
equals(Object) IntArrayList
equals(Object) Interval
equals(Object) IntervalSet
Are two IntervalSets equal? Because all intervals are sorted
and disjoint, equals is a simple linear walk over both lists
to make sure they are the same.
equals(Object) IntSet
equals(Object) BitSet
equals(Object, Object, TreeAdaptor) TreeWizard
Compare t1 and t2; return true if token types/text, structure match exactly.
equals(Object, Object) TreeWizard
Compare type, structure, and text of two trees, assuming adaptor in
this instance of a TreeWizard.
equals(Object) GrammarAST
Make nodes unique based upon Token so we can add them to a Set; if
not a GrammarAST, check type.
error(Message) Antlr3ErrorLog
Sends an error message from ANTLR analysis to the Maven Log sink.
error(ToolMessage) Antlr3ErrorLog
Sends an error message from the ANTLR tool to the Maven Log sink.
error(NoViableAltException) DFA
A hook for debugging interface
error TreePatternLexer
error(Message) ANTLRErrorListener
error(ToolMessage) ANTLRErrorListener
error(int) ErrorManager
error(int, Throwable) ErrorManager
error(int, Object) ErrorManager
error(int, Object, Object) ErrorManager
error(int, Object, Throwable) ErrorManager
ErrorManager org.antlr.tool
Defines all the errors ANTLR can generator for both the tool and for
issues with a grammar.
ErrorManager() ErrorManager
errorNode(Object) BlankDebugEventListener
errorNode(Object) DebugEventHub
errorNode(Object) DebugEventListener
Upon syntax error, recognizers bracket the error with an error node
if they are building ASTs.
errorNode(Object) DebugEventRepeater
errorNode(Object) DebugEventSocketProxy
errorNode(TokenStream, Token, Token, RecognitionException) DebugTreeAdaptor
errorNode(TokenStream, Token, Token, RecognitionException) BaseTreeAdaptor
create tree node that holds the start and stop tokens associated
with an error.
errorNode(TokenStream, Token, Token, RecognitionException) TreeAdaptor
Return a tree node representing an error.
errorRecovery RecognizerSharedState
This is true when we see an error and before having successfully
matched a token.
ERRORS_FORCING_NO_ANALYSIS ErrorManager
Do not do perform analysis if one of these happens
ERRORS_FORCING_NO_CODEGEN ErrorManager
Do not do code gen if one of these happens
ESC ANTLRTokenTypes
ESC ANTLRTreePrinterTokenTypes
ESC AssignTokenTypesWalkerTokenTypes
ESC CodeGenTreeWalkerTokenTypes
ESC DefineGrammarItemsWalkerTokenTypes
ESC TreeToNFAConverterTokenTypes
escapeChar(int) CPPTarget
escapeForJava(String) JUnitCodeGen
escapeNewlines(String) DebugEventSocketProxy
escapeString(String) CPPTarget
Converts a String into a representation that can be use as a literal
when surrounded by double-quotes.
ETC ANTLRTokenTypes
ETC ANTLRTreePrinterTokenTypes
ETC AssignTokenTypesWalkerTokenTypes
ETC CodeGenTreeWalkerTokenTypes
ETC DefineGrammarItemsWalkerTokenTypes
ETC TreeToNFAConverterTokenTypes
eventHandler() RemoteDebugEventSocketListener
examineAllExecutableActions() Grammar
Before generating code, we examine all actions that can have
$x.y and $y stuff in them because some code generation depends on
Rule.referencedPredefinedRuleAttributes.
examineExecResult(int, Object) gUnitBaseTest
examineRuleMemoization(IntStream, int, String) Profiler
Track memoization; this is not part of standard debug interface
but is triggered by profiling.
exception GrammarSyntaxMessage
exceptionGroup() ANTLRParser
exceptionGroup(AST) ANTLRTreePrinter
exceptionGroup(AST) AssignTokenTypesWalker
exceptionGroup(AST, StringTemplate) CodeGenTreeWalker
exceptionGroup(AST) DefineGrammarItemsWalker
exceptionGroup(AST) TreeToNFAConverter
exceptionHandler() ANTLRParser
exceptionHandler(AST) ANTLRTreePrinter
exceptionHandler(AST) AssignTokenTypesWalker
exceptionHandler(AST, StringTemplate) CodeGenTreeWalker
exceptionHandler(AST) DefineGrammarItemsWalker
exceptionHandler(AST) TreeToNFAConverter
excludes Antlr3Mojo
Provides an explicit list of any grammars that should be excluded from
the generate phase of the plugin.
execLexer(String, String, boolean) gUnitBaseTest
execParser(String, String, boolean) gUnitBaseTest
execTest() gUnitExecutor
execTreeParser(String, String, String, boolean) gUnitBaseTest
execute() Antlr3Mojo
The main entry point for this Mojo, it is responsible for converting
ANTLR 3.x grammars into the target language specified by the grammar.
execute() GUnitExecuteMojo
exitDecision(int) BlankDebugEventListener
exitDecision(int) DebugEventHub
exitDecision(int) DebugEventListener
exitDecision(int) DebugEventRepeater
exitDecision(int) DebugEventSocketProxy
exitDecision(int) ParseTreeBuilder
exitDecision(int) Profiler
exitRule(String, String) BlankDebugEventListener
exitRule(String, String) DebugEventHub
exitRule(String, String) DebugEventListener
This is the last thing executed before leaving a rule.
exitRule(String, String) DebugEventRepeater
exitRule(String, String) DebugEventSocketProxy
exitRule(String, String) ParseTreeBuilder
exitRule(String, String) Profiler
exitRule(String) TraceDebugEventListener
exitRule(String) Tracer
exitSubRule(int) BlankDebugEventListener
exitSubRule(int) DebugEventHub
exitSubRule(int) DebugEventListener
exitSubRule(int) DebugEventRepeater
exitSubRule(int) DebugEventSocketProxy
exitSubRule(int) TraceDebugEventListener
expecting MismatchedSetException
expecting MismatchedTokenException
expecting MismatchedTreeNodeException
externalAnalysisAbort Grammar
An external tool requests that DFA analysis abort prematurely.
externallyAbortNFAToDFAConversion() Grammar
Terminate DFA creation (grammar analysis).
extractAttribute(String) Attribute
For decls like "String foo" or "char *foo32[3]" compute the ID
and type declarations.
extractInformationFromTreeNodeStream(IntStream) RecognitionException
g GrammarSemanticsMessage
g GrammarSerializerFoo
g GrammarSyntaxMessage
gated SemanticContext.Predicate
Is this a {...}?=> gating predicate or a normal disambiguating {..}?
If any predicate in expression is gated, then expression is considered
gated.
GATED_SEMPRED ANTLRTokenTypes
GATED_SEMPRED ANTLRTreePrinterTokenTypes
GATED_SEMPRED AssignTokenTypesWalkerTokenTypes
GATED_SEMPRED CodeGenTreeWalkerTokenTypes
GATED_SEMPRED DefineGrammarItemsWalkerTokenTypes
GATED_SEMPRED TreeToNFAConverterTokenTypes
genClassHeader(StringTemplateGroup, String, String, String) JUnitCodeGen
GENERATE_SWITCHES_WHEN_POSSIBLE CodeGenerator
generateDFAs(Grammar) Tool
generateLocalFOLLOW(GrammarAST, String, String, int) CodeGenerator
Error recovery in ANTLR recognizers.
generateMethodForRule(String) Grammar
Should codegen.g gen rule for ruleName?
If synpred, only gen if used in a DFA.
generateNFAs(Grammar) Tool
generateRecognizer(Grammar) Tool
Create NFA, DFA and generate code for grammar.
generateSpecialState(DFAState) CodeGenerator
A special state is huge (too big for state tables) or has a predicated
edge.
generator DFA
Which generator to use if we're building state tables
generator CodeGenTreeWalker
generator BuildDependencyGenerator
generator Grammar
If non-null, this is the code generator we will use to generate
recognizers in the target language.
genExpr(CodeGenerator, StringTemplateGroup, DFA) SemanticContext.AND
genExpr(CodeGenerator, StringTemplateGroup, DFA) SemanticContext
Generate an expression that will evaluate the semantic context,
given a set of output templates.
genExpr(CodeGenerator, StringTemplateGroup, DFA) SemanticContext.NOT
genExpr(CodeGenerator, StringTemplateGroup, DFA) SemanticContext.OR
genExpr(CodeGenerator, StringTemplateGroup, DFA) SemanticContext.Predicate
genExpr(CodeGenerator, StringTemplateGroup, DFA) SemanticContext.TruePredicate
genFixedLookaheadDecision(StringTemplateGroup, DFA) ACyclicDFACodeGenerator
genLabelExpr(StringTemplateGroup, Transition, int) CodeGenerator
Generate an expression for traversing an edge.
genLookaheadDecision(StringTemplate, DFA) CodeGenerator
Generate code that computes the predicted alt given a DFA.
genRecognizer() CodeGenerator
Given the grammar to which we are attached, walk the AST associated
with that grammar to create NFAs.
genRecognizerFile(Tool, CodeGenerator, Grammar, StringTemplate) CTarget
genRecognizerFile(Tool, CodeGenerator, Grammar, StringTemplate) Target
genRecognizerHeaderFile(Tool, CodeGenerator, Grammar, StringTemplate, String) CPPTarget
genRecognizerHeaderFile(Tool, CodeGenerator, Grammar, StringTemplate, String) CTarget
genRecognizerHeaderFile(Tool, CodeGenerator, Grammar, StringTemplate, String) ObjCTarget
genRecognizerHeaderFile(Tool, CodeGenerator, Grammar, StringTemplate, String) Target
genSemanticPredicateExpr(StringTemplateGroup, Transition) CodeGenerator
genSetExpr(StringTemplateGroup, IntSet, int, boolean) CodeGenerator
For intervals such as [3..3, 30..35], generate an expression that
tests the lookahead similar to LA(1)==3 || (LA(1)>=30&&LA(1)<=35)
genTestRuleMethods(StringTemplateGroup) JUnitCodeGen
genTokenTypeConstants(StringTemplate) CodeGenerator
Set attributes tokens and literals attributes in the incoming
code template.
genTokenTypeNames(StringTemplate) CodeGenerator
Generate a token names table that maps token type to a printable
name: either the label like INT or the literal like "begin".
genTokenVocabOutput() CodeGenerator
Generate a token vocab file with all the token names/types.
get(int) IntArrayList
get(int) IntervalSet
Get the ith element of ordered set.
get(int) OrderedHashSet
get(int) CommonTokenStream
Return absolute token i; ignore which channel the tokens are on;
that is, count all tokens not just on-channel tokens.
get(int) DebugTokenStream
get(int) DebugTreeNodeStream
get(int) FastQueue
Return element i elements ahead of current element.
get(int) TokenStream
Get a token at an absolute index i; 0..n-1.
get(int) BufferedTreeNodeStream
get(int) TreeNodeStream
Get a tree node at an absolute index i; 0..n-1.
getAbsoluteFileName(String) Stats
getAcceptState(int) DFA
getAcceptStateReachable() DFAState
Is an accept state reachable from this state?
getActions() Grammar
getActions() Rule
getActual() AbstractTest
getActualResult() AbstractTest
getAdaptor() GrammarInfo
getAllCharValues() Grammar
If there is a char vocabulary, use it; else return min to max char
as defined by the target.
getAllImportedRules(Grammar) CompositeGrammar
Get all rule definitions from all direct/indirect delegate grammars
of g.
getAllImportedRules() Grammar
Get set of all rules imported from all delegate grammars even if
indirectly delegated.
getAllRuleRefsInAltsWithRewrites() Rule
For use with rewrite rules, we must track all rule AST results on the
left-hand-side; so we need Lists.
getAllTokenRefsInAltsWithRewrites() Rule
For use with rewrite rules, we must track all tokens matched on the
left-hand-side; so we need Lists.
getAltSet() DFAState
Get the set of all alts mentioned by all NFA configurations in this
DFA state.
getAnalysisTimeoutReport() GrammarReport
getAncestor(int) BaseTree
Walk upwards and get first ancestor with this token type.
getAncestor(int) Tree
Walk upwards and get first ancestor with this token type.
getAncestors() BaseTree
Return a list of all ancestors of this node.
getAncestors() Tree
Return a list of all ancestors of this node.
getANTLRCharLiteralForChar(int) Grammar
Return a string representing the escaped char for code c.
getArrowheadType() DOTGenerator
getArtificialRulesForSyntacticPredicates(ANTLRParser, LinkedHashMap) Grammar
for any syntactic predicates, we need to define rules for them; they will get
defined automatically like any other rule.
getAtom() Label
return the single atom label or INVALID if not a single atom
getAttribute(String) AttributeScope
getAttribute(String) RuleLabelScope
If you label a rule reference, you can access that rule's
return values as well as any predefined attributes.
getAttributes() AttributeScope
Used by templates to get all attributes
getAttributeScope(String) Rule
Return the scope containing name
getAutoBacktrackMode() DFA
getAutoBacktrackMode(int) Grammar
getBacktrackingLevel() BaseRecognizer
getBacktrackingReport() GrammarReport
getBaseTemplates() CodeGenerator
getBlockOption(GrammarAST, String) Grammar
getBlockOption(String) GrammarAST
getBlockOptions() GrammarAST
getChannel() ClassicToken
getChannel() CommonToken
getChannel() RemoteDebugEventSocketListener.ProxyToken
getChannel() Token
getCharErrorDisplay(int) Lexer
getCharIndex() Lexer
What is the index of the current character of lookahead?
getCharPositionInLine() ANTLRStringStream
getCharPositionInLine() CharStream
The index of the character relative to the beginning of the line 0..n-1
getCharPositionInLine() ClassicToken
getCharPositionInLine() CommonToken
getCharPositionInLine() RemoteDebugEventSocketListener.ProxyToken
getCharPositionInLine() Lexer
getCharPositionInLine() Token
The index of the first character relative to the beginning of the line 0..n-1
getCharPositionInLine() BaseTree
getCharPositionInLine() CommonTree
getCharPositionInLine() Tree
getCharStream() Lexer
getCharValueFromGrammarCharLiteral(String) Grammar
Given a literal like (the 3 char sequence with single quotes) 'a',
return the int value of 'a'.
getChild(Object, int) DebugTreeAdaptor
getChild(int) BaseTree
getChild(Object, int) BaseTreeAdaptor
getChild(Object, int) CommonTreeAdaptor
getChild(int) Tree
getChild(Object, int) TreeAdaptor
Get a child 0..n-1 node
getChild(int) GrammarAST
Get the ith child from 0
getChildCount(Object) DebugTreeAdaptor
getChildCount() BaseTree
getChildCount(Object) BaseTreeAdaptor
getChildCount(Object) CommonTreeAdaptor
getChildCount() Tree
getChildCount(Object) TreeAdaptor
How many children? If 0, then this is a leaf node
getChildIndex(Object) DebugTreeAdaptor
getChildIndex() BaseTree
BaseTree doesn't track child indexes.
getChildIndex() CommonTree
getChildIndex(Object) CommonTreeAdaptor
getChildIndex() Tree
This node is what child index? 0..n-1
getChildIndex(Object) TreeAdaptor
What index is this node in the child list? Range: 0..n-1
If your node type doesn't handle this, it's ok but the tree rewrites
in tree parsers need this functionality.
getChildren() BaseTree
Get the children internal List; note that if you directly mess with
the list, do so at your own risk.
getChildrenAsArray() GrammarAST
getCodeGenerator() Grammar
getCollapsedBlockAsSet(State) NFAFactory
Given a collapsed block of alts (a set of atoms), pull out
the set and return it.
getColumn() GrammarAST
getConflictingAlts() DFAState
Walk each NFA configuration in this DFA state looking for a conflict
where (s|i|ctx) and (s|j|ctx) exist, indicating that state s with
context conflicting ctx predicts alts i and j.
getControl() AbstractInputEditor
getConversionTimeout() Tool
Provide the current setting of the conversion timeout on DFA creation.
getCurrentInputSymbol(IntStream) BaseRecognizer
Match needs to return the current input symbol, which gets put
into the label for the associated token ref; e.g., x=ID.
getCurrentInputSymbol(IntStream) Parser
getCurrentInputSymbol(IntStream) TreeParser
getCurrentRule() TestCaseEditController
getCurrentRule() NFAFactory
getCurrentRuleName() CodeGenTreeWalker
getCurrentSymbol() LookaheadStream
getCurrentSymbol() BufferedTreeNodeStream
getCurrentTimeStamp() Tool
Return a time stamp string accurate to sec: yyyy-mm-dd hh:mm:ss
getDanglingStates() DecisionProbe
return set of states w/o emanating edges and w/o resolving sem preds.
getDebugListener() DebugParser
getDebugListener() DebugTreeAdaptor
getDebugListener() DebugTreeParser
getDecision(int) Grammar
getDecisionASTNode() DFA
What GrammarAST node (derived from the grammar) is this DFA
associated with? It will point to the start of a block or
the loop back of a (...)+ block etc...
getDecisionBlockAST(int) Grammar
getDecisionNFAStartState(int) Grammar
getDecisionNFAStartStateList() Grammar
getDecisionNumber() DFA
getDecisionNumber() NFAState
getDefaultActionScope(int) Grammar
Given a grammar type, what should be the default action scope?
If I say @members in a COMBINED grammar, for example, the
default scope should be "parser".
getDelegatedRuleReferences() Grammar
getDelegatedRules(Grammar) CompositeGrammar
Get set of rules for grammar g that need to have manual delegation
methods.
getDelegatedRules() Grammar
Get the set of Rules that need to have manual delegations
like "void rule() { importedGrammar.rule(); }"
If this grammar is master, get list of all rule definitions from all
delegate grammars.
getDelegateNames() Grammar
getDelegates(Grammar) CompositeGrammar
Get list of all delegates from all grammars in the delegate subtree of g.
getDelegates() Grammar
Get list of all delegates from all grammars directly or indirectly
imported into this grammar.
getDelegator(Grammar) CompositeGrammar
Get parent of this grammar
getDelegator() Grammar
Who's my direct parent grammar?
getDelegators(Grammar) CompositeGrammar
Return list of delegate grammars from root down to g.
getDelegators() Grammar
Get list of all delegators.
getDependencies() BuildDependencyGenerator
getDependenciesFileList() BuildDependencyGenerator
Return a list of File objects that name files ANTLR will read
to process T.g; This can be .tokens files if the grammar uses the tokenVocab option
as well as any imported grammar files.
getDescription() DecisionProbe
Return a string like "3:22: ( A {;} | B )" that describes this
decision.
getDescription() DFA
getDescription() NFAState
getDescription() DFA
getDescription() RewriteRuleElementStream
getDFALocations(Set) GrammarReport
getDFAPathStatesToTarget(DFAState) DecisionProbe
getDFAStatesWithSyntacticallyAmbiguousAlts() DecisionProbe
Return all DFA states in this DFA that have NFA configurations that
conflict.
getDirectDelegates(Grammar) CompositeGrammar
getDirectDelegates() Grammar
getDisabledAlternatives(DFAState) DecisionProbe
Which alts were specifically turned off to resolve nondeterminisms?
This is different than the unreachable alts.
getDisabledAlternatives() DFAState
When more than one alternative can match the same input, the first
alternative is chosen to resolve the conflict.
getDOT(State) DOTGenerator
Return a String containing a DOT description that, when displayed,
will show the incoming state machine visually.
getEdgeLabel(Transition) DOTGenerator
Fix edge strings so they print out in DOT properly;
generate any gated predicates on edge too.
getElementLabel(String, int, CodeGenerator) Rule
For references to tokens rather than by label such as $ID, we
need to get the existing label for the ID ref or create a new
one.
getEmbeddedView() WorkSpaceController
getError() gUnitTestResult
getErrorHeader(RecognitionException) BaseRecognizer
What is the error header, normally line/character position information?
getErrorHeader(RecognitionException) TreeParser
Prefix error message with the grammar name because message is
always intended for the programmer because the parser built
the input tree not the user.
getErrorListener() ErrorManager
getErrorMessage(RecognitionException, String[]) BaseRecognizer
What error message should be generated for the various
exception types?
Not very object-oriented code, but I like having all error message
generation within one method rather than spread among all of the
exception classes.
getErrorMessage(RecognitionException, String[]) Lexer
getErrorMessage(RecognitionException, String[]) TreeParser
Tree parsers parse nodes they usually have a token object as
payload.
getErrorState() ErrorManager
getEventElements(String) RemoteDebugEventSocketListener
getExcludePatterns() GUnitExecuteMojo
getExpected() AbstractTest
getExpected() BooleanTest
getExpected() OutputTest
getExpected() ReturnTest
getExpectedResult() AbstractTest
getFactory() NFA
getFileDirectory(String) Tool
Return the directory containing the grammar file for this grammar.
getFileName() Grammar
getFirstChildWithType(int) BaseTree
getFirstChildWithType(int) GrammarAST
getGatedPredicateContext() SemanticContext.AND
getGatedPredicateContext() SemanticContext
Given a semantic context expression tree, return a tree with all
nongated predicates set to true and then reduced.
getGatedPredicateContext() SemanticContext.NOT
getGatedPredicateContext() SemanticContext.OR
getGatedPredicateContext() SemanticContext.Predicate
getGatedPredicatesInNFAConfigurations() DFAState
For gated productions, we need an OR'd list of all predicates for the
target of an edge so we can gate the edge based upon the predicates
associated with taking that path (if any).
getGatedSyntacticPredicatesInNFAConfigurations() DFAState
getGeneratedFileList() BuildDependencyGenerator
From T.g return a list of File objects that
name files ANTLR will emit from T.g.
getGenerator() BuildDependencyGenerator
getGlobalScope(String) Grammar
Get a global scope
getGlobalScopes() Grammar
getGrammar() ANTLRParser
getGrammar(String) CompositeGrammar
getGrammarClassLoader() gUnitExecutor
getGrammarFileName() BaseRecognizer
For debugging and other purposes, might want the grammar name.
getGrammarFileNames() Tool
Provide the List of all grammar file names that the ANTLR tool will
process or has processed.
getGrammarIsRoot() Grammar
getGrammarMaxLookahead() Grammar
getGrammarModifier() GrammarSpelunker
getGrammarName() GrammarInfo
getGrammarName() TestSuite
getGrammarName() GrammarSpelunker
getGrammarTree() Grammar
getGrammarTypeString() Grammar
getGtype() ANTLRParser
getHasMultipleReturnValues() Rule
If a rule has no user-defined return values and nobody references
it's start/stop (predefined attributes), then there is no need to
define a struct; otherwise for now we assume a struct.
getHasReturnValue() Rule
getHasSingleReturnValue() Rule
getHeader() AbstractTest
getHeader() GrammarInfo
getImplicitlyGeneratedLexerFileName() Grammar
getImportedGrammars() GrammarSpelunker
getImportedVocabFile(String) Tool
Return a File descriptor for vocab file.
getIncludePatterns() GUnitExecuteMojo
getIncludesPatterns() Antlr3Mojo
getIncompletelyCoveredAlts(DFAState) DecisionProbe
Return a list of alts whose predicate context was insufficient to
resolve a nondeterminism for state d.
getIndirectDelegates(Grammar) CompositeGrammar
Get delegates below direct delegates of g
getIndirectDelegates() Grammar
Get delegates below direct delegates
getInlineActions() Rule
getInput() TestCase
getInputSequenceDisplay(List) DecisionProbe
Given List, return a String with a useful representation
of the associated input string.
getInputStream() ClassicToken
getInputStream() CommonToken
getInputStream() RemoteDebugEventSocketListener.ProxyToken
getInputStream() Token
From what character stream was this token created? You don't have to
implement but it's nice to know where a Token comes from if you have
include files etc...
getInputSymbol(int) Tracer
getIntervals() IntervalSet
Return a list of Interval objects.
getJavaCompressedAccept() DFA
getJavaCompressedEOF() DFA
getJavaCompressedEOT() DFA
getJavaCompressedMax() DFA
getJavaCompressedMin() DFA
getJavaCompressedSpecial() DFA
getJavaCompressedTransition() DFA
getKindOfOps(List, Class) TokenRewriteStream
getKindOfOps(List, Class, int) TokenRewriteStream
Get all operations before an index of a particular kind
getLabel() TestCaseInputFile
getLabel(String) Rule
getLabelForSet(IntervalSet) LL1DFA
getLabels(Set<GrammarAST>, int) Grammar
Given a set of all rewrite elements on right of ->, filter for
label types such as Grammar.TOKEN_LABEL, Grammar.TOKEN_LIST_LABEL, ...
getLanguage() GrammarSpelunker
getLastChild() GrammarAST
getLastRewriteTokenIndex() TokenRewriteStream
getLastRewriteTokenIndex(String) TokenRewriteStream
getLastSibling() GrammarAST
getLeftRecursiveRules() Grammar
Return a list of left-recursive rules; no analysis can be done
successfully on these.
getLexerGrammar() Grammar
If the grammar is a combined grammar, return the text of the implicit
lexer grammar.
getLexicalRuleName() gUnitTestSuite
getLibDirectory() Antlr3Mojo
getLibraryDirectory() Tool
Return the Path to the directory in which ANTLR will search for ancillary
files such as .tokens vocab files and imported grammar files.
getLibraryFile(String) Tool
Name a file from the -lib dir.
getLine() gUnitTestInput
getLine() ANTLRStringStream
getLine() CharStream
ANTLR tracks the line information automatically
getLine() ClassicToken
getLine() CommonToken
getLine() RemoteDebugEventSocketListener.ProxyToken
getLine() Lexer
getLine() Token
The line number on which this token was matched; line=1..n
getLine() BaseTree
getLine() CommonTree
getLine() Tree
In case we don't have a token payload, what is the line for errors?
getLine() GrammarAST
getLineColumnToLookaheadDFAMap() Grammar
getListOfArgumentsFromAction(String, int) CodeGenerator
getListOfArgumentsFromAction(String, int, int, int, List<String>) CodeGenerator
Given an arg action like
[x, (*a).foo(21,33), 3.2+1, '\n',
"a,oo\nick", {bl, "fdkj"eck}, ["cat\n,", x, 43]]
convert to a list of arguments.
getLocalAttributeScope(String) Rule
Get the arg, return value, or predefined property for this rule
getLocallyDefinedOption(String) Grammar
getLocallyDefinedRule(String) Grammar
getLocationFormat() ErrorManager
Return a StringTemplate that refers to the current format used for
emitting messages.
getLocationTemplate() Message
Return a new template instance for the location part of a Message.
getLookaheadDepth() DFAState
getLookaheadDFA(int) Grammar
getLookaheadDFA() GrammarAST
getLookaheadDFAColumnsForLineInFile(int) Grammar
returns a list of column numbers for all decisions
on a particular line so ANTLRWorks choose the decision
depending on the location of the cursor (otherwise,
ANTLRWorks has to give the *exact* location which
is not easy from the user point of view).
getLookaheadDFAFromPositionInFile(int, int) Grammar
Useful for ANTLRWorks to map position in file to the DFA for display
getMake() Tool
Indicate whether the tool will analyze the dependencies of the provided grammar
file list and ensure that grammars with dependencies are built
after any of the other gramamrs in the list that they are dependent on.
getMaxCharValue(CodeGenerator) CPPTarget
Character constants get truncated to this value.
getMaxCharValue(CodeGenerator) RubyTarget
getMaxCharValue(CodeGenerator) Target
Some targets only support ASCII or 8-bit chars/strings.
getMaxCharValue() Grammar
What is the max char value possible for this grammar's target? Use
unicode max if no target defined.
getMaxElement() IntervalSet
getMaxLookaheadDepth() DFA
Return k if decision is LL(k) for some k else return max int
getMaxStateNumber() DFA
What is the max state number ever created? This may be beyond
getNumberOfStates().
getMaxTokenType() Grammar
How many token types have been allocated so far?
getMessage() RewriteCardinalityException
getMessage(int) ErrorManager
Given a message ID, return a StringTemplate that somebody can fill
with data.
getMessageFormat() ErrorManager
getMessageFormat() Tool
Returns the current setting of the message format descriptor
getMessageTemplate() Message
Return a new template instance every time someone tries to print
a Message.
getMessageType(int) ErrorManager
getMinAlt(Set<Integer>) NFAToDFAConverter
getMinElement() IntervalSet
Return minimum element >= 0
getMissingSymbol(IntStream, RecognitionException, int, BitSet) BaseRecognizer
Conjure up a missing token during error recovery.
getMissingSymbol(IntStream, RecognitionException, int, BitSet) DebugTreeParser
getMissingSymbol(IntStream, RecognitionException, int, BitSet) Parser
getMissingSymbol(IntStream, RecognitionException, int, BitSet) TreeParser
getMissingType() MissingTokenException
getModel() IController
getModel() RuleListController
getModel() RunnerController
getModel() StatusBarController
getModel() TestCaseEditController
getModel() WorkSpaceController
getName() Rule
getName() AttributeScope
getNewNFAStateNumber() NFA
getNewNFAStateNumber() CompositeGrammar
getNewTokenType() Grammar
Return a new unique integer in the token type space
getNFADecisionStartState() DFA
getNFAPath(NFAState, int, List, List) DecisionProbe
Given a sample input sequence, you usually would like to know the
path taken through the NFA.
getNFAPathStatesForAlt(int, int, List) DecisionProbe
Given an alternative associated with a nondeterministic DFA state,
find the path of NFA states associated with the labels sequence.
getNFAStartState() GrammarAST
getNFAStateForAltOfDecision(NFAState, int) Grammar
Get the ith alternative (1..n) from a decision; return null when
an invalid alt is requested.
getNode(Object) Graph
getNodeIndex(Object) BufferedTreeNodeStream
What is the stream index for node? 0..n-1
Return -1 if node not found.
getNodeNumber(Object) DOTTreeGenerator
getNodeST(TreeAdaptor, Object) DOTTreeGenerator
getNonDeterministicAlts() DecisionProbe
getNonDeterministicAlts() DFAState
getNonDeterministicAltsForState(DFAState) DecisionProbe
Return the sorted list of alts that conflict within a single state.
getNondeterministicStatesResolvedWithSemanticPredicate() DecisionProbe
getNonImportDependenciesFileList() BuildDependencyGenerator
Return a list of File objects that name files ANTLR will read
to process T.g; This can only be .tokens files and only
if they use the tokenVocab option.
getNotEmpty() Rule
getNumberOfAlts() DFA
getNumberOfAltsForDecisionNFA(NFAState) Grammar
Decisions are linked together with transition(1).
getNumberOfChildrenWithType(int) GrammarAST
getNumberOfCyclicDecisions() Grammar
getNumberOfDecisions() Grammar
getNumberOfHiddenTokens(int, int) Profiler
Get num hidden tokens between i..j inclusive
getNumberOfStates() DecisionProbe
How many states does the DFA predictor have?
getNumberOfStates() DFA
getNumberOfSyntaxErrors() BaseRecognizer
Get number of recognition errors (lexer, parser, tree parser).
getNumberOfTransitions() DFAState
getNumberOfTransitions() NFAState
getNumberOfTransitions() State
getNumErrors() ErrorManager
getNumErrors() Tool
Returns the number of errors that the analysis/processing threw up.
getOption(String) CompositeGrammar
getOption(String) CompositeGrammarTree
Find an option by looking up towards the root grammar rather than down
getOption(String) Grammar
getOuterAltNum() CodeGenTreeWalker
getOutput() gUnitTestResult
getOutput() TestCase
getOutputDirectory() Antlr3Mojo
getOutputDirectory(String) Tool
Return the location where ANTLR will generate output files for a given file.
getOutputDirectory() Tool
Return the Path to the base output directory, where ANTLR
will generate all the output files for the current language target as
well as any ancillary files such as .tokens vocab files.
getOutputDirectoryPath() JUnitCodeGen
getOutputFile(Grammar, String) Tool
This method is used by all code generators to create new output
files.
getParent(Object) DebugTreeAdaptor
getParent() BaseTree
BaseTree doesn't track parent pointers.
getParent() CommonTree
getParent(Object) CommonTreeAdaptor
getParent() Tree
getParent(Object) TreeAdaptor
Who is the parent node of this node; if null, implies node is root.
getPostOrderedGrammarList() CompositeGrammarTree
Return a postorder list of grammars; root is last in list
getPredicates(NFAState) LL1Analyzer
Return predicate expression found via epsilon edges from s.
getPredicatesPerNonDeterministicAlt(DFAState, Set) NFAToDFAConverter
Return a mapping from nondeterministc alt to combined list of predicates.
getPreOrderedGrammarList() CompositeGrammarTree
Return a postorder list of grammars; root is last in list
getProgram(String) TokenRewriteStream
getRankdir() DOTGenerator
getReachableLabels() DFAState
getReasonForFailure() DFA
getRecognizerFileName(String, int) CodeGenerator
Generate TParser.java and TLexer.java from T.g if combined, else
just use T.java as output regardless of type.
getRecognizerName() Grammar
Get the name of the generated recognizer; may or may not be same
as grammar name.
getRecognizerST() CodeGenerator
getReferencedRule() Grammar.LabelElementPair
getReportFormat() ErrorManager
getResult(gUnitTestResult) AbstractTest
getResult(gUnitTestResult) BooleanTest
getResult(gUnitTestResult) OutputTest
getResult(gUnitTestResult) ReturnTest
getReturned() gUnitTestResult
getRootGrammar() CompositeGrammar
getRootGrammar(String) Tool
Get a grammar mentioned on the command-line and any delegates
getRule(int) TestSuite
getRule(String) TestSuite
getRule(String) CompositeGrammar
getRule(String) CompositeGrammarTree
Find a rule by looking in current grammar then down towards the
delegate grammars.
getRule(String) Grammar
getRule(String, String) Grammar
getRuleCount() TestSuite
getRuleElementST(String, String, GrammarAST, GrammarAST, String) CodeGenTreeWalker
getRuleIndex(String, String) Grammar
getRuleIndex(String) Grammar
getRuleInvocationStack() BaseRecognizer
Return List of the rules in your parser instance
leading up to a call to this method.
getRuleInvocationStack(Throwable, String) BaseRecognizer
A more general version of getRuleInvocationStack where you can
pass in, for example, a RecognitionException to get it's rule
stack trace.
getRuleLabel(String) Rule
getRuleLabels() Rule
getRuleListLabel(String) Rule
getRuleListLabels() Rule
getRuleMemoization(int, int) BaseRecognizer
Given a rule number and a start token index number, return
MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
start index.
getRuleMemoizationCacheSize() BaseRecognizer
return how many rule/input-index pairs there are in total.
getRuleModifier(String) Grammar
getRuleName() gUnitTestSuite
getRuleName(int) Grammar
getRuleRefsInAlt(String, int) Rule
getRuleRefsInAlt(int) Rule
getRules() Grammar
getRulesForStringTemplate() TestSuite
getRuleStartState(String) Grammar
getRuleStartState(String, String) Grammar
getRuleStopState(String) Grammar
getRuleTestSuites() GrammarInfo
getRunLengthEncoding(List) DFA
Compress the incoming data list so that runs of same number are
encoded as number,value pair sequences.
getSampleInputSequenceUsingStateSet(State, State, Set, List<Label>) DecisionProbe
Given a start state and a final state, find a list of edge labels
between the two ignoring epsilon.
getSampleNonDeterministicInputSequence(DFAState) DecisionProbe
Return a List indicating an input sequence that can be matched
from the start state of the DFA to the targetState (which is known
to have a problem).
getScript() ITestCaseInput
getScript() ITestCaseOutput
getScript() TestCaseInputFile
getScript() TestCaseInputMultiString
getScript() TestCaseInputString
getScript() TestCaseOutputAST
getScript() TestCaseOutputResult
getScript() TestCaseOutputReturn
getScript() TestCaseOutputStdOut
getScript(TestSuite) TestSuiteFactory
Get the text script from the testSuite.
getSemanticContext() Label
getSemanticContext() PredicateLabel
getSemanticContextForAlt(DFAState, int) DecisionProbe
Each state in the DFA represents a different input sequence for an
alt of the decision.
getSet() Label
getSetFromRule(TreeToNFAConverter, String) Grammar
Get the set equivalent (if any) of the indicated rule from this
grammar.
getSetValue() GrammarAST
getSingleElement() BitSet
Get the first element you find and return it.
getSingleElement() IntervalSet
If this set is a single integer, return it otherwise Label.INVALID
getSingleElement() IntSet
getSingleton() ImageFactory
getSingleValueReturnName() Rule
getSingleValueReturnType() Rule
getSourceDirectory() Antlr3Mojo
getSourceName() ANTLRFileStream
getSourceName() ANTLRStringStream
getSourceName() BaseRecognizer
getSourceName() CommonTokenStream
getSourceName() DebugTokenStream
getSourceName() DebugTreeNodeStream
getSourceName() IntStream
Where are you getting symbols from? Normally, implementations will
pass the buck all the way to the lexer who can ask its input stream
for the file name or whatever.
getSourceName() Lexer
getSourceName() Parser
getSourceName() TokenSource
Where are you getting tokens from? normally the implication will simply
ask lexers input stream.
getSourceName() BufferedTreeNodeStream
getSourceName() CommonTreeNodeStream
getSourceName() TreeParser
getSourceName() Interpreter
getStart() ParserRuleReturnScope
getStart() RuleReturnScope
Return the start token or tree
getStart() TreeRuleReturnScope
getStartIndex() CommonToken
getState(int) DFA
getState(int) NFA
getState(int) CompositeGrammar
getStateLabel(State) DOTGenerator
getStateLabelIndexKey(int, int) DecisionProbe
getStop() ParserRuleReturnScope
getStop() RuleReturnScope
Return the stop token or tree
getStopIndex() CommonToken
getStringLiterals() Grammar
Get the list of ANTLR String literals
getStringTemplateErrorListener() ErrorManager
getSTSuffix(GrammarAST, GrammarAST, String) CodeGenTreeWalker
Return a non-empty template name suffix if the token is to be
tracked, added to a tree, or both.
getSynPredForAlt(NFAState, int) LL1DFA
getSyntacticPredicate(String) Grammar
getSyntacticPredicates() Grammar
getTarget64BitStringFromValue(long) ActionScriptTarget
Convert long to two 32-bit numbers separted by a comma.
getTarget64BitStringFromValue(long) DelphiTarget
getTarget64BitStringFromValue(long) JavaScriptTarget
Convert long to two 32-bit numbers separted by a comma.
getTarget64BitStringFromValue(long) Target
Convert long to 0xNNNNNNNNNNNNNNNN by default for spitting out
with bitsets.
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) ActionScriptTarget
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) CPPTarget
Convert from an ANTLR char literal found in a grammar file to
an equivalent char literal in the target language.
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) CTarget
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) DelphiTarget
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) ObjCTarget
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) Perl5Target
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) PythonTarget
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) RubyTarget
getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator, String) Target
Convert from an ANTLR char literal found in a grammar file to
an equivalent char literal in the target language.
getTargetStringLiteralFromANTLRStringLiteral(CodeGenerator, String) CPPTarget
Convert from an ANTLR string literal found in a grammar file to
an equivalent string literal in the target language.
getTargetStringLiteralFromANTLRStringLiteral(CodeGenerator, String) CTarget
Convert from an ANTLR string literal found in a grammar file to
an equivalent string literal in the C target.
getTargetStringLiteralFromANTLRStringLiteral(CodeGenerator, String) DelphiTarget
getTargetStringLiteralFromANTLRStringLiteral(CodeGenerator, String) ObjCTarget
Convert from an ANTLR string literal found in a grammar file to
an equivalent string literal in the target language.
getTargetStringLiteralFromANTLRStringLiteral(CodeGenerator, String) Target
Convert from an ANTLR string literal found in a grammar file to
an equivalent string literal in the target language.
getTargetStringLiteralFromString(String, boolean) DelphiTarget
getTargetStringLiteralFromString(String, boolean) Target
Given a random string of Java unicode chars, return a new string with
optionally appropriate quote characters for target language and possibly
with some escaped characters.
getTargetStringLiteralFromString(String) Target
getTemplate() RuleReturnScope
Has a value potentially if output=template; Don't use StringTemplate
type as it then causes a dependency with ST lib.
getTemplates() CodeGenerator
getTestCaseIndex() AbstractTest
getTestCaseIndex() ITestCase
Get the index of the test case in the test group for a rule.
getTestCases() Rule
getTestedRuleName() AbstractTest
getTestedRuleName() ITestCase
Get the name of the rule that is tested by this test case.
getTestsuiteDir(String, String) Interp
getTestSuiteFile() TestSuite
getText() AbstractTest
getText() BooleanTest
getText() OutputTest
getText() ReturnTest
getText() TestCaseEditController.InputMultiEditor
getText() TestCaseEditController.OutputAstEditor
getText() ClassicToken
getText() CommonToken
getText(Object) DebugTreeAdaptor
getText() RemoteDebugEventSocketListener.ProxyToken
getText() RemoteDebugEventSocketListener.ProxyTree
getText() Lexer
Return the text matched so far for the current token or any
text override.
getText() Token
Get the text of the token
getText(Object) BaseTreeAdaptor
getText() CommonErrorNode
getText() CommonTree
getText(Object) CommonTreeAdaptor
getText() ParseTree
getText() Tree
getText(Object) TreeAdaptor
getText() GrammarAST
getToken(Object) DebugTreeAdaptor
getToken() CommonTree
getToken(Object) CommonTreeAdaptor
What is the Token associated with this node? If
you are not using CommonTree, then you must
override this in your own adaptor.
getToken(Object) TreeAdaptor
Return the token object from which this node was created.
getToken() GrammarAST
getTokenDisplayName(int) Grammar
Given a token type, get a meaningful name for it such as the ID
or string literal.
getTokenDisplayNames() Grammar
Get a list of all token IDs and literals that have an associated
token type.
getTokenElementST(String, String, GrammarAST, GrammarAST, String) CodeGenTreeWalker
getTokenErrorDisplay(Token) BaseRecognizer
How should a token be displayed in an error message? The default
is to display just the text, but during development you might
want to have a lot of information spit out.
getTokenIDs() Grammar
Get the list of tokens that are IDs like BLOCK and LPAREN
getTokenIndex() ClassicToken
getTokenIndex() CommonToken
getTokenIndex() RemoteDebugEventSocketListener.ProxyToken
getTokenIndex() Token
An index from 0..n-1 of the token object in the input stream.
getTokenLabel(String) Rule
getTokenListLabel(String) Rule
getTokenNameForTokensRuleAlt(int) DecisionProbe
From an alt number associated with artificial Tokens rule, return
the name of the token that is associated with that alt.
getTokenNames() BaseRecognizer
Used to print out token names like ID during debugging and
error reporting.
getTokenRefsInAlt(String, int) Rule
getTokenRefsInAlt(int) Rule
getTokens() TestSuite
getTokens() CommonTokenStream
getTokens(int, int) CommonTokenStream
getTokens(int, int, BitSet) CommonTokenStream
Given a start and stop index, return a List of all tokens in
the token type BitSet.
getTokens(int, int, List) CommonTokenStream
getTokens(int, int, int) CommonTokenStream
getTokenSource() CommonTokenStream
getTokenSource() DebugTokenStream
getTokenSource() TokenStream
Where is this stream pulling tokens from? This is not the name, but
the object that provides Token objects.
getTokenStartIndex(Object) DebugTreeAdaptor
getTokenStartIndex() RemoteDebugEventSocketListener.ProxyTree
getTokenStartIndex() CommonTree
getTokenStartIndex(Object) CommonTreeAdaptor
getTokenStartIndex() ParseTree
getTokenStartIndex() Tree
What is the smallest token index (indexing from 0) for this node
and its children?
getTokenStartIndex(Object) TreeAdaptor
Get the token start index for this subtree; return -1 if no such index
getTokenStopIndex(Object) DebugTreeAdaptor
getTokenStopIndex() RemoteDebugEventSocketListener.ProxyTree
getTokenStopIndex() CommonTree
getTokenStopIndex(Object) CommonTreeAdaptor
getTokenStopIndex() ParseTree
getTokenStopIndex() Tree
What is the largest token index (indexing from 0) for this node
and its children?
getTokenStopIndex(Object) TreeAdaptor
Get the token stop index for this subtree; return -1 if no such index
getTokenStream() DebugTreeNodeStream
getTokenStream() Parser
getTokenStream() BufferedTreeNodeStream
getTokenStream() CommonTreeNodeStream
getTokenStream() TreeNodeStream
If the tree associated with this stream was created from a TokenStream,
you can specify it here.
getTokenStream() Strip
getTokenTextAndTypeAsTargetLabel(CodeGenerator, String, int) ObjCTarget
Target must be able to override the labels used for token types.
getTokenType(String) TreeWizard
Using the map of token names to token types, return the type.
getTokenType(String) Grammar
getTokenType(Label) RandomPhrase
getTokenTypeAsTargetLabel(CodeGenerator, int) ActionScriptTarget
getTokenTypeAsTargetLabel(int) CodeGenerator
Get a meaningful name for a token type useful during code generation.
getTokenTypeAsTargetLabel(CodeGenerator, int) ObjCTarget
If we have a label, prefix it with the recognizer's name
getTokenTypeAsTargetLabel(CodeGenerator, int) PythonTarget
Target must be able to override the labels used for token types
getTokenTypeAsTargetLabel(CodeGenerator, int) RubyTarget
getTokenTypeAsTargetLabel(CodeGenerator, int) Target
Target must be able to override the labels used for token types
getTokenTypes() Grammar
Return a set of all possible token or char types for this grammar
getTokenTypesAsTargetLabels(Set<GrammarAST>) CodeGenTreeWalker
Convert rewrite AST lists to target labels list
getTokenTypesWithoutID() Grammar
Return an ordered integer list of token types that have no
corresponding token ID like INT or KEYWORD_BEGIN; for stuff
like 'begin'.
getTokenVocab() BuildDependencyGenerator
getTokenVocab() GrammarSpelunker
getTool() Grammar
getTransition(int) DFAState
getTree() ParseTreeBuilder
getTree() RuleReturnScope
Has a value potentially if output=AST;
getTreeAdaptor() DebugEventSocketProxy
getTreeAdaptor() DebugTreeAdaptor
getTreeAdaptor() DebugTreeNodeStream
getTreeAdaptor() BufferedTreeNodeStream
getTreeAdaptor() CommonTreeNodeStream
getTreeAdaptor() TreeNodeStream
What adaptor can tell me how to interpret/navigate nodes and
trees.
getTreeGrammarName() GrammarInfo
getTreeNodeStream() TreeParser
getTreeRuleName() gUnitTestSuite
getTreeSource() DebugTreeNodeStream
getTreeSource() BufferedTreeNodeStream
getTreeSource() CommonTreeNodeStream
getTreeSource() TreeNodeStream
Where is this stream pulling nodes from? This is not the name, but
the object that provides node objects.
getType() AbstractTest
getType() BooleanTest
getType() OutputTest
getType() ReturnTest
getType() ClassicToken
getType() CommonToken
getType(Object) DebugTreeAdaptor
getType() RemoteDebugEventSocketListener.ProxyToken
getType() RemoteDebugEventSocketListener.ProxyTree
getType() Token
getType(Object) BaseTreeAdaptor
getType() CommonErrorNode
getType() CommonTree
getType(Object) CommonTreeAdaptor
getType() ParseTree
getType() Tree
Return a token type; needed for tree parsing
getType(Object) TreeAdaptor
For tree parsing, I need to know the token type of a node
getType() GrammarAST
getTypeString(int) JUnitCodeGen
getUnescapedStringFromGrammarStringLiteral(String) Grammar
ANTLR does not convert escape sequences during the parse phase because
it could not know how to print String/char literals back out when
printing grammars etc...
getUnexpectedToken() UnwantedTokenException
getUnexpectedType() RecognitionException
Return the token type or char of the unexpected input element
getUnionOfPredicates(Map) NFAToDFAConverter
OR together all predicates from the alts.
getUniqueAlt() DFAState
Return the uniquely mentioned alt from the NFA configurations;
Ignore the resolved bit etc...
getUniqueID(Object) DebugTreeAdaptor
getUniqueID(Object) BaseTreeAdaptor
getUniqueID(Object) TreeAdaptor
For identifying trees.
getUniquelyPredictedAlt() DFAState
Walk each configuration and if they are all the same alt, return
that alt else return NFA.INVALID_ALT_NUMBER.
getUniqueStates() DFA
getUnitTestResult() GrammarInfo
getUnreachableAlts() DecisionProbe
Get a list of all unreachable alternatives for this decision.
getUnreachableAlts() DFA
Return a list of Integer alt numbers for which no lookahead could
be computed or for which no single DFA accept state predicts those
alts.
getUserMaxLookahead() DFA
The user may specify a max, acyclic lookahead for any decision.
getUserMaxLookahead(int) Grammar
getView() IController
getView() RuleListController
getView() RunnerController
getView() StatusBarController
getView() TestCaseEditController
getView() TestCaseEditController.InputMultiEditor
getView() TestCaseEditController.OutputAstEditor
getView() WorkSpaceController
getVocabFileName() CodeGenerator
What is the name of the vocab file generated for this grammar?
Returns null if no .tokens file should be generated.
getWildcardST(GrammarAST, GrammarAST, String) CodeGenTreeWalker
global_k Grammar
Is there a global fixed lookahead set for this grammar?
If 0, nothing specified.
grammar DFAOptimizer
grammar LL1Analyzer
grammar NFA
This NFA represents which grammar?
grammar CodeGenerator
Which grammar are we generating code for? Each generator
is attached to a specific grammar.
grammar ANTLRParser
grammar(Grammar) ANTLRParser
grammar ANTLRTreePrinter
grammar(AST) ANTLRTreePrinter
grammar AssignTokenTypesWalker
grammar(AST, Grammar) AssignTokenTypesWalker
grammar CodeGenTreeWalker
grammar(AST, Grammar, StringTemplate, StringTemplate, StringTemplate) CodeGenTreeWalker
grammar DefineGrammarItemsWalker
grammar(AST, Grammar) DefineGrammarItemsWalker
grammar TreeToNFAConverter
Which grammar are we converting an NFA for?
grammar(AST) TreeToNFAConverter
grammar AttributeScope
grammar BuildDependencyGenerator
grammar CompositeGrammarTree
grammar DOTGenerator
grammar FASerializer
Grammar org.antlr.tool
Represents a grammar in memory.
Grammar(Tool, String, CompositeGrammar) Grammar
Create a grammar from file name.
Grammar() Grammar
Useful for when you are sure that you are not part of a composite
already.
Grammar(String) Grammar
Used for testing; only useful on noncomposite grammars.
Grammar(Tool, String) Grammar
Used for testing and Interp/RandomPhrase.
grammar GrammarReport
grammar GrammarSanity
grammar(int, String) GrammarSerializerFoo
grammar Interpreter
grammar NameSpaceChecker
grammar Rule
To which grammar does this belong?
Grammar.Decision org.antlr.tool
Grammar.Decision() Grammar.Decision
Grammar.LabelElementPair org.antlr.tool
Grammar.LabelElementPair(Token, GrammarAST) Grammar.LabelElementPair
GRAMMAR_EXT TestSuiteFactory
GRAMMAR_FILE_EXTENSION Grammar
GRAMMAR_STATS_FILENAME GrammarReport
GrammarAnalysisAbortedMessage org.antlr.tool
Reports the condition that ANTLR's LL(*) analysis engine terminated
early.
GrammarAnalysisAbortedMessage(DecisionProbe) GrammarAnalysisAbortedMessage
GrammarAST org.antlr.tool
Grammars are first converted to ASTs using this class and then are
converted to NFAs via a tree walker.
GrammarAST() GrammarAST
GrammarAST(int, String) GrammarAST
GrammarDanglingStateMessage org.antlr.tool
Reports a potential parsing issue with a decision; the decision is
nondeterministic in some way.
GrammarDanglingStateMessage(DecisionProbe, DFAState) GrammarDanglingStateMessage
grammarDecisionDescription NoViableAltException
grammarError(int, Grammar, Token, Object, Object) ErrorManager
grammarError(int, Grammar, Token, Object) ErrorManager
grammarError(int, Grammar, Token) ErrorManager
grammarFileName DebugEventSocketProxy
grammarFileName RemoteDebugEventSocketListener
grammarFileName BuildDependencyGenerator
grammarFileName GrammarSpelunker
grammarHeader() GrammarSpelunker
GrammarInfo org.antlr.gunit
GrammarInfo() GrammarInfo
grammarInfo gUnitExecutor
grammarInfo JUnitCodeGen
GrammarInsufficientPredicatesMessage org.antlr.tool
GrammarInsufficientPredicatesMessage(DecisionProbe, DFAState, Map<Integer, Set<Token>>) GrammarInsufficientPredicatesMessage
grammarModifier GrammarSpelunker
grammarName TestSuite
grammarName GrammarSpelunker
GrammarNonDeterminismMessage org.antlr.tool
Reports a potential parsing issue with a decision; the decision is
nondeterministic in some way.
GrammarNonDeterminismMessage(DecisionProbe, DFAState) GrammarNonDeterminismMessage
GrammarReport org.antlr.tool
GrammarReport(Grammar) GrammarReport
GrammarSanity org.antlr.tool
Factor out routines that check sanity of rules, alts, grammars, etc..
GrammarSanity(Grammar) GrammarSanity
GrammarSemanticsMessage org.antlr.tool
A problem with the symbols and/or meaning of a grammar such as rule
redefinition.
GrammarSemanticsMessage(int, Grammar, Token) GrammarSemanticsMessage
GrammarSemanticsMessage(int, Grammar, Token, Object) GrammarSemanticsMessage
GrammarSemanticsMessage(int, Grammar, Token, Object, Object) GrammarSemanticsMessage
GrammarSerializerFoo org.antlr.tool
Serialize a grammar into a highly compressed form with
only the info needed to recognize sentences.
GrammarSerializerFoo(Grammar) GrammarSerializerFoo
grammarSpec(AST, String) ANTLRTreePrinter
grammarSpec(AST) AssignTokenTypesWalker
grammarSpec(AST) CodeGenTreeWalker
grammarSpec(AST) DefineGrammarItemsWalker
grammarSpec(AST) TreeToNFAConverter
GrammarSpelunker org.antlr.tool
Load a grammar file and scan it just until we learn a few items
of interest.
GrammarSpelunker(String, String) GrammarSpelunker
GrammarSpelunker.Scanner org.antlr.tool
Strip comments and then return stream of words and
tokens {';', ':', '{', '}'}
GrammarSpelunker.Scanner(Reader) GrammarSpelunker.Scanner
GrammarSyntaxMessage org.antlr.tool
A problem with the syntax of your antlr grammar such as
"The '{' came as a complete surprise to me at this point in your program"
GrammarSyntaxMessage(int, Grammar, Token, RecognitionException) GrammarSyntaxMessage
GrammarSyntaxMessage(int, Grammar, Token, Object, RecognitionException) GrammarSyntaxMessage
grammarTree Grammar
An AST that records entire input grammar with all rules.
grammarTreeToString(GrammarAST) Grammar
grammarTreeToString(GrammarAST, boolean) Grammar
grammarType() ANTLRParser
grammarTypeToFileNameSuffix Grammar
grammarTypeToRulePropertiesScope RuleLabelScope
grammarTypeToString Grammar
GrammarUnreachableAltsMessage org.antlr.tool
Reports a potential parsing issue with a decision; the decision is
nondeterministic in some way.
GrammarUnreachableAltsMessage(DecisionProbe, List) GrammarUnreachableAltsMessage
grammarWarning(int, Grammar, Token, Object, Object) ErrorManager
grammarWarning(int, Grammar, Token, Object) ErrorManager
grammarWarning(int, Grammar, Token) ErrorManager
Graph org.antlr.misc
A generic graph with edges; Each node as a single Object payload.
Graph() Graph
Graph.Node org.antlr.misc
Graph.Node(Object) Graph.Node
groomQualifiedFileName(String, String) BuildDependencyGenerator
grow() IntArrayList
growToInclude(int) BitSet
Grows the set to a larger number of bits.
growToInclude(int) BitSet
Grows the set to a larger number of bits.
gtype ANTLRParser
gUnitAdapter org.antlr.gunit.swingui.runner
Adapter between gUnitEditor Swing GUI and gUnit command-line tool.
gUnitAdapter(TestSuite) gUnitAdapter
gUnitBaseTest org.antlr.gunit
All gUnit-generated JUnit class should extend this class
which implements the essential methods for triggering
ANTLR parser/tree walker
gUnitBaseTest() gUnitBaseTest
GUnitExecuteMojo org.antlr.mojo.antlr3
Takes gUnit scripts and directly performs testing.
GUnitExecuteMojo() GUnitExecuteMojo
gUnitExecutor org.antlr.gunit
gUnitExecutor(GrammarInfo, String) gUnitExecutor
gUnitExecutor(GrammarInfo, ClassLoader, String) gUnitExecutor
gUnitTestInput org.antlr.gunit
A class which contains input information of an individual testuite
gUnitTestInput(String, boolean, int) gUnitTestInput
gUnitTestResult org.antlr.gunit
gUnitTestResult(boolean, String) gUnitTestResult
gUnitTestResult(boolean, String, boolean) gUnitTestResult
gUnitTestResult(boolean, String, String) gUnitTestResult
gUnitTestSuite org.antlr.gunit
gUnitTestSuite() gUnitTestSuite
gUnitTestSuite(String) gUnitTestSuite
gUnitTestSuite(String, String) gUnitTestSuite
IController org.antlr.gunit.swingui
id() ANTLRParser
ID ANTLRTokenTypes
ID ANTLRTreePrinterTokenTypes
ID AssignTokenTypesWalkerTokenTypes
ID CodeGenTreeWalkerTokenTypes
ID DefineGrammarItemsWalkerTokenTypes
ID TreeToNFAConverterTokenTypes
ID RemoteDebugEventSocketListener.ProxyTree
ID TreePatternLexer
ID GrammarAST
idList() ANTLRParser
IGNORE_STRING_IN_GRAMMAR_FILE_NAME Grammar
ImageFactory org.antlr.gunit.swingui
implicitLexer Grammar
Was this created from a COMBINED grammar?
IMPLIES ANTLRTokenTypes
IMPLIES ANTLRTreePrinterTokenTypes
IMPLIES AssignTokenTypesWalkerTokenTypes
IMPLIES CodeGenTreeWalkerTokenTypes
IMPLIES DefineGrammarItemsWalkerTokenTypes
IMPLIES TreeToNFAConverterTokenTypes
IMPORT ANTLRTokenTypes
IMPORT ANTLRTreePrinterTokenTypes
IMPORT AssignTokenTypesWalkerTokenTypes
IMPORT CodeGenTreeWalkerTokenTypes
IMPORT DefineGrammarItemsWalkerTokenTypes
IMPORT TreeToNFAConverterTokenTypes
imported Rule
importedGrammars GrammarSpelunker
importGrammar(GrammarAST, String) Grammar
Import the rules/tokens of a delegate grammar.
imports() GrammarSpelunker
importTokenVocabulary(Grammar) Grammar
Pull your token definitions from an existing grammar in memory.
importTokenVocabulary(GrammarAST, String) Grammar
Load a vocab file .tokens and return max token type found.
in DebugEventSocketProxy
incidentEdgeLabel NFAState
For o-A->o type NFA tranitions, record the label that leads to this
state.
includes Antlr3Mojo
Provides an explicit list of all the grammars that should
be included in the generate phase of the plugin.
inDecision() Profiler
The parser is in a decision if the decision depth > 0.
index() ANTLRStringStream
Return the current input symbol index 0..n where n indicates the
last symbol has been read.
index ClassicToken
What token number is this from 0..n-1 tokens
index CommonToken
What token number is this from 0..n-1 tokens; < 0 implies invalid index
index() CommonTokenStream
index() DebugTokenStream
index() DebugTreeNodeStream
index() IntStream
Return the current input symbol index 0..n where n indicates the
last symbol has been read.
index() LookaheadStream
index RecognitionException
What is index of token/char were we looking at when the error occurred?
index() BufferedTreeNodeStream
index(Object) TreeWizard
Walk the entire tree and make a node name to nodes mapping.
index Rule
indexToDecision Grammar
Each subrule/rule is a decision point and we must track them so we
can go back later and build DFA predictors for them.
info(String) Antlr3ErrorLog
Sends an informational message to the Maven log sink.
info(String) ANTLRErrorListener
info(String) ErrorManager
init(Grammar) AssignTokenTypesWalker
init(Grammar) CodeGenTreeWalker
init() TokenRewriteStream
init(Grammar) AssignTokenTypesBehavior
INITACTION ANTLRTokenTypes
INITACTION ANTLRTreePrinterTokenTypes
INITACTION AssignTokenTypesWalkerTokenTypes
INITACTION CodeGenTreeWalkerTokenTypes
INITACTION DefineGrammarItemsWalkerTokenTypes
INITACTION TreeToNFAConverterTokenTypes
initAltRelatedInfo() DFA
initASTPatterns() AssignTokenTypesWalker
initComponents() RunnerController.RunnerView
initComponents() WorkSpaceView
initContextTrees(int) NFAToDFAConverter
INITIAL_BUFFER_SIZE ANTLRReaderStream
INITIAL_CALL_STACK_SIZE BufferedTreeNodeStream
INITIAL_CALL_STACK_SIZE CommonTreeNodeStream
INITIAL_DECISION_LIST_SIZE Grammar
INITIAL_FOLLOW_STACK_SIZE BaseRecognizer
INITIAL_NUM_TRANSITIONS DFAState
INITIAL_SIZE IntArray
initialize(TestSuite) RuleListController
initialize(int, String) GrammarAST
initialize(AST) GrammarAST
initialize(Token) GrammarAST
initialStreamState DebugTokenStream
initialStreamState DebugTreeNodeStream
initIdToMessageNameMapping() ErrorManager
initTokenSymbolTables() CompositeGrammar
initValue Attribute
The optional attribute intialization expression
inlineActions Rule
Track all executable actions other than named actions like @init.
input AbstractInputEditor
input CommonToken
input DebugTokenStream
input DebugTreeNodeStream
input Tracer
input Lexer
Where is the lexer drawing characters from?
input Parser
input RecognitionException
What input stream did the error occur in?
input CommonErrorNode
input TreeParser
input Interpreter
inputDirectory GrammarSpelunker
inputIsFile gUnitTestInput
insertAfter(Token, Object) TokenRewriteStream
insertAfter(int, Object) TokenRewriteStream
insertAfter(String, Token, Object) TokenRewriteStream
insertAfter(String, int, Object) TokenRewriteStream
insertBefore(Token, Object) TokenRewriteStream
insertBefore(int, Object) TokenRewriteStream
insertBefore(String, Token, Object) TokenRewriteStream
insertBefore(String, int, Object) TokenRewriteStream
inserted MissingTokenException
insufficientPredicates(DecisionProbe, DFAState, Map<Integer, Set<Token>>) ErrorManager
INT ANTLRTokenTypes
INT ANTLRTreePrinterTokenTypes
INT AssignTokenTypesWalkerTokenTypes
INT CodeGenTreeWalkerTokenTypes
INT DefineGrammarItemsWalkerTokenTypes
INT TreeToNFAConverterTokenTypes
IntArray org.antlr.runtime.misc
A dynamic array that uses int not Integer objects.
IntArray() IntArray
IntArrayList org.antlr.misc
An ArrayList based upon int members.
IntArrayList() IntArrayList
IntArrayList(int) IntArrayList
integer(int) Utils
Integer objects are immutable so share all Integers with the
same value up to some max size.
INTEGER_POOL_MAX_VALUE Utils
INTERNAL_RULE_REF ANTLRTokenTypes
INTERNAL_RULE_REF ANTLRTreePrinterTokenTypes
INTERNAL_RULE_REF AssignTokenTypesWalkerTokenTypes
INTERNAL_RULE_REF CodeGenTreeWalkerTokenTypes
INTERNAL_RULE_REF DefineGrammarItemsWalkerTokenTypes
INTERNAL_RULE_REF TreeToNFAConverterTokenTypes
internalError(Object, Throwable) ErrorManager
internalError(Object) ErrorManager
internalOption_PrintDFA Tool
internalOption_PrintGrammarTree Tool
internalOption_ShowNFAConfigsInDFA Tool
internalOption_watchNFAConversion Tool
Interp org.antlr.gunit
The main gUnit interpreter entry point.
Interp() Interp
Interp org.antlr.tool
Interpret any ANTLR grammar:
java Interp file.g tokens-to-ignore start-rule input-file
java Interp C.g 'WS COMMENT' program t.c
where the WS and COMMENT are the names of tokens you want to have
the parser ignore.
Interp() Interp
Interpreter org.antlr.tool
The recognition interpreter/engine for grammars.
Interpreter(Grammar, IntStream) Interpreter
intersect(Label, Label) Label
intersection(LookaheadSet) LookaheadSet
intersection(Interval) Interval
Return the interval in common between this and o
intersection(AttributeScope) AttributeScope
Return the set of keys that collide from
this and other.
Interval org.antlr.misc
An immutable inclusive interval a..b
Interval(int, int) Interval
INTERVAL_POOL_MAX_VALUE Interval
intervals IntervalSet
The list of sorted, disjoint intervals.
IntervalSet org.antlr.misc
A set of integers that relies on ranges being common to do
"run-length-encoded" like compression (if you view an IntSet like
a BitSet with runs of 0s and 1s).
IntervalSet() IntervalSet
Create a set with no elements
IntervalSet(List<Interval>) IntervalSet
IntSet org.antlr.misc
A generic set of ints that has an efficient implementation, BitSet,
which is a compressed bitset and is useful for ints that
are small, for example less than 500 or so, and w/o many ranges.
IntStream org.antlr.runtime
A simple stream of integers used when all I care about is the char
or token type sequence (such as interpretation).
INVALID Label
INVALID_ALT_NUMBER NFA
INVALID_NODE Tree
INVALID_PRED_VALUE SemanticContext.Predicate
INVALID_RULE_INDEX Grammar
INVALID_STATE_NUMBER State
INVALID_TOKEN Token
INVALID_TOKEN_TYPE Token
InvalidInputException org.antlr.gunit
InvalidInputException() InvalidInputException
invalids gUnitExecutor
invokingState NFAContext
The NFA state that invoked another rule's start state is recorded
on the rule invocation context stack.
isAcceptState() State
isAction() ActionLabel
isAction() Label
isAction() Transition
isAtom() Label
isAtomTokenType(int) Grammar
isBuiltFromString() Grammar
isCyclic() DecisionProbe
isCyclic() DFA
Is this DFA cyclic? That is, are there any loops? If not, then
the DFA is essentially an LL(k) predictor for some fixed, max k value.
isCyclicDecision DebugParser
Used to differentiate between fixed lookahead and cyclic DFA decisions
while profiling.
isCyclicDecision DebugTreeParser
Used to differentiate between fixed lookahead and cyclic DFA decisions
while profiling.
isDebug() Tool
Indicate if ANTLR has generated, or will generate a debug version of the
recognizer.
isDecisionState() NFAState
isDepend() Tool
Indicates whether ANTLR has supplied, or will supply, a list of all the things
that the input grammar depends upon and all the things that will be generated
when that grammar is successfully analyzed.
isDeterministic() DecisionProbe
If no states are dead-ends, no alts are unreachable, there are
no nondeterminisms unresolved by syn preds, all is ok with decision.
isDynamicGlobalScope AttributeScope
Not a rule scope, but visible to all rules "scope symbols { ...}"
isDynamicRuleScope AttributeScope
Visible to all rules, but defined in rule "scope { int i; }"
isEmpty() NFAContext
A context is empty if there is no parent; meaning nobody pushed
anything on the call stack.
isEmptyRule(GrammarAST) Grammar
Rules like "a : ;" and "a : {...} ;" should not generate
try/catch blocks for RecognitionException.
isEOTTargetState() NFAState
isEpsilon() ActionLabel
isEpsilon() Label
isEpsilon() Transition
isForceAllFilesToOutputDir() Tool
Indicates whether ANTLR will force all files to the output directory, even
if the input files have relative paths from the input directory.
isGenerate_DFA_dot() Tool
Indicates whether ANTLR has generated or will generate a description of
all the NFAs in
Dot format
isGenerate_NFA_dot() Tool
Indicates whether ANTLR has gnerated or will generate a description of
all the NFAs in
Dot format
isGreedy() DFA
isLexerTest() gUnitTestResult
isLexicalRule gUnitTestSuite
isLexicalRule() gUnitTestSuite
isListLabel(String) CodeGenTreeWalker
isNextNonActionElementEOA(GrammarAST) GrammarSanity
isNil() LookaheadSet
isNil() BitSet
isNil() IntervalSet
return true if this set has no members
isNil() IntSet
isNil() BitSet
isNil(Object) DebugTreeAdaptor
isNil() BaseTree
isNil(Object) BaseTreeAdaptor
isNil() CommonErrorNode
isNil() CommonTree
isNil() Tree
Indicates the node is a nil node but may still have children, meaning
the tree is a flat list.
isNil(Object) TreeAdaptor
Is tree considered a nil node used to make lists of child nodes?
isNonLLStarDecision() DecisionProbe
Found recursion in > 1 alt
isParameterScope AttributeScope
isPass() TestCase
isPredefinedLexerRuleScope AttributeScope
isPredefinedRuleScope AttributeScope
isPrintGrammar() Tool
Indicates whether ANTLR has printed, or will print, a version of the input grammar
file(s) that is stripped of any action code embedded within.
isProfile() Tool
Indicates whether ANTLR has generated or will generate a version of the
recognizer that gathers statistics about its execution, which it prints when
it terminates.
isReduced() DecisionProbe
isReduced() DFA
Is the DFA reduced? I.e., does every state have a path to an accept
state? If not, don't delete as we need to generate an error indicating
which paths are "dead ends".
isReport() Tool
Indicates whether ANTLR has generated or will generate a report of various
elements of the grammar analysis, once it it has finished analyzing a grammar
file.
isResolvedWithPredicates() DFAState
isReturnScope AttributeScope
isSemanticPredicate() Label
isSemanticPredicate() PredicateLabel
isSemanticPredicate() Transition
isSet() Label
isSuccess() gUnitTestResult
issueInvalidAttributeError(String, String, Rule, Token, int) CodeGenerator
issueInvalidAttributeError(String, Rule, Token, int) CodeGenerator
issueInvalidScopeError(String, String, Rule, Token, int) CodeGenerator
issueRecursionWarnings() DecisionProbe
issueWarnings() DecisionProbe
isSynPred Rule
isSyntacticPredicate() SemanticContext.AND
isSyntacticPredicate() SemanticContext
isSyntacticPredicate() SemanticContext.NOT
isSyntacticPredicate() SemanticContext.OR
isSyntacticPredicate() SemanticContext.Predicate
isTokensRuleDecision() DFA
Is this DFA derived from the NFA for the Tokens rule?
isTrace() Tool
Indicate whether ANTLR has generated, or will generate a version of the
recognizer that prints trace messages on entry and exit of each rule.
isValidActionScope(int, String) CTarget
Is scope in @scope::name {action} valid for this kind of grammar?
Targets like C++ may want to allow new scopes like headerfile or
some such.
isValidActionScope(int, String) Target
Is scope in @scope::name {action} valid for this kind of grammar?
Targets like C++ may want to allow new scopes like headerfile or
some such.
isValidSet(TreeToNFAConverter, GrammarAST) Grammar
Given set tree like ( SET A B ), check that A and B
are both valid sets themselves, else we must tree like a BLOCK
isValidSimpleElementNode(GrammarAST) GrammarSanity
isVerbose() Tool
Indicates whether ANTLR will be verbose when analyzing grammar files, such as
displaying the names of the files it is generating and similar information.
it CommonTreeNodeStream
The tree iterator we using
iterator() BufferedTreeNodeStream
ITestCase org.antlr.gunit
ITestCase object locates one test case in a gUnit script by specifying the
tested rule and the index number of the test case in that group.
ITestCaseInput org.antlr.gunit.swingui.model
ITestCaseOutput org.antlr.gunit.swingui.model
ITestSuite org.antlr.gunit
A gUnit script file is an Antlr "test suite".
random RandomPhrase
RandomPhrase org.antlr.tool
Generate a random phrase given a grammar.
RandomPhrase() RandomPhrase
randomPhrase(Grammar, List<Integer>, String) RandomPhrase
an experimental method to generate random phrases for a given
grammar given a start rule.
range() ANTLRParser
RANGE ANTLRTokenTypes
RANGE ANTLRTreePrinterTokenTypes
RANGE AssignTokenTypesWalkerTokenTypes
RANGE CodeGenTreeWalkerTokenTypes
RANGE DefineGrammarItemsWalkerTokenTypes
RANGE TreeToNFAConverterTokenTypes
range(int, int) BitSet
range() GrammarSerializerFoo
rankdir DOTGenerator
RCURLY ANTLRTokenTypes
RCURLY ANTLRTreePrinterTokenTypes
RCURLY AssignTokenTypesWalkerTokenTypes
RCURLY CodeGenTreeWalkerTokenTypes
RCURLY DefineGrammarItemsWalkerTokenTypes
RCURLY TreeToNFAConverterTokenTypes
reach(DFAState, Label) NFAToDFAConverter
Given the set of NFA states in DFA state d, find all NFA states
reachable traversing label arcs.
REACHABLE_BUSY DecisionProbe
REACHABLE_BUSY DFA
REACHABLE_NO DecisionProbe
REACHABLE_NO DFA
REACHABLE_UNKNOWN DFA
REACHABLE_YES DecisionProbe
REACHABLE_YES DFA
reachableLabels DFAState
As this state is constructed (i.e., as NFA states are added), we
can easily check for non-epsilon transitions because the only
transition that could be a valid label is transition(0).
reachesState(DFAState, DFAState, Set) DecisionProbe
Given a start state and a target state, return true if start can reach
target state.
READ_BUFFER_SIZE ANTLRReaderStream
readAlt(DataInputStream) SerializedGrammar
readBlock(DataInputStream) SerializedGrammar
readFile(DataInputStream) SerializedGrammar
readRule(DataInputStream) SerializedGrammar
readRules(DataInputStream, int) SerializedGrammar
readString(DataInputStream) SerializedGrammar
recognitionException(RecognitionException) BlankDebugEventListener
recognitionException(RecognitionException) DebugEventHub
recognitionException(RecognitionException) DebugEventListener
A recognition exception occurred such as NoViableAltException.
recognitionException(RecognitionException) DebugEventRepeater
recognitionException(RecognitionException) DebugEventSocketProxy
recognitionException(RecognitionException) ParseTreeBuilder
recognitionException(RecognitionException) Profiler
RecognitionException org.antlr.runtime
The root of the ANTLR exception hierarchy.
RecognitionException() RecognitionException
Used for remote debugger deserialization
RecognitionException(IntStream) RecognitionException
recognizer DebugEventSocketProxy
Who am i debugging?
recognizer DFA
Which recognizer encloses this DFA? Needed to check backtracking
RecognizerSharedState org.antlr.runtime
The set of fields needed by an abstract recognizer to recognize input
and recover from errors etc...
RecognizerSharedState() RecognizerSharedState
RecognizerSharedState(RecognizerSharedState) RecognizerSharedState
recognizerST CodeGenerator
recognizerST CodeGenTreeWalker
The overall lexer/parser template; simulate dynamically scoped
attributes by making this an instance var of the walker.
recover(IntStream, RecognitionException) BaseRecognizer
Recover from an error found on the input stream.
recover(RecognitionException) Lexer
Lexers can normally match any char in it's vocabulary after matching
a token, so do the easy thing and just kill a character and hope
it all works out.
recoverFromMismatchedSet(IntStream, RecognitionException, BitSet) BaseRecognizer
Not currently used
recoverFromMismatchedToken(IntStream, int, BitSet) BaseRecognizer
Attempt to recover from a single missing or extra token.
recoverFromMismatchedToken(IntStream, int, BitSet) TreeParser
We have DOWN/UP nodes in the stream that have no line info; override.
recursionDepthEmanatingFromState(int) NFAContext
Given an NFA state number, how many times has the NFA-to-DFA
conversion pushed that state on the stack? In other words,
the NFA state must be a rule invocation state and this method
tells you how many times you've been to this state.
recursionOverflow(DecisionProbe, DFAState, int, Collection, Collection) ErrorManager
RecursionOverflowMessage org.antlr.tool
Indicates recursion overflow.
RecursionOverflowMessage(DecisionProbe, DFAState, int, Collection, Collection) RecursionOverflowMessage
recursiveAltSet DFA
Track whether an alt discovers recursion for each alt during
NFA to DFA conversion; >1 alt with recursion implies nonregular.
reduced DFA
Is this DFA reduced? I.e., can all states lead to an accept state?
reduceToSingleOperationPerIndex(List) TokenRewriteStream
We need to combine operations and report invalid operations (like
overlapping replaces that are not completed nested).
refClosureBusy CompositeGrammar
Used during getRuleReferenceClosure to detect computation cycles
referencedPredefinedRuleAttributes Rule
Do not generate start, stop etc...
referencedRule RuleLabelScope
referencedRuleName Grammar.LabelElementPair
referenceRuleLabelPredefinedAttribute(String) Grammar
To yield smaller, more readable code, track which rules have their
predefined attributes accessed.
release(int) ANTLRStringStream
release(int) CommonTokenStream
release(int) DebugTokenStream
release(int) DebugTreeNodeStream
release(int) IntStream
You may want to commit to a backtrack but don't want to force the
stream to keep bookkeeping objects around for a marker that is
no longer necessary.
release(int) LookaheadStream
release(int) BufferedTreeNodeStream
RemoteDebugEventSocketListener org.antlr.runtime.debug
RemoteDebugEventSocketListener(DebugEventListener, String, int) RemoteDebugEventSocketListener
RemoteDebugEventSocketListener.ProxyToken org.antlr.runtime.debug
RemoteDebugEventSocketListener.ProxyToken(int) RemoteDebugEventSocketListener.ProxyToken
RemoteDebugEventSocketListener.ProxyToken(int, int, int, int, int, String) RemoteDebugEventSocketListener.ProxyToken
RemoteDebugEventSocketListener.ProxyTree org.antlr.runtime.debug
RemoteDebugEventSocketListener.ProxyTree(int, int, int, int, int, String) RemoteDebugEventSocketListener.ProxyTree
RemoteDebugEventSocketListener.ProxyTree(int) RemoteDebugEventSocketListener.ProxyTree
remove(int) LookaheadSet
remove(int) BitSet
remove(int) IntervalSet
remove(int) IntSet
remove this element from this set
remove(Object) OrderedHashSet
remove(int) BitSet
remove() FastQueue
Get and remove first element in queue
remove() LookaheadStream
Get and remove first element in queue; override FastQueue.remove()
remove() BufferedTreeNodeStream.StreamIterator
remove() TreeIterator
removeErrorListener() ErrorManager
removeRecursiveOverflowState(DFAState) DecisionProbe
If a recursion overflow is resolve with predicates, then we need
to shut off the warning that would be generated.
removeState(DFAState) DFA
removeTransition(int) DFAState
removeUselessLabels(Map) Grammar
A label on a rule is useless if the rule has no return value, no
tree or template output, and it is not referenced in an action.
replace(String, String, String) Utils
Given a source string, src,
a string to replace, replacee,
and a string to replace with, replacer,
return a new string w/ the replacing done.
replace(int, Object) TokenRewriteStream
replace(int, int, Object) TokenRewriteStream
replace(Token, Object) TokenRewriteStream
replace(Token, Token, Object) TokenRewriteStream
replace(String, int, int, Object) TokenRewriteStream
replace(String, Token, Token, Object) TokenRewriteStream
replaceChildren(Object, int, int, Object) DebugTreeAdaptor
replaceChildren(Object, int, int, Object) DebugTreeNodeStream
replaceChildren(int, int, Object) BaseTree
Delete children from start to stop and replace with t even if t is
a list (nil-root tree).
replaceChildren(Object, int, int, Object) BufferedTreeNodeStream
replaceChildren(Object, int, int, Object) CommonTreeAdaptor
replaceChildren(Object, int, int, Object) CommonTreeNodeStream
replaceChildren(int, int, Object) Tree
Delete children from start to stop and replace with t even if t is
a list (nil-root tree).
replaceChildren(Object, int, int, Object) TreeAdaptor
Replace from start to stop child index of parent with t, which might
be a list.
replaceChildren(Object, int, int, Object) TreeNodeStream
Replace from start to stop child index of parent with t, which might
be a list.
report Antlr3Mojo
If set to true, then after the tool has processed an input grammar file
it will report variaous statistics about the parser, such as information
on cyclic DFAs, which rules may use backtracking, and so on.
reportAltPredicateContext(DFAState, Map) DecisionProbe
Report the list of predicates found for each alternative; copy
the list because this set gets altered later by the method
tryToResolveWithSemanticPredicates() while flagging NFA configurations
in d as resolved.
reportAnalysisTimeout() DecisionProbe
reportDanglingState(DFAState) DecisionProbe
Report the fact that DFA state d is not a state resolved with
predicates and yet it has no emanating edges.
reportError(RecognitionException) ANTLRParser
reportError(RecognitionException) ANTLRTreePrinter
reportError(RecognitionException) AssignTokenTypesWalker
reportError(RecognitionException) CodeGenTreeWalker
reportError(String) CodeGenTreeWalker
reportError(RecognitionException) DefineGrammarItemsWalker
reportError(RecognitionException) TreeToNFAConverter
reportError(RecognitionException) BaseRecognizer
Report a recognition problem.
reportError(IOException) DebugParser
reportError(RecognitionException) DebugParser
reportError(IOException) DebugTreeParser
reportError(RecognitionException) DebugTreeParser
reportError(RecognitionException) Lexer
reportIncompletelyCoveredAlts(DFAState, Map<Integer, Set<Token>>) DecisionProbe
reportLexerRuleNondeterminism(DFAState, Set<Integer>) DecisionProbe
Currently the analysis reports issues between token definitions, but
we don't print out warnings in favor of just picking the first token
definition found in the grammar ala lex/flex.
reportNondeterminism(DFAState, Set<Integer>) DecisionProbe
reportNondeterminismResolvedWithSemanticPredicate(DFAState) DecisionProbe
reportNonLLStarDecision(DFA) DecisionProbe
Report that at least 2 alts have recursive constructs.
reportRecursionOverflow(DFAState, NFAConfiguration) DecisionProbe
reportScanError(RecognitionException) Interpreter
reportST Message
reportTransformation(Object, Object) TreeRewriter
Override this if you need transformation tracing to go somewhere
other than stdout or if you're not using Tree-derived trees.
reset() DecisionProbe
reset() DFAState
reset() ANTLRStringStream
Reset the stream so that it's in the same state it was
when the object was created *except* the data array is not
touched.
reset() BaseRecognizer
reset the parser's state; subclasses must rewinds the input stream
reset() CommonTokenStream
reset() DebugTreeNodeStream
reset() Lexer
reset() FastQueue
reset() LookaheadStream
reset() Parser
reset() BufferedTreeNodeStream
reset() CommonTreeNodeStream
reset() RewriteRuleElementStream
Reset the condition of this stream so that it appears we have
not consumed any of its elements.
reset() TreeIterator
reset() TreeNodeStream
Reset the tree node stream in such a way that it acts like
a freshly constructed stream.
reset() TreeParser
resetErrorState() ErrorManager
resetStateNumbersToBeContiguous() DFA
Walk all states and reset their numbers to be a contiguous sequence
of integers starting from 0.
resolveByChoosingFirstAlt(DFAState, Set) NFAToDFAConverter
resolveByPickingExitAlt(DFAState, Set) NFAToDFAConverter
Resolve state d by choosing exit alt, which is same value as the
number of alternatives.
resolveByPickingMinAlt(DFAState, Set) NFAToDFAConverter
Turn off all configurations associated with the
set of incoming nondeterministic alts except the min alt number.
resolved NFAConfiguration
Indicate that this configuration has been resolved and no further
DFA processing should occur with it.
resolvedWithPredicates DFAState
Rather than recheck every NFA configuration in a DFA state (after
resolving) in findNewDFAStatesAndAddDFATransitions just check
this boolean.
resolveLocalURL(Artifact) GUnitExecuteMojo
resolveNonDeterminisms(DFAState) NFAToDFAConverter
If > 1 NFA configurations within this DFA state have identical
NFA state and context, but differ in their predicted
TODO update for new context suffix stuff 3-9-2005
alternative then a single input sequence predicts multiple alts.
resolveWithPredicate NFAConfiguration
This bit is used to indicate a semantic predicate will be
used to resolve the conflict.
resultPane WorkSpaceView
RET ANTLRTokenTypes
RET ANTLRTreePrinterTokenTypes
RET AssignTokenTypesWalkerTokenTypes
RET CodeGenTreeWalkerTokenTypes
RET DefineGrammarItemsWalkerTokenTypes
RET TreeToNFAConverterTokenTypes
returnScope Rule
The return values of a rule and predefined rule attributes
ReturnTest org.antlr.gunit
ReturnTest(Token) ReturnTest
rewind(int) ANTLRStringStream
rewind() ANTLRStringStream
rewind(int) CommonTokenStream
rewind() CommonTokenStream
rewind(int) BlankDebugEventListener
rewind() BlankDebugEventListener
rewind(int) DebugEventHub
rewind() DebugEventHub
rewind(int) DebugEventListener
After an arbitrairly long lookahead as with a cyclic DFA (or with
any backtrack), this informs the debugger that stream should be
rewound to the position associated with marker.
rewind() DebugEventListener
Rewind to the input position of the last marker.
rewind(int) DebugEventRepeater
rewind() DebugEventRepeater
rewind(int) DebugEventSocketProxy
rewind() DebugEventSocketProxy
rewind(int) DebugTokenStream
rewind() DebugTokenStream
rewind(int) DebugTreeNodeStream
rewind() DebugTreeNodeStream
rewind(int) IntStream
Reset the stream so that next call to index would return marker.
rewind() IntStream
Rewind to the input position of the last marker.
rewind(int) LookaheadStream
rewind() LookaheadStream
rewind(int) BufferedTreeNodeStream
rewind() BufferedTreeNodeStream
rewrite() ANTLRParser
REWRITE ANTLRTokenTypes
rewrite(AST) ANTLRTreePrinter
REWRITE ANTLRTreePrinterTokenTypes
rewrite(AST) AssignTokenTypesWalker
REWRITE AssignTokenTypesWalkerTokenTypes
rewrite(AST) CodeGenTreeWalker
REWRITE CodeGenTreeWalkerTokenTypes
rewrite(AST) DefineGrammarItemsWalker
REWRITE DefineGrammarItemsWalkerTokenTypes
rewrite(AST) TreeToNFAConverter
REWRITE TreeToNFAConverterTokenTypes
rewrite(TreeAdaptor, CommonTree, String[]) Strip
rewrite_alternative() ANTLRParser
rewrite_alternative(AST) CodeGenTreeWalker
rewrite_alternative(AST) DefineGrammarItemsWalker
rewrite_atom() ANTLRParser
rewrite_atom(AST, boolean) CodeGenTreeWalker
rewrite_atom(AST) DefineGrammarItemsWalker
rewrite_block() ANTLRParser
rewrite_block(AST, String) CodeGenTreeWalker
rewrite_block(AST) DefineGrammarItemsWalker
rewrite_ebnf() ANTLRParser
rewrite_ebnf(AST) CodeGenTreeWalker
rewrite_ebnf(AST) DefineGrammarItemsWalker
rewrite_element() ANTLRParser
rewrite_element(AST) CodeGenTreeWalker
rewrite_element(AST) DefineGrammarItemsWalker
rewrite_indirect_template_head() ANTLRParser
-> ({expr})(a={...}, ...)
rewrite_template() ANTLRParser
Build a tree for a template rewrite:
^(TEMPLATE (ID|ACTION) ^(ARGLIST ^(ARG ID ACTION) ...) )
where ARGLIST is always there even if no args exist.
rewrite_template(AST) ANTLRTreePrinter
rewrite_template(AST) CodeGenTreeWalker
rewrite_template(AST) DefineGrammarItemsWalker
rewrite_template_arg() ANTLRParser
rewrite_template_args() ANTLRParser
rewrite_template_head() ANTLRParser
-> foo(a={...}, ...)
rewrite_tree() ANTLRParser
rewrite_tree(AST) CodeGenTreeWalker
rewrite_tree(AST) DefineGrammarItemsWalker
rewriteBlockNestingLevel CodeGenTreeWalker
RewriteCardinalityException org.antlr.runtime.tree
Base class for all exceptions thrown during AST rewrite construction.
RewriteCardinalityException(String) RewriteCardinalityException
RewriteEarlyExitException org.antlr.runtime.tree
No elements within a (...)+ in a rewrite rule
RewriteEarlyExitException() RewriteEarlyExitException
RewriteEarlyExitException(String) RewriteEarlyExitException
RewriteEmptyStreamException org.antlr.runtime.tree
Ref to ID or expr but no tokens in ID stream or subtrees in expr stream
RewriteEmptyStreamException(String) RewriteEmptyStreamException
rewriteMode() Grammar
rewriteRefsDeep GrammarAST
rewriteRefsShallow GrammarAST
If this is a BLOCK node for a rewrite rule, track referenced
elements here.
RewriteRuleElementStream org.antlr.runtime.tree
A generic list of elements tracked in an alternative to be used in
a -> rewrite rule.
RewriteRuleElementStream(TreeAdaptor, String) RewriteRuleElementStream
RewriteRuleElementStream(TreeAdaptor, String, Object) RewriteRuleElementStream
Create a stream with one element
RewriteRuleElementStream(TreeAdaptor, String, List) RewriteRuleElementStream
Create a stream, but feed off an existing list
RewriteRuleNodeStream org.antlr.runtime.tree
Queues up nodes matched on left side of -> in a tree parser.
RewriteRuleNodeStream(TreeAdaptor, String) RewriteRuleNodeStream
RewriteRuleNodeStream(TreeAdaptor, String, Object) RewriteRuleNodeStream
Create a stream with one element
RewriteRuleNodeStream(TreeAdaptor, String, List) RewriteRuleNodeStream
Create a stream, but feed off an existing list
rewriteRuleRefs CodeGenTreeWalker
RewriteRuleSubtreeStream org.antlr.runtime.tree
RewriteRuleSubtreeStream(TreeAdaptor, String) RewriteRuleSubtreeStream
RewriteRuleSubtreeStream(TreeAdaptor, String, Object) RewriteRuleSubtreeStream
Create a stream with one element
RewriteRuleSubtreeStream(TreeAdaptor, String, List) RewriteRuleSubtreeStream
Create a stream, but feed off an existing list
RewriteRuleTokenStream org.antlr.runtime.tree
RewriteRuleTokenStream(TreeAdaptor, String) RewriteRuleTokenStream
RewriteRuleTokenStream(TreeAdaptor, String, Object) RewriteRuleTokenStream
Create a stream with one element
RewriteRuleTokenStream(TreeAdaptor, String, List) RewriteRuleTokenStream
Create a stream, but feed off an existing list
rewriteTreeNestingLevel CodeGenTreeWalker
right SemanticContext.AND
right StateCluster
RIGHT_EDGE_OF_BLOCK NFAState
rollback(int) TokenRewriteStream
rollback(String, int) TokenRewriteStream
Rollback the instruction stream for a program so that
the indicated instruction (via instructionIndex) is no
longer in the stream.
ROOT ANTLRTokenTypes
ROOT ANTLRTreePrinterTokenTypes
ROOT AssignTokenTypesWalkerTokenTypes
ROOT CodeGenTreeWalkerTokenTypes
root DefineGrammarItemsWalker
ROOT DefineGrammarItemsWalkerTokenTypes
ROOT TreeToNFAConverterTokenTypes
root BufferedTreeNodeStream
Pull nodes from which tree?
root CommonTreeNodeStream
Pull nodes from which tree?
root TreeIterator
RPAREN ANTLRTokenTypes
RPAREN ANTLRTreePrinterTokenTypes
RPAREN AssignTokenTypesWalkerTokenTypes
RPAREN CodeGenTreeWalkerTokenTypes
RPAREN DefineGrammarItemsWalkerTokenTypes
RPAREN TreeToNFAConverterTokenTypes
RubyTarget org.antlr.codegen
RubyTarget() RubyTarget
rule RuleClosureTransition
Ptr to the rule definition object for this rule ref
rule() ANTLRParser
RULE ANTLRTokenTypes
rule(AST) ANTLRTreePrinter
RULE ANTLRTreePrinterTokenTypes
rule(AST) AssignTokenTypesWalker
RULE AssignTokenTypesWalkerTokenTypes
rule(AST) CodeGenTreeWalker
RULE CodeGenTreeWalkerTokenTypes
rule(AST) DefineGrammarItemsWalker
RULE DefineGrammarItemsWalkerTokenTypes
rule(AST) TreeToNFAConverter
RULE TreeToNFAConverterTokenTypes
rule gUnitTestSuite
Rule org.antlr.gunit.swingui.model
ANTLR v3 Rule Information.
Rule(String) Rule
rule() TreeFilter.fptr
rule() TreeRewriter.fptr
rule(String) GrammarSerializerFoo
Rule org.antlr.tool
Combine the info associated with a rule.
Rule(Grammar, String, int, int) Rule
RULE_BLOCK_NESTING_LEVEL CodeGenTreeWalker
RULE_LABEL Grammar
RULE_LIST_LABEL Grammar
RULE_REF ANTLRTokenTypes
RULE_REF ANTLRTreePrinterTokenTypes
RULE_REF AssignTokenTypesWalkerTokenTypes
RULE_REF CodeGenTreeWalkerTokenTypes
RULE_REF DefineGrammarItemsWalkerTokenTypes
RULE_REF TreeToNFAConverterTokenTypes
ruleAction() ANTLRParser
Match stuff like @init {int i;}
ruleAction(AST) ANTLRTreePrinter
ruleAction(AST, Rule) DefineGrammarItemsWalker
ruleActions() ANTLRParser
RuleClosureTransition org.antlr.analysis
A transition used to reference another rule.
RuleClosureTransition(Rule, NFAState, NFAState) RuleClosureTransition
ruleIndex CompositeGrammar
Rules are uniquely labeled from 1..n among all grammars
ruleIndexToRuleList CompositeGrammar
Map a rule index to its name; use a Vector on purpose as new
collections stuff won't let me setSize and make it grow.
ruleLabels Rule
A list of all LabelElementPair attached to rule references like f=field
RuleLabelScope org.antlr.tool
RuleLabelScope(Rule, Token) RuleLabelScope
ruleLevel Profiler
RuleListController org.antlr.gunit.swingui
RuleListController() RuleListController
ruleListLabels Rule
A list of all rule ref list LabelElementPair like ids+=expr
ruleMemo RecognizerSharedState
An array[size num rules] of Map that tracks
the stop token index for each rule.
ruleName FailedPredicateException
rulePostProcessing(Object) DebugTreeAdaptor
rulePostProcessing(Object) BaseTreeAdaptor
Transform ^(nil x) to x and nil to null
rulePostProcessing(Object) TreeAdaptor
Given the root of the subtree created for this rule, post process
it to do any simplifications or whatever you want.
ruleref() ANTLRParser
ruleRef(GrammarAST) GrammarSerializerFoo
ruleRefs Grammar
The unique set of all rule references in any rule; set of tree node
objects so two refs to same rule can exist but at different line/position.
RuleReturnScope org.antlr.runtime
Rules can return start/stop info as well as possible trees and templates
RuleReturnScope() RuleReturnScope
rules() ANTLRParser
rules(AST) ANTLRTreePrinter
rules(AST) AssignTokenTypesWalker
rules(AST, StringTemplate) CodeGenTreeWalker
rules(AST) DefineGrammarItemsWalker
rules(AST) TreeToNFAConverter
rules TestSuite
rules SerializedGrammar
ruleScope Rule
the attributes defined with "scope {...}" inside a rule
ruleScopeSpec() ANTLRParser
ruleScopeSpec(AST) ANTLRTreePrinter
ruleScopeSpec(AST) AssignTokenTypesWalker
ruleScopeSpec(AST) CodeGenTreeWalker
ruleScopeSpec(AST, Rule) DefineGrammarItemsWalker
ruleScopeSpec(AST) TreeToNFAConverter
ruleStartTokenIndex GrammarAST
If this is a RULE node then track rule's start, stop tokens' index.
ruleStopTokenIndex GrammarAST
ruleWithReturn JUnitCodeGen
run() NFAConversionThread
run() gUnitAdapter
run() RemoteDebugEventSocketListener
RUN_FAIL ImageFactory
RUN_PASS ImageFactory
runLexer(String, String, gUnitTestInput) gUnitExecutor
RunnerController org.antlr.gunit.swingui
RunnerController() RunnerController
RunnerController.RunnerView org.antlr.gunit.swingui
RunnerController.RunnerView() RunnerController.RunnerView
runParser(String, String, String, gUnitTestInput) gUnitExecutor
RUNTIME_STATS_FILENAME Profiler
runTreeParser(String, String, String, String, gUnitTestInput) gUnitExecutor
sampleBadState RecursionOverflowMessage
sanityCheckParentAndChildIndexes() BaseTree
sanityCheckParentAndChildIndexes(Tree, int) BaseTree
SAVE ImageFactory
saveTestSuite(TestSuite) TestSuiteFactory
scan(String, DebugEventListener, List) Interpreter
For a given input char stream, try to match against the NFA
starting at startRule.
scan(String) Interpreter
scan(String, List) Interpreter
scanner GrammarSpelunker
SCOPE ANTLRTokenTypes
SCOPE ANTLRTreePrinterTokenTypes
SCOPE AssignTokenTypesWalkerTokenTypes
SCOPE CodeGenTreeWalkerTokenTypes
SCOPE DefineGrammarItemsWalkerTokenTypes
SCOPE TreeToNFAConverterTokenTypes
scopedRuleRefs Grammar
scopes Grammar
Track the scopes defined outside of rules and the scopes associated
with all rules (even if empty).
scrollCode WorkSpaceView
seek(int) ANTLRStringStream
consume() ahead until p==index; can't just set p=index as we must
update line and charPositionInLine.
seek(int) CommonTokenStream
seek(int) DebugTokenStream
seek(int) DebugTreeNodeStream
seek(int) IntStream
Set the input cursor to the position indicated by index.
seek(int) LookaheadStream
Seek to a 0-indexed position within data buffer.
seek(int) BufferedTreeNodeStream
semanticContext NFAConfiguration
The set of semantic predicates associated with this NFA
configuration.
semanticContext PredicateLabel
A tree of semantic predicates from the grammar AST if label==SEMPRED.
SemanticContext org.antlr.analysis
A binary tree structure used to record the semantic context in which
an NFA configuration is valid.
SemanticContext() SemanticContext
SemanticContext.AND org.antlr.analysis
SemanticContext.AND(SemanticContext, SemanticContext) SemanticContext.AND
SemanticContext.NOT org.antlr.analysis
SemanticContext.NOT(SemanticContext) SemanticContext.NOT
SemanticContext.OR org.antlr.analysis
SemanticContext.OR(SemanticContext, SemanticContext) SemanticContext.OR
SemanticContext.Predicate org.antlr.analysis
SemanticContext.Predicate() SemanticContext.Predicate
SemanticContext.Predicate(GrammarAST) SemanticContext.Predicate
SemanticContext.Predicate(SemanticContext.Predicate) SemanticContext.Predicate
SemanticContext.TruePredicate org.antlr.analysis
SemanticContext.TruePredicate() SemanticContext.TruePredicate
semanticPredicate(boolean, String) BlankDebugEventListener
semanticPredicate(boolean, String) DebugEventHub
semanticPredicate(boolean, String) DebugEventListener
A semantic predicate was evaluate with this result and action text
semanticPredicate(boolean, String) DebugEventRepeater
semanticPredicate(boolean, String) DebugEventSocketProxy
semanticPredicate(boolean, String) Profiler
SEMI ANTLRTokenTypes
SEMI ANTLRTreePrinterTokenTypes
SEMI AssignTokenTypesWalkerTokenTypes
SEMI CodeGenTreeWalkerTokenTypes
SEMI DefineGrammarItemsWalkerTokenTypes
SEMI TreeToNFAConverterTokenTypes
SEMPRED Label
label is a semantic predicate; implies label is epsilon also
SEMPRED ANTLRTokenTypes
SEMPRED ANTLRTreePrinterTokenTypes
SEMPRED AssignTokenTypesWalkerTokenTypes
SEMPRED CodeGenTreeWalkerTokenTypes
SEMPRED DefineGrammarItemsWalkerTokenTypes
SEMPRED TreeToNFAConverterTokenTypes
serialize(State) FASerializer
serialize(State, boolean) FASerializer
Return a string representation of a state machine.
SerializedGrammar org.antlr.runtime
SerializedGrammar(String) SerializedGrammar
serializeNode(StringBuffer, Object) DebugEventSocketProxy
serializeText(StringBuffer, String) DebugEventSocketProxy
serializeToken(Token) DebugEventSocketProxy
serverSocket DebugEventSocketProxy
SET Label
label is a set of tokens or char
set(AST, GrammarAST, GrammarAST) CodeGenTreeWalker
set(AST) TreeToNFAConverter
set(int, int) IntArrayList
Set the ith element.
set(int, T) OrderedHashSet
Replace an existing value with a new value; updates the element
list and the hash table, but not the key as that has not changed.
setAcceptState(int, DFAState) DFA
setAcceptState(boolean) State
setAcceptStateReachable(int) DFAState
setActions(Map<String, GrammarAST>) Rule
setActual(String) AbstractTest
setAdaptor(String) GrammarInfo
setArrowheadType(String) DOTGenerator
setBacktrackingLevel(int) BaseRecognizer
setBlock(AST) CodeGenTreeWalker
setBlockOption(Grammar, String, Object) GrammarAST
Save the option key/value pair and process it; return the key
or null if invalid option.
setBlockOptions(Map<String, Object>) GrammarAST
setChannel(int) ClassicToken
setChannel(int) CommonToken
setChannel(int) RemoteDebugEventSocketListener.ProxyToken
setChannel(int) Token
setCharPositionInLine(int) ANTLRStringStream
setCharPositionInLine(int) CharStream
setCharPositionInLine(int) ClassicToken
setCharPositionInLine(int) CommonToken
setCharPositionInLine(int) RemoteDebugEventSocketListener.ProxyToken
setCharPositionInLine(int) Token
setCharStream(CharStream) Lexer
Set the char stream and reset the lexer
setChild(Object, int, Object) DebugTreeAdaptor
setChild(int, Tree) BaseTree
setChild(Object, int, Object) BaseTreeAdaptor
setChild(int, Tree) Tree
Set ith child (0..n-1) to t; t must be non-null and non-nil node
setChild(Object, int, Object) TreeAdaptor
Set ith child (0..n-1) to t; t must be non-null and non-nil node
setChildIndex(Object, int) DebugTreeAdaptor
setChildIndex(int) BaseTree
setChildIndex(int) CommonTree
setChildIndex(Object, int) CommonTreeAdaptor
setChildIndex(int) Tree
setChildIndex(Object, int) TreeAdaptor
setCodeGenerator(CodeGenerator) Grammar
setColumn(int) GrammarAST
setColumn(int) Message
setConversionTimeout(int) Tool
Set the timeout value (in milliseconds) after which DFA creation stops
setCurrentRule(Rule) NFAFactory
setCurrentRuleName(String) CodeGenTreeWalker
setCurrentTestCase(TestCase) TestCaseEditController
setDebug(boolean) CodeGenerator
setDebug(boolean) Tool
Indicate whether ANTLR should generate a debug version of the
recognizer.
setDebugListener(DebugEventListener) DebugParser
Provide a new debug event listener for this parser.
setDebugListener(DebugEventListener) DebugTokenStream
setDebugListener(DebugEventListener) DebugTreeAdaptor
setDebugListener(DebugEventListener) DebugTreeNodeStream
setDebugListener(DebugEventListener) DebugTreeParser
Provide a new debug event listener for this parser.
setDecisionASTNode(GrammarAST) NFAState
What AST node is associated with this NFAState? When you
set the AST node, I set the node to point back to this NFA state.
setDecisionBlockAST(int, GrammarAST) Grammar
setDecisionNFA(int, NFAState) Grammar
setDecisionNumber(int) NFAState
setDelegationRoot(Grammar) CompositeGrammar
setDepend(boolean) Tool
Indicate whether ANTLR should supply a list of all the things
that the input grammar depends upon and all the things that will be generated
when that gramamr is successfully analyzed.
setDescription(String) NFAState
setEditor(JComponent) TestCaseEditController.AbstractEditorPane
setElement(AST) CodeGenTreeWalker
setElement(AST, IntSet) TreeToNFAConverter
setEOTTargetState(boolean) NFAState
setError(String) gUnitTestResult
setErrorListener(ANTLRErrorListener) ErrorManager
In general, you'll want all errors to go to a single spot.
setFactory(NFAFactory) NFA
setFileName(String) Grammar
setForceAllFilesToOutputDir(boolean) Tool
Indicates whether ANTLR will force all files to the output directory, even
if the input files have relative paths from the input directory.
setForceRelativeOutput(boolean) Tool
Used by build tools to force the output files to always be
relative to the base output directory, even though the tool
had to set the output directory to an absolute path as it
cannot rely on the workign directory like command line invocation
can.
setFormat(String) ErrorManager
The format gets reset either from the Tool if the user supplied a command line option to that effect
Otherwise we just use the default "antlr".
setGenerate_DFA_dot(boolean) Tool
Indicates whether ANTLR should generate a description of
all the NFAs in
Dot format
setGenerate_NFA_dot(boolean) Tool
Indicate whether ANTLR should generate a description of
all the NFAs in
Dot format
setGrammar(Grammar) ANTLRParser
setGrammarContent(String) Grammar
setGrammarFileNames(List<String>) Tool
Provide the List of all grammar file names that the ANTLR tool should process.
setGrammarName(String) GrammarInfo
setGrammarName(String) TestSuite
setGrammarName(String) TestSuiteAdapter
setGtype(int) ANTLRParser
setHeader(String, String, String, int, int) AbstractTest
setHeader(String) GrammarInfo
setInput(ITestCaseInput) AbstractInputEditor
setInput(ITestCaseInput) TestCase
setInputDirectory(String) Tool
Set the base location of input files.
setInputStream(CharStream) ClassicToken
setInputStream(CharStream) CommonToken
setInputStream(CharStream) RemoteDebugEventSocketListener.ProxyToken
setInputStream(CharStream) Token
setLastRewriteTokenIndex(String, int) TokenRewriteStream
setLexicalRuleName(String) gUnitTestSuite
setLibDirectory(String) Tool
Set the Path to the directory in which ANTLR will search for ancillary
files such as .tokens vocab files and imported grammar files.
setLine(int) ANTLRStringStream
setLine(int) CharStream
Because this stream can rewind, we need to be able to reset the line
setLine(int) ClassicToken
setLine(int) CommonToken
setLine(int) RemoteDebugEventSocketListener.ProxyToken
setLine(int) Token
setLine(int) GrammarAST
setLine(int) Message
setListSelectionListener(ListSelectionListener) RuleListController
setLocale(Locale) ErrorManager
We really only need a single locale for entire running ANTLR code
in a single VM.
setLookaheadDepth(int) DFAState
setLookaheadDFA(int, DFA) Grammar
Set the lookahead DFA for a particular decision.
setLookaheadDFA(DFA) GrammarAST
setMake(boolean) Tool
Indicate whether the tool should analyze the dependencies of the provided grammar
file list and ensure that the grammars with dependencies are built
after any of the other gramamrs in the list that they are dependent on.
setMaxSwitchCaseLabels(int) Tool
Set the threshold of case labels beyond which ANTLR will not instruct the target template
to generate switch() { case xxx: ...
setMessageFormat(String) Tool
Set the message format to one of ANTLR, gnu, vs2005
setMessageID(int) Message
setMinSwitchAlts(int) Tool
Set the threshold of the number alts, below which ANTLR will not instruct the target
template to use a switch statement.
setName(String) Grammar
setNFAConfigurations(OrderedHashSet<NFAConfiguration>) DFAState
setNFAStartState(NFAState) GrammarAST
setOfDFAWhoseAnalysisTimedOut Grammar
setOfNondeterministicDecisionNumbers Grammar
setOfNondeterministicDecisionNumbersResolvedWithPredicates Grammar
setOption(String, Object, Token) Grammar
Save the option key/value pair and process it; return the key
or null if invalid option.
setOption(Map, Set, Grammar, String, Object) GrammarAST
setOption(String, Object, Token) Rule
Save the option key/value pair and process it; return the key
or null if invalid option.
setOptions(Map, Token) Grammar
setOptions(Grammar, Map) GrammarAST
setOptions(Map, Token) Rule
setOuterAltNum(int) CodeGenTreeWalker
setOutput(ITestCaseOutput) TestCase
setOutputDirectory(String) Tool
Set the location (base directory) where output files should be produced
by the ANTLR tool.
setOutputDirectoryPath(String) JUnitCodeGen
setParent(Object, Object) DebugTreeAdaptor
setParent(Tree) BaseTree
setParent(Tree) CommonTree
setParent(Object, Object) CommonTreeAdaptor
setParent(Tree) Tree
setParent(Object, Object) TreeAdaptor
setParser(DebugParser) Profiler
setPass(boolean) TestCase
setPrintGrammar(boolean) Tool
Indicate whether ANTLR should print a version of the input grammar
file(s) that is stripped of any action code embedded within.
setProfile(boolean) CodeGenerator
setProfile(boolean) Tool
Indicate whether ANTLR should generate a version of the
recognizer that gathers statistics about its execution, which it prints when
it terminates.
setProgress(int) StatusBarController
setProgressIndetermined(boolean) StatusBarController
setRankdir(String) DOTGenerator
setReport(boolean) Tool
Indicate whether ANTLR should generate a report of various
elements of the grammar analysis, once it it has finished analyzing a grammar
file.
setRule(AST) TreeToNFAConverter
setRule(String) StatusBarController
setRuleAST(String, GrammarAST) Grammar
setRuleName(String) gUnitTestSuite
setRules(List<Rule>) TestSuite
setScript(String) ITestCaseInput
setScript(String) ITestCaseOutput
setScript(String) TestCaseInputFile
setScript(String) TestCaseInputMultiString
setScript(String) TestCaseInputString
setScript(String) TestCaseOutputAST
setScript(boolean) TestCaseOutputResult
setScript(String) TestCaseOutputResult
setScript(String) TestCaseOutputReturn
setScript(String) TestCaseOutputStdOut
setSet(IntSet) Label
setSetValue(IntSet) GrammarAST
setSize(int) IntArrayList
setStartIndex(int) CommonToken
setState(int, DFAState) DFA
setStopIndex(int) CommonToken
setSynPredGateIfNotAlready(StringTemplate) Grammar
setTerminalOption(Grammar, String, Object) GrammarAST
setTestCaseIndex(int) AbstractTest
setTestedRuleName(String) AbstractTest
setText(String) StatusBarController
setText(String) TestCaseEditController.InputMultiEditor
setText(String) TestCaseEditController.OutputAstEditor
setText(String) ClassicToken
setText(String) CommonToken
Override the text for this token.
setText(Object, String) DebugTreeAdaptor
setText(String) RemoteDebugEventSocketListener.ProxyToken
setText(String) Lexer
Set the complete text of this token; it wipes any previous
changes to the text.
setText(String) Token
setText(Object, String) BaseTreeAdaptor
setText(Object, String) TreeAdaptor
Node constructors can set the text of a node
setText(String) GrammarAST
setToBlockWithSet(GrammarAST) ANTLRParser
setTokenBoundaries(Object, int, int) BlankDebugEventListener
setTokenBoundaries(Object, int, int) DebugEventHub
setTokenBoundaries(Object, int, int) DebugEventListener
Set the token start/stop token index for a subtree root or node.
setTokenBoundaries(Object, int, int) DebugEventRepeater
setTokenBoundaries(Object, int, int) DebugEventSocketProxy
setTokenBoundaries(Object, Token, Token) DebugTreeAdaptor
setTokenBoundaries(Object, int, int) TraceDebugEventListener
setTokenBoundaries(Object, Token, Token) CommonTreeAdaptor
Track start/stop token for subtree root created for a rule.
setTokenBoundaries(Object, Token, Token) TreeAdaptor
Where are the bounds in the input token stream for this node and
all children? Each rule that creates AST nodes will call this
method right before returning.
setTokenIndex(int) ClassicToken
setTokenIndex(int) CommonToken
setTokenIndex(int) RemoteDebugEventSocketListener.ProxyToken
setTokenIndex(int) Token
setTokens(CommonTokenStream) TestSuite
setTokenSource(TokenSource) CommonTokenStream
Reset this token stream by setting its token source.
setTokenStartIndex(int) RemoteDebugEventSocketListener.ProxyTree
setTokenStartIndex(int) CommonTree
setTokenStartIndex(int) ParseTree
setTokenStartIndex(int) Tree
setTokenStopIndex(int) RemoteDebugEventSocketListener.ProxyTree
setTokenStopIndex(int) CommonTree
setTokenStopIndex(int) ParseTree
setTokenStopIndex(int) Tree
setTokenStream(TokenStream) Parser
Set the token stream and reset the parser
setTokenStream(TokenStream) BufferedTreeNodeStream
setTokenStream(TokenStream) CommonTreeNodeStream
setTokenTypeChannel(int, int) CommonTokenStream
A simple filter mechanism whereby you can tell this token stream
to force all tokens of type ttype to be on channel.
setTool(Tool) ErrorManager
setTool(Tool) Grammar
setTrace(boolean) CodeGenerator
setTrace(boolean) Tool
Indicate whether ANTLR should generate a version of the
recognizer that prints trace messages on entry and exit of each rule
setTransition0(Transition) NFAState
Used during optimization to reset a state to have the (single)
transition another state has.
setTreeAdaptor(TreeAdaptor) DebugEventSocketProxy
setTreeAdaptor(TreeAdaptor) BufferedTreeNodeStream
setTreeAdaptor(TreeAdaptor) CommonTreeNodeStream
setTreeEnclosingRuleNameDeeply(String) GrammarAST
setTreeGrammarName(String) GrammarInfo
setTreeNodeStream(TreeNodeStream) TreeParser
Set the input stream
setTreeRuleName(String) gUnitTestSuite
setType(int) ClassicToken
setType(int) CommonToken
setType(Object, int) DebugTreeAdaptor
setType(int) RemoteDebugEventSocketListener.ProxyToken
setType(int) Token
setType(Object, int) BaseTreeAdaptor
setType(Object, int) TreeAdaptor
Node constructors can set the type of a node
setType(int) GrammarAST
setUniqueNavigationNodes(boolean) DebugTreeNodeStream
It is normally this object that instructs the node stream to
create unique nav nodes, but to satisfy interface, we have to
define it.
setUniqueNavigationNodes(boolean) BufferedTreeNodeStream
setUniqueNavigationNodes(boolean) CommonTreeNodeStream
setUniqueNavigationNodes(boolean) TreeNodeStream
As we flatten the tree, we use UP, DOWN nodes to represent
the tree structure.
setUnitTestResult(StringBuffer) GrammarInfo
setUnknownTokenBoundaries() CommonTree
For every node in this subtree, make sure it's start/stop token's
are set.
setUserMaxLookahead(int) DFA
setValue(String) TestCaseEditController.OutputResultEditor
setValue GrammarAST
If this is a SET node, what are the elements?
setVerbose(boolean) Tool
Indicate whether ANTLR should be verbose when analyzing grammar files, such as
displaying the names of the files it is generating and similar information.
show() WorkSpaceController
showActions ANTLRTreePrinter
showTransformations TreeRewriter
simulateTreeConstruction(Object) DebugTreeAdaptor
^(A B C): emit create A, create B, add child, ...
single_rewrite(AST) ANTLRTreePrinter
SINGLE_THREADED_NFA_CONVERSION NFAToDFAConverter
Should ANTLR launch multiple threads to convert NFAs to DFAs?
With a 2-CPU box, I note that it's about the same single or
multithreaded.
singleAtomTransitionEmanating NFAConfiguration
Indicates that the NFA state associated with this configuration
has exactly one transition and it's an atom (not epsilon etc...).
singleElement RewriteRuleElementStream
Track single elements w/o creating a list.
size() BitSet
size() IntArrayList
size() IntervalSet
size() IntSet
Return the size of this set (not the underlying implementation's
allocated memory size, for example).
size() OrderedHashSet
size() ANTLRStringStream
size() BitSet
size() CommonTokenStream
size() DebugTokenStream
size() DebugTreeNodeStream
size() IntStream
Only makes sense for streams that buffer everything up probably, but
might be useful to display the entire stream or for testing.
size() FastQueue
size() IntArray
This only tracks elements added via push/add.
size() LookaheadStream
Size of entire stream is unknown; we only know buffer size from FastQueue
size() BufferedTreeNodeStream
size() RewriteRuleElementStream
size() AttributeScope
skip() Lexer
Instruct the lexer to skip creating a token for current lexer rule
and look for another token.
SKIP_TOKEN Token
In an action, a lexer rule can set token to this SKIP_TOKEN and ANTLR
will avoid creating a token for this symbol and try to fetch another.
skipOffTokenChannels(int) CommonTokenStream
Given a starting index, return the index of the first on-channel
token.
skipOffTokenChannelsReverse(int) CommonTokenStream
SL_COMMENT ANTLRTokenTypes
SL_COMMENT ANTLRTreePrinterTokenTypes
SL_COMMENT AssignTokenTypesWalkerTokenTypes
SL_COMMENT CodeGenTreeWalkerTokenTypes
SL_COMMENT DefineGrammarItemsWalkerTokenTypes
SL_COMMENT TreeToNFAConverterTokenTypes
socket DebugEventSocketProxy
sort() Graph
DFS-based topological sort.
sortGrammarFiles() Tool
special DFA
special DFA
specialStates DFA
List of special DFAState objects
specialStateSTs DFA
List of ST for special states.
specialStateTransition(int, IntStream) DFA
splitListClient WorkSpaceView
SRC ANTLRTokenTypes
SRC ANTLRTreePrinterTokenTypes
SRC AssignTokenTypesWalkerTokenTypes
SRC CodeGenTreeWalkerTokenTypes
SRC DefineGrammarItemsWalkerTokenTypes
SRC TreeToNFAConverterTokenTypes
STAR ANTLRTokenTypes
STAR ANTLRTreePrinterTokenTypes
STAR AssignTokenTypesWalkerTokenTypes
STAR CodeGenTreeWalkerTokenTypes
STAR DefineGrammarItemsWalkerTokenTypes
STAR TreeToNFAConverterTokenTypes
start CommonToken
The char position into the input buffer where this token starts
start() RemoteDebugEventSocketListener
Create a thread to listen to the remote running recognizer
start ParserRuleReturnScope
start CommonErrorNode
start TreeRuleReturnScope
First node or root node of tree matched for this rule.
startIndex CommonTree
What token indexes bracket all tokens associated with this node
and below?
startRule(String) TestSuiteAdapter
startsAfter(Interval) Interval
Does this.a start after other.b? May or may not be disjoint
startsAfterDisjoint(Interval) Interval
Does this start completely after other? Disjoint
startsAfterNonDisjoint(Interval) Interval
Does this start after other? NonDisjoint
startsBeforeDisjoint(Interval) Interval
Does this start completely before other? Disjoint
startsBeforeNonDisjoint(Interval) Interval
Does this start at or before other? Nondisjoint
startState DFA
What's the start state for this DFA?
startState Grammar.Decision
startState Rule
state NFAConfiguration
The NFA state associated with this configuration
State org.antlr.analysis
A generic state machine state.
State() State
state BaseRecognizer
State of a lexer, parser, or tree parser are collected into a state
object so the state can be shared.
stateChanged(ChangeEvent) WorkSpaceController.TabChangeListener
StateCluster org.antlr.analysis
A Cluster object points to the left/right (start and end) states of a
state machine.
StateCluster(NFAState, NFAState) StateCluster
stateCounter DFA
Unique state numbers per DFA
stateCounter CompositeGrammar
Used to assign state numbers; all grammars in composite share common
NFA space.
stateCounter FASerializer
Each state we walk will get a new state number for serialization
purposes.
stateNumber State
stateNumber NoViableAltException
stateNumberTranslator FASerializer
Rather than add a new instance variable to NFA and DFA just for
serializing machines, map old state numbers to new state numbers
by a State object -> Integer new state number HashMap.
stateReachable DecisionProbe
Used to find paths through syntactically ambiguous DFA.
states DFA
Maps the state number to the actual DFAState.
statesResolvedWithSemanticPredicatesSet DecisionProbe
Was a syntactic ambiguity resolved with predicates? Any DFA
state that predicts more than one alternative, must be resolved
with predicates or it should be reported to the user.
statesVisitedAtInputDepth DecisionProbe
Used while finding a path through an NFA whose edge labels match
an input sequence.
statesVisitedDuringSampleSequence DecisionProbe
statesWithSyntacticallyAmbiguousAltsSet DecisionProbe
Track all DFA states with nondeterministic alternatives.
stateToAltSetWithSemanticPredicatesMap DecisionProbe
Track the predicates for each alt per DFA state;
more than one DFA state might have syntactically ambig alt prediction.
stateToIncompletelyCoveredAltsMap DecisionProbe
Tracks alts insufficiently covered.
stateToRecursionOverflowConfigurationsMap DecisionProbe
Recursion is limited to a particular depth.
stateToSyntacticallyAmbiguousTokensRuleAltsMap DecisionProbe
Track just like stateToSyntacticallyAmbiguousAltsMap, but only
for nondeterminisms that arise in the Tokens rule such as keyword vs
ID rule.
Stats org.antlr.runtime.misc
Stats routines needed by profiler etc...
Stats() Stats
StatusBarController org.antlr.gunit.swingui
StatusBarController() StatusBarController
stddev(int[]) Stats
Compute the sample (unbiased estimator) standard deviation following:
Computing Deviations: Standard Accuracy
Tony F.
stderr gUnitBaseTest
stdout gUnitBaseTest
stlib DOTGenerator
Library of output templates; use
format
stop CommonToken
The char position into the input buffer where this token stops
stop ParserRuleReturnScope
stop CommonErrorNode
stopIndex CommonTree
What token indexes bracket all tokens associated with this node
and below?
stopState Rule
STRAY_BRACKET ANTLRTokenTypes
STRAY_BRACKET ANTLRTreePrinterTokenTypes
STRAY_BRACKET AssignTokenTypesWalkerTokenTypes
STRAY_BRACKET CodeGenTreeWalkerTokenTypes
STRAY_BRACKET DefineGrammarItemsWalkerTokenTypes
STRAY_BRACKET TreeToNFAConverterTokenTypes
streams GrammarSerializerFoo
STRING_LITERAL ANTLRTokenTypes
STRING_LITERAL ANTLRTreePrinterTokenTypes
STRING_LITERAL AssignTokenTypesWalkerTokenTypes
STRING_LITERAL CodeGenTreeWalkerTokenTypes
STRING_LITERAL DefineGrammarItemsWalkerTokenTypes
STRING_LITERAL TreeToNFAConverterTokenTypes
stringAlias AssignTokenTypesWalker
stringAlias2 AssignTokenTypesWalker
stringLiterals AssignTokenTypesBehavior
stringLiteralToTypeMap CompositeGrammar
Map token literals like "while" to its token type.
Strip org.antlr.tool
A basic action stripper.
Strip(String[]) Strip
STRIP_NONREDUCED_STATES DOTGenerator
stripWildCardAlts(Set) DecisionProbe
Get the last disabled alt number and check in the grammar to see
if that alt is a simple wildcard.
subset(BitSet) BitSet
Is this contained within a?
substring(int, int) ANTLRStringStream
substring(int, int) CharStream
For infinite streams, you don't need this; primarily I'm providing
a useful interface for action code.
subtract(LookaheadSet) LookaheadSet
subtract(IntSet) BitSet
subtract(IntSet) IntervalSet
Compute this-other via this&~other.
subtract(IntSet) IntSet
subtractInPlace(BitSet) BitSet
Subtract the elements of 'a' from 'this' in-place.
suffix(NFAContext) NFAContext
[$] suffix any context
[21 $] suffix [21 12 $]
[21 12 $] suffix [21 $]
[21 18 $] suffix [21 18 12 9 $]
[21 18 12 9 $] suffix [21 18 $]
[21 12 $] not suffix [21 9 $]
Example "[21 $] suffix [21 12 $]" means: rule r invoked current rule
from state 21.
sum(int[]) Stats
sval TreePatternLexer
Set when token type is ID or ARG (name mimics Java's StreamTokenizer)
SYN_SEMPRED ANTLRTokenTypes
SYN_SEMPRED ANTLRTreePrinterTokenTypes
SYN_SEMPRED AssignTokenTypesWalkerTokenTypes
SYN_SEMPRED CodeGenTreeWalkerTokenTypes
SYN_SEMPRED DefineGrammarItemsWalkerTokenTypes
SYN_SEMPRED TreeToNFAConverterTokenTypes
sync(int) LookaheadStream
Make sure we have 'need' elements from current position p.
synpred SemanticContext.Predicate
syntactic predicates are converted to semantic predicates
but synpreds are generated slightly differently.
SYNPRED ANTLRTokenTypes
SYNPRED ANTLRTreePrinterTokenTypes
SYNPRED AssignTokenTypesWalkerTokenTypes
SYNPRED CodeGenTreeWalkerTokenTypes
SYNPRED DefineGrammarItemsWalkerTokenTypes
SYNPRED TreeToNFAConverterTokenTypes
SYNPRED_RULE_PREFIX Grammar
SYNPREDGATE_ACTION_NAME Grammar
synPredNamesUsedInDFA Grammar
Track names of preds so we can avoid generating preds that aren't used
Computed during NFA to DFA conversion.
synPredUsedInDFA(DFA, SemanticContext) Grammar
syntaxError(int, Grammar, Token, Object, RecognitionException) ErrorManager
syntaxErrors RecognizerSharedState
Did the recognizer encounter a syntax error? Track how many.
tab() ANTLRLexer
advance the current column number by one; don't do tabs.
tabEditors WorkSpaceView
target Transition
The target of this transition
target CodeGenerator
The target specifies how to write out files and do other language
specific actions.
Target org.antlr.codegen
The code generator for ANTLR can usually be retargeted just by providing
a new X.stg file for language X, however, sometimes the files that must
be generated vary enough that some X-specific functionality is required.
Target() Target
targetCharValueEscape Target
For pure strings of Java 16-bit unicode char, how can we display
it in the target language as a literal.
targetRules RecursionOverflowMessage
TEMPLATE ANTLRTokenTypes
TEMPLATE ANTLRTreePrinterTokenTypes
TEMPLATE AssignTokenTypesWalkerTokenTypes
TEMPLATE CodeGenTreeWalkerTokenTypes
TEMPLATE DefineGrammarItemsWalkerTokenTypes
TEMPLATE TreeToNFAConverterTokenTypes
templates CodeGenerator
Where are the templates this generator should use to generate code?
templates CodeGenTreeWalker
templates BuildDependencyGenerator
terminal() ANTLRParser
terminalOptions GrammarAST
terminate() BlankDebugEventListener
terminate() DebugEventHub
terminate() DebugEventListener
Parsing is over; successfully or not.
terminate() DebugEventRepeater
terminate() DebugEventSocketProxy
terminate() Profiler
TEST_SUITE_EXT TestSuiteFactory
testBlockAsSet(AST) TreeToNFAConverter
Check to see if this block can be a set.
TestCase org.antlr.gunit.swingui.model
TestCase(ITestCaseInput, ITestCaseOutput) TestCase
TestCaseEditController org.antlr.gunit.swingui
TestCaseEditController(WorkSpaceView) TestCaseEditController
TestCaseEditController() TestCaseEditController
TestCaseEditController.AbstractEditorPane org.antlr.gunit.swingui
TestCaseEditController.AbstractEditorPane(JComboBox, String) TestCaseEditController.AbstractEditorPane
TestCaseEditController.InputEditorPane org.antlr.gunit.swingui
TestCaseEditController.InputEditorPane(JComboBox) TestCaseEditController.InputEditorPane
TestCaseEditController.InputFileEditor org.antlr.gunit.swingui
TestCaseEditController.InputFileEditor() TestCaseEditController.InputFileEditor
TestCaseEditController.InputMultiEditor org.antlr.gunit.swingui
TestCaseEditController.InputMultiEditor() TestCaseEditController.InputMultiEditor
TestCaseEditController.InputStringEditor org.antlr.gunit.swingui
TestCaseEditController.InputStringEditor() TestCaseEditController.InputStringEditor
TestCaseEditController.OutputAstEditor org.antlr.gunit.swingui
TestCaseEditController.OutputAstEditor() TestCaseEditController.OutputAstEditor
TestCaseEditController.OutputEditorPane org.antlr.gunit.swingui
TestCaseEditController.OutputEditorPane(JComboBox) TestCaseEditController.OutputEditorPane
TestCaseEditController.OutputResultEditor org.antlr.gunit.swingui
TestCaseEditController.OutputResultEditor() TestCaseEditController.OutputResultEditor
TestCaseEditController.OutputReturnEditor org.antlr.gunit.swingui
TestCaseEditController.OutputReturnEditor() TestCaseEditController.OutputReturnEditor
TestCaseEditController.OutputStdEditor org.antlr.gunit.swingui
TestCaseEditController.OutputStdEditor() TestCaseEditController.OutputStdEditor
TestCaseInputFile org.antlr.gunit.swingui.model
TestCaseInputFile(String) TestCaseInputFile
TestCaseInputMultiString org.antlr.gunit.swingui.model
TestCaseInputMultiString(String) TestCaseInputMultiString
TestCaseInputString org.antlr.gunit.swingui.model
TestCaseInputString(String) TestCaseInputString
TestCaseOutputAST org.antlr.gunit.swingui.model
TestCaseOutputAST(String) TestCaseOutputAST
TestCaseOutputResult org.antlr.gunit.swingui.model
TestCaseOutputResult(boolean) TestCaseOutputResult
TestCaseOutputReturn org.antlr.gunit.swingui.model
TestCaseOutputReturn(String) TestCaseOutputReturn
TestCaseOutputStdOut org.antlr.gunit.swingui.model
TestCaseOutputStdOut(String) TestCaseOutputStdOut
TESTGROUP ImageFactory
TESTGROUPX ImageFactory
testInput gUnitTestInput
testSetElement(AST) TreeToNFAConverter
Match just an element; no ast suffix etc..
testSetRule(AST) TreeToNFAConverter
TESTSUITE ImageFactory
TestSuite org.antlr.gunit.swingui.model
TestSuite(String, File) TestSuite
TestSuiteAdapter org.antlr.gunit.swingui.runner
Adapter class for gunit parser to save information into testsuite object.
TestSuiteAdapter(TestSuite) TestSuiteAdapter
TestSuiteFactory org.antlr.gunit.swingui.model
TestSuiteFactory() TestSuiteFactory
testSuiteFile TestSuite
testSuites gUnitTestSuite
A map which stores input/output pairs (individual testsuites).
text ClassicToken
text CommonToken
We need to be able to change the text once in a while.
text RemoteDebugEventSocketListener.ProxyTree
text RecognizerSharedState
You can set the text for the current token to override what is in
the input char buffer.
TEXTFILE ImageFactory
TEXTFILE16 ImageFactory
threshold Barrier
throwsSpec() ANTLRParser
timedOut DecisionProbe
Did ANTLR have to terminate early on the analysis of this decision?
toArray() BitSet
toArray() IntervalSet
toArray() BitSet
Is this contained within a?
toArray(List) Profiler
toDebugString() TokenRewriteStream
toDebugString(int, int) TokenRewriteStream
toDOT(Object, TreeAdaptor, StringTemplate, StringTemplate) DOTTreeGenerator
toDOT(Object, TreeAdaptor) DOTTreeGenerator
toDOT(Tree) DOTTreeGenerator
Generate DOT (graphviz) for a whole tree not just a node.
toDOTDefineEdges(Object, TreeAdaptor, StringTemplate) DOTTreeGenerator
toDOTDefineNodes(Object, TreeAdaptor, StringTemplate) DOTTreeGenerator
toInputString() ParseTree
Print out the leaves of this tree, which means printing original
input back out.
token RecognitionException
The current Token when an error occurred.
token RecognizerSharedState
The goal of all lexer rules/methods is to create a token object.
Token org.antlr.runtime
token CommonTree
A single token is the payload
token GrammarAST
This AST node was created from what token?
token(GrammarAST) GrammarSerializerFoo
token GrammarSpelunker
TOKEN_LABEL Grammar
TOKEN_LIST_LABEL Grammar
TOKEN_REF ANTLRTokenTypes
TOKEN_REF ANTLRTreePrinterTokenTypes
TOKEN_REF AssignTokenTypesWalkerTokenTypes
TOKEN_REF CodeGenTreeWalkerTokenTypes
TOKEN_REF DefineGrammarItemsWalkerTokenTypes
TOKEN_REF TreeToNFAConverterTokenTypes
tokenBuffer Grammar
This is the buffer of *all* tokens found in the grammar file
including whitespace tokens etc...
tokenIDRefs Grammar
The unique set of all token ID references in any rule
tokenIDToTypeMap CompositeGrammar
Map token like ID (but not literals like "while") to its token type
tokenIndex RemoteDebugEventSocketListener.ProxyTree
tokenIndexesAreInvalid() RemoteDebugEventSocketListener
tokenizer TreePatternParser
tokenLabels Rule
A list of all LabelElementPair attached to tokens like id=ID
tokenListLabels Rule
A list of all Token list LabelElementPair like ids+=ID
tokenNameToTypeMap TreeWizard
TokenRewriteStream org.antlr.runtime
Useful for dumping out the input stream after doing some
augmentation or other manipulations.
TokenRewriteStream() TokenRewriteStream
TokenRewriteStream(TokenSource) TokenRewriteStream
TokenRewriteStream(TokenSource, int) TokenRewriteStream
tokenRuleDefs AssignTokenTypesBehavior
Track actual lexer rule defs so we don't get repeated token defs in
generated lexer.
TOKENS ANTLRTokenTypes
TOKENS ANTLRTreePrinterTokenTypes
TOKENS AssignTokenTypesWalkerTokenTypes
TOKENS CodeGenTreeWalkerTokenTypes
TOKENS DefineGrammarItemsWalkerTokenTypes
TOKENS TreeToNFAConverterTokenTypes
tokens TestSuite
tokens CommonTokenStream
Record every single token pulled from the source so we can reproduce
chunks of it later.
tokens BufferedTreeNodeStream
IF this tree (root) was created from a token stream, track it.
tokens CommonTreeNodeStream
If this tree (root) was created from a token stream, track it.
tokens AssignTokenTypesBehavior
tokens Strip
tokenScope AttributeScope
All token scopes (token labels) share the same fixed scope of
of predefined attributes.
tokenSource CommonTokenStream
TokenSource org.antlr.runtime
A source of tokens must provide a sequence of tokens via nextToken()
and also must reveal it's source of characters; CommonToken's text is
computed from a CharStream; it only store indices into the char stream.
tokenSpec() ANTLRParser
tokenSpec(AST) ANTLRTreePrinter
tokenSpec(AST) AssignTokenTypesWalker
tokenSpec(AST) DefineGrammarItemsWalker
tokensSpec() ANTLRParser
tokensSpec(AST) ANTLRTreePrinter
tokensSpec(AST) AssignTokenTypesWalker
tokensSpec(AST) DefineGrammarItemsWalker
tokenStartCharIndex RecognizerSharedState
What character index in the stream did the current token start at?
Needed, for example, to get the text for current token.
tokenStartCharPositionInLine RecognizerSharedState
The character position of first character within the line
tokenStartLine RecognizerSharedState
The line on which the first character of the token resides
TokenStream org.antlr.runtime
A stream of tokens accessing tokens from a TokenSource
tokenTypeSet LookaheadSet
tokenVocab BuildDependencyGenerator
tokenVocab GrammarSpelunker
toList() BitSet
toList() IntervalSet
toList() IntSet
toNotifyString() Profiler
toNotifyString() GrammarReport
Create a single-line stats report about this grammar suitable to
send to the notify page at antlr.org
tool CodeGenerator
A reference to the ANTLR tool so we can learn about output directories
and such.
Tool org.antlr.gunit.swingui
Tool() Tool
tool Antlr3Mojo
An instance of the ANTLR tool build
Tool org.antlr
The main ANTLR entry point.
Tool() Tool
Tool(String[]) Tool
tool BuildDependencyGenerator
tool Grammar
toolbar WorkSpaceView
ToolMessage org.antlr.tool
A generic message from the tool such as "file not found" type errors; there
is no reason to create a special object for each error unlike the grammar
errors, which may be rather complex.
ToolMessage(int) ToolMessage
ToolMessage(int, Object) ToolMessage
ToolMessage(int, Throwable) ToolMessage
ToolMessage(int, Object, Object) ToolMessage
ToolMessage(int, Object, Throwable) ToolMessage
toOriginalString() TokenRewriteStream
toOriginalString(int, int) TokenRewriteStream
toPackedArray() BitSet
toPackedArray() BitSet
topdown() TreeFilter
topdown() TreeRewriter
toRuntimeBitSet() IntervalSet
toString() ActionLabel
toString(Grammar) ActionLabel
toString() DFA
toString() DFAState
Print all NFA states plus what alts they predict
toString() Label
Predicates are lists of AST nodes from the NFA created from the
grammar, but the same predicate could be cut/paste into multiple
places in the grammar.
toString(Grammar) Label
toString(Grammar) LookaheadSet
toString() LookaheadSet
toString() NFAConfiguration
toString(boolean) NFAConfiguration
toString() NFAContext
toString() NFAState
toString() PredicateLabel
toString(Grammar) PredicateLabel
toString() SemanticContext.AND
toString() SemanticContext.NOT
toString() SemanticContext.OR
toString() SemanticContext.Predicate
toString() SemanticContext.TruePredicate
toString() Transition
toString(AST, Grammar, boolean) ANTLRTreePrinter
Call this to figure out how to print
toString() Rule
toString() TestCase
toString() TestCaseInputFile
toString() TestCaseInputMultiString
toString() TestCaseInputString
toString() TestCaseOutputAST
toString() TestCaseOutputResult
toString() TestCaseOutputReturn
toString() TestCaseOutputStdOut
toString() BitSet
toString(Grammar) BitSet
Transform a bit set into a string by formatting each element as an integer
separator The string to put in between elements
toString(String, List) BitSet
Create a string representation where instead of integer elements, the
ith element of vocabulary is displayed instead.
toString() Graph.Node
toString() IntArrayList
toString() Interval
toString() IntervalSet
toString(Grammar) IntervalSet
toString() IntSet
toString(Grammar) IntSet
toString() OrderedHashSet
toString() BitSet
toString(String[]) BitSet
toString() ClassicToken
toString() CommonToken
toString() CommonTokenStream
toString(int, int) CommonTokenStream
toString(Token, Token) CommonTokenStream
toString() DebugTokenStream
toString(int, int) DebugTokenStream
toString(Token, Token) DebugTokenStream
toString(Object, Object) DebugTreeNodeStream
toString() Profiler
toString(String) Profiler
toString() RemoteDebugEventSocketListener.ProxyToken
toString() RemoteDebugEventSocketListener.ProxyTree
toString() FailedPredicateException
toString() FastQueue
Return string of current buffer contents; non-destructive
toString() MismatchedNotSetException
toString() MismatchedRangeException
toString() MismatchedSetException
toString() MismatchedTokenException
toString() MismatchedTreeNodeException
toString() MissingTokenException
toString() NoViableAltException
toString() SerializedGrammar
toString() TokenRewriteStream
toString(String) TokenRewriteStream
toString(int, int) TokenRewriteStream
toString(String, int, int) TokenRewriteStream
toString(int, int) TokenStream
Return the text of all tokens from start to stop, inclusive.
toString(Token, Token) TokenStream
Because the user is not required to use a token with an index stored
in it, we must provide a means for two token objects themselves to
indicate the start/end location.
toString() BaseTree
Override to say how a node (not a tree) should look as text
toString(Object, Object) BufferedTreeNodeStream
toString() CommonErrorNode
toString() CommonTree
toString(Object, Object) CommonTreeNodeStream
toString() ParseTree
toString() Tree
toString(Object, Object) TreeNodeStream
Return the text of all nodes from start to stop, inclusive.
toString() TreeWizard.TreePattern
toString() UnwantedTokenException
toString() Attribute
toString() AttributeScope
toString() Grammar.LabelElementPair
toString() Grammar
toString() GrammarAnalysisAbortedMessage
toString() GrammarDanglingStateMessage
toString() GrammarInsufficientPredicatesMessage
toString() GrammarNonDeterminismMessage
toString() GrammarReport
Given a stats line suitable for sending to the antlr.org site,
return a human-readable version.
toString(String) GrammarReport
toString() GrammarSemanticsMessage
toString() GrammarSyntaxMessage
toString() GrammarUnreachableAltsMessage
toString() LeftRecursionCyclesMessage
toString(StringTemplate) Message
toString() NonRegularDecisionMessage
toString() RecursionOverflowMessage
toString() Rule
Used during grammar imports to see if sets of rules intersect...
toString() ToolMessage
toStringOfHalfWords() BitSet
Dump a comma-separated list of the words making up the bit set.
toStringOfWords() BitSet
Dump a comma-separated list of the words making up the bit set.
toStrings(List) BaseRecognizer
A convenience method for use most often with template rewrites.
toStringTree() BaseTree
Print out a whole tree not just a node
toStringTree() Tree
toStringWithHiddenTokens() ParseTree
Emit a token and all hidden nodes before.
toStringWithRanges() BitSet
toTokenString(int, int) BufferedTreeNodeStream
Debugging
toTokenTypeString() BufferedTreeNodeStream
Used for testing, just return the token type stream
toTokenTypeString() CommonTreeNodeStream
For debugging; destructive: moves tree iterator to end.
toTree(Object) RewriteRuleElementStream
Ensure stream emits trees; tokens must be converted to AST nodes.
toTree(Object) RewriteRuleNodeStream
toTree(Object) RewriteRuleTokenStream
Don't convert to a tree unless they explicitly call nextTree.
trace CodeGenerator
Create a Tracer object and make the recognizer invoke this.
trace Antlr3Mojo
If set to true, the generated parser code will log rule entry and exit points
to stdout as an aid to debugging.
TraceDebugEventListener org.antlr.runtime.debug
Print out (most of) the events...
TraceDebugEventListener(TreeAdaptor) TraceDebugEventListener
traceIn(String, int, Object) BaseRecognizer
traceIn(String, int) Lexer
traceIn(String, int) Parser
traceIn(String, int) TreeParser
traceOut(String, int, Object) BaseRecognizer
traceOut(String, int) Lexer
traceOut(String, int) Parser
traceOut(String, int) TreeParser
Tracer org.antlr.runtime.debug
The default tracer mimics the traceParser behavior of ANTLR 2.x.
Tracer(IntStream) Tracer
traceStatesLookingForLeftRecursion(NFAState, Set, List<Set<Rule>>) GrammarSanity
From state s, look for any transition to a rule that is currently
being traced.
trackAltsWithRewrites(GrammarAST, int) Rule
Track which rules have rewrite rules.
trackInlineAction(GrammarAST) DefineGrammarItemsWalker
trackInlineAction(GrammarAST) Rule
trackRuleReferenceInAlt(GrammarAST, int) Rule
trackString(GrammarAST) AssignTokenTypesWalker
trackString(GrammarAST) AssignTokenTypesBehavior
Track string literals (could be in tokens{} section)
trackToken(GrammarAST) AssignTokenTypesWalker
trackToken(GrammarAST) AssignTokenTypesBehavior
trackTokenReferenceInAlt(GrammarAST, int) Rule
Track a token ID or literal like '+' and "void" as having been referenced
somewhere within the alts (not rewrite sections) of a rule.
trackTokenRule(GrammarAST, GrammarAST, GrammarAST) AssignTokenTypesWalker
trackTokenRule(GrammarAST, GrammarAST, GrammarAST) AssignTokenTypesBehavior
trackUseOfSyntacticPredicates(Grammar) SemanticContext.AND
trackUseOfSyntacticPredicates(Grammar) SemanticContext.NOT
trackUseOfSyntacticPredicates(Grammar) SemanticContext.OR
trackUseOfSyntacticPredicates(Grammar) SemanticContext.Predicate
trackUseOfSyntacticPredicates(Grammar) SemanticContext
Notify the indicated grammar of any syn preds used within this context
transition DFA
transition(int) DFAState
transition NFAState
transition(int) NFAState
transition(int) State
Transition org.antlr.analysis
A generic transition between any two state machine states.
Transition(Label, State) Transition
Transition(int, State) Transition
transition DFA
transitionEdgeTables DFA
just the Vector indicating which unique edge table is at
position i.
transitions DFAState
Track the transitions emanating from this DFA state.
translateAction(String, GrammarAST) CodeGenerator
translateActionAttributeReferences(Map) CodeGenerator
Actions may reference $x::y attributes, call translateAction on
each action and replace that action in the Map.
translateActionAttributeReferencesForSingleScope(Rule, Map) CodeGenerator
Use for translating rule @init{...} actions that have no scope
translateArgAction(String, GrammarAST) CodeGenerator
Translate an action like [3,"foo",a[3]] and return a List of the
translated actions.
translateDisplayAltToWalkAlt(int) NFAState
The DFA decision for this NFA decision state always has
an exit path for loops as n+1 for n alts in the loop.
translateTemplateConstructor(String, int, Token, String) CodeGenerator
Given a template constructor action like %foo(a={...}) in
an action, translate it to the appropriate template constructor
from the templateLib.
transmit(String) DebugEventSocketProxy
trappedException CommonErrorNode
tree() ANTLRParser
tree(AST) ANTLRTreePrinter
tree(AST) AssignTokenTypesWalker
tree(AST) CodeGenTreeWalker
tree(AST) DefineGrammarItemsWalker
tree(AST) TreeToNFAConverter
Tree org.antlr.runtime.tree
What does a tree look like? ANTLR has a number of support classes
such as CommonTreeNodeStream that work on these kinds of trees.
tree TreeIterator
tree Rule
The AST representing the whole rule
TREE_BEGIN ANTLRTokenTypes
TREE_BEGIN ANTLRTreePrinterTokenTypes
TREE_BEGIN AssignTokenTypesWalkerTokenTypes
TREE_BEGIN CodeGenTreeWalkerTokenTypes
TREE_BEGIN DefineGrammarItemsWalkerTokenTypes
TREE_BEGIN TreeToNFAConverterTokenTypes
TREE_GRAMMAR ANTLRTokenTypes
TREE_GRAMMAR ANTLRTreePrinterTokenTypes
TREE_GRAMMAR AssignTokenTypesWalkerTokenTypes
TREE_GRAMMAR CodeGenTreeWalkerTokenTypes
TREE_GRAMMAR DefineGrammarItemsWalkerTokenTypes
TREE_GRAMMAR TreeToNFAConverterTokenTypes
tree_option Strip
TREE_PARSER Grammar
TreeAdaptor org.antlr.runtime.tree
How to create and navigate trees.
TreeFilter org.antlr.runtime.tree
Cut-n-paste from material I'm not using in the book anymore (edit later
to make sense):
Now, how are we going to test these tree patterns against every
subtree in our original tree? In what order should we visit nodes?
For this application, it turns out we need a simple ``apply once''
rule application strategy and a ``down then up'' tree traversal
strategy.
TreeFilter(TreeNodeStream) TreeFilter
TreeFilter(TreeNodeStream, RecognizerSharedState) TreeFilter
TreeFilter.fptr org.antlr.runtime.tree
TreeIterator org.antlr.runtime.tree
Return a node stream from a doubly-linked tree whose nodes
know what child index they are.
TreeIterator(Object) TreeIterator
TreeIterator(TreeAdaptor, Object) TreeIterator
TreeNodeStream org.antlr.runtime.tree
A stream of tree nodes, accessing nodes from a tree of some kind
TreeParser org.antlr.runtime.tree
A parser for a stream of tree nodes.
TreeParser(TreeNodeStream) TreeParser
TreeParser(TreeNodeStream, RecognizerSharedState) TreeParser
treeParserPath gUnitBaseTest
TreePatternLexer org.antlr.runtime.tree
TreePatternLexer(String) TreePatternLexer
TreePatternParser org.antlr.runtime.tree
TreePatternParser(TreePatternLexer, TreeWizard, TreeAdaptor) TreePatternParser
TreeRewriter org.antlr.runtime.tree
TreeRewriter(TreeNodeStream) TreeRewriter
TreeRewriter(TreeNodeStream, RecognizerSharedState) TreeRewriter
TreeRewriter.fptr org.antlr.runtime.tree
treeRoot() ANTLRParser
treeRule gUnitTestSuite
TreeRuleReturnScope org.antlr.runtime.tree
This is identical to the ParserRuleReturnScope except that
the start property is a tree nodes not Token object
when you are parsing trees.
TreeRuleReturnScope() TreeRuleReturnScope
TreeToNFAConverter org.antlr.grammar.v2
Build an NFA from a tree representing an ANTLR grammar.
TreeToNFAConverter(Grammar, NFA, NFAFactory) TreeToNFAConverter
TreeToNFAConverter() TreeToNFAConverter
TreeToNFAConverterTokenTypes org.antlr.grammar.v2
treeToUniqueIDMap BaseTreeAdaptor
System.identityHashCode() is not always unique; we have to
track ourselves.
TreeVisitor org.antlr.runtime.tree
Do a depth first walk of a tree, applying pre() and post() actions
as we discover and finish nodes.
TreeVisitor(TreeAdaptor) TreeVisitor
TreeVisitor() TreeVisitor
TreeVisitorAction org.antlr.runtime.tree
How to execute code for node t when a visitor visits node t.
TreeWizard org.antlr.runtime.tree
Build and navigate trees with this object.
TreeWizard(TreeAdaptor) TreeWizard
During fillBuffer(), we can make a reverse index from a set
of token types of interest to the list of indexes into the
node stream.
TreeWizard(TreeAdaptor, Map) TreeWizard
TreeWizard(TreeAdaptor, String[]) TreeWizard
TreeWizard(String[]) TreeWizard
TreeWizard.ContextVisitor org.antlr.runtime.tree
TreeWizard.TreePattern org.antlr.runtime.tree
When using %label:TOKENNAME in a tree for parse(), we must
track the label.
TreeWizard.TreePattern(Token) TreeWizard.TreePattern
TreeWizard.TreePatternTreeAdaptor org.antlr.runtime.tree
This adaptor creates TreePattern objects for use during scan()
TreeWizard.TreePatternTreeAdaptor() TreeWizard.TreePatternTreeAdaptor
TreeWizard.Visitor org.antlr.runtime.tree
TreeWizard.Visitor() TreeWizard.Visitor
TreeWizard.WildcardTreePattern org.antlr.runtime.tree
TreeWizard.WildcardTreePattern(Token) TreeWizard.WildcardTreePattern
trim(int[], int) Profiler
trimGrammar() DefineGrammarItemsWalker
Remove any lexer rules from a COMBINED; already passed to lexer
trimLexerImportsIntoCombined() CompositeGrammarTree
TRUE DebugEventListener
serialized version of true
TRUE_PRED SemanticContext.Predicate
tryToResolveWithSemanticPredicates(DFAState, Set) NFAToDFAConverter
See if a set of nondeterministic alternatives can be disambiguated
with the semantic predicate contexts of the alternatives.
ttype TreePatternParser
turnOffOtherAlts(DFAState, int, Set<Integer>) NFAToDFAConverter
turn off all states associated with alts other than the good one
(as long as they are one of the nondeterministic ones)
txtEditor WorkSpaceView
type ClassicToken
type CommonToken
type RemoteDebugEventSocketListener.ProxyTree
type RecognizerSharedState
The token type for the current token
type SerializedGrammar
type Attribute
The type; might be empty such as for Python which has no static typing
type Grammar.LabelElementPair
type Grammar
What type of grammar is this: lexer, parser, tree walker
typeToStringLiteralList CompositeGrammar
Reverse index for stringLiteralToTypeMap
typeToTokenList CompositeGrammar
Map a token type to its token name.