All Classes and Interfaces
Class
Description
This abstract base class is provided so performance-critical applications can
use virtual- instead of interface-dispatch when calling comparator methods.
Stores information about a
DFAState which is an accept state under
some condition.Find token and rule refs plus refs to them in actions;
side-effect: update Alternatives
Any ALT (which can be child of ALT_REWRITE node)
An outermost alternative for a rule.
A StructDecl to handle a '#' label on alt
This class represents profiling event information for an ambiguity.
This implementation of
ANTLRToolListener reports messages to the
Log instance provided by Maven.Parses ANTLR 4 grammar files
*.g4 and transforms them into Java
source files.How to emit recognition errors.
The interface for defining strategies to deal with syntax errors encountered
during a parse by ANTLR-generated parsers.
Deprecated.
Deprecated.
as of 4.7 Please use
CharStreams interface.Read in an ANTLR grammar and build an AST.
The definitive ANTLR v3 grammar to parse ANTLR v4 grammars.
Defines behavior of object able to handle error messages from ANTLR including
both tool errors like "can't write file" and grammar ambiguity warnings.
Set implementation with closed hashing (open addressing).Represents a location with context in an ATN.
This class was derived from
ATNConfig purely as a memory
optimization.This class was derived from
ATNConfig.SemanticContextATNConfig purely as a memory
optimization.This class was derived from
ATNConfig purely as a memory
optimization.Represents a set of ATN configurations (see
ATNConfig).A pair of states pointing to the left/right (start and end) states of a
state submachine.
Standalone micro-benchmark for ATN hot-path optimizations.
An ATN walker that knows how to dump them to serialized strings.
The following images show the relation of states and
ATNState.transitions for various grammar constructs.Represents the type of recognizer an ATN applies to.
A simple visitor that walks everywhere it can go starting from s,
without going into an infinite cycle.
TODO: make all transitions sets? no, should remove set edges
Track the names of attributes defined in arg lists, return values,
scope blocks etc...
Trigger checks for various kinds of attribute expressions.
Track the attributes within retval, arg lists etc...
Grammars, rules, and alternatives all have symbols visible to
actions.
This implementation of
ANTLRErrorStrategy responds to syntax errors
by immediately canceling the parse operation with a
ParseCancellationException.Provides an empty default implementation of
ANTLRErrorListener.Font metrics.
No side-effects except for setting options into the appropriate node.
Terminal node of a simple
(a|b|c) block.The start of a regular
(...) block.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.Given a grammar file, show the dependencies on .tokens etc...
A source of characters for an ANTLR lexer.
This class represents the primary interface for creating
CharStreams
from a variety of sources as of 4.7.Measures
CharStreams.fromString(String) independently from lexing.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.
A chunk is either a token tag, a rule tag, or a span of literal text within a
tree pattern.
Package-private
int → V map with O(1) empty ClearableIntObjectHashMap.clear().Package-private
long → V open-addressed map with O(1) empty
ClearableLongObjectHashMap.clear(), used as the ATN config merge index.Contains Rewrite block (usually as last op)
The code associated with the outermost alternative of a rule.
General controller for code gen.
Filter list of SrcOps and return; default is pass-through filter
Alternative to
ANTLRInputStream which treats the input
as a series of Unicode code points, instead of a series of UTF-16
code units.Utility class to create
AtomTransition, RangeTransition,
and SetTransition appropriately based on the range of the input.This default implementation of
TokenFactory creates
CommonToken objects.This class extends
BufferedTokenStream with functionality to filter
token streams to tokens on a particular channel (tokens where
Token.getChannel() returns a particular value).Deterministic, machine-readable end-to-end harness for A/B performance
verification across commits.
Thread-safe
int → int map for rare-write / frequent-read workloads.JDK
ConcurrentMap view over ConcurrentIntIntMap.This class stores information about a configuration conflict.
public XContext X() { }public List<XContext> X() { }
public XContext X(int i) { }This class represents profiling event information for a context sensitivity.
public Token X() { }public List<Token> X() { }
public Token X(int i) { }Loads the ANTLR Java runtime sources that are already packaged as
resources of
antlr4-perf-testsuite (see ../runtime resource
directory in the module POM).This is the base class for gathering detailed information about prediction
events which occur during parsing.
This class contains profiling gathered for a particular decision.
This is the default implementation of
ANTLRErrorStrategy used for
error reporting and recovery in ANTLR parsers.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.
A DFA walker that knows how to dump them to serialized strings.
A DFA state represents a set of possible ATN configurations.
Map a predicate to a predicted alternative.
This implementation of
ANTLRErrorListener can be used to identify
certain potential correctness and performance problems in grammars.The DOT (part of graphviz) generation aspect.
Sometimes we need to map a key to a value but key is two pieces of data.
This implementation of
AbstractEdgeMap represents an empty edge map.Epsilon-closure engine for adaptive LL(*) prediction.
This interface provides an abstract concept of object equality independent of
Object.equals(java.lang.Object) (object equality) and the == operator
(reference equality).This class represents profiling event information for a syntax error
identified during prediction.
Represents a token that was consumed during resynchronization
rather than during a valid match operation.
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.
A complex enumeration of all the error messages that the tool can issue.
Utility class to parse escapes like:
\\n
\\uABCD
\\u{10ABCD}
\\p{Foo}
\\P{Bar}
\\p{Baz=Blech}
\\P{Baz=Blech}
A semantic predicate failed during validation.
A limited map (many unsupported operations) that lets me use
varying hashCode/equals.
Count how many of each key we have; not thread safe
A node representing erroneous token range in token stream
A simple visitor, based upon the classic double dispatch method,
for walking GrammarAST trees resulting from parsing ANTLR grammars.
An
InterpreterRuleContext that knows which alternative
for a rule was matched.A heavier weight
ParserInterpreter that creates parse trees
that track alternative numbers for subtree roots.We want to stop and track the first error but we cannot bail out like
BailErrorStrategy as consume() constructs trees.A problem with the symbols and/or meaning of a grammar such as rule
redefinition.
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"
A CommonToken that can also track it's original location,
derived from options on the element ref like BEGIN<line=34,...>.
Handle left-recursion and block-set transforms
The definitive ANTLR v3 tree grammar to walk/visit ANTLR v4 grammars.
A generic graph with edges; Each node as a single Object payload.
This class provides an empty implementation of
graphemesListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
graphemesParser.Synthetic sources accepted by
GroovyLike.g4: nls/sep, fields,
methods, left-recursive expressions, elvis, closures, and postfix calls.This class provides an empty implementation of
GroovyLikeListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
GroovyLikeParser.Serial + parallel Groovy-like parse harness.
Groovy-like serial/parallel parse helpers.
Sparse open-addressed edge map used while a DFA state has only a few outgoing
edges.
Display help information on antlr4-maven-plugin.
Call
Call
mvn antlr4:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.Display help information on antlr4-testgen-maven-plugin.
Call
Call
mvn antlr4-testgen:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.This signifies any kind of mismatched input exceptions such as
when the current input does not match the expected token.
Just a hook so we can call
Instrumentation
methods like sizeof().This class extends
ParserRuleContext by allowing the value of
InterpreterRuleContext.getRuleIndex() to be explicitly set for the context.An immutable inclusive interval a..b
This class implements the
IntSet backed by a sorted array of
non-overlapping intervals.A generic set of integers.
A simple stream of symbols whose values are represented as integers.
This class provides an empty implementation of
JavaListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
JavaParser.JMH black-box benchmarks for the optimized-fork Java runtime.
All the rule elements we can label like tokens, rules, sets, wildcard.
the various kinds of labels.
Using a tree walker on the rules, determine if a rule is directly left-recursive and if it follows
our pattern.
Remove left-recursive rule refs, add precedence args to recursive rule refs.
Find left-recursive rules
A lexer is recognizer that draws input symbols from a character stream.
Represents a single action which can be executed following the successful
match of a lexer rule.
Represents an executor for a sequence of lexer actions which traversed during
the matching operation of a lexer rule (token).
Represents the serialization type of a
LexerAction.ATN interpreter for lexers.
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.Implements the
channel lexer action by calling
Lexer.setChannel(int) with the assigned channel.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.This implementation of
LexerAction is used for tracking input offsets
for position-dependent actions within a LexerActionExecutor.Implements the
mode lexer action by calling Lexer.mode(int) with
the assigned mode.Implements the
more lexer action by calling Lexer.more().Implements the
popMode lexer action by calling Lexer.popMode().Implements the
pushMode lexer action by calling
Lexer.pushMode(int) with the assigned mode.Implements the
skip lexer action by calling Lexer.skip().Implements the
type lexer action by calling Lexer.setType(int)
with the assigned type.A model object representing a parse tree listener file.
Provides an implementation of
TokenSource as a wrapper around a list
of Token objects.(A | B | C)
An optional block is just an alternative block where the last alternative
is epsilon.
(A B C)?
This class represents profiling event information for tracking the lookahead
depth required in order to make a prediction.
Mark the end of a * or + loop.
Indicate field of OutputModelObject is an element to be walked by
OutputModelWalker.
This annotation marks a field, parameter, local variable, or method (return
value) as never being
null.Indicates that the parser could not decide which of two or more paths
to take based upon the remaining input.
This annotation marks a field, parameter, local variable, or method (return
value) as potentially having the value
null.This default implementation of
EqualityComparator uses object equality
for comparisons by calling Object.hashCode() and Object.equals(java.lang.Object).Package-private JDK
Set over an open-addressed HPPC table with
O(1) empty OpenAddressedHashSet.clear().Lexer configuration set that merges configs only when they are fully equal
(including prediction context and lexer actions), preserving first-match
preference order among alternatives.
I need the get-element-i functionality so I'm subclassing
LinkedHashMap.
A HashMap that remembers the order that the elements were added.
This receives events from SourceGenTriggers.g and asks factory to do work.
Convert an output model tree to template hierarchy by walking
the output model.
This exception is thrown to cancel a parsing operation.
This class provides access to specific and aggregate statistics gathered
during profiling of a parser.
Tight parse loop for throughput A/B and async-profiler.
This is all the parsing support code essentially; most of it is error recovery stuff.
ATN construction routines triggered by ATNBuilder.g.
The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
How to emit recognition errors for parsers.
A parser simulator that mimics what ANTLR's generated
parser code does.
A rule invocation record for parsing.
An interface to access the tree of
RuleContext objects created
during a parse that makes the data structure look like a simple parse tree.This interface describes the minimal core of methods triggered
by
ParseTreeWalker.Represents the result of matching a
ParseTree against a tree pattern.A pattern like
<ID> = <expr>; converted to a ParseTree by
ParseTreePatternMatcher.compile(String, int).A tree pattern matching mechanism for ANTLR
ParseTrees.Associate a property with a parse tree node.
This interface defines the basic notion of a parse tree visitor.
Shared parse/lex helpers for JMH and the comparative harness.
Lexer/parser factory for one generated language front end.
Start of
(A|B|...)+ loop.Decision state for
A+ and (A|B)+.This class represents profiling event information for semantic predicate
evaluations which occur during prediction.
TODO: this is old comment:
A tree of semantic predicates from the grammar AST if label==SEMPRED.
Used to cache
PredictionContext objects.Shared equality/hash contract for (
PredictionContext, int)
keys used by PredictionContextCache.getChild(org.antlr.v4.runtime.atn.PredictionContext, int).Mutable probe for
PredictionContextCache.getChild(org.antlr.v4.runtime.atn.PredictionContext, int) lookups.Immutable identity-based commutative key for a pair of
PredictionContext instances.Shared equality/hash contract for identity-based commutative pairs of
PredictionContext used by PredictionContextCache.join(org.antlr.v4.runtime.atn.PredictionContext, org.antlr.v4.runtime.atn.PredictionContext) and by
ArrayPredictionContext equality.This enumeration defines the prediction modes available in ANTLR 4 along with
utility methods for analyzing configuration sets for conflicts and/or
ambiguities.
A Map that uses just the state and the stack context as the key.
This implementation of
ANTLRErrorListener dispatches all calls to a
collection of delegate listeners.Package-private reach / target-state engine for adaptive LL(*) prediction.
Random-access view of ATN configurations for a single
ParserATNSimulator.computeTargetState(org.antlr.v4.runtime.dfa.DFA, org.antlr.v4.runtime.dfa.DFAState, org.antlr.v4.runtime.ParserRuleContext, int, boolean, org.antlr.v4.runtime.atn.PredictionContextCache) invocation.The root of the ANTLR exception hierarchy.
Used to throw us out of deeply nested element back to end of a rule's
alt list.
Lazily allocated, capacity-preserving scratch
ATNConfigSet for
prediction and lexing hot paths.A rule context is a record of a single rule invocation.
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.
This annotation allows multiple
RuleDependency annotations to be
applied to a single element.Declares a dependency upon a grammar rule, along with a set of zero or more
dependent rules.
A compile-time validator for rule dependencies.
Tag indicated AST node is a rule element like token or rule ref.
The last node in the ATN for a rule, unless that rule is the start symbol.
A
Token object representing an entire subtree matched by a parser
rule; e.g., <expr>.Parse args, return values, locals
A tree structure used to record the semantic context in which
an ATN configuration is valid.
A semantic context which is true whenever none of the contained contexts
is false.
This is the base class for semantic context "operators", which operate on
a collection of semantic context "operands".
A semantic context which is true whenever at least one of the contained
contexts is true.
Do as much semantic checking as we can and fill in grammar
with rules, actions, and token definitions.
A transition containing a set of values.
Immutable snapshot of DFA simulation position for
ParserATNSimulator.execDFA(org.antlr.v4.runtime.dfa.DFA, org.antlr.v4.runtime.TokenStream, int, org.antlr.v4.runtime.atn.SimulatorState) / ParserATNSimulator.execATN(org.antlr.v4.runtime.dfa.DFA, org.antlr.v4.runtime.TokenStream, int, org.antlr.v4.runtime.atn.SimulatorState).Deprecated.
Use
HashEdgeMap instead.The block that begins a closure loop.
This object models the structure holding all of the parameters,
return values, local variables, and labels associated with a rule.
Check for symbol problems; no side-effects.
Collects (create) rules, terminals, strings, actions, scopes etc...
A tree that knows about an interval in a token stream
is some kind of syntax tree.
Represents a placeholder tag in a tree pattern.
Run a lexer/parser combo, optionally printing tree string or generating
postscript file.
Deprecated.
Represents a span of raw text (concrete syntax) between tags in a tree
pattern string.
Test how fast we can lex Java and some unicode graphemes using old and
new unicode stream mechanism.
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.
x=ID or implicit _tID label
The default mechanism for creating tokens.
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.The Tokens rule start state linking to each lexer rule start state
Useful for rewriting out a buffered input token stream after doing some
augmentation or other manipulations on it.
Distinguish between insert after/before to do the "insert afters"
first and then the "insert befores" at same index.
I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
instructions.
A
Token object representing a token of a particular type; e.g.,
<ID>.Override error handling for use with ANTLR tool itself; leaves
nothing in grammar associated with Tool so others can use in IDEs, ...
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.
An ATN transition between any two ATN states.
The basic notion of a tree has a parent, a payload, and a list of children.
Adaptor ANTLR trees to
TreeForTreeLayout.A set of utility routines useful for all kinds of ANTLR trees.
Do not buffer up the entire char stream.
Code-generated utility class mapping Unicode properties to Unicode code point ranges.
StringTemplate controller used to generate parameters to feed
to
unicodedata.st to code-generate UnicodeData.java,
used by the tool for Unicode property escapes like \\p\{Lu\}.Utility class to escape Unicode code points using various
languages' syntaxes.
Look for errors and deadcode stuff
This interface provides information about the vocabulary used by a
recognizer.
This class provides a default implementation of the
Vocabulary
interface.Represent a subset of XPath XML path syntax for use in identifying nodes in
parse trees.
Either
ID at start of path or ...//ID in middle of path.
CharStreamsinterface.