Ejemplo n.º 1
0
        // support

        public virtual void DefineImplicitLabel(GrammarAST ast, LabeledOp op)
        {
            Decl d;

            if (ast.Type == ANTLRParser.SET || ast.Type == ANTLRParser.WILDCARD)
            {
                string implLabel =
                    GetTarget().GetImplicitSetLabel(ast.Token.TokenIndex.ToString());
                d = GetTokenLabelDecl(implLabel);
                ((TokenDecl)d).isImplicit = true;
            }
            else if (ast.Type == ANTLRParser.RULE_REF)
            { // a rule reference?
                Rule   r         = g.GetRule(ast.Text);
                string implLabel = GetTarget().GetImplicitRuleLabel(ast.Text);
                string ctxName   =
                    GetTarget().GetRuleFunctionContextStructName(r);
                d = new RuleContextDecl(this, implLabel, ctxName);
                ((RuleContextDecl)d).isImplicit = true;
            }
            else
            {
                string implLabel = GetTarget().GetImplicitTokenLabel(ast.Text);
                d = GetTokenLabelDecl(implLabel);
                ((TokenDecl)d).isImplicit = true;
            }
            op.GetLabels().Add(d);
            // all labels must be in scope struct in case we exec action out of context
            GetCurrentRuleFunction().AddContextDecl(ast.GetAltLabel(), d);
        }
Ejemplo n.º 2
0
        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 LeftRecursiveRuleFunction(OutputModelFactory factory, LeftRecursiveRule r)
            : base(factory, r)
        {
            // Since we delete x=lr, we have to manually add decls for all labels
            // on left-recur refs to proper structs
            foreach (System.Tuple <GrammarAST, string> pair in r.leftRecursiveRuleRefLabels)
            {
                GrammarAST idAST    = pair.Item1;
                string     altLabel = pair.Item2;
                string     label    = idAST.Text;
                GrammarAST rrefAST  = (GrammarAST)idAST.Parent.GetChild(1);
                if (rrefAST.Type == ANTLRParser.RULE_REF)
                {
                    Rule            targetRule = factory.GetGrammar().GetRule(rrefAST.Text);
                    string          ctxName    = factory.GetTarget().GetRuleFunctionContextStructName(targetRule);
                    RuleContextDecl d;
                    if (idAST.Parent.Type == ANTLRParser.ASSIGN)
                    {
                        d = new RuleContextDecl(factory, label, ctxName);
                    }
                    else
                    {
                        d = new RuleContextListDecl(factory, label, ctxName);
                    }

                    StructDecl @struct = ruleCtx;
                    if (altLabelCtxs != null)
                    {
                        AltLabelStructDecl s;
                        if (altLabel != null && altLabelCtxs.TryGetValue(altLabel, out s) && s != null)
                        {
                            @struct = s; // if alt label, use subctx
                        }
                    }

                    @struct.AddDecl(d); // stick in overall rule's ctx
                }
            }
        }