Example #1
0
        private static int Main(string[] args)
        {
            Stream inputFile = null;

            Grammar      grammar       = null;
            ErrorHandler handler       = new ErrorHandler();
            string       inputFileInfo = null; // Filename plus revision time.

            Lexers.Scanner scanner = null;
            Parser.Parser  parser  = null;
            Assembly       assm    = Assembly.GetExecutingAssembly();
            object         info    = Attribute.GetCustomAttribute(assm, typeof(AssemblyFileVersionAttribute));

            versionInfo = ((AssemblyFileVersionAttribute)info).Version;

            try {
                string filename = ProcessOptions(args);

                if (filename == null)
                {
                    return(MC_OK);
                }

                try {
                    inputFile     = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
                    inputFileInfo = filename + " - " + File.GetLastWriteTime(filename).ToString();
                }
                catch (IOException x) {
                    string message;
                    inputFile = null;
                    if (x is FileNotFoundException)
                    {
                        message = String.Format(CultureInfo.InvariantCulture,
                                                "Source file <{0}> not found{1}",
                                                filename, Environment.NewLine);
                    }
                    else
                    {
                        message = String.Format(CultureInfo.InvariantCulture,
                                                "Source file <{0}> could not be opened{1}",
                                                filename, Environment.NewLine);
                    }
                    handler.AddError(4, message, null);   // aast.AtStart;
                    return(MC_FILEERROR);
                }

                scanner = new Lexers.Scanner(inputFile);
                scanner.SetHandler(handler);

                parser = new Parser.Parser(filename, inputFileInfo, scanner, handler);
                //
                // If the parse is successful, then process the grammar.
                // Otherwise just report the errors that have been listed.
                //
                if (parser.Parse())
                {
                    grammar = parser.Grammar;

                    if (Terminal.Max > 255)
                    {
                        handler.ListError(null, 103, CharacterUtilities.Map(Terminal.Max), '\'');
                    }

                    LALRGenerator         generator = new LALRGenerator(grammar);
                    List <AutomatonState> states    = generator.BuildStates();
                    generator.ComputeLookAhead();
                    generator.BuildParseTable();
                    if (!grammar.CheckGrammar(handler))
                    {
                        throw new ArgumentException("Non-terminating grammar");
                    }
                    //
                    // If the grammar has non-terminating non-terms we cannot
                    // create a diagnostic report as the grammar is incomplete.
                    //
                    if (!handler.Errors)
                    {
                        CodeGenerator emitter = new CodeGenerator(grammar);
                        emitter.Generate(states);
                    }

                    bool DoDiagnose = Diagnose && !grammar.HasNonTerminatingNonTerms;
                    if (Report || DoDiagnose)
                    {
                        string htmlName = System.IO.Path.ChangeExtension(filename, ".report.html");
                        try {
                            System.IO.FileStream   htmlFile   = new System.IO.FileStream(htmlName, System.IO.FileMode.Create);
                            System.IO.StreamWriter htmlWriter = new System.IO.StreamWriter(htmlFile);
                            Grammar.HtmlHeader(htmlWriter, filename);

                            if (Report && DoDiagnose)
                            {
                                grammar.GenerateCompoundReport(htmlWriter, inputFileInfo, states);
                            }
                            else if (Report)
                            {
                                grammar.GenerateReport(htmlWriter, inputFileInfo, states);
                            }

                            Grammar.HtmlTrailer(htmlWriter);

                            if (htmlFile != null)
                            {
                                htmlWriter.Flush();
                                htmlFile.Close();
                            }
                        }
                        catch (System.IO.IOException) {
                            Console.Error.WriteLine("Cannot create html output file {0}", htmlName);
                        }
                    }
                }
            }
            catch (System.Exception e) {
                if (e is TooManyErrorsException)
                {
                    return(MC_TOOMANYERRORS);
                }
                Console.Error.WriteLine("Unexpected Error {0}", e.Message);

                if (NoThrowOnError)
                {
                    // report the error, do not let it go into the void
                    Console.Error.WriteLine(e);
                    return(MC_EXCEPTION);
                }
            }
            finally {
                if (handler.Errors || handler.Warnings)
                {
                    handler.DumpAll((scanner == null ? null : scanner.Buffer), Console.Error);
                }
                if ((Listing || handler.Errors || handler.Warnings) && parser != null)
                {
                    string       listName   = parser.ListfileName;
                    StreamWriter listStream = ListingFile(listName);
                    if (listStream != null)
                    {
                        handler.MakeListing(scanner.Buffer, listStream, parser.SourceFileInfo, versionInfo);
                    }
                }
            }
            return(MC_OK);
        }