public LabelElementPair(Grammar g, GrammarAST label, GrammarAST element, int labelOp)
        {
            this.label = label;
            this.element = element;
            // compute general case for label type
            if (element.GetFirstDescendantWithType(tokenTypeForTokens) != null)
            {
                if (labelOp == ANTLRParser.ASSIGN)
                    type = LabelType.TOKEN_LABEL;
                else
                    type = LabelType.TOKEN_LIST_LABEL;
            }
            else if (element.GetFirstDescendantWithType(ANTLRParser.RULE_REF) != null)
            {
                if (labelOp == ANTLRParser.ASSIGN)
                    type = LabelType.RULE_LABEL;
                else
                    type = LabelType.RULE_LIST_LABEL;
            }

            // now reset if lexer and string
            if (g.IsLexer())
            {
                if (element.GetFirstDescendantWithType(ANTLRParser.STRING_LITERAL) != null)
                {
                    if (labelOp == ANTLRParser.ASSIGN)
                        type = LabelType.LEXER_STRING_LABEL;
                }
            }
        }

 public Choice(OutputModelFactory factory,
               GrammarAST blkOrEbnfRootAST,
               IList<CodeBlockForAlt> alts)
     : base(factory, blkOrEbnfRootAST)
 {
     this.alts = alts;
 }

 public GrammarAST(GrammarAST node)
     : base(node)
 {
     this.g = node.g;
     this.atnState = node.atnState;
     this.textOverride = node.textOverride;
 }

 public Loop(OutputModelFactory factory,
             GrammarAST blkOrEbnfRootAST,
             IList<CodeBlockForAlt> alts)
     : base(factory, blkOrEbnfRootAST, alts)
 {
     bool nongreedy = (blkOrEbnfRootAST is QuantifierAST) && !((QuantifierAST)blkOrEbnfRootAST).GetGreedy();
     exitAlt = nongreedy ? 1 : alts.Count + 1;
 }

 public virtual void ReduceBlocksToSets(GrammarAST root)
 {
     CommonTreeNodeStream nodes = new CommonTreeNodeStream(new GrammarASTAdaptor(), root);
     GrammarASTAdaptor adaptor = new GrammarASTAdaptor();
     BlockSetTransformer transformer = new BlockSetTransformer(nodes, g);
     transformer.TreeAdaptor = adaptor;
     transformer.Downup(root);
 }

 protected SrcOp(OutputModelFactory factory, GrammarAST ast)
     : base(factory, ast)
 {
     if (ast != null)
         uniqueID = ast.Token.TokenIndex;
     enclosingBlock = factory.GetCurrentBlock();
     enclosingRuleRunction = factory.GetCurrentRuleFunction();
 }

        //	@ModelElement public ThrowNoViableAlt error;

        public AltBlock(OutputModelFactory factory,
                        GrammarAST blkOrEbnfRootAST,
                        IList<CodeBlockForAlt> alts)
            : base(factory, blkOrEbnfRootAST, alts)
        {
            decision = ((BlockStartState)blkOrEbnfRootAST.atnState).decision;
            // interp.predict() throws exception
            //		this.error = new ThrowNoViableAlt(factory, blkOrEbnfRootAST, null);
        }

 public TestSetInline(OutputModelFactory factory, GrammarAST ast, IntervalSet set, int wordSize)
     : base(factory, ast)
 {
     bitsetWordSize = wordSize;
     Bitset[] withZeroOffset = CreateBitsets(factory, set, wordSize, true);
     Bitset[] withoutZeroOffset = CreateBitsets(factory, set, wordSize, false);
     this.bitsets = withZeroOffset.Length <= withoutZeroOffset.Length ? withZeroOffset : withoutZeroOffset;
     this.varName = "_la";
 }

 public override void DiscoverRule(RuleAST rule, GrammarAST ID,
                          IList<GrammarAST> modifiers, ActionAST arg,
                          ActionAST returns, GrammarAST thrws,
                          GrammarAST options, ActionAST locals,
                          IList<GrammarAST> actions,
                          GrammarAST block)
 {
     currentRule = g.GetRule(ID.Text);
 }

 public override IList<SrcOp> RuleRef(GrammarAST ID, GrammarAST label, GrammarAST args)
 {
     InvokeRule invokeOp = new InvokeRule(this, ID, label);
     // If no manual label and action refs as token/rule not label, we need to define implicit label
     if (controller.NeedsImplicitLabel(ID, invokeOp))
         DefineImplicitLabel(ID, invokeOp);
     AddToLabelList listLabelOp = GetAddToListOpIfListLabelPresent(invokeOp, label);
     return List(invokeOp, listLabelOp);
 }

 public MatchSet(OutputModelFactory factory, GrammarAST ast)
     : base(factory, ast)
 {
     SetTransition st = (SetTransition)ast.atnState.Transition(0);
     int wordSize = factory.GetGenerator().GetTarget().GetInlineTestSetWordSize();
     expr = new TestSetInline(factory, null, st.set, wordSize);
     Decl.Decl d = new TokenTypeDecl(factory, expr.varName);
     factory.GetCurrentRuleFunction().AddLocalDecl(d);
     capture = new CaptureNextTokenType(factory, expr.varName);
 }

 public ThrowRecognitionException(OutputModelFactory factory, GrammarAST ast, IntervalSet expecting)
     : base(factory, ast)
 {
     //this.decision = ((BlockStartState)ast.ATNState).decision;
     grammarLine = ast.Line;
     grammarLine = ast.CharPositionInLine;
     grammarFile = factory.GetGrammar().fileName;
     //this.expecting = factory.createExpectingBitSet(ast, decision, expecting, "error");
     //		factory.defineBitSet(this.expecting);
 }

 public StarBlock(OutputModelFactory factory,
                  GrammarAST blkOrEbnfRootAST,
                  IList<CodeBlockForAlt> alts)
     : base(factory, blkOrEbnfRootAST, alts)
 {
     loopLabel = factory.GetTarget().GetLoopLabel(blkOrEbnfRootAST);
     StarLoopEntryState star = (StarLoopEntryState)blkOrEbnfRootAST.atnState;
     loopBackStateNumber = star.loopBackState.stateNumber;
     decision = star.decision;
 }

        //	public BitSetDecl expecting;

        public Sync(OutputModelFactory factory,
                    GrammarAST blkOrEbnfRootAST,
                    IntervalSet expecting,
                    int decision,
                    string position)
            : base(factory, blkOrEbnfRootAST)
        {
            this.decision = decision;
            //		this.expecting = factory.createExpectingBitSet(ast, decision, expecting, position);
            //		factory.defineBitSet(this.expecting);
        }

        public LL1AltBlock(OutputModelFactory factory, GrammarAST blkAST, IList<CodeBlockForAlt> alts)
            : base(factory, blkAST, alts)
        {
            this.decision = ((DecisionState)blkAST.atnState).decision;

            /* Lookahead for each alt 1..n */
            IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision];
            altLook = GetAltLookaheadAsStringLists(altLookSets);

            IntervalSet expecting = IntervalSet.Or(altLookSets); // combine alt sets
            this.error = GetThrowNoViableAlt(factory, blkAST, expecting);
        }

        public LL1StarBlockSingleAlt(OutputModelFactory factory, GrammarAST starRoot, IList<CodeBlockForAlt> alts)
            : base(factory, starRoot, alts)
        {

            StarLoopEntryState star = (StarLoopEntryState)starRoot.atnState;
            loopBackStateNumber = star.loopBackState.stateNumber;
            this.decision = star.decision;
            IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision];
            Debug.Assert(altLookSets.Length == 2);
            IntervalSet enterLook = altLookSets[0];
            IntervalSet exitLook = altLookSets[1];
            loopExpr = AddCodeForLoopLookaheadTempVar(enterLook);
        }

 public PlusBlock(OutputModelFactory factory,
                  GrammarAST plusRoot,
                  IList<CodeBlockForAlt> alts)
     : base(factory, plusRoot, alts)
 {
     BlockAST blkAST = (BlockAST)plusRoot.GetChild(0);
     PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState;
     PlusLoopbackState loop = blkStart.loopBackState;
     stateNumber = blkStart.loopBackState.stateNumber;
     blockStartStateNumber = blkStart.stateNumber;
     loopBackStateNumber = loop.stateNumber;
     this.error = GetThrowNoViableAlt(factory, plusRoot, null);
     decision = loop.decision;
 }

        public InvokeRule(ParserFactory factory, GrammarAST ast, GrammarAST labelAST)
            : base(factory, ast)
        {
            if (ast.atnState != null)
            {
                RuleTransition ruleTrans = (RuleTransition)ast.atnState.Transition(0);
                stateNumber = ast.atnState.stateNumber;
            }

            this.name = ast.Text;
            Rule r = factory.GetGrammar().GetRule(name);
            ctxName = factory.GetTarget().GetRuleFunctionContextStructName(r);

            // TODO: move to factory
            RuleFunction rf = factory.GetCurrentRuleFunction();
            if (labelAST != null)
            {
                // for x=r, define <rule-context-type> x and list_x
                string label = labelAST.Text;
                if (labelAST.Parent.Type == ANTLRParser.PLUS_ASSIGN)
                {
                    factory.DefineImplicitLabel(ast, this);
                    string listLabel = factory.GetTarget().GetListLabel(label);
                    RuleContextListDecl l = new RuleContextListDecl(factory, listLabel, ctxName);
                    rf.AddContextDecl(ast.GetAltLabel(), l);
                }
                else
                {
                    RuleContextDecl d = new RuleContextDecl(factory, label, ctxName);
                    labels.Add(d);
                    rf.AddContextDecl(ast.GetAltLabel(), d);
                }
            }

            ActionAST arg = (ActionAST)ast.GetFirstChildWithType(ANTLRParser.ARG_ACTION);
            if (arg != null)
            {
                argExprsChunks = ActionTranslator.TranslateAction(factory, rf, arg.Token, arg);
            }

            // If action refs rule as rulename not label, we need to define implicit label
            if (factory.GetCurrentOuterMostAlt().ruleRefsInActions.ContainsKey(ast.Text))
            {
                string label = factory.GetTarget().GetImplicitRuleLabel(ast.Text);
                RuleContextDecl d = new RuleContextDecl(factory, label, ctxName);
                labels.Add(d);
                rf.AddContextDecl(ast.GetAltLabel(), d);
            }
        }

        public override void DiscoverRule(RuleAST rule, GrammarAST ID,
                                 IList<GrammarAST> modifiers, ActionAST arg,
                                 ActionAST returns, GrammarAST thrws,
                                 GrammarAST options, ActionAST locals,
                                 IList<GrammarAST> actions,
                                 GrammarAST block)
        {
            int numAlts = block.ChildCount;
            Rule r;
            if (LeftRecursiveRuleAnalyzer.HasImmediateRecursiveRuleRefs(rule, ID.Text))
            {
                r = new LeftRecursiveRule(g, ID.Text, rule);
            }
            else
            {
                r = new Rule(g, ID.Text, rule, numAlts);
            }
            rules[r.name] = r;

            if (arg != null)
            {
                r.args = ScopeParser.ParseTypedArgList(arg, arg.Text, g);
                r.args.type = AttributeDict.DictType.ARG;
                r.args.ast = arg;
                arg.resolver = r.alt[currentOuterAltNumber];
            }

            if (returns != null)
            {
                r.retvals = ScopeParser.ParseTypedArgList(returns, returns.Text, g);
                r.retvals.type = AttributeDict.DictType.RET;
                r.retvals.ast = returns;
            }

            if (locals != null)
            {
                r.locals = ScopeParser.ParseTypedArgList(locals, locals.Text, g);
                r.locals.type = AttributeDict.DictType.LOCAL;
                r.locals.ast = locals;
            }

            foreach (GrammarAST a in actions)
            {
                // a = ^(AT ID ACTION)
                ActionAST action = (ActionAST)a.GetChild(1);
                r.namedActions[a.GetChild(0).Text] = action;
                action.resolver = r;
            }
        }

        public LeftRecursiveRuleAnalyzer(GrammarAST ruleAST,
                                         AntlrTool tool, string ruleName, string language)
            : base(new CommonTreeNodeStream(new GrammarASTAdaptor(ruleAST.Token.InputStream), ruleAST))
        {
            this.tool = tool;
            this.ruleName = ruleName;
            this.language = language;
            this.tokenStream = ruleAST.g.tokenStream;
            if (this.tokenStream == null)
            {
                throw new InvalidOperationException("grammar must have a token stream");
            }

            LoadPrecRuleTemplates();
        }