MiniSharp.InputContext.Compile C# (CSharp) 메소드

		public bool Compile(List<Input> inputs)
		{
			this.inputs = inputs;
			var parser = new CSharpParser();
			var project = (IProjectContent)new CSharpProjectContent();

			// Parse each input
			var parsing = Stopwatch.StartNew();
			foreach (var input in inputs) {
				input.tree = parser.Parse(input.contents, input.name);
				input.file = input.tree.ToTypeSystem();
				project = project.AddOrUpdateFiles(input.file);
			}
			timingInMilliseconds["Parsing"] = parsing.ElapsedMilliseconds;

			// Add errors and warnings
			foreach (var diagnostic in parser.ErrorsAndWarnings) {
				diagnostics.Add(diagnostic);
			}

			// Compilation fails for parse errors
			if (parser.HasErrors) {
				return false;
			}

			// Scan the type system
			var compiling = Stopwatch.StartNew();
			compilation = project.CreateCompilation();
			root = compilation.RootNamespace;
			ScanTypes(root);
			timingInMilliseconds["Compiling"] = compiling.ElapsedMilliseconds;

			// Scan the syntax tree, linking it to the type system
			var visitor = new Visitor(this);
			foreach (var input in inputs) {
				visitor.resolver = input.resolver = new CSharpAstResolver(compilation, input.tree, input.file);
				input.tree.AcceptVisitor(visitor);
			}

			// Transform the syntax tree into valid JavaScript
			var lowering = Stopwatch.StartNew();
			var success = LoweringContext.Lower(this);
			timingInMilliseconds["Lowering"] = lowering.ElapsedMilliseconds;
			return success;
		}

        public static int Main(string[] args)
        {
            var boolFlags = new Dictionary<string, bool> {
                { "--minify", false },
                { "--mangle", false },
                { "--timing", false },
                { "--server", false },
                { "--source-map", false },
            };
            string outputPath = null;

            // Parse command-line arguments
            var inputs = new List<Input>();
            for (var i = 0; i < args.Length; i++) {
                var arg = args[i];

                // Help
                if (arg == "-h" || arg == "-help" || arg == "--help" || arg == "-?" || arg == "/?") {
                    WriteUsage();
                    return 0;
                }

                // Boolean flags
                if (boolFlags.ContainsKey(arg)) {
                    if (boolFlags[arg]) {
                        Console.WriteLine("Duplicate flag \"" + arg + "\"");
                        return 1;
                    }
                    boolFlags[arg] = true;
                    continue;
                }

                // Output file
                if (arg == "--output" || arg == "-o") {
                    if (outputPath != null) {
                        Console.WriteLine("Duplicate flag \"" + arg + "\"");
                        return 1;
                    }
                    if (i + 1 == args.Length) {
                        Console.WriteLine("Missing path for flag \"" + arg + "\"");
                        return 1;
                    }
                    outputPath = args[++i];
                    continue;
                }

                // Invalid flags
                if (arg.StartsWith("-")) {
                    Console.WriteLine("Invalid flag \"" + arg + "\"");
                    return 1;
                }

                // Input files
                inputs.Add(new Input(arg, File.ReadAllText(arg)));
            }

            // The server option ignores all other options
            if (boolFlags["--server"]) {
                return RunLocalServer() ? 0 : 1;
            }

            // Show usage if there are no inputs
            if (inputs.Count == 0) {
                WriteUsage();
                return 1;
            }

            // Parse inputs
            var context = new InputContext();
            if (!context.Compile(inputs)) {
                Console.Write(context.GenerateLog());
                return 1;
            }

            // Generate output
            var output = new OutputContext(context);
            output.ShouldMinify = boolFlags["--minify"];
            output.ShouldMangle = boolFlags["--mangle"];
            output.SourceMap = boolFlags["--source-map"] ? outputPath != null ? SourceMap.External : SourceMap.Inline : SourceMap.None;
            if (outputPath != null) {
                File.WriteAllText(outputPath, output.Code);
                if (output.SourceMap == SourceMap.External) {
                    File.WriteAllText(outputPath + ".map", output.SourceMapCode);
                }
            } else {
                Console.Write(output.Code);
            }

            // Write out timing info for debugging
            if (boolFlags["--timing"]) {
                foreach (var pair in context.timingInMilliseconds) {
                    Console.Error.WriteLine(pair.Key + ": " + pair.Value + "ms");
                }
            }

            return 0;
        }