antlr
public class CSharpCodeGenerator extends CodeGenerator
Field Summary | |
---|---|
int | astVarNumber |
int | blockNestingLevel |
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 |
String | exceptionThrown |
protected boolean | genAST |
String | labeledElementASTType |
String | labeledElementInit |
String | labeledElementType |
String | lt1Value |
protected static String | NONUNIQUE Special value used to mark duplicate in treeVariableMap |
int | saveIndexCreateLevel |
protected boolean | saveText |
protected int | syntacticPredLevel |
String | throwNoViable |
Hashtable | treeVariableMap Mapping between the ids used in the current alt, and the
names of variables used to represent their AST values. |
boolean | usingCustomAST |
Constructor Summary | |
---|---|
CSharpCodeGenerator() Create a CSharp 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. |
void | exitIfError() |
void | gen() Generate the parser, lexer, treeparser, and token types in CSharp |
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 CSharp file |
void | gen(OneOrMoreBlock blk) Generate code for the given grammar element. |
void | gen(ParserGrammar g) Generate the parser CSharp 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 CSharp file |
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) 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 | genBlockInitAction(AlternativeBlock blk) Generate the init action 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. |
CSharpBlockFinishingInfo | 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() Generate a header that is common to all CSharp files |
void | genInitFactory(Grammar g) |
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, TokenManager tm) Gen a named rule block.
|
protected void | genSemPred(String pred, int line) |
protected void | genSemPredMap() Write an array of Strings which are the semantic predicate
expressions. |
protected void | genSynPred(SynPredBlock blk, String lookaheadExpr) |
protected void | genTokenDefinitions(TokenManager tm) |
void | genTokenStrings() 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 CSharp file |
String | getASTCreateString(Vector v) Get a string for an expression to generate creation of an AST subtree. |
String | getASTCreateString(GrammarAtom atom, String astCtorArgs) Get a string for an expression to generate creating of an AST node |
String | getASTCreateString(String astCtorArgs) Returns a string expression that creates an AST node using the specified
AST constructor argument string.
|
protected String | getBitsetName(int index) Given the index of a bitset in the bitset list, generate a unique name.
|
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 |
String | getTokenTypesClassName() Helper method that returns the name of the interface/class/enum type for
token type constants. |
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.
|
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. |
void | setupOutput(String className) This method exists so a subclass, namely VAJCodeGenerator,
can open the file in its own evil way. |
String[] | split(String str, String sep) |
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.
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: 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: atom The grammar node for which you are creating the node str The arguments to the AST constructor
Parameters: astCtorArgs The arguments to the AST constructor
Parameters: index The index of the bitset in the bitset list.
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: str A String.