antlr
public class CppCodeGenerator extends CodeGenerator
Field Summary | |
---|---|
int | astVarNumber |
static int | caseSizeThreshold |
String | commonExtraArgs |
String | commonExtraParams |
String | commonLocalVars |
String | currentASTResult |
RuleBlock | currentRule |
Hashtable | declaredASTVariables Used to keep track of which AST variables have been defined in a rule
(except for the #rule_name and #rule_name_in var's |
boolean | DEBUG_CPP_CODE_GENERATOR |
String | exceptionThrown |
protected boolean | genAST |
protected boolean | genHashLines |
String | labeledElementASTInit |
String | labeledElementASTType |
String | labeledElementInit |
String | labeledElementType |
String | lt1Value |
protected boolean | noConstructors |
protected static String | NONUNIQUE |
protected String | outputFile |
protected int | outputLine |
protected boolean | saveText |
protected int | syntacticPredLevel |
String | throwNoViable |
Hashtable | treeVariableMap |
boolean | usingCustomAST |
Constructor Summary | |
---|---|
CppCodeGenerator() Create a C++ code-generator using the given Grammar.
|
Method Summary | |
---|---|
protected int | addSemPred(String predicate) Adds a semantic predicate string to the sem pred vector
These strings will be used to build an array of sem pred names
when building a debugging parser. |
protected int | countLines(String s) |
void | exitIfError() |
void | gen() Generate the parser, lexer, treeparser, and token types in C++ |
void | gen(ActionElement action) Generate code for the given grammar element. |
void | gen(AlternativeBlock blk) Generate code for the given grammar element. |
void | gen(BlockEndElement end) Generate code for the given grammar element. |
void | gen(CharLiteralElement atom) Generate code for the given grammar element.
|
void | gen(CharRangeElement r) Generate code for the given grammar element.
|
void | gen(LexerGrammar g) Generate the lexer C++ files |
void | gen(OneOrMoreBlock blk) Generate code for the given grammar element. |
void | gen(ParserGrammar g) Generate the parser C++ file |
void | gen(RuleRefElement rr) Generate code for the given grammar element. |
void | gen(StringLiteralElement atom) Generate code for the given grammar element. |
void | gen(TokenRangeElement r) Generate code for the given grammar element. |
void | gen(TokenRefElement atom) Generate code for the given grammar element. |
void | gen(TreeElement t) |
void | gen(TreeWalkerGrammar g) Generate the tree-parser C++ files |
void | gen(WildcardElement wc) Generate code for the given grammar element. |
void | gen(ZeroOrMoreBlock blk) Generate code for the given grammar element. |
protected void | genAlt(Alternative alt, AlternativeBlock blk) Generate an alternative. |
protected void | genASTDeclaration(AlternativeElement el) |
protected void | genASTDeclaration(AlternativeElement el, String node_type) |
protected void | genASTDeclaration(AlternativeElement el, String var_name, String node_type) |
protected void | genBitsets(Vector bitsetList, int maxVocabulary, String prefix) Generate all the bitsets to be used in the parser or lexer
Generate the raw bitset data like "long _tokenSet1_data[] = {...};"
and the BitSet object declarations like
"BitSet _tokenSet1 = new BitSet(_tokenSet1_data);"
Note that most languages do not support object initialization inside a
class definition, so other code-generators may have to separate the
bitset declarations from the initializations (e.g., put the
initializations in the generated constructor instead). |
protected void | genBitsetsHeader(Vector bitsetList, int maxVocabulary) |
protected void | genBlockInitAction(AlternativeBlock blk) Generate the initaction for a block, which may be a RuleBlock or a
plain AlternativeBLock. |
protected void | genBlockPreamble(AlternativeBlock blk) Generate the header for a block, which may be a RuleBlock or a
plain AlternativeBlock. |
void | genBody(LexerGrammar g) |
void | genBody(ParserGrammar g) |
void | genBody(TreeWalkerGrammar g) |
protected void | genCases(BitSet p) Generate a series of case statements that implement a BitSet test. |
CppBlockFinishingInfo | genCommonBlock(AlternativeBlock blk, boolean noTestForSingle) Generate common code for a block of alternatives; return a postscript
that needs to be generated at the end of the block. |
protected void | genHeader(String fileName) Generate a header that is common to all C++ files |
void | genInclude(LexerGrammar g) |
void | genInclude(ParserGrammar g) |
void | genInclude(TreeWalkerGrammar g) |
void | genInitFactory(Grammar g) |
void | genLineNo(int line) Generate a #line or // line depending on options |
void | genLineNo(GrammarElement el) Generate a #line or // line depending on options |
void | genLineNo(Token t) Generate a #line or // line depending on options |
void | genLineNo2() Generate a #line or // line depending on options |
protected void | genMatch(BitSet b) |
protected void | genMatch(GrammarAtom atom) |
protected void | genMatchUsingAtomText(GrammarAtom atom) |
protected void | genMatchUsingAtomTokenType(GrammarAtom atom) |
void | genNextToken() Generate the nextToken() rule.
nextToken() is a synthetic lexer rule that is the implicit OR of all
user-defined lexer rules. |
void | genRule(RuleSymbol s, boolean startSymbol, int ruleNum, String prefix) Gen a named rule block.
|
void | genRuleHeader(RuleSymbol s, boolean startSymbol) |
protected void | genSemPred(String pred, int line) |
protected void | genSemPredMap(String prefix) Write an array of Strings which are the semantic predicate
expressions. |
protected void | genSynPred(SynPredBlock blk, String lookaheadExpr) |
void | genTokenStrings(String prefix) Generate a static array containing the names of the tokens,
indexed by the token type values. |
protected void | genTokenTypes(TokenManager tm) Generate the token types C++ file |
String | getASTCreateString(Vector v) Get a string for an expression to generate creation of an AST subtree. |
String | getASTCreateString(GrammarAtom atom, String str) Get a string for an expression to generate creating of an AST node |
String | getASTCreateString(String str) Get a string for an expression to generate creating of an AST node |
protected String | getLookaheadTestExpression(Lookahead[] look, int k) |
protected String | getLookaheadTestExpression(Alternative alt, int maxDepth) Generate a lookahead test expression for an alternate. |
protected String | getLookaheadTestTerm(int k, BitSet p) Generate a depth==1 lookahead test expression given the BitSet.
|
String | getRangeExpression(int k, int[] elems) Return an expression for testing a contiguous renage of elements |
protected boolean | lookaheadIsEmpty(Alternative alt, int maxDepth) Is the lookahead for this alt empty? |
String | mapTreeId(String idParam, ActionTransInfo transInfo) Map an identifier to it's corresponding tree-node variable.
|
void | printAction(Token t) Print an action stored in a token surrounded by #line stuff |
void | printHeaderAction(String name) Print a header action by #line stuff also process any tree construction |
protected void | println(String s) Output tab indent followed by a String followed by newline,
to the currentOutput stream. |
protected String | processActionForSpecialSymbols(String actionStr, int line, RuleBlock currentRule, ActionTransInfo tInfo) Lexically process tree-specifiers in the action.
|
String | processStringForASTConstructor(String str) Process a string for an simple expression for use in xx/action.g
it is used to cast simple tokens/references to the right type for
the generated language. |
protected void | _print(String s) Output a String to the currentOutput stream.
|
protected void | _printAction(String s) Print an action without leading tabs, attempting to
preserve the current indentation level for multi-line actions
Ignored if string is null. |
protected void | _println(String s) Output a String followed by newline, to the currentOutput stream.
|
Parameters: blk The {...} action to generate
Parameters: blk The "x|y|z|..." block to generate
Parameters: blk The block-end element to generate. Block-end elements are synthesized by the grammar parser to represent the end of a block.
Parameters: blk The character literal reference to generate
Parameters: blk The character-range reference to generate
Parameters: blk The (...)+ block to generate
Parameters: blk The rule-reference to generate
Parameters: blk The string-literal reference to generate
Parameters: blk The token-range reference to generate
Parameters: blk The token-reference to generate
Parameters: wc The wildcard element to generate
Parameters: blk The (...)* block to generate
Parameters: alt The alternative to generate blk The block to which the alternative belongs
Parameters: bitsetList The list of bitsets to generate. maxVocabulary Ensure that each generated bitset can contain at least this value. prefix string glued in from of bitset names used for namespace qualifications.
UNKNOWN: The block for which the preamble is to be generated.
UNKNOWN: The block for which the preamble is to be generated.
Parameters: p The Bitset for which cases are to be generated
Parameters: blk The block to generate noTestForSingle If true, then it does not generate a test for a single alternative.
Parameters: RuleBlock
Parameters: rule The name of the rule to generate startSymbol true if the rule is a start symbol (i.e., not referenced elsewhere)
Parameters: v A Vector of String, where each element is an expression in the target language yielding an AST node.
Parameters: str The arguments to the AST constructor
Parameters: str The arguments to the AST constructor
Parameters: k The lookahead level p The lookahead set for level k
Parameters: k The lookahead level elems The elements representing the set, usually from BitSet.toArray().
Returns: String containing test expression.
Parameters: idParam The identifier name to map
Returns: The mapped id (which may be the same as the input), or null if the mapping is invalid due to duplicates
Parameters: name The name of the header part
Parameters: s The string to output
Parameters: str A String.
Parameters: s The string to output
Parameters: s The action string to output
Parameters: s The string to output