All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AbstractEqualityComparator<T> |
This abstract base class is provided so performance-critical applications can
use virtual- instead of interface-dispatch when calling comparator methods.
|
| AbstractParseTreeVisitor<T> |
|
| AbstractPredicateTransition |
|
| Action |
|
| ActionAST |
|
| ActionChunk |
|
| ActionSniffer |
Find token and rule refs plus refs to them in actions;
side-effect: update Alternatives
|
| ActionSplitter |
|
| ActionSplitterListener |
|
| ActionTemplate |
|
| ActionText |
|
| ActionTransition |
|
| ActionTranslator |
|
| AddToLabelList |
|
| AltAST |
Any ALT (which can be child of ALT_REWRITE node)
|
| AltBlock |
|
| Alternative |
An outermost alternative for a rule.
|
| AltLabelStructDecl |
A StructDecl to handle a -> label on alt
|
| AmbiguityInfo |
This class represents profiling event information for an ambiguity.
|
| AnalysisPipeline |
|
| Antlr4ErrorLog |
This implementation of ANTLRToolListener reports messages to the
Log instance provided by Maven. |
| Antlr4Mojo |
Parses ANTLR 4 grammar files *.g4 and transforms them into Java
source files.
|
| ANTLRErrorListener |
How to emit recognition errors.
|
| ANTLRErrorStrategy |
The interface for defining strategies to deal with syntax errors encountered
during a parse by ANTLR-generated parsers.
|
| ANTLRFileStream |
This is an ANTLRInputStream that is loaded from a file all at once
when you construct the object. |
| ANTLRInputStream |
|
| ANTLRLexer |
Read in an ANTLR grammar and build an AST.
|
| ANTLRMessage |
|
| ANTLRParser |
The definitive ANTLR v3 grammar to parse ANTLR v4 grammars.
|
| ANTLRParser.action_return |
|
| ANTLRParser.actionElement_return |
|
| ANTLRParser.actionScopeName_return |
|
| ANTLRParser.alternative_return |
|
| ANTLRParser.alternativeEntry_return |
|
| ANTLRParser.altList_return |
|
| ANTLRParser.atom_return |
|
| ANTLRParser.block_return |
|
| ANTLRParser.blockEntry_return |
|
| ANTLRParser.blockSet_return |
|
| ANTLRParser.blockSuffix_return |
|
| ANTLRParser.channelsSpec_return |
|
| ANTLRParser.delegateGrammar_return |
|
| ANTLRParser.delegateGrammars_return |
|
| ANTLRParser.ebnf_return |
|
| ANTLRParser.ebnfSuffix_return |
|
| ANTLRParser.element_return |
|
| ANTLRParser.elementEntry_return |
|
| ANTLRParser.elementOption_return |
|
| ANTLRParser.elementOptions_return |
|
| ANTLRParser.exceptionGroup_return |
|
| ANTLRParser.exceptionHandler_return |
|
| ANTLRParser.finallyClause_return |
|
| ANTLRParser.grammarSpec_return |
|
| ANTLRParser.grammarType_return |
|
| ANTLRParser.id_return |
|
| ANTLRParser.labeledAlt_return |
|
| ANTLRParser.labeledElement_return |
|
| ANTLRParser.labeledLexerElement_return |
|
| ANTLRParser.lexerAlt_return |
|
| ANTLRParser.lexerAltList_return |
|
| ANTLRParser.lexerAtom_return |
|
| ANTLRParser.lexerBlock_return |
|
| ANTLRParser.lexerCommand_return |
|
| ANTLRParser.lexerCommandExpr_return |
|
| ANTLRParser.lexerCommandName_return |
|
| ANTLRParser.lexerCommands_return |
|
| ANTLRParser.lexerElement_return |
|
| ANTLRParser.lexerElements_return |
|
| ANTLRParser.lexerRule_return |
|
| ANTLRParser.lexerRuleBlock_return |
|
| ANTLRParser.localsSpec_return |
|
| ANTLRParser.modeSpec_return |
|
| ANTLRParser.notSet_return |
|
| ANTLRParser.option_return |
|
| ANTLRParser.optionsSpec_return |
|
| ANTLRParser.optionValue_return |
|
| ANTLRParser.parserRule_return |
|
| ANTLRParser.prequelConstruct_return |
|
| ANTLRParser.qid_return |
|
| ANTLRParser.range_return |
|
| ANTLRParser.rule_return |
|
| ANTLRParser.ruleAction_return |
|
| ANTLRParser.ruleAltList_return |
|
| ANTLRParser.ruleBlock_return |
|
| ANTLRParser.ruleEntry_return |
|
| ANTLRParser.rulePrequel_return |
|
| ANTLRParser.rulePrequels_return |
|
| ANTLRParser.ruleref_return |
|
| ANTLRParser.ruleReturns_return |
|
| ANTLRParser.rules_return |
|
| ANTLRParser.setElement_return |
|
| ANTLRParser.sync_return |
|
| ANTLRParser.terminal_return |
|
| ANTLRParser.throwsSpec_return |
|
| ANTLRParser.tokensSpec_return |
|
| ANTLRParser.v3tokenSpec_return |
|
| ANTLRParser.wildcard_return |
|
| ANTLRToolListener |
Defines behavior of object able to handle error messages from ANTLR including
both tool errors like "can't write file" and grammar ambiguity warnings.
|
| ArgAction |
|
| ArgRef |
|
| Array2DHashSet<T> |
Set implementation with closed hashing (open addressing). |
| ArrayPredictionContext |
|
| ATN |
|
| ATNBuilder |
|
| ATNBuilder.atom_return |
|
| ATNBuilder.blockSet_return |
|
| ATNBuilder.element_return |
|
| ATNBuilder.lexerCommandExpr_return |
|
| ATNBuilder.setElement_return |
|
| ATNBuilder.subrule_return |
|
| ATNBuilder.terminal_return |
|
| ATNConfig |
A tuple: (ATN state, predicted alt, syntactic, semantic context).
|
| ATNConfigSet |
Specialized Set<ATNConfig> that can track
info about the set, with support for combining similar configurations using a
graph-structured stack. |
| ATNConfigSet.AbstractConfigHashSet |
|
| ATNConfigSet.ConfigEqualityComparator |
|
| ATNConfigSet.ConfigHashSet |
The reason that we need this is because we don't want the hash map to use
the standard hash code and equals.
|
| ATNDeserializationOptions |
|
| ATNDeserializer |
|
| ATNFactory |
|
| ATNFactory.Handle |
A pair of states pointing to the left/right (start and end) states of a
state submachine.
|
| ATNOptimizer |
|
| ATNPrinter |
An ATN walker that knows how to dump them to serialized strings.
|
| ATNSerializer |
|
| ATNSimulator |
|
| ATNState |
The following images show the relation of states and
ATNState.transitions for various grammar constructs. |
| ATNType |
Represents the type of recognizer an ATN applies to.
|
| ATNVisitor |
A simple visitor that walks everywhere it can go starting from s,
without going into an infinite cycle.
|
| AtomTransition |
TODO: make all transitions sets? no, should remove set edges
|
| Attribute |
Track the names of attributes defined in arg lists, return values,
scope blocks etc...
|
| AttributeChecks |
Trigger checks for various kinds of attribute expressions.
|
| AttributeDecl |
|
| AttributeDict |
Track the attributes within retval, arg lists etc...
|
| AttributeDict.DictType |
|
| AttributeResolver |
Grammars, rules, and alternatives all have symbols visible to
actions.
|
| BailErrorStrategy |
|
| BaseErrorListener |
|
| BaseListenerFile |
|
| BaseVisitorFile |
|
| BasicBlockStartState |
|
| BasicFontMetrics |
Font metrics.
|
| BasicSemanticChecks |
No side-effects except for setting options into the appropriate node.
|
| BasicState |
|
| BlankActionSplitterListener |
|
| BlankOutputModelFactory |
|
| BlockAST |
|
| BlockEndState |
Terminal node of a simple (a|b|c) block.
|
| BlockSetTransformer |
|
| BlockSetTransformer.blockSet_return |
|
| BlockSetTransformer.ebnfBlockSet_return |
|
| BlockSetTransformer.ebnfSuffix_return |
|
| BlockSetTransformer.elementOption_return |
|
| BlockSetTransformer.elementOptions_return |
|
| BlockSetTransformer.setAlt_return |
|
| BlockSetTransformer.setElement_return |
|
| BlockSetTransformer.topdown_return |
|
| BlockStartState |
The start of a regular (...) block.
|
| BufferedTokenStream |
This implementation of TokenStream loads tokens from a
TokenSource on-demand, and places the tokens in a buffer to provide
access to any previous token by index. |
| BuildDependencyGenerator |
Given a grammar file, show the dependencies on .tokens etc...
|
| CaptureNextToken |
|
| CaptureNextTokenType |
|
| CharStream |
A source of characters for an ANTLR lexer.
|
| CharSupport |
|
| Choice |
The class hierarchy underneath SrcOp is pretty deep but makes sense that,
for example LL1StarBlock is a kind of LL1Loop which is a kind of Choice.
|
| CodeBlock |
|
| CodeBlockForAlt |
Contains Rewrite block (usually as last op)
|
| CodeBlockForOuterMostAlt |
The code associated with the outermost alternative of a rule.
|
| CodeGenerator |
General controller for code gen.
|
| CodeGeneratorExtension |
Filter list of SrcOps and return; default is pass-through filter
|
| CodeGenPipeline |
|
| CommonToken |
|
| CommonTokenFactory |
|
| CommonTokenStream |
|
| ConsoleErrorListener |
|
| ContextGetterDecl |
|
| ContextRuleGetterDecl |
public XContext X() { }
|
| ContextRuleListGetterDecl |
public List<XContext> X() { }
public XContext X(int i) { }
|
| ContextRuleListIndexedGetterDecl |
|
| ContextSensitivityInfo |
This class represents profiling event information for a context sensitivity.
|
| ContextTokenGetterDecl |
public Token X() { }
|
| ContextTokenListGetterDecl |
public List<Token> X() { }
public Token X(int i) { }
|
| ContextTokenListIndexedGetterDecl |
|
| CppTarget |
|
| CSharpTarget |
|
| dbg |
|
| DecisionEventInfo |
This is the base class for gathering detailed information about prediction
events which occur during parsing.
|
| DecisionInfo |
This class contains profiling gathered for a particular decision.
|
| DecisionState |
|
| Decl |
|
| DefaultErrorStrategy |
This is the default implementation of ANTLRErrorStrategy used for
error reporting and recovery in ANTLR parsers. |
| DefaultOutputModelFactory |
Create output objects for elements *within* rule functions except
buildOutputModel() which builds outer/root model object and any
objects such as RuleFunction that surround elements in rule
functions.
|
| DefaultToolListener |
|
| DFA |
|
| DFASerializer |
A DFA walker that knows how to dump them to serialized strings.
|
| DFAState |
A DFA state represents a set of possible ATN configurations.
|
| DFAState.PredPrediction |
Map a predicate to a predicted alternative.
|
| DiagnosticErrorListener |
This implementation of ANTLRErrorListener can be used to identify
certain potential correctness and performance problems in grammars. |
| DispatchMethod |
|
| DOTGenerator |
The DOT (part of graphviz) generation aspect.
|
| DoubleKeyMap<Key1,Key2,Value> |
Sometimes we need to map a key to a value but key is two pieces of data.
|
| ElementFrequenciesVisitor |
|
| ElementListDecl |
|
| EmptyPredictionContext |
|
| EpsilonTransition |
|
| EqualityComparator<T> |
This interface provides an abstract concept of object equality independent of
Object.equals(java.lang.Object) (object equality) and the == operator
(reference equality). |
| ErrorInfo |
This class represents profiling event information for a syntax error
identified during prediction.
|
| ErrorManager |
|
| ErrorNode |
|
| ErrorNodeImpl |
Represents a token that was consumed during resynchronization
rather than during a valid match operation.
|
| ErrorSeverity |
Abstracts away the definition of Message severity and the text that should
display to represent that severity if there is no StringTemplate available
to do it.
|
| ErrorType |
A complex enumeration of all the error messages that the tool can issue.
|
| ExceptionClause |
|
| FailedPredicateException |
A semantic predicate failed during validation.
|
| FlexibleHashMap<K,V> |
A limited map (many unsupported operations) that lets me use
varying hashCode/equals.
|
| FlexibleHashMap.Entry<K,V> |
|
| FrequencySet<T> |
Count how many of each key we have; not thread safe
|
| GoTarget |
|
| GoTarget.JavaStringRenderer |
|
| Grammar |
|
| GrammarAST |
|
| GrammarASTAdaptor |
|
| GrammarASTErrorNode |
A node representing erroneous token range in token stream
|
| GrammarASTVisitor |
A simple visitor, based upon the classic double dispatch method,
for walking GrammarAST trees resulting from parsing ANTLR grammars.
|
| GrammarASTWithOptions |
|
| GrammarInterpreterRuleContext |
|
| GrammarParserInterpreter |
A heavier weight ParserInterpreter that creates parse trees
that track alternative numbers for subtree roots. |
| GrammarParserInterpreter.BailButConsumeErrorStrategy |
We want to stop and track the first error but we cannot bail out like
BailErrorStrategy as consume() constructs trees. |
| GrammarRootAST |
|
| GrammarSemanticsMessage |
A problem with the symbols and/or meaning of a grammar such as rule
redefinition.
|
| GrammarSyntaxMessage |
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"
|
| GrammarToken |
A CommonToken that can also track it's original location,
derived from options on the element ref like BEGIN<line=34,...>.
|
| GrammarTransformPipeline |
Handle left-recursion and block-set transforms
|
| GrammarTreeVisitor |
The definitive ANTLR v3 tree grammar to walk/visit ANTLR v4 grammars.
|
| GrammarTreeVisitor.action_return |
|
| GrammarTreeVisitor.actionElement_return |
|
| GrammarTreeVisitor.alternative_return |
|
| GrammarTreeVisitor.astOperand_return |
|
| GrammarTreeVisitor.atom_return |
|
| GrammarTreeVisitor.block_return |
|
| GrammarTreeVisitor.blockSet_return |
|
| GrammarTreeVisitor.blockSuffix_return |
|
| GrammarTreeVisitor.channelSpec_return |
|
| GrammarTreeVisitor.channelsSpec_return |
|
| GrammarTreeVisitor.delegateGrammar_return |
|
| GrammarTreeVisitor.delegateGrammars_return |
|
| GrammarTreeVisitor.ebnfSuffix_return |
|
| GrammarTreeVisitor.element_return |
|
| GrammarTreeVisitor.elementOption_return |
|
| GrammarTreeVisitor.elementOptions_return |
|
| GrammarTreeVisitor.exceptionGroup_return |
|
| GrammarTreeVisitor.exceptionHandler_return |
|
| GrammarTreeVisitor.finallyClause_return |
|
| GrammarTreeVisitor.grammarSpec_return |
|
| GrammarTreeVisitor.labeledElement_return |
|
| GrammarTreeVisitor.labeledLexerElement_return |
|
| GrammarTreeVisitor.lexerAlternative_return |
|
| GrammarTreeVisitor.lexerAtom_return |
|
| GrammarTreeVisitor.lexerBlock_return |
|
| GrammarTreeVisitor.lexerCommand_return |
|
| GrammarTreeVisitor.lexerCommandExpr_return |
|
| GrammarTreeVisitor.lexerElement_return |
|
| GrammarTreeVisitor.lexerElements_return |
|
| GrammarTreeVisitor.lexerOuterAlternative_return |
|
| GrammarTreeVisitor.lexerRule_return |
|
| GrammarTreeVisitor.lexerRuleBlock_return |
|
| GrammarTreeVisitor.lexerSubrule_return |
|
| GrammarTreeVisitor.locals_return |
|
| GrammarTreeVisitor.mode_return |
|
| GrammarTreeVisitor.option_return |
|
| GrammarTreeVisitor.optionsSpec_return |
|
| GrammarTreeVisitor.optionValue_return |
|
| GrammarTreeVisitor.outerAlternative_return |
|
| GrammarTreeVisitor.prequelConstruct_return |
|
| GrammarTreeVisitor.prequelConstructs_return |
|
| GrammarTreeVisitor.range_return |
|
| GrammarTreeVisitor.rule_return |
|
| GrammarTreeVisitor.ruleAction_return |
|
| GrammarTreeVisitor.ruleBlock_return |
|
| GrammarTreeVisitor.ruleModifier_return |
|
| GrammarTreeVisitor.ruleref_return |
|
| GrammarTreeVisitor.ruleReturns_return |
|
| GrammarTreeVisitor.rules_return |
|
| GrammarTreeVisitor.setElement_return |
|
| GrammarTreeVisitor.subrule_return |
|
| GrammarTreeVisitor.terminal_return |
|
| GrammarTreeVisitor.throwsSpec_return |
|
| GrammarTreeVisitor.tokenSpec_return |
|
| GrammarTreeVisitor.tokensSpec_return |
|
| Graph<T> |
A generic graph with edges; Each node as a single Object payload.
|
| Graph.Node<T> |
|
| GraphicsSupport |
|
| HelpMojo |
Display help information on antlr4-maven-plugin.
Call mvn antlr4:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.
|
| InputMismatchException |
This signifies any kind of mismatched input exceptions such as
when the current input does not match the expected token.
|
| IntegerList |
|
| IntegerStack |
|
| InterpreterRuleContext |
|
| Interval |
An immutable inclusive interval a..b
|
| IntervalSet |
This class implements the IntSet backed by a sorted array of
non-overlapping intervals. |
| IntSet |
A generic set of integers.
|
| IntStream |
A simple stream of symbols whose values are represented as integers.
|
| InvokeRule |
|
| IterativeParseTreeWalker |
An iterative (read: non-recursive) pre-order and post-order tree walker that
doesn't use the thread stack but heap-based stacks.
|
| JavaScriptTarget |
|
| JavaScriptTarget.JavaStringRenderer |
|
| JavaTarget |
|
| JavaTarget.JavaStringRenderer |
|
| JFileChooserConfirmOverwrite |
|
| LabeledOp |
All the rule elements we can label like tokens, rules, sets, wildcard.
|
| LabelElementPair |
|
| LabelRef |
|
| LabelType |
the various kinds of labels.
|
| LeftRecursionCyclesMessage |
|
| LeftRecursionDetector |
|
| LeftRecursiveRule |
|
| LeftRecursiveRuleAltInfo |
|
| LeftRecursiveRuleAnalyzer |
Using a tree walker on the rules, determine if a rule is directly left-recursive and if it follows
our pattern.
|
| LeftRecursiveRuleAnalyzer.ASSOC |
|
| LeftRecursiveRuleFunction |
|
| LeftRecursiveRuleTransformer |
Remove left-recursive rule refs, add precedence args to recursive rule refs.
|
| LeftRecursiveRuleWalker |
Find left-recursive rules
|
| LeftRecursiveRuleWalker.outerAlternative_return |
|
| LeftRecursiveRuleWalker.ruleBlock_return |
|
| Lexer |
|
| Lexer |
A lexer is recognizer that draws input symbols from a character stream.
|
| LexerAction |
Represents a single action which can be executed following the successful
match of a lexer rule.
|
| LexerActionExecutor |
Represents an executor for a sequence of lexer actions which traversed during
the matching operation of a lexer rule (token).
|
| LexerActionType |
|
| LexerATNConfig |
|
| LexerATNFactory |
|
| LexerATNSimulator |
"dup" of ParserInterpreter
|
| LexerATNSimulator.SimState |
When we hit an accept state in either the DFA or the ATN, we
have to notify the character stream to start buffering characters
via IntStream.mark() and record the current state. |
| LexerChannelAction |
|
| LexerCustomAction |
|
| LexerDFASerializer |
|
| LexerFactory |
|
| LexerFile |
|
| LexerGrammar |
|
| LexerIndexedCustomAction |
|
| LexerInterpreter |
|
| LexerModeAction |
Implements the mode lexer action by calling Lexer.mode(int) with
the assigned mode. |
| LexerMoreAction |
|
| LexerNoViableAltException |
|
| LexerPopModeAction |
|
| LexerPushModeAction |
|
| LexerSkipAction |
|
| LexerTypeAction |
|
| ListenerDispatchMethod |
|
| ListenerFile |
A model object representing a parse tree listener file.
|
| ListLabelRef |
|
| ListTokenSource |
Provides an implementation of TokenSource as a wrapper around a list
of Token objects. |
| LL1AltBlock |
(A | B | C)
|
| LL1Analyzer |
|
| LL1Choice |
|
| LL1Loop |
|
| LL1OptionalBlock |
An optional block is just an alternative block where the last alternative
is epsilon.
|
| LL1OptionalBlockSingleAlt |
(A B C)?
|
| LL1PlusBlockSingleAlt |
|
| LL1StarBlockSingleAlt |
|
| LocalRef |
|
| LogManager |
|
| LogManager.Record |
|
| LookaheadEventInfo |
This class represents profiling event information for tracking the lookahead
depth required in order to make a prediction.
|
| Loop |
|
| LoopEndState |
Mark the end of a * or + loop.
|
| MatchNotSet |
|
| MatchSet |
|
| MatchToken |
|
| ModelElement |
Indicate field of OutputModelObject is an element to be walked by
OutputModelWalker.
|
| MultiMap<K,V> |
|
| MurmurHash |
|
| MutableInt |
|
| NonLocalAttrRef |
|
| NotAST |
|
| NotNull |
Deprecated.
|
| NotSetTransition |
|
| NoViableAltException |
Indicates that the parser could not decide which of two or more paths
to take based upon the remaining input.
|
| ObjectEqualityComparator |
|
| OptionalBlock |
|
| OptionalBlockAST |
|
| OrderedATNConfigSet |
|
| OrderedATNConfigSet.LexerConfigHashSet |
|
| OrderedHashMap<K,V> |
I need the get-element-i functionality so I'm subclassing
LinkedHashMap.
|
| OrderedHashSet<T> |
A HashMap that remembers the order that the elements were added.
|
| OutputFile |
|
| OutputModelController |
This receives events from SourceGenTriggers.g and asks factory to do work.
|
| OutputModelFactory |
|
| OutputModelObject |
|
| OutputModelWalker |
Convert an output model tree to template hierarchy by walking
the output model.
|
| Pair<A,B> |
|
| ParseCancellationException |
This exception is thrown to cancel a parsing operation.
|
| ParseInfo |
This class provides access to specific and aggregate statistics gathered
during profiling of a parser.
|
| Parser |
|
| Parser |
This is all the parsing support code essentially; most of it is error recovery stuff.
|
| Parser.TrimToSizeListener |
|
| ParserATNFactory |
ATN construction routines triggered by ATNBuilder.g.
|
| ParserATNSimulator |
The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
|
| ParserFactory |
|
| ParserFile |
|
| ParserInterpreter |
A parser simulator that mimics what ANTLR's generated
parser code does.
|
| ParserRuleContext |
A rule invocation record for parsing.
|
| ParseTree |
An interface to access the tree of RuleContext objects created
during a parse that makes the data structure look like a simple parse tree. |
| ParseTreeListener |
This interface describes the minimal core of methods triggered
by ParseTreeWalker. |
| ParseTreeMatch |
Represents the result of matching a ParseTree against a tree pattern. |
| ParseTreePattern |
|
| ParseTreePatternMatcher |
A tree pattern matching mechanism for ANTLR ParseTrees. |
| ParseTreePatternMatcher.CannotInvokeStartRule |
|
| ParseTreePatternMatcher.StartRuleDoesNotConsumeFullPattern |
|
| ParseTreeProperty<V> |
Associate a property with a parse tree node.
|
| ParseTreeVisitor<T> |
This interface defines the basic notion of a parse tree visitor.
|
| ParseTreeWalker |
|
| PlusBlock |
|
| PlusBlockAST |
|
| PlusBlockStartState |
Start of (A|B|...)+ loop.
|
| PlusLoopbackState |
Decision state for A+ and (A|B)+.
|
| PostScriptDocument |
|
| PrecedencePredicateTransition |
|
| PredAST |
|
| Predicate<T> |
|
| PredicateEvalInfo |
This class represents profiling event information for semantic predicate
evaluations which occur during prediction.
|
| PredicateTransition |
TODO: this is old comment:
A tree of semantic predicates from the grammar AST if label==SEMPRED.
|
| PredictionContext |
|
| PredictionContextCache |
|
| PredictionMode |
This enumeration defines the prediction modes available in ANTLR 4 along with
utility methods for analyzing configuration sets for conflicts and/or
ambiguities.
|
| ProfilingATNSimulator |
|
| ProxyErrorListener |
This implementation of ANTLRErrorListener dispatches all calls to a
collection of delegate listeners. |
| Python2Target |
|
| Python2Target.PythonStringRenderer |
|
| Python3Target |
|
| Python3Target.PythonStringRenderer |
|
| QRetValueRef |
|
| QuantifierAST |
|
| RangeAST |
|
| RangeTransition |
|
| RecognitionException |
The root of the ANTLR exception hierarchy.
|
| Recognizer |
|
| Recognizer<Symbol,ATNInterpreter extends ATNSimulator> |
|
| ResyncToEndOfRuleBlock |
Used to throw us out of deeply nested element back to end of a rule's
alt list.
|
| RetValueRef |
|
| Rule |
|
| RuleActionFunction |
|
| RuleAST |
|
| RuleCollector |
|
| RuleContext |
A rule context is a record of a single rule invocation.
|
| RuleContextDecl |
|
| RuleContextListDecl |
|
| RuleContextWithAltNum |
A handy class for use with
options {contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum;}
that provides a backing field / impl for the outer alternative number
matched for an internal parse tree node.
|
| RuleElement |
|
| RuleElementAST |
Tag indicated AST node is a rule element like token or rule ref.
|
| RuleFunction |
|
| RuleNode |
|
| RulePropertyRef |
|
| RulePropertyRef_ctx |
|
| RulePropertyRef_parser |
|
| RulePropertyRef_start |
|
| RulePropertyRef_stop |
|
| RulePropertyRef_text |
|
| RuleRefAST |
|
| RuleSempredFunction |
|
| RuleStartState |
|
| RuleStopState |
The last node in the ATN for a rule, unless that rule is the start symbol.
|
| RuleTagToken |
A Token object representing an entire subtree matched by a parser
rule; e.g., <expr>. |
| RuleTransition |
|
| RuntimeMetaData |
This class provides access to the current version of the ANTLR 4 runtime
library as compile-time and runtime constants, along with methods for
checking for matching version numbers and notifying listeners in the case
where a version mismatch is detected.
|
| ScopeParser |
Parse args, return values, locals
|
| SemanticContext |
A tree structure used to record the semantic context in which
an ATN configuration is valid.
|
| SemanticContext.AND |
A semantic context which is true whenever none of the contained contexts
is false.
|
| SemanticContext.Operator |
This is the base class for semantic context "operators", which operate on
a collection of semantic context "operands".
|
| SemanticContext.OR |
A semantic context which is true whenever at least one of the contained
contexts is true.
|
| SemanticContext.PrecedencePredicate |
|
| SemanticContext.Predicate |
|
| SemanticPipeline |
Do as much semantic checking as we can and fill in grammar
with rules, actions, and token definitions.
|
| SemPred |
|
| SerializedATN |
|
| SetAST |
|
| SetAttr |
|
| SetNonLocalAttr |
|
| SetTransition |
A transition containing a set of values.
|
| SingletonPredictionContext |
|
| SourceGenTriggers |
|
| SourceGenTriggers.alt_return |
|
| SourceGenTriggers.alternative_return |
|
| SrcOp |
|
| StarBlock |
|
| StarBlockAST |
|
| StarBlockStartState |
The block that begins a closure loop.
|
| StarLoopbackState |
|
| StarLoopEntryState |
|
| StructDecl |
This object models the structure holding all of the parameters,
return values, local variables, and labels associated with a rule.
|
| SwiftTarget |
|
| SwiftTarget.SwiftStringRenderer |
|
| SymbolChecks |
Check for symbol problems; no side-effects.
|
| SymbolCollector |
Collects (create) rules, terminals, strings, actions, scopes etc...
|
| Sync |
|
| SyntaxTree |
A tree that knows about an interval in a token stream
is some kind of syntax tree.
|
| SystemFontMetrics |
|
| TailEpsilonRemover |
|
| Target |
|
| TerminalAST |
|
| TerminalNode |
|
| TerminalNodeImpl |
|
| TestRig |
Run a lexer/parser combo, optionally printing tree string or generating
postscript file.
|
| TestRig |
Deprecated. |
| TestSetInline |
|
| TestSetInline.Bitset |
|
| ThisRulePropertyRef_ctx |
|
| ThisRulePropertyRef_parser |
|
| ThisRulePropertyRef_start |
|
| ThisRulePropertyRef_stop |
|
| ThisRulePropertyRef_text |
|
| ThrowEarlyExitException |
|
| ThrowNoViableAlt |
|
| ThrowRecognitionException |
|
| Token |
A token has properties: text, type, line, character position in the line
(so we can ignore tabs), token channel, index, and source from which
we obtained this token.
|
| TokenDecl |
x=ID or implicit _tID label
|
| TokenFactory<Symbol extends Token> |
The default mechanism for creating tokens.
|
| TokenListDecl |
|
| TokenPropertyRef |
|
| TokenPropertyRef_channel |
|
| TokenPropertyRef_index |
|
| TokenPropertyRef_int |
|
| TokenPropertyRef_line |
|
| TokenPropertyRef_pos |
|
| TokenPropertyRef_text |
|
| TokenPropertyRef_type |
|
| TokenRef |
|
| TokenSource |
A source of tokens must provide a sequence of tokens via TokenSource.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. |
| TokensStartState |
The Tokens rule start state linking to each lexer rule start state
|
| TokenStream |
|
| TokenStreamRewriter |
Useful for rewriting out a buffered input token stream after doing some
augmentation or other manipulations on it.
|
| TokenTagToken |
A Token object representing a token of a particular type; e.g.,
<ID>. |
| TokenTypeDecl |
|
| TokenVocabParser |
|
| Tool |
|
| Tool.Option |
|
| Tool.OptionArgType |
|
| ToolANTLRLexer |
|
| ToolANTLRParser |
Override error handling for use with ANTLR tool itself; leaves
nothing in grammar associated with Tool so others can use in IDEs, ...
|
| ToolMessage |
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.
|
| Transition |
An ATN transition between any two ATN states.
|
| Tree |
The basic notion of a tree has a parent, a payload, and a list of children.
|
| TreeLayoutAdaptor |
Adaptor ANTLR trees to TreeForTreeLayout.
|
| TreePostScriptGenerator |
|
| Trees |
|
| Trees |
A set of utility routines useful for all kinds of ANTLR trees.
|
| TreeTextProvider |
|
| TreeViewer |
|
| TreeViewer.DefaultTreeTextProvider |
|
| TreeViewer.VariableExtentProvide |
|
| Triple<A,B,C> |
|
| UnbufferedCharStream |
Do not buffer up the entire char stream.
|
| UnbufferedTokenStream<T extends Token> |
|
| UseDefAnalyzer |
Look for errors and deadcode stuff
|
| Utils |
|
| Utils |
|
| Utils.Filter<T> |
|
| Utils.Func0<TResult> |
|
| Utils.Func1<T1,TResult> |
|
| v3TreeGrammarException |
|
| v4ParserException |
|
| VisitorDispatchMethod |
|
| VisitorFile |
|
| Vocabulary |
This interface provides information about the vocabulary used by a
recognizer.
|
| VocabularyImpl |
This class provides a default implementation of the Vocabulary
interface. |
| Wildcard |
|
| WildcardTransition |
|
| WritableToken |
|
| XPath |
Represent a subset of XPath XML path syntax for use in identifying nodes in
parse trees.
|
| XPathElement |
|
| XPathLexer |
|
| XPathLexerErrorListener |
|
| XPathRuleAnywhereElement |
Either ID at start of path or ...//ID in middle of path.
|
| XPathRuleElement |
|
| XPathTokenAnywhereElement |
|
| XPathTokenElement |
|
| XPathWildcardAnywhereElement |
|
| XPathWildcardElement |
|