Antlr4.Analysis.LeftFactoringRuleTransformer.TranslateLeftFactoredRules C# (CSharp) Method

        public virtual void TranslateLeftFactoredRules()
        {
            // translate all rules marked for auto left factoring
            foreach (Rule r in _rules.Values)
            {
                if (Grammar.IsTokenName(r.name))
                {
                    continue;
                }

                ActionAST leftFactoredRules;
                if (!r.namedActions.TryGetValue(LEFTFACTOR, out leftFactoredRules) || leftFactoredRules == null)
                {
                    continue;
                }

                string leftFactoredRuleAction = leftFactoredRules.ToString();
                leftFactoredRuleAction = leftFactoredRuleAction.Substring(1, leftFactoredRuleAction.Length - 2);
                string[] rules = leftFactoredRuleAction.Split(',');
                for (int i = 0; i < rules.Length; i++)
                    rules[i] = rules[i].Trim();

                if (rules.Length == 0)
                {
                    continue;
                }

#if false
                LOGGER.log(Level.FINE, "Left factoring {0} out of alts in grammar rule {1}", new object[] { Arrays.toString(rules), r.name });
#endif

                ISet<GrammarAST> translatedBlocks = new HashSet<GrammarAST>();
                IList<GrammarAST> blocks = r.ast.GetNodesWithType(ANTLRParser.BLOCK);
                foreach (GrammarAST block in blocks)
                {
                    for (GrammarAST current = (GrammarAST)block.Parent; current != null; current = (GrammarAST)current.GetAncestor(ANTLRParser.BLOCK))
                    {
                        if (translatedBlocks.Contains(current))
                        {
                            // an enclosing decision was already factored
                            goto continueBlockLoop;
                        }
                    }

                    if (rules.Length != 1)
                    {
                        throw new NotImplementedException("Chained left factoring is not yet implemented.");
                    }

                    if (!TranslateLeftFactoredDecision(block, rules[0], false, DecisionFactorMode.COMBINED_FACTOR, true))
                    {
                        // couldn't translate the decision
                        continue;
                    }

                    translatedBlocks.Add(block);

                    continueBlockLoop:
                    ;
                }
            }
        }

        public virtual void Process()
        {
            if (g.ast == null)
                return;

            // COLLECT RULE OBJECTS
            RuleCollector ruleCollector = new RuleCollector(g);
            ruleCollector.Process(g.ast);

            // CLONE RULE ASTs FOR CONTEXT REFERENCE
            foreach (Rule rule in ruleCollector.rules.Values)
            {
                IList<RuleAST> list;
                if (!g.contextASTs.TryGetValue(rule.GetBaseContext(), out list) || list == null)
                {
                    list = new List<RuleAST>();
                    g.contextASTs[rule.GetBaseContext()] = list;
                }

                list.Add((RuleAST)rule.ast.DupTree());
            }

            // DO BASIC / EASY SEMANTIC CHECKS
            int prevErrors = g.tool.errMgr.GetNumErrors();
            BasicSemanticChecks basics = new BasicSemanticChecks(g, ruleCollector);
            basics.Process();
            if (g.tool.errMgr.GetNumErrors() > prevErrors)
                return;

            // TRANSFORM LEFT-RECURSIVE RULES
            prevErrors = g.tool.errMgr.GetNumErrors();
            LeftRecursiveRuleTransformer lrtrans =
                new LeftRecursiveRuleTransformer(g.ast, ruleCollector.rules.Values, g);
            lrtrans.TranslateLeftRecursiveRules();

            // don't continue if we got errors during left-recursion elimination
            if (g.tool.errMgr.GetNumErrors() > prevErrors)
            {
                return;
            }

            // AUTO LEFT FACTORING
            LeftFactoringRuleTransformer lftrans = new LeftFactoringRuleTransformer(g.ast, ruleCollector.rules, g);
            lftrans.TranslateLeftFactoredRules();

            // STORE RULES IN GRAMMAR
            foreach (Rule r in ruleCollector.rules.Values)
            {
                g.DefineRule(r);
            }

            // COLLECT SYMBOLS: RULES, ACTIONS, TERMINALS, ...
            SymbolCollector collector = new SymbolCollector(g);
            collector.Process(g.ast);

            // CHECK FOR SYMBOL COLLISIONS
            SymbolChecks symcheck = new SymbolChecks(g, collector);
            symcheck.Process(); // side-effect: strip away redef'd rules.

            foreach (GrammarAST a in collector.namedActions)
            {
                g.DefineAction(a);
            }

            // LINK (outermost) ALT NODES WITH Alternatives
            foreach (Rule r in g.rules.Values)
            {
                for (int i = 1; i <= r.numberOfAlts; i++)
                {
                    r.alt[i].ast.alt = r.alt[i];
                }
            }

            // ASSIGN TOKEN TYPES
            g.ImportTokensFromTokensFile();
            if (g.IsLexer())
            {
                AssignLexerTokenTypes(g, collector.tokensDefs);
            }
            else
            {
                AssignTokenTypes(g, collector.tokensDefs,
                                 collector.tokenIDRefs, collector.terminals);
            }

            symcheck.CheckForModeConflicts(g);

            AssignChannelTypes(g, collector.channelDefs);

            // CHECK RULE REFS NOW (that we've defined rules in grammar)
            symcheck.CheckRuleArgs(g, collector.rulerefs);
            IdentifyStartRules(collector);
            symcheck.CheckForQualifiedRuleIssues(g, collector.qualifiedRulerefs);

            // don't continue if we got symbol errors
            if (g.tool.GetNumErrors() > 0)
                return;

            // CHECK ATTRIBUTE EXPRESSIONS FOR SEMANTIC VALIDITY
            AttributeChecks.CheckAllAttributeExpressions(g);

            UseDefAnalyzer.TrackTokenRuleRefsInActions(g);
        }