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.
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