public LeftRecursiveRuleAnalyzer(ITreeNodeStream input, Grammar g, string ruleName) : base(input) { this.g = g; this.ruleName = ruleName; language = (string)g.GetOption("language"); generator = new CodeGenerator(g.Tool, g, language); generator.LoadTemplates(language); recRuleTemplates = LoadPrecRuleTemplates(g.Tool); }
public ActionTranslator( CodeGenerator generator, string ruleName, GrammarAST actionAST ) : this(new ANTLRStringStream( actionAST.Token.Text )) { this.generator = generator; this.grammar = generator.grammar; this.enclosingRule = grammar.GetLocallyDefinedRule( ruleName ); this.actionToken = actionAST.Token; this.outerAltNum = actionAST.outerAltNum; }
public void Init( Grammar g ) { this.grammar = g; this.generator = grammar.CodeGenerator; this.templates = generator.Templates; }
/** Create NFA, DFA and generate code for grammar. * Create NFA for any delegates first. Once all NFA are created, * it's ok to create DFA, which must check for left-recursion. That check * is done by walking the full NFA, which therefore must be complete. * After all NFA, comes DFA conversion for root grammar then code gen for * root grammar. DFA and code gen for delegates comes next. */ protected virtual void GenerateRecognizer( Grammar grammar ) { string language = (string)grammar.GetOption( "language" ); if ( language != null ) { CodeGenerator generator = new CodeGenerator( this, grammar, language ); grammar.CodeGenerator = generator; generator.Debug = Debug; generator.Profile = Profile; generator.Trace = Trace; // generate NFA early in case of crash later (for debugging) if ( Generate_NFA_dot ) { GenerateNFAs( grammar ); } // GENERATE CODE generator.GenRecognizer(); if ( Generate_DFA_dot ) { GenerateDFAs( grammar ); } IList<Grammar> delegates = grammar.GetDirectDelegates(); for ( int i = 0; delegates != null && i < delegates.Count; i++ ) { Grammar @delegate = (Grammar)delegates[i]; if ( @delegate != grammar ) { // already processing this one GenerateRecognizer( @delegate ); } } } }
public ActionTranslator( CodeGenerator generator, string ruleName, IToken actionToken, int outerAltNum ) : this(new ANTLRStringStream( actionToken.Text )) { this.generator = generator; grammar = generator.grammar; this.enclosingRule = grammar.GetRule( ruleName ); this.actionToken = actionToken; this.outerAltNum = outerAltNum; }
public ACyclicDFACodeGenerator( CodeGenerator parent ) { this._parentGenerator = parent; }
// e.g., ".h" protected internal virtual void GenRecognizerHeaderFile( AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate headerFileST, string extName ) { // no header file by default }
protected internal virtual void PerformGrammarAnalysis( CodeGenerator generator, Grammar grammar ) { // Build NFAs from the grammar AST grammar.BuildNFA(); // Create the DFA predictors for each decision grammar.CreateLookaheadDFAs(); }
protected internal virtual void GenRecognizerFile( AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate outputFileST ) { string fileName = generator.GetRecognizerFileName( grammar.name, grammar.type ); generator.Write( outputFileST, fileName ); }
/** Target must be able to override the labels used for token types */ public virtual string GetTokenTypeAsTargetLabel( CodeGenerator generator, int ttype ) { string name = generator.grammar.GetTokenDisplayName( ttype ); // If name is a literal, return the token type instead if ( name[0] == '\'' ) { return ttype.ToString(); //String.valueOf( ttype ); } return name; }
/** Convert from an ANTLR string literal found in a grammar file to * an equivalent string literal in the target language. For Java, this * is the translation 'a\n"' -> "a\n\"". Expect single quotes * around the incoming literal. Just flip the quotes and replace * double quotes with \" * * Note that we have decided to allow poeple to use '\"' without * penalty, so we must build the target string in a loop as Utils.replae * cannot handle both \" and " without a lot of messing around. * */ public virtual string GetTargetStringLiteralFromANTLRStringLiteral( CodeGenerator generator, string literal ) { StringBuilder sb = new StringBuilder(); StringBuilder @is = new StringBuilder( literal ); // Opening quote // sb.Append( '"' ); for ( int i = 1; i < @is.Length - 1; i++ ) { if ( @is[i] == '\\' ) { // Anything escaped is what it is! We assume that // people know how to escape characters correctly. However // we catch anything that does not need an escape in Java (which // is what the default implementation is dealing with and remove // the escape. The C target does this for instance. // switch ( @is[i + 1] ) { // Pass through any escapes that Java also needs // case '"': case 'n': case 'r': case 't': case 'b': case 'f': case '\\': case 'u': // Assume unnnn sb.Append( '\\' ); // Pass the escape through break; default: // Remove the escape by virtue of not adding it here // Thus \' becomes ' and so on // break; } // Go past the \ character // i++; } else { // Chracters that don't need \ in ANTLR 'strings' but do in Java // if ( @is[i] == '"' ) { // We need to escape " in Java // sb.Append( '\\' ); } } // Add in the next character, which may have been escaped // sb.Append( @is[i] ); } // Append closing " and return // sb.Append( '"' ); return sb.ToString(); }
/** Convert from an ANTLR char literal found in a grammar file to * an equivalent char literal in the target language. For most * languages, this means leaving 'x' as 'x'. Actually, we need * to escape '\u000A' so that it doesn't get converted to \n by * the compiler. Convert the literal to the char value and then * to an appropriate target char literal. * * Expect single quotes around the incoming literal. */ public virtual string GetTargetCharLiteralFromANTLRCharLiteral( CodeGenerator generator, string literal ) { StringBuilder buf = new StringBuilder(); buf.Append( '\'' ); int c = Grammar.GetCharValueFromGrammarCharLiteral( literal ); if ( c < Label.MIN_CHAR_VALUE ) { return "'\u0000'"; } if ( c < targetCharValueEscape.Length && targetCharValueEscape[c] != null ) { buf.Append( targetCharValueEscape[c] ); } else if ( c <= 0x7f && !char.IsControl( (char)c ) ) { // normal char buf.Append( (char)c ); } else { // must be something unprintable...use \\uXXXX // turn on the bit above max "\\uFFFF" value so that we pad with zeros // then only take last 4 digits string hex = c.ToString( "X4" ); buf.Append( "\\u" ); buf.Append( hex ); } buf.Append( '\'' ); return buf.ToString(); }
/** Some targets only support ASCII or 8-bit chars/strings. For example, * C++ will probably want to return 0xFF here. */ public virtual int GetMaxCharValue( CodeGenerator generator ) { return Label.MAX_CHAR_VALUE; }