C# (CSharp) Antlr.Runtime.Tree.CommonTree.HasAncestor Exemples

Exemple #1

        public virtual void Rewrite(ITreeAdaptor adaptor, CommonTree t, string[] tokenNames)
        {
            TreeWizard wiz = new TreeWizard(adaptor, tokenNames);

            // ACTIONS STUFF
            wiz.Visit(t, ANTLRParser.ACTION, (tree) =>
            {
                ACTION(tokens, (CommonTree)tree);
            });

            // ^('@' id ACTION) rule actions
            wiz.Visit(t, ANTLRParser.AMPERSAND, (tree) =>
            {
                CommonTree a      = (CommonTree)t;
                CommonTree action = null;
                if (a.ChildCount == 2)
                {
                    action = (CommonTree)a.GetChild(1);
                }
                else if (a.ChildCount == 3)
                {
                    action = (CommonTree)a.GetChild(2);
                }

                if (action.Type == ANTLRParser.ACTION)
                {
                    tokens.Delete(a.TokenStartIndex, a.TokenStopIndex);
                    KillTrailingNewline(tokens, action.TokenStopIndex);
                }
            });

            wiz.Visit(t, ANTLRParser.ACTION, (tree) =>
            {
            });

            // wipe rule arguments
            wiz.Visit(t, ANTLRParser.ARG, (tree) =>
            {
                CommonTree a = (CommonTree)t;
                a            = (CommonTree)a.GetChild(0);
                tokens.Delete(a.token.TokenIndex);
                KillTrailingNewline(tokens, a.token.TokenIndex);
            });

            // wipe rule return declarations
            wiz.Visit(t, ANTLRParser.RET, (tree) =>
            {
                CommonTree a   = (CommonTree)t;
                CommonTree ret = (CommonTree)a.GetChild(0);
                tokens.Delete(a.token.TokenIndex, ret.token.TokenIndex);
            });

            // comment out semantic predicates
            wiz.Visit(t, ANTLRParser.SEMPRED, (tree) =>
            {
                CommonTree a = (CommonTree)t;
                tokens.Replace(a.token.TokenIndex, "/*" + a.Text + "*/");
            });

            // comment out semantic predicates
            wiz.Visit(t, ANTLRParser.GATED_SEMPRED, (tree) =>
            {
                CommonTree a = (CommonTree)t;
                string text  = tokens.ToString(a.TokenStartIndex, a.TokenStopIndex);
                tokens.Replace(a.TokenStartIndex, a.TokenStopIndex, "/*" + text + "*/");
            });

            // comment scope specs
            wiz.Visit(t, ANTLRParser.SCOPE, (tree) =>
            {
                CommonTree a = (CommonTree)t;
                tokens.Delete(a.TokenStartIndex, a.TokenStopIndex);
                KillTrailingNewline(tokens, a.TokenStopIndex);
            });

            // args r[x,y] -> ^(r [x,y])
            wiz.Visit(t, ANTLRParser.ARG_ACTION, (tree) =>
            {
                CommonTree a = (CommonTree)t;
                if (a.Parent.Type == ANTLRParser.RULE_REF)
                {
                    tokens.Delete(a.TokenStartIndex, a.TokenStopIndex);
                }
            });

#if false // what is this token type in the C# ported version of the V3 grammar?
            // ^('=' id ^(RULE_REF [arg])), ...
            wiz.Visit(t, ANTLRParser.LABEL_ASSIGN, (tree) =>
            {
                CommonTree a = (CommonTree)t;
                if (!a.HasAncestor(ANTLRParser.OPTIONS))
                {
                    // avoid options
                    CommonTree child = (CommonTree)a.GetChild(0);
                    // kill "id="
                    tokens.Delete(a.token.TokenIndex);
                    tokens.Delete(child.token.TokenIndex);
                }
            });
#endif

#if false // what is this token type in the C# ported version of the V3 grammar?
            // ^('+=' id ^(RULE_REF [arg])), ...
            wiz.Visit(t, ANTLRParser.LIST_LABEL_ASSIGN, (tree) =>
            {
                CommonTree a     = (CommonTree)t;
                CommonTree child = (CommonTree)a.GetChild(0);
                // kill "id+="
                tokens.Delete(a.token.TokenIndex);
                tokens.Delete(child.token.TokenIndex);
            });
#endif

            // AST STUFF

            wiz.Visit(t, ANTLRParser.REWRITE, (tree) =>
            {
                CommonTree a     = (CommonTree)t;
                CommonTree child = (CommonTree)a.GetChild(0);
                int stop         = child.TokenStopIndex;
                if (child.Type == ANTLRParser.SEMPRED)
                {
                    CommonTree rew = (CommonTree)a.GetChild(1);
                    stop           = rew.TokenStopIndex;
                }
                tokens.Delete(a.token.TokenIndex, stop);
                KillTrailingNewline(tokens, stop);
            });

            wiz.Visit(t, ANTLRParser.ROOT, (tree) =>
            {
                tokens.Delete(((CommonTree)t).token.TokenIndex);
            });

            wiz.Visit(t, ANTLRParser.BANG, (tree) =>
            {
                tokens.Delete(((CommonTree)t).token.TokenIndex);
            });
        }