public ActionAnalysisLexer(Grammar grammar, string ruleName, GrammarAST actionAST)
     : this(new ANTLRStringStream(actionAST.Token.Text))
 {
     this.grammar = grammar;
     this.enclosingRule = grammar.GetLocallyDefinedRule(ruleName);
     this.actionToken = actionAST.Token;
     this.outerAltNum = actionAST.outerAltNum;
 }

 protected void TrackInlineAction( GrammarAST actionAST )
 {
     Rule r = grammar.GetRule( currentRuleName );
     if ( r != null )
     {
         r.TrackInlineAction( actionAST );
     }
 }

        public int CountAltsForBlock(GrammarAST t)
        {
            int n = 0;
            for ( int i = 0; i < t.ChildCount; i++ )
            {
                if ( t.GetChild( i ).Type == ALT )
                    n++;
            }

            return n;
        }

        public static bool BlockHasSynPred(GrammarAST blockAST)
        {
            GrammarAST c1 = blockAST.FindFirstType(ANTLRParser.SYN_SEMPRED);
            GrammarAST c2 = blockAST.FindFirstType(ANTLRParser.BACKTRACK_SEMPRED);
            if (c1 != null || c2 != null)
                return true;
            //		System.out.println(blockAST.enclosingRuleName+
            //						   " "+blockAST.getLine()+":"+blockAST.getColumn()+" no preds AST="+blockAST.toStringTree());

            return false;
        }

        /** Convert e ? e : e  ->  ? e : e_[nextPrec] */
        public override void TernaryAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt)
        {
            altTree = GrammarAST.DupTree(altTree);
            rewriteTree = GrammarAST.DupTree(rewriteTree);

            StripSynPred(altTree);
            StripLeftRecursion(altTree);

            int nextPrec = NextPrecedence(alt);
            StringTemplate refST = recRuleTemplates.GetInstanceOf("recRuleRef");
            refST.SetAttribute("ruleName", ruleName);
            refST.SetAttribute("arg", nextPrec);
            altTree = ReplaceLastRuleRef(altTree, refST.Render());

            string altText = Text(altTree);
            altText = altText.Trim();
            altText += "{}"; // add empty alt to prevent pred hoisting
            StringTemplate nameST = recRuleTemplates.GetInstanceOf("recRuleName");
            nameST.SetAttribute("ruleName", ruleName);
            rewriteTree = ReplaceRuleRefs(rewriteTree, "$" + nameST.Render());
            string rewriteText = Text(rewriteTree);
            ternaryAlts.Add(alt, altText + (rewriteText != null ? " " + rewriteText : ""));
            //System.out.println("ternaryAlt " + alt + ": " + altText + ", rewrite=" + rewriteText);
        }

 public void StripSynPred(GrammarAST altAST)
 {
     GrammarAST t = (GrammarAST)altAST.GetChild(0);
     if (t.Type == ANTLRParser.BACKTRACK_SEMPRED ||
          t.Type == ANTLRParser.SYNPRED ||
          t.Type == ANTLRParser.SYN_SEMPRED)
     {
         altAST.DeleteChild(0);
     }
 }

        public override void SetTokenPrec(GrammarAST t, int alt)
        {
            int ttype = g.GetTokenType(t.Text);
            //tokenToPrec.Add(ttype, alt);
            tokenToPrec[ttype] = alt;

            ASSOC assoc = ASSOC.left;
            if (t.terminalOptions != null)
            {
                object o;
                t.terminalOptions.TryGetValue("assoc", out o);
                string a = o as string;
                if (a != null)
                {
                    if (a.Equals(ASSOC.right.ToString()))
                    {
                        assoc = ASSOC.right;
                    }
                    else
                    {
                        ErrorManager.Error(ErrorManager.MSG_ILLEGAL_OPTION_VALUE, "assoc", assoc);
                    }
                }
            }

            ASSOC currentAssociativity;
            if (altAssociativity.TryGetValue(alt, out currentAssociativity))
            {
                if (currentAssociativity != assoc)
                    ErrorManager.Error(ErrorManager.MSG_ALL_OPS_NEED_SAME_ASSOC, alt);
            }
            else
            {
                altAssociativity.Add(alt, assoc);
            }

            //System.out.println("op " + alt + ": " + t.getText()+", assoc="+assoc);
        }

 public GrammarAST ReplaceLastRuleRef(GrammarAST t, string name)
 {
     if (t == null)
         return null;
     GrammarAST last = null;
     foreach (GrammarAST rref in t.FindAllType(RULE_REF))
     {
         last = rref;
     }
     if (last != null && last.Text.Equals(ruleName))
         last.Text = name;
     return t;
 }

        protected override void Alias( GrammarAST t, GrammarAST s )
        {
            string tokenID = t.Text;
            string literal = s.Text;
            string prevAliasLiteralID;
            _aliasesReverseIndex.TryGetValue(literal, out prevAliasLiteralID);
            if ( prevAliasLiteralID != null )
            { // we've seen this literal before
                if ( tokenID.Equals( prevAliasLiteralID ) )
                {
                    // duplicate but identical alias; might be tokens {A='a'} and
                    // lexer rule A : 'a' ;  Is ok, just return
                    return;
                }

                // give error unless both are rules (ok if one is in tokens section)
                if ( !( tokenRuleDefs.Contains( tokenID ) && tokenRuleDefs.Contains( prevAliasLiteralID ) ) )
                {
                    // don't allow alias if A='a' in tokens section and B : 'a'; is rule.
                    // Allow if both are rules.  Will get DFA nondeterminism error later.
                    ErrorManager.GrammarError( ErrorManager.MSG_TOKEN_ALIAS_CONFLICT,
                                              grammar,
                                              t.Token,
                                              tokenID + "=" + literal,
                                              prevAliasLiteralID );
                }
                return; // don't do the alias
            }
            int existingLiteralType = grammar.GetTokenType( literal );
            if ( existingLiteralType != Label.INVALID )
            {
                // we've seen this before from a tokenVocab most likely
                // don't assign a new token type; use existingLiteralType.
                _tokens[tokenID] = existingLiteralType;
            }
            string prevAliasTokenID;
            _aliases.TryGetValue(tokenID, out prevAliasTokenID);
            if ( prevAliasTokenID != null )
            {
                ErrorManager.GrammarError( ErrorManager.MSG_TOKEN_ALIAS_REASSIGNMENT,
                                          grammar,
                                          t.Token,
                                          tokenID + "=" + literal,
                                          prevAliasTokenID );
                return; // don't do the alias
            }
            _aliases[tokenID] = literal;
            _aliasesReverseIndex[literal] = tokenID;
        }

 protected override void TrackToken( GrammarAST t )
 {
     // imported token names might exist, only add if new
     // Might have ';'=4 in vocab import and SEMI=';'. Avoid
     // setting to UNASSIGNED if we have loaded ';'/SEMI
     if ( grammar.GetTokenType( t.Text ) == Label.INVALID &&
          !_tokens.ContainsKey( t.Text ) )
     {
         _tokens[t.Text] = Unassigned;
     }
 }

 /** Build what amounts to an epsilon transition with a semantic
  *  predicate action.  The pred is a pointer into the AST of
  *  the SEMPRED token.
  */
 public virtual StateCluster BuildSemanticPredicate( GrammarAST pred )
 {
     // don't count syn preds
     if ( !pred.Text.StartsWith( Grammar.SynpredRulePrefix, StringComparison.OrdinalIgnoreCase ) )
     {
         _nfa.Grammar.numberOfSemanticPredicates++;
     }
     NFAState left = NewState();
     NFAState right = NewState();
     Transition e = new Transition( new PredicateLabel( pred ), right );
     left.AddTransition( e );
     StateCluster g = new StateCluster( left, right );
     return g;
 }

 /** From char 'c' build StateCluster o-intValue(c)->o
  */
 public virtual StateCluster BuildCharLiteralAtom( GrammarAST charLiteralAST )
 {
     int c = Grammar.GetCharValueFromGrammarCharLiteral( charLiteralAST.Text );
     return BuildAtom( c, charLiteralAST );
 }

 public virtual StateCluster BuildAtom( GrammarAST atomAST )
 {
     int tokenType = _nfa.Grammar.GetTokenType( atomAST.Text );
     return BuildAtom( tokenType, atomAST );
 }

 /** Build what amounts to an epsilon transition with an action.
  *  The action goes into NFA though it is ignored during analysis.
  *  It slows things down a bit, but I must ignore predicates after
  *  having seen an action (5-5-2008).
  */
 public virtual StateCluster BuildAction( GrammarAST action )
 {
     NFAState left = NewState();
     NFAState right = NewState();
     Transition e = new Transition( new ActionLabel( action ), right );
     left.AddTransition( e );
     return new StateCluster( left, right );
 }

 public virtual void TernaryAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt)
 {
 }

 /** Track string literals (could be in tokens{} section) */
 protected override void TrackString( GrammarAST t )
 {
     // if lexer, don't allow aliasing in tokens section
     if ( currentRuleName == null && grammar.type == GrammarType.Lexer )
     {
         ErrorManager.GrammarError( ErrorManager.MSG_CANNOT_ALIAS_TOKENS_IN_LEXER,
                                   grammar,
                                   t.Token,
                                   t.Text );
         return;
     }
     // in a plain parser grammar rule, cannot reference literals
     // (unless defined previously via tokenVocab option)
     // don't warn until we hit root grammar as may be defined there.
     if ( grammar.IsRoot &&
          grammar.type == GrammarType.Parser &&
          grammar.GetTokenType( t.Text ) == Label.INVALID )
     {
         ErrorManager.GrammarError( ErrorManager.MSG_LITERAL_NOT_ASSOCIATED_WITH_LEXER_RULE,
                                   grammar,
                                   t.Token,
                                   t.Text );
     }
     // Don't record literals for lexers, they are things to match not tokens
     if ( grammar.type == GrammarType.Lexer )
     {
         return;
     }
     // otherwise add literal to token types if referenced from parser rule
     // or in the tokens{} section
     if ( ( currentRuleName == null ||
           Rule.GetRuleType(currentRuleName) == RuleType.Parser) &&
                                                             grammar.GetTokenType( t.Text ) == Label.INVALID )
     {
         _stringLiterals[t.Text] = UnassignedInParserRule;
     }
 }

 /** From set build single edge graph o->o-set->o.  To conform to
  *  what an alt block looks like, must have extra state on left.
  */
 public virtual StateCluster BuildSet( IIntSet set, GrammarAST associatedAST )
 {
     NFAState left = NewState();
     NFAState right = NewState();
     left.associatedASTNode = associatedAST;
     right.associatedASTNode = associatedAST;
     Label label = new Label( set );
     Transition e = new Transition( label, right );
     left.AddTransition( e );
     StateCluster g = new StateCluster( left, right );
     return g;
 }

        protected override void TrackTokenRule( GrammarAST t,
                                      GrammarAST modifier,
                                      GrammarAST block )
        {
            // imported token names might exist, only add if new
            if ( grammar.type == GrammarType.Lexer || grammar.type == GrammarType.Combined )
            {
                if (Rule.GetRuleType(t.Text) == RuleType.Parser)
                {
                    return;
                }
                if ( t.Text.Equals( Grammar.ArtificialTokensRuleName ) )
                {
                    // don't add Tokens rule
                    return;
                }

                // track all lexer rules so we can look for token refs w/o
                // associated lexer rules.
                grammar.composite.LexerRules.Add( t.Text );

                int existing = grammar.GetTokenType( t.Text );
                if ( existing == Label.INVALID )
                {
                    _tokens[t.Text] = Unassigned;
                }
                // look for "<TOKEN> : <literal> ;" pattern
                // (can have optional action last)
                if ( block.HasSameTreeStructure( charAlias ) ||
                     block.HasSameTreeStructure( stringAlias ) ||
                     block.HasSameTreeStructure( charAlias2 ) ||
                     block.HasSameTreeStructure( stringAlias2 ) )
                {
                    tokenRuleDefs.Add( t.Text );
                    /*
                Grammar parent = grammar.composite.getDelegator(grammar);
                boolean importedByParserOrCombined =
                    parent!=null &&
                    (parent.type==GrammarType.Lexer||parent.type==GrammarType.Parser);
                    */
                    if ( grammar.type == GrammarType.Combined || grammar.type == GrammarType.Lexer )
                    {
                        // only call this rule an alias if combined or lexer
                        Alias( t, (GrammarAST)block.GetChild( 0 ).GetChild( 0 ) );
                    }
                }
            }
            // else error
        }

        /** For a non-lexer, just build a simple token reference atom.
         *  For a lexer, a string is a sequence of char to match.  That is,
         *  "fog" is treated as 'f' 'o' 'g' not as a single transition in
         *  the DFA.  Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states
         *  for n characters.
         */
        public virtual StateCluster BuildStringLiteralAtom( GrammarAST stringLiteralAST )
        {
            if ( _nfa.Grammar.type == GrammarType.Lexer )
            {
                StringBuilder chars =
                    Grammar.GetUnescapedStringFromGrammarStringLiteral( stringLiteralAST.Text );
                NFAState first = NewState();
                NFAState last = null;
                NFAState prev = first;
                for ( int i = 0; i < chars.Length; i++ )
                {
                    int c = chars[i];
                    NFAState next = NewState();
                    TransitionBetweenStates( prev, next, c );
                    prev = last = next;
                }
                return new StateCluster( first, last );
            }

            // a simple token reference in non-Lexers
            int tokenType = _nfa.Grammar.GetTokenType( stringLiteralAST.Text );
            return BuildAtom( tokenType, stringLiteralAST );
        }

        public override void OtherAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt)
        {
            altTree = GrammarAST.DupTree(altTree);
            rewriteTree = GrammarAST.DupTree(rewriteTree);
            StripSynPred(altTree);
            StripLeftRecursion(altTree);
            string altText = Text(altTree);

            string rewriteText = Text(rewriteTree);
            otherAlts.Add(altText + (rewriteText != null ? " " + rewriteText : ""));
            //System.out.println("otherAlt " + alt + ": " + altText + ", rewrite=" + rewriteText);
        }