All Classes and Interfaces
Class
Description
We need to set Rule.referencedPredefinedRuleAttributes before
code generation.
An NFA configuration context stack overflowed.
Analysis took too long; bail out of entire DFA construction.
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.
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 ...
Defines behavior of object able to handle error messages from ANTLR including
both tool errors like "can't write file" and grammar ambiguity warnings.
This is a char buffer stream that is loaded from a file
all at once when you construct the object.
A kind of ReaderStream that pulls from an InputStream.
Read in an ANTLR grammar and build an AST.
Vacuum all input from a Reader and then treat it like a StringStream.
A pretty quick CharStream that pulls all data from an array
directly.
Print out a grammar (no pretty printing).
ANTLR v3 grammar written in ANTLR v3 with AST construction
ANTLR v3 tree grammar to walk trees created by ANTLRv3.g
Move all of the functionality from assign.types.g grammar file.
[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.
Track the names of attributes define in arg lists, return values,
scope blocks etc...
Track the attributes within a scope.
A very simple barrier wait.
A generic recognizer that can handle recognizers generated from
lexer, parser, and tree grammars.
A generic tree implementation with no payload.
A TreeAdaptor that works with any Tree implementation.
A BitSet to replace java.util.BitSet.
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.
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.
A buffered stream of tree nodes.
Given a grammar file, show the dependencies on .tokens etc...
A source of characters for an ANTLR lexer
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.
A Token object like we'd use in ANTLR 2.x; has an actual string created
and associated with this object.
ANTLR's code generator.
Walk a grammar and generate code by gradually building up
a bigger and bigger StringTemplate.
A node representing erroneous token range in token stream
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).
A tree node that is wrapper for a Token object.
A TreeAdaptor that works with any Tree implementation.
A tree of component (delegate) grammars.
A tree of grammars
Broadcast debug events to multiple listeners.
All debugging events that a recognizer can trigger.
A simple event repeater (proxy) that delegates all functionality to the
listener sent into the ctor.
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.
A TreeAdaptor proxy that fires debugging events to a DebugEventListener
delegate and uses the TreeAdaptor delegate to do the actual work.
Debug any tree node stream.
Collection of information about what is wrong with a decision as
discovered while building the DFA predictor.
A DFA (converted from a grammar's NFA).
A DFA implemented as a set of transition tables.
A module to perform optimizations on DFAs.
A DFA state represents a set of possible NFA configurations.
The DOT (part of graphviz) generation aspect.
A utility class to generate DOT diagrams (graphviz) from
arbitrary trees.
The recognizer did not match anything for a (..)+ loop.
Defines all the errors ANTLR can generator for both the tool and for
issues with a grammar.
A semantic predicate failed during validation.
An aspect of FA (finite automata) that knows how to dump them to serialized
strings.
A queue that can dequeue and get(i) in O(1) and grow arbitrarily large.
Represents a grammar in memory.
Reports the condition that ANTLR's LL(*) analysis engine terminated
early.
Grammars are first converted to ASTs using this class and then are
converted to NFAs via a tree walker.
Reports a potential parsing issue with a decision; the decision is
nondeterministic in some way.
Reports a potential parsing issue with a decision; the decision is
nondeterministic in some way.
Factor out routines that check sanity of rules, alts, grammars, etc..
A problem with the symbols and/or meaning of a grammar such as rule
redefinition.
Serialize a grammar into a highly compressed form with
only the info needed to recognize sentences.
Load a grammar file and scan it just until we learn a few items
of interest.
Strip comments and then return stream of words and
tokens {';', ':', '{', '}'}
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"
Reports a potential parsing issue with a decision; the decision is
nondeterministic in some way.
A generic graph with edges; Each node as a single Object payload.
A dynamic array that uses int not Integer objects.
An ArrayList based upon int members.
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.
The recognition interpreter/engine for grammars.
An immutable inclusive interval a..b
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).
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.
A simple stream of integers used when all I care about is the char
or token type sequence (such as interpretation).
A state machine transition label.
Similar to LeftRecursionMessage except this is used for announcing
cycles found by walking rules without decisions; the other msg is
invoked when a decision DFA construction finds a problem in closure.
A lexer is recognizer that draws input symbols from a character stream.
Created by IntelliJ IDEA.
A special DFA that is exactly LL(1) or LL(1) with backtracking mode
predicates to resolve edge set collisions.
An LL(1) lookahead set; contains a set of token types and a "hasEOF"
condition when the set contains EOF.
A lookahead queue that knows how to mark/release locations
in the buffer for backtracking purposes.
The ANTLR code calls methods on ErrorManager to report errors etc...
A mismatched char or Token or tree node
We were expecting a token but it's not found.
A hash table that maps a key to a list of elements not just a single.
Java won't let you modify an Integer; not sure how that's more
efficient, but...here's one that let's you modify it.
An NFA (collection of NFAStates) constructed from a grammar.
An NFA state, predicted alt, and syntactic/semantic context.
A tree node for tracking the call chains for NFAs that invoke
other NFAs.
Convert all decisions i..j inclusive in a thread
Routines to construct StateClusters from EBNF grammar constructs.
A state within an NFA.
Code that embodies the NFA conversion to DFA.
Used to abort DFA construction when we find non-LL(*) decision; i.e.,
a decision that has recursion in more than a single alt.
More a single alternative recurses so this decision is not regular.
A HashMap that remembers the order that the elements were added.
A parser for TokenStreams.
Rules that return more than a single value must return an object
containing all the values.
A record of the rules used to match a token sequence.
This parser listener tracks rule entry/exit and token matches
to build a simple parse tree using ParseTree nodes.
Using the debug event interface, track what is happening in the parser
and record statistics about the runtime.
Generate a random phrase given a grammar.
The root of the ANTLR exception hierarchy.
The set of fields needed by an abstract recognizer to recognize input
and recover from errors etc...
Indicates recursion overflow.
Base class for all exceptions thrown during AST rewrite construction.
No elements within a (...)+ in a rewrite rule
Ref to ID or expr but no tokens in ID stream or subtrees in expr stream
A generic list of elements tracked in an alternative to be used in
a -> rewrite rule.
Queues up nodes matched on left side of -> in a tree parser.
Combine the info associated with a rule.
A transition used to reference another rule.
Rules can return start/stop info as well as possible trees and templates
A binary tree structure used to record the semantic context in which
an NFA configuration is valid.
A generic state machine state.
A Cluster object points to the left/right (start and end) states of a
state machine.
Stats routines needed by profiler etc...
A basic action stripper.
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.
Useful for dumping out the input stream after doing some
augmentation or other manipulations.
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.
A stream of tokens accessing tokens from a TokenSource
The main ANTLR entry point.
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.
Print out (most of) the events...
The default tracer mimics the traceParser behavior of ANTLR 2.x.
A generic transition between any two state machine states.
What does a tree look like? ANTLR has a number of support classes
such as CommonTreeNodeStream that work on these kinds of trees.
How to create and navigate trees.
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.
Return a node stream from a doubly-linked tree whose nodes
know what child index they are.
A stream of tree nodes, accessing nodes from a tree of some kind
A parser for a stream of tree nodes.
This is identical to the ParserRuleReturnScope except that
the start property is a tree nodes not Token object
when you are parsing trees.
Build an NFA from a tree representing an ANTLR grammar.
Do a depth first walk of a tree, applying pre() and post() actions
as we discover and finish nodes.
How to execute code for node t when a visitor visits node t.
Build and navigate trees with this object.
When using %label:TOKENNAME in a tree for parse(), we must
track the label.
This adaptor creates TreePattern objects for use during scan()
An extra token while parsing a TokenStream