All Classes and Interfaces
Class
Description
Perform the following translations:
AST related translations
## -> currentRule_AST
#(x,y,z) -> codeGenerator.getASTCreateString(vector-of(x,y,z))
#[x] -> codeGenerator.getASTCreateString(x)
#x -> codeGenerator.mapTreeId(x)
Inside context of #(...), you can ref (x,y,z), [x], and x as shortcuts.
Perform the following translations:
AST related translations
## -> currentRule_AST
#(x,y,z) -> codeGenerator.getASTCreateString(vector-of(x,y,z))
#[x] -> codeGenerator.getASTCreateString(x)
#x -> codeGenerator.mapTreeId(x)
Inside context of #(...), you can ref (x,y,z), [x], and x as shortcuts.
Perform the following translations:
AST related translations
## -> currentRule_AST
#(x,y,z) -> codeGenerator.getASTCreateString(vector-of(x,y,z))
#[x] -> codeGenerator.getASTCreateString(x)
#x -> codeGenerator.mapTreeId(x)
Inside context of #(...), you can ref (x,y,z), [x], and x as shortcuts.
Perform the following translations:
AST related translations
## -> currentRule_AST
#(x,y,z) -> codeGenerator.getASTCreateString(vector-of(x,y,z))
#[x] -> codeGenerator.getASTCreateString(x)
#x -> codeGenerator.mapTreeId(x)
Inside context of #(...), you can ref (x,y,z), [x], and x as shortcuts.
This class contains information about how an action
was translated (using the AST conversion rules).
Intermediate data class holds information about an alternative
A list of alternatives
Simple class that uses build.Tool to compile ANTLR's Java stuff
Simple lexer/parser for reading token definition files
in support of the import/export vocab option for grammars.
Default implementation of
IASDebugStream methods.Minimal AST node interface used by ANTLR AST generation
and tree-walker.
ASTArray is a class that allows ANTLR to
generate code that can create and initialize an array
in one expression, like:
(new ASTArray(3)).add(x).add(y).add(z)
AST Support code shared by TreeParser and Parser.
There is only one instance of this class
ASTPair: utility class used for manipulating a pair of ASTs
representing the current AST root and current AST sibling.
A Child-Sibling Tree.
A BitSet to replace java.util.BitSet.
BlockContext stores the information needed when creating an
alternative (list of elements).
All alternative blocks are "terminated" by BlockEndElements unless
they are rule blocks (in which case they use RuleEndElement).
Interface used by BitSet to format elements of the set when
converting to string
A circular buffer object used by CharBuffer
Anything that goes wrong while generating a stream of characters
Wrap an IOException in a CharStreamException
A generic ANTLR code generator.
Common AST node implementation
A CommonAST whose initialization copies hidden token
information from the Token used to create a node.
Generate MyParser.cpp, MyParser.hpp, MyLexer.cpp, MyLexer.hpp
and MyParserTokenTypes.hpp
Generates MyParser.cs, MyLexer.cs and MyParserTokenTypes.cs
This type was created in VisualAge.
DefineGrammarSymbols is a behavior for the ANTLRParser that adds all
the token and rule symbols to the grammar symbol table.
Generate MyParser.txt, MyLexer.txt and MyParserTokenTypes.txt
Generate P.sgml, a cross-linked representation of P with or without actions
Simple class to dump the contents of an AST to the output
A Grammar holds a set of rules (which are stored
in a symbol table).
A GrammarAnalyzer computes lookahead from Grammar (which contains
a grammar symbol table) and can then answer questions about the
grammar.
A GrammarAtom is either a token ref, a character ref, or string.
A GrammarElement is a generic node in our
data structure that holds a grammar in memory.
Stores header action, grammar preamble, file options, and
list of grammars in the file
A GrammarSymbol is a generic symbol that can be
added to the symbol table for a grammar.
Generate P.html, a cross-linked representation of P with or without actions
Provides information used by the 'Input Text' view
of Antlr Studio.
Static implementation of the TokenManager, used for importVocab option
A simple indexed vector: a normal vector except that you must
specify a key when adding an element.
A Stream of characters fed to the lexer from a InputStream that can
be rewound via mark()/rewind() methods.
A dummy implementation of a CharBufferListener -- this class is not
meant to be used by itself -- it's meant to be subclassed
Generate MyParser.java, MyLexer.java and MyParserTokenTypes.java
Defines a strategy that can be used to manage the printwriter
being used to write JavaCodeGenerator output
TODO generalize so all code gens could use?
Lexer-specific grammar subclass
This object contains the data associated with an
input stream of characters.
A simple List interface that describes operations
on a list.
A linked list cell, which contains a ref to the object and next cell.
An enumeration of a LList.
A Linked List Implementation (not thread-safe for simplicity)
(adds to the tail) (has an enumeration)
A linear-approximate LL(k) grammar analzyer.
An LL(k) parser.
This object holds all information needed to represent
the lookahead for any particular lookahead computation
for a single lookahead depth.
A class to assist in firing parser events
NOTE: I intentionally _did_not_ synchronize the event firing and
add/remove listener methods.
Parser-specific grammar subclass
This object contains the data associated with an
input stream of tokens.
Override the standard matching and rule entry/exit routines
to build parse trees.
PreservingFileWriter only overwrites target if the new file is different.
Generate MyParser.java, MyLexer.java and MyParserTokenTypes.java
A list of alternatives and info contained in
the rule definition.
Contains a list of all places that reference
this enclosing rule.
A simple stack definition; restrictive in that you cannot
access arbitrary stack elements.
Adapted from JavaWorld article by Michael Daconta
A token is minimally a token type.
Interface that describes the set of defined tokens
Provides offset info for a token.
All offsets are 0-based.
All offsets are 0-based.
A private circular buffer object used by the token buffer
This object is a TokenStream that passes through all
tokens except for those that you tell it to discard.
Anything that goes wrong while generating a stream of tokens.
This object filters a token stream coming from a lexer
or another TokenStream so that only certain token channels
get transmitted to the parser.
Wraps an IOException in a TokenStreamException
Wraps a RecognitionException in a TokenStreamException so you
can pass it along.
Aborted recognition of current token.
This token stream tracks the *entire* token stream coming from
a lexer, but does not pass on the whitespace (or whatever else
you want to discard) to the parser.
I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
instructions.
A token stream MUX (multiplexor) knows about n token streams
and can multiplex them onto the same channel for use by token
stream consumer like a parser.
This token knows what index 0..n-1 it is from beginning of stream.
An application-specific build tool for ANTLR.
Tester for the preprocessor
The context needed to add root,child elements to a Tree.
A TreeElement is a block with one alternative and a root node
This object contains the data associated with an
input AST.
Parser-specific grammar subclass