Exemple #1
0
        public void GenerateNoErrors()
        {
            var input = MakeUpGrammar();

            SetupOptions();

            using (var reader = new StringReader(input)) {
                var parser = new CSharpCCParser(reader);

                CSharpCCGlobals.FileName = CSharpCCGlobals.OriginalFileName = "SimpleParser.cc";
                parser.csharpcc_input();
                CSharpCCGlobals.CreateOutputDir(Options.getOutputDirectory().FullName);

                Semanticize.start();
                ParseGen.start();
                LexGen.start();
                OtherFilesGen.start();
            }

            Assert.AreEqual(0, CSharpCCErrors.ErrorCount);
        }
Exemple #2
0
        public static int MainProgram(String[] args)
        {
            // Initialize all static state
            ReInitAll();

            CSharpCCGlobals.BannerLine("Parser Generator", "");

            CSharpCCParser parser = null;

            if (args.Length == 0)
            {
                Console.Out.WriteLine("");
                help_message();
                return(1);
            }
            else
            {
                Console.Out.WriteLine("(type \"csharpcc\" with no arguments for help)");
            }

            if (Options.IsOption(args[args.Length - 1]))
            {
                Console.Out.WriteLine("Last argument \"" + args[args.Length - 1] + "\" is not a filename.");
                return(1);
            }
            for (int arg = 0; arg < args.Length - 1; arg++)
            {
                if (!Options.IsOption(args[arg]))
                {
                    Console.Out.WriteLine("Argument \"" + args[arg] + "\" must be an option setting.");
                    return(1);
                }
                Options.SetCmdLineOption(args[arg]);
            }

            try {
                FileInfo fp = new FileInfo(args[args.Length - 1]);
                if (!fp.Exists)
                {
                    Console.Out.WriteLine("File " + args[args.Length - 1] + " not found.");
                    return(1);
                }
                parser =
                    new CSharpCCParser(
                        new StreamReader(new FileStream(args[args.Length - 1], FileMode.Open, FileAccess.Read, FileShare.Read),
                                         Encoding.GetEncoding(Options.getGrammarEncoding())));
            } catch (SecurityException) {
                Console.Out.WriteLine("Security violation while trying to open " + args[args.Length - 1]);
                return(1);
            } catch (FileNotFoundException) {
                Console.Out.WriteLine("File " + args[args.Length - 1] + " not found.");
                return(1);
            }

            try {
                Console.Out.WriteLine("Reading from file " + args[args.Length - 1] + " . . .");
                CSharpCCGlobals.FileName      = CSharpCCGlobals.OriginalFileName = args[args.Length - 1];
                CSharpCCGlobals.TreeGenerated = CSharpCCGlobals.IsGeneratedBy("CSTree", args[args.Length - 1]);
                CSharpCCGlobals.ToolNames     = CSharpCCGlobals.GetToolNames(args[args.Length - 1]);
                parser.csharpcc_input();
                CSharpCCGlobals.CreateOutputDir(Options.getOutputDirectory().FullName);

                if (Options.getUnicodeInput())
                {
                    NfaState.unicodeWarningGiven = true;
                    Console.Out.WriteLine("Note: UNICODE_INPUT option is specified. " +
                                          "Please make sure you create the parser/lexer using a Reader with the correct character encoding.");
                }

                Semanticize.start();
                ParseGen.start();
                LexGen.start();
                OtherFilesGen.start();

                if ((CSharpCCErrors.ErrorCount == 0) && (Options.getBuildParser() || Options.getBuildTokenManager()))
                {
                    if (CSharpCCErrors.WarningCount == 0)
                    {
                        Console.Out.WriteLine("Parser generated successfully.");
                    }
                    else
                    {
                        Console.Out.WriteLine("Parser generated with 0 errors and "
                                              + CSharpCCErrors.WarningCount + " warnings.");
                    }
                    return(0);
                }
                else
                {
                    Console.Out.WriteLine("Detected " + CSharpCCErrors.ErrorCount + " errors and "
                                          + CSharpCCErrors.WarningCount + " warnings.");
                    return((CSharpCCErrors.ErrorCount == 0) ? 0 : 1);
                }
            } catch (MetaParseException e) {
                Console.Out.WriteLine("Detected " + CSharpCCErrors.ErrorCount + " errors and "
                                      + CSharpCCErrors.WarningCount + " warnings.");
                return(1);
            } catch (ParseException e) {
                Console.Out.WriteLine(e.ToString());
                Console.Out.WriteLine("Detected " + (CSharpCCErrors.ErrorCount + 1) + " errors and "
                                      + CSharpCCErrors.WarningCount + " warnings.");
                return(1);
            }
        }