[System] Remove Process.Start and related API from TvOS/WatchOS.

[mono.git] / mcs / mcs / driver.cs

diff --git a/mcs/mcs/driver.cs b/mcs/mcs/driver.cs
index 920951ea2efa225dacd25689325bd6be545db0f9..0a11914328ae79629b356b78bd879de1942f3b69 100644 (file)
--- a/mcs/mcs/driver.cs
+++ b/mcs/mcs/driver.cs
@@ -20,6 +20,7 @@ using System.IO;
 using System.Text;
 using System.Globalization;
 using System.Diagnostics;
+using System.Threading;
 
 namespace Mono.CSharp
 {
@@ -41,7 +42,7 @@ namespace Mono.CSharp
                        }
                }
 
-               void tokenize_file (SourceFile sourceFile, ModuleContainer module)
+               void tokenize_file (SourceFile sourceFile, ModuleContainer module, ParserSession session)
                {
                        Stream input;
 
@@ -56,7 +57,7 @@ namespace Mono.CSharp
                                SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
                                var file = new CompilationSourceFile (module, sourceFile);
 
-                               Tokenizer lexer = new Tokenizer (reader, file);
+                               Tokenizer lexer = new Tokenizer (reader, file, session, ctx.Report);
                                int token, tokens = 0, errors = 0;
 
                                while ((token = lexer.token ()) != Token.EOF){
@@ -77,48 +78,95 @@ namespace Mono.CSharp
 
                        Location.Initialize (sources);
 
+                       var session = new ParserSession {
+                               UseJayGlobalArrays = true,
+                               LocatedTokens = new LocatedToken[15000]
+                       };
+
                        for (int i = 0; i < sources.Count; ++i) {
                                if (tokenize_only) {
-                                       tokenize_file (sources[i], module);
+                                       tokenize_file (sources[i], module, session);
                                } else {
-                                       Parse (sources[i], module);
+                                       Parse (sources[i], module, session, Report);
                                }
                        }
                }
 
-               public void Parse (SourceFile file, ModuleContainer module)
+#if false
+               void ParseParallel (ModuleContainer module)
+               {
+                       var sources = module.Compiler.SourceFiles;
+
+                       Location.Initialize (sources);
+
+                       var pcount = Environment.ProcessorCount;
+                       var threads = new Thread[System.Math.Max (2, pcount - 1)];
+
+                       for (int i = 0; i < threads.Length; ++i) {
+                               var t = new Thread (l => {
+                                       var session = new ParserSession () {
+                                               //UseJayGlobalArrays = true,
+                                       };
+
+                                       var report = new Report (ctx, Report.Printer); // TODO: Implement flush at once printer
+
+                                       for (int ii = (int) l; ii < sources.Count; ii += threads.Length) {
+                                               Parse (sources[ii], module, session, report);
+                                       }
+
+                                       // TODO: Merge warning regions
+                               });
+
+                               t.Start (i);
+                               threads[i] = t;
+                       }
+
+                       for (int t = 0; t < threads.Length; ++t) {
+                               threads[t].Join ();
+                       }
+               }
+#endif
+
+               public void Parse (SourceFile file, ModuleContainer module, ParserSession session, Report report)
                {
                        Stream input;
 
                        try {
                                input = File.OpenRead (file.Name);
                        } catch {
-                               Report.Error (2001, "Source file `{0}' could not be found", file.Name);
+                               report.Error (2001, "Source file `{0}' could not be found", file.Name);
                                return;
                        }
 
                        // Check 'MZ' header
                        if (input.ReadByte () == 77 && input.ReadByte () == 90) {
 
-                               Report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
+                               report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
                                input.Close ();
                                return;
                        }
 
                        input.Position = 0;
-                       SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
+                       SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding, session.StreamReaderBuffer);
+
+                       Parse (reader, file, module, session, report);
+
+                       if (ctx.Settings.GenerateDebugInfo && report.Errors == 0 && !file.HasChecksum) {
+                               input.Position = 0;
+                               var checksum = session.GetChecksumAlgorithm ();
+                               file.SetChecksum (checksum.ComputeHash (input));
+                       }
 
-                       Parse (reader, file, module);
                        reader.Dispose ();
                        input.Close ();
                }
 
-               public static void Parse (SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module)
+               public static void Parse (SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, ParserSession session, Report report)
                {
                        var file = new CompilationSourceFile (module, sourceFile);
                        module.AddTypeContainer (file);
 
-                       CSharpParser parser = new CSharpParser (reader, file);
+                       CSharpParser parser = new CSharpParser (reader, file, report, session);
                        parser.parse ();
                }
                
@@ -153,6 +201,7 @@ namespace Mono.CSharp
 
                public static string GetPackageFlags (string packages, Report report)
                {
+#if MONO_FEATURE_PROCESS_START
                        ProcessStartInfo pi = new ProcessStartInfo ();
                        pi.FileName = "pkg-config";
                        pi.RedirectStandardOutput = true;
@@ -191,6 +240,9 @@ namespace Mono.CSharp
 
                        p.Close ();
                        return pkgout;
+#else
+                       throw new NotSupportedException ("Process.Start is not supported on this platform.");
+#endif // MONO_FEATURE_PROCESS_START
                }
 
                //
@@ -211,6 +263,11 @@ namespace Mono.CSharp
                                return false;
                        }
 
+                       if (settings.Platform == Platform.AnyCPU32Preferred && (settings.Target == Target.Library || settings.Target == Target.Module)) {
+                               Report.Error (4023, "Platform option `anycpu32bitpreferred' is valid only for executables");
+                               return false;
+                       }
+
                        TimeReporter tr = new TimeReporter (settings.Timestamps);
                        ctx.TimeReporter = tr;
                        tr.StartTotal ();
@@ -251,6 +308,12 @@ namespace Mono.CSharp
                                output_file = output_file_name;
                        } else {
                                output_file_name = Path.GetFileName (output_file);
+
+                               if (string.IsNullOrEmpty (Path.GetFileNameWithoutExtension (output_file_name)) ||
+                                       output_file_name.IndexOfAny (Path.GetInvalidFileNameChars ()) >= 0) {
+                                       Report.Error (2021, "Output file name is not valid");
+                                       return false;
+                               }
                        }
 
 #if STATIC
@@ -269,6 +332,7 @@ namespace Mono.CSharp
                        tr.Start (TimeReporter.TimerType.CreateTypeTotal);
                        module.CreateContainer ();
                        importer.AddCompiledAssembly (assembly);
+                       references_loader.CompiledAssembly = assembly;
                        tr.Stop (TimeReporter.TimerType.CreateTypeTotal);
 
                        references_loader.LoadReferences (module);
@@ -302,6 +366,9 @@ namespace Mono.CSharp
 #endif
                        module.InitializePredefinedTypes ();
 
+                       if (settings.GetResourceStrings != null)
+                               module.LoadGetResourceStrings (settings.GetResourceStrings);
+
                        tr.Start (TimeReporter.TimerType.ModuleDefinitionTotal);
                        module.Define ();
                        tr.Stop (TimeReporter.TimerType.ModuleDefinitionTotal);
@@ -333,7 +400,8 @@ namespace Mono.CSharp
                        tr.Stop (TimeReporter.TimerType.CloseTypes);
 
                        tr.Start (TimeReporter.TimerType.Resouces);
-                       assembly.EmbedResources ();
+                       if (!settings.WriteMetadataOnly)
+                               assembly.EmbedResources ();
                        tr.Stop (TimeReporter.TimerType.Resouces);
 
                        if (Report.Errors > 0)