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.
Parses ANTLR grammar files
*.g and transforms them into Java source
files.Defines behavior of object able to handle error messages from ANTLR including
both tool errors like "can't write file" and grammar ambiguity warnings.
Read in an ANTLR grammar and build an AST.
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 BitSet to replace java.util.BitSet.
Given a grammar file, show the dependencies on .tokens etc...
ANTLR's code generator.
Walk a grammar and generate code by gradually building up
a bigger and bigger ST.
A tree of component (delegate) grammars.
A tree of grammars
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 module to perform optimizations on DFAs.
A DFA state represents a set of possible NFA configurations.
The DOT (part of graphviz) generation aspect.
Defines all the errors ANTLR can generator for both the tool and for
issues with a grammar.
An aspect of FA (finite automata) that knows how to dump them to serialized
strings.
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.
Simplifying report dramatically for LL(*) paper.
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.
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 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.
Find left-recursive rules
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.
The ANTLR code calls methods on ErrorManager to report errors etc...
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.
Generate a random phrase given a grammar.
Indicates recursion overflow.
Combine the info associated with a rule.
A transition used to reference another rule.
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.
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.
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.
This extension of
STGroupFile automatically sets the group's
STErrorListener to ErrorManager.getSTErrorListener().A generic transition between any two state machine states.
Build an NFA from a tree representing an ANTLR grammar.