All Classes

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
ActionTransition
AmbiguityInfo	This class represents profiling event information for an ambiguity.
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	Deprecated. as of 4.7 Please use CharStreams interface.
ANTLRInputStream	Deprecated. as of 4.7 Please use CharStreams interface.
Array2DHashSet<T>	Set implementation with closed hashing (open addressing).
ArrayPredictionContext
ATN
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	Deserialize ATNs for JavaTarget; it's complicated by the fact that java requires that we serialize the list of integers as 16 bit characters in a string.
ATNSerializer	This class represents a target neutral serializer for ATNs.
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.
AtomTransition	TODO: make all transitions sets? no, should remove set edges
BailErrorStrategy	This implementation of ANTLRErrorStrategy responds to syntax errors by immediately canceling the parse operation with a ParseCancellationException.
BaseErrorListener	Provides an empty default implementation of ANTLRErrorListener.
BasicBlockStartState
BasicState
BlockEndState	Terminal node of a simple (a|b|c) block.
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.
CharStream	A source of characters for an ANTLR lexer.
CharStreams	This class represents the primary interface for creating CharStreams from a variety of sources as of 4.7.
CodePointBuffer	Wrapper for ByteBuffer / CharBuffer / IntBuffer.
CodePointBuffer.Builder
CodePointBuffer.Type
CodePointCharStream	Alternative to ANTLRInputStream which treats the input as a series of Unicode code points, instead of a series of UTF-16 code units.
CodePointTransitions	Utility class to create AtomTransition, RangeTransition, and SetTransition appropriately based on the range of the input.
CommonToken
CommonTokenFactory	This default implementation of TokenFactory creates CommonToken objects.
CommonTokenStream	This class extends BufferedTokenStream with functionality to filter token streams to tokens on a particular channel (tokens where Token.getChannel() returns a particular value).
ConsoleErrorListener
ContextSensitivityInfo	This class represents profiling event information for a context sensitivity.
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
DefaultErrorStrategy	This is the default implementation of ANTLRErrorStrategy used for error reporting and recovery in ANTLR parsers.
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.
DoubleKeyMap<Key1,Key2,Value>	Sometimes we need to map a key to a value but key is two pieces of data.
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.
ErrorNode
ErrorNodeImpl	Represents a token that was consumed during resynchronization rather than during a valid match operation.
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>
InputMismatchException	This signifies any kind of mismatched input exceptions such as when the current input does not match the expected token.
IntegerList
IntegerStack
InterpreterDataReader
InterpreterDataReader.InterpreterData
InterpreterRuleContext	This class extends ParserRuleContext by allowing the value of InterpreterRuleContext.getRuleIndex() to be explicitly set for the context.
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.
IterativeParseTreeWalker	An iterative (read: non-recursive) pre-order and post-order tree walker that doesn't use the thread stack but heap-based stacks.
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	Represents the serialization type of a LexerAction.
LexerATNConfig
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	Implements the channel lexer action by calling Lexer.setChannel(int) with the assigned channel.
LexerCustomAction	Executes a custom lexer action by calling Recognizer.action(org.antlr.v4.runtime.RuleContext, int, int) with the rule and action indexes assigned to the custom action.
LexerDFASerializer
LexerIndexedCustomAction	This implementation of LexerAction is used for tracking input offsets for position-dependent actions within a LexerActionExecutor.
LexerInterpreter
LexerModeAction	Implements the mode lexer action by calling Lexer.mode(int) with the assigned mode.
LexerMoreAction	Implements the more lexer action by calling Lexer.more().
LexerNoViableAltException
LexerPopModeAction	Implements the popMode lexer action by calling Lexer.popMode().
LexerPushModeAction	Implements the pushMode lexer action by calling Lexer.pushMode(int) with the assigned mode.
LexerSkipAction	Implements the skip lexer action by calling Lexer.skip().
LexerTypeAction	Implements the type lexer action by calling Lexer.setType(int) with the assigned type.
ListTokenSource	Provides an implementation of TokenSource as a wrapper around a list of Token objects.
LL1Analyzer
LogManager
LogManager.Record
LookaheadEventInfo	This class represents profiling event information for tracking the lookahead depth required in order to make a prediction.
LoopEndState	Mark the end of a * or + loop.
MultiMap<K,V>
MurmurHash
NotNull	Deprecated. THIS IS HERE FOR BACKWARD COMPATIBILITY WITH 4.5 ONLY.
NotSetTransition
NoViableAltException	Indicates that the parser could not decide which of two or more paths to take based upon the remaining input.
ObjectEqualityComparator	This default implementation of EqualityComparator uses object equality for comparisons by calling Object.hashCode() and Object.equals(java.lang.Object).
OrderedATNConfigSet
OrderedATNConfigSet.LexerConfigHashSet
OrderedHashSet<T>	A HashMap that remembers the order that the elements were added.
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	This is all the parsing support code essentially; most of it is error recovery stuff.
Parser.TrimToSizeListener
ParserATNSimulator	The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
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	A pattern like <ID> = <expr>; converted to a ParseTree by ParseTreePatternMatcher.compile(String, int).
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
PlusBlockStartState	Start of (A|B|...)+ loop.
PlusLoopbackState	Decision state for A+ and (A|B)+.
PrecedencePredicateTransition
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	Used to cache PredictionContext objects.
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.
RangeTransition
RecognitionException	The root of the ANTLR exception hierarchy.
Recognizer<Symbol,ATNInterpreter extends ATNSimulator>
RuleContext	A rule context is a record of a single rule invocation.
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.
RuleNode
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.
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.Empty
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
SetTransition	A transition containing a set of values.
SingletonPredictionContext
StarBlockStartState	The block that begins a closure loop.
StarLoopbackState
StarLoopEntryState
SyntaxTree	A tree that knows about an interval in a token stream is some kind of syntax tree.
TerminalNode
TerminalNodeImpl
TestRig	Deprecated.
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.
TokenFactory<Symbol extends Token>	The default mechanism for creating tokens.
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	An IntStream whose symbols are Token instances.
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>.
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.
Trees	A set of utility routines useful for all kinds of ANTLR trees.
Triple<A,B,C>
UnbufferedCharStream	Do not buffer up the entire char stream.
UnbufferedTokenStream<T extends Token>
Utils
Vocabulary	This interface provides information about the vocabulary used by a recognizer.
VocabularyImpl	This class provides a default implementation of the Vocabulary interface.
WildcardTransition
WritableToken
XPath	Represent a subset of XPath XML path syntax for use in identifying nodes in parse trees.
XPathElement
XPathLexer	Mimic the old XPathLexer from .g4 file
XPathLexerErrorListener
XPathRuleAnywhereElement	Either ID at start of path or ...//ID in middle of path.
XPathRuleElement
XPathTokenAnywhereElement
XPathTokenElement
XPathWildcardAnywhereElement
XPathWildcardElement