Antlr4.Codegen.AbstractTarget.GrammarSymbolCausesIssueInGeneratedCode C# (CSharp) Method

        public virtual bool GrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode)
        {
            switch (idNode.Parent.Type)
            {
            case ANTLRParser.ASSIGN:
                switch (idNode.Parent.Parent.Type)
                {
                case ANTLRParser.ELEMENT_OPTIONS:
                case ANTLRParser.OPTIONS:
                    return false;

                default:
                    break;
                }

                break;

            case ANTLRParser.AT:
            case ANTLRParser.ELEMENT_OPTIONS:
                return false;

            case ANTLRParser.LEXER_ACTION_CALL:
                if (idNode.ChildIndex == 0)
                {
                    // first child is the command name which is part of the ANTLR language
                    return false;
                }

                // arguments to the command should be checked
                break;

            default:
                break;
            }

            return VisibleGrammarSymbolCausesIssueInGeneratedCode(idNode);
        }

        public virtual void Process()
        {
            CodeGenerator  gen    = new CodeGenerator(g);
            AbstractTarget target = gen.GetTarget();

            if (target == null)
            {
                return;
            }

            IntervalSet idTypes = new IntervalSet();

            idTypes.Add(ANTLRParser.ID);
            idTypes.Add(ANTLRParser.RULE_REF);
            idTypes.Add(ANTLRParser.TOKEN_REF);
            IList <GrammarAST> idNodes = g.ast.GetNodesWithType(idTypes);

            foreach (GrammarAST idNode in idNodes)
            {
                if (target.GrammarSymbolCausesIssueInGeneratedCode(idNode))
                {
                    g.tool.errMgr.GrammarError(ErrorType.USE_OF_BAD_WORD,
                                               g.fileName, idNode.Token,
                                               idNode.Text);
                }
            }

            // all templates are generated in memory to report the most complete
            // error information possible, but actually writing output files stops
            // after the first error is reported
            int errorCount = g.tool.errMgr.GetNumErrors();

            if (g.IsLexer())
            {
                if (target.NeedsHeader())
                {
                    Template lexerHeader = gen.GenerateLexer(true); // Header file if needed.
                    if (g.tool.errMgr.GetNumErrors() == errorCount)
                    {
                        WriteRecognizer(lexerHeader, gen, true);
                    }
                }
                Template lexer = gen.GenerateLexer(false);
                if (g.tool.errMgr.GetNumErrors() == errorCount)
                {
                    WriteRecognizer(lexer, gen, false);
                }
            }
            else
            {
                if (target.NeedsHeader())
                {
                    Template parserHeader = gen.GenerateParser(true);
                    if (g.tool.errMgr.GetNumErrors() == errorCount)
                    {
                        WriteRecognizer(parserHeader, gen, true);
                    }
                }
                Template parser = gen.GenerateParser(false);
                if (g.tool.errMgr.GetNumErrors() == errorCount)
                {
                    WriteRecognizer(parser, gen, false);
                }

                if (g.tool.gen_listener)
                {
                    if (target.NeedsHeader())
                    {
                        Template listenerHeader = gen.GenerateListener(true);
                        if (g.tool.errMgr.GetNumErrors() == errorCount)
                        {
                            gen.WriteListener(listenerHeader, true);
                        }
                    }
                    Template listener = gen.GenerateListener(false);
                    if (g.tool.errMgr.GetNumErrors() == errorCount)
                    {
                        gen.WriteListener(listener, false);
                    }

                    if (target.NeedsHeader())
                    {
                        Template baseListener = gen.GenerateBaseListener(true);
                        if (g.tool.errMgr.GetNumErrors() == errorCount)
                        {
                            gen.WriteBaseListener(baseListener, true);
                        }
                    }
                    if (target.WantsBaseListener())
                    {
                        Template baseListener = gen.GenerateBaseListener(false);
                        if (g.tool.errMgr.GetNumErrors() == errorCount)
                        {
                            gen.WriteBaseListener(baseListener, false);
                        }
                    }
                }
                if (g.tool.gen_visitor)
                {
                    if (target.NeedsHeader())
                    {
                        Template visitorHeader = gen.GenerateVisitor(true);
                        if (g.tool.errMgr.GetNumErrors() == errorCount)
                        {
                            gen.WriteVisitor(visitorHeader, true);
                        }
                    }
                    Template visitor = gen.GenerateVisitor(false);
                    if (g.tool.errMgr.GetNumErrors() == errorCount)
                    {
                        gen.WriteVisitor(visitor, false);
                    }

                    if (target.NeedsHeader())
                    {
                        Template baseVisitor = gen.GenerateBaseVisitor(true);
                        if (g.tool.errMgr.GetNumErrors() == errorCount)
                        {
                            gen.WriteBaseVisitor(baseVisitor, true);
                        }
                    }
                    if (target.WantsBaseVisitor())
                    {
                        Template baseVisitor = gen.GenerateBaseVisitor(false);
                        if (g.tool.errMgr.GetNumErrors() == errorCount)
                        {
                            gen.WriteBaseVisitor(baseVisitor, false);
                        }
                    }
                }
            }

            gen.WriteVocabFile();
        }