mcs/mcs/driver.cs

   1 //
   2 // driver.cs: The compiler command line driver.
   3 //
   4 // Authors:
   5 //   Miguel de Icaza (miguel@gnu.org)
   6 //   Marek Safar (marek.safar@gmail.com)
   7 //
   8 // Dual licensed under the terms of the MIT X11 or GNU GPL
   9 //
  10 // Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
  11 // Copyright 2004, 2005, 2006, 2007, 2008 Novell, Inc
  12 //
  13
  14 using System;
  15 using System.Reflection;
  16 using System.Reflection.Emit;
  17 using System.Collections.Generic;
  18 using System.IO;
  19 using System.Text;
  20 using System.Globalization;
  21 using System.Diagnostics;
  22
  23 namespace Mono.CSharp
  24 {
  25         /// <summary>
  26         ///    The compiler driver.
  27         /// </summary>
  28         class Driver
  29         {
  30                 readonly CompilerContext ctx;
  31
  32                 public Driver (CompilerContext ctx)
  33                 {
  34                         this.ctx = ctx;
  35                 }
  36
  37                 Report Report {
  38                         get {
  39                                 return ctx.Report;
  40                         }
  41                 }
  42
  43                 void tokenize_file (CompilationSourceFile file)
  44                 {
  45                         Stream input;
  46
  47                         try {
  48                                 input = File.OpenRead (file.Name);
  49                         } catch {
  50                                 Report.Error (2001, "Source file `" + file.Name + "' could not be found");
  51                                 return;
  52                         }
  53
  54                         using (input){
  55                                 SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
  56                                 Tokenizer lexer = new Tokenizer (reader, file, ctx);
  57                                 int token, tokens = 0, errors = 0;
  58
  59                                 while ((token = lexer.token ()) != Token.EOF){
  60                                         tokens++;
  61                                         if (token == Token.ERROR)
  62                                                 errors++;
  63                                 }
  64                                 Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors");
  65                         }
  66
  67                         return;
  68                 }
  69
  70                 void Parse (ModuleContainer module)
  71                 {
  72                         Location.Initialize (module.Compiler.SourceFiles);
  73
  74                         bool tokenize_only = module.Compiler.Settings.TokenizeOnly;
  75                         var sources = module.Compiler.SourceFiles;
  76                         for (int i = 0; i < sources.Count; ++i) {
  77                                 if (tokenize_only) {
  78                                         tokenize_file (sources[i]);
  79                                 } else {
  80                                         Parse (sources[i], module);
  81                                 }
  82                         }
  83                 }
  84
  85                 void Parse (CompilationSourceFile file, ModuleContainer module)
  86                 {
  87                         Stream input;
  88
  89                         try {
  90                                 input = File.OpenRead (file.Name);
  91                         } catch {
  92                                 Report.Error (2001, "Source file `{0}' could not be found", file.Name);
  93                                 return;
  94                         }
  95
  96                         // Check 'MZ' header
  97                         if (input.ReadByte () == 77 && input.ReadByte () == 90) {
  98                                 Report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
  99                                 input.Close ();
 100                                 return;
 101                         }
 102
 103                         input.Position = 0;
 104                         SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
 105
 106                         Parse (reader, file, module);
 107                         reader.Dispose ();
 108                         input.Close ();
 109                 }
 110
 111                 public void Parse (SeekableStreamReader reader, CompilationSourceFile file, ModuleContainer module)
 112                 {
 113                         file.NamespaceContainer = new NamespaceEntry (module, null, file, null);
 114
 115                         CSharpParser parser = new CSharpParser (reader, file);
 116                         parser.parse ();
 117                 }
 118
 119                 public static int Main (string[] args)
 120                 {
 121                         Location.InEmacs = Environment.GetEnvironmentVariable ("EMACS") == "t";
 122
 123                         var r = new Report (new ConsoleReportPrinter ());
 124                         CommandLineParser cmd = new CommandLineParser (r);
 125                         var settings = cmd.ParseArguments (args);
 126                         if (settings == null || r.Errors > 0)
 127                                 return 1;
 128
 129                         if (cmd.HasBeenStopped)
 130                                 return 0;
 131
 132                         Driver d = new Driver (new CompilerContext (settings, r));
 133
 134                         if (d.Compile () && d.Report.Errors == 0) {
 135                                 if (d.Report.Warnings > 0) {
 136                                         Console.WriteLine ("Compilation succeeded - {0} warning(s)", d.Report.Warnings);
 137                                 }
 138                                 Environment.Exit (0);
 139                                 return 0;
 140                         }
 141
 142
 143                         Console.WriteLine("Compilation failed: {0} error(s), {1} warnings",
 144                                 d.Report.Errors, d.Report.Warnings);
 145                         Environment.Exit (1);
 146                         return 1;
 147                 }
 148
 149                 public static string GetPackageFlags (string packages, Report report)
 150                 {
 151                         ProcessStartInfo pi = new ProcessStartInfo ();
 152                         pi.FileName = "pkg-config";
 153                         pi.RedirectStandardOutput = true;
 154                         pi.UseShellExecute = false;
 155                         pi.Arguments = "--libs " + packages;
 156                         Process p = null;
 157                         try {
 158                                 p = Process.Start (pi);
 159                         } catch (Exception e) {
 160                                 if (report == null)
 161                                         throw;
 162
 163                                 report.Error (-27, "Couldn't run pkg-config: " + e.Message);
 164                                 return null;
 165                         }
 166
 167                         if (p.StandardOutput == null) {
 168                                 if (report == null)
 169                                         throw new ApplicationException ("Specified package did not return any information");
 170
 171                                 report.Warning (-27, 1, "Specified package did not return any information");
 172                                 p.Close ();
 173                                 return null;
 174                         }
 175
 176                         string pkgout = p.StandardOutput.ReadToEnd ();
 177                         p.WaitForExit ();
 178                         if (p.ExitCode != 0) {
 179                                 if (report == null)
 180                                         throw new ApplicationException (pkgout);
 181
 182                                 report.Error (-27, "Error running pkg-config. Check the above output.");
 183                                 p.Close ();
 184                                 return null;
 185                         }
 186
 187                         p.Close ();
 188                         return pkgout;
 189                 }
 190
 191                 //
 192                 // Main compilation method
 193                 //
 194                 public bool Compile ()
 195                 {
 196                         var settings = ctx.Settings;
 197
 198                         //
 199                         // If we are an exe, require a source file for the entry point or
 200                         // if there is nothing to put in the assembly, and we are not a library
 201                         //
 202                         if (settings.FirstSourceFile == null &&
 203                                 ((settings.Target == Target.Exe || settings.Target == Target.WinExe || settings.Target == Target.Module) ||
 204                                 settings.Resources == null)) {
 205                                 Report.Error (2008, "No files to compile were specified");
 206                                 return false;
 207                         }
 208
 209                         TimeReporter tr = new TimeReporter (settings.Timestamps);
 210                         ctx.TimeReporter = tr;
 211                         tr.StartTotal ();
 212
 213                         var module = new ModuleContainer (ctx);
 214                         RootContext.ToplevelTypes = module;
 215
 216                         tr.Start (TimeReporter.TimerType.ParseTotal);
 217                         Parse (module);
 218                         tr.Stop (TimeReporter.TimerType.ParseTotal);
 219
 220                         if (Report.Errors > 0)
 221                                 return false;
 222
 223                         if (settings.TokenizeOnly || settings.ParseOnly) {
 224                                 tr.StopTotal ();
 225                                 tr.ShowStats ();
 226                                 return true;
 227                         }
 228
 229                         if (RootContext.ToplevelTypes.NamespaceEntry != null)
 230                                 throw new InternalErrorException ("who set it?");
 231
 232                         var output_file = settings.OutputFile;
 233                         string output_file_name;
 234                         if (output_file == null) {
 235                                 var source_file = settings.FirstSourceFile;
 236
 237                                 if (source_file == null) {
 238                                         Report.Error (1562, "If no source files are specified you must specify the output file with -out:");
 239                                         return false;
 240                                 }
 241
 242                                 output_file_name = source_file.Name;
 243                                 int pos = output_file_name.LastIndexOf ('.');
 244
 245                                 if (pos > 0)
 246                                         output_file_name = output_file_name.Substring (0, pos);
 247
 248                                 output_file_name += settings.TargetExt;
 249                                 output_file = output_file_name;
 250                         } else {
 251                                 output_file_name = Path.GetFileName (output_file);
 252                         }
 253
 254 #if STATIC
 255                         var importer = new StaticImporter (module);
 256                         var references_loader = new StaticLoader (importer, ctx);
 257
 258                         tr.Start (TimeReporter.TimerType.AssemblyBuilderSetup);
 259                         var assembly = new AssemblyDefinitionStatic (module, references_loader, output_file_name, output_file);
 260                         assembly.Create (references_loader.Domain);
 261                         tr.Stop (TimeReporter.TimerType.AssemblyBuilderSetup);
 262
 263                         // Create compiler types first even before any referenced
 264                         // assembly is loaded to allow forward referenced types from
 265                         // loaded assembly into compiled builder to be resolved
 266                         // correctly
 267                         tr.Start (TimeReporter.TimerType.CreateTypeTotal);
 268                         module.CreateType ();
 269                         importer.AddCompiledAssembly (assembly);
 270                         tr.Stop (TimeReporter.TimerType.CreateTypeTotal);
 271
 272                         references_loader.LoadReferences (module);
 273
 274                         tr.Start (TimeReporter.TimerType.PredefinedTypesInit);
 275                         if (!ctx.BuildinTypes.CheckDefinitions (module))
 276                                 return false;
 277
 278                         tr.Stop (TimeReporter.TimerType.PredefinedTypesInit);
 279
 280                         references_loader.LoadModules (assembly, module.GlobalRootNamespace);
 281 #else
 282                         var assembly = new AssemblyDefinitionDynamic (module, output_file_name, output_file);
 283                         module.SetDeclaringAssembly (assembly);
 284
 285                         var importer = new ReflectionImporter (module, ctx.BuildinTypes);
 286                         assembly.Importer = importer;
 287
 288                         var loader = new DynamicLoader (importer, ctx);
 289                         loader.LoadReferences (module);
 290
 291                         if (!ctx.BuildinTypes.CheckDefinitions (module))
 292                                 return false;
 293
 294                         if (!assembly.Create (AppDomain.CurrentDomain, AssemblyBuilderAccess.Save))
 295                                 return false;
 296
 297                         module.CreateType ();
 298
 299                         loader.LoadModules (assembly, module.GlobalRootNamespace);
 300 #endif
 301                         module.InitializePredefinedTypes ();
 302
 303                         tr.Start (TimeReporter.TimerType.UsingResolve);
 304                         foreach (var source_file in ctx.SourceFiles) {
 305                                 source_file.NamespaceContainer.Resolve ();
 306                         }
 307                         tr.Stop (TimeReporter.TimerType.UsingResolve);
 308
 309                         tr.Start (TimeReporter.TimerType.ModuleDefinitionTotal);
 310                         module.Define ();
 311                         tr.Stop (TimeReporter.TimerType.ModuleDefinitionTotal);
 312
 313                         if (Report.Errors > 0)
 314                                 return false;
 315
 316                         if (settings.Documentation != null &&
 317                                 !settings.Documentation.OutputDocComment (
 318                                         output_file, Report))
 319                                 return false;
 320
 321                         assembly.Resolve ();
 322
 323                         if (Report.Errors > 0)
 324                                 return false;
 325
 326
 327                         tr.Start (TimeReporter.TimerType.EmitTotal);
 328                         assembly.Emit ();
 329                         tr.Stop (TimeReporter.TimerType.EmitTotal);
 330
 331                         if (Report.Errors > 0){
 332                                 return false;
 333                         }
 334
 335                         tr.Start (TimeReporter.TimerType.CloseTypes);
 336                         module.CloseType ();
 337                         tr.Stop (TimeReporter.TimerType.CloseTypes);
 338
 339                         tr.Start (TimeReporter.TimerType.Resouces);
 340                         assembly.EmbedResources ();
 341                         tr.Stop (TimeReporter.TimerType.Resouces);
 342
 343                         if (Report.Errors > 0)
 344                                 return false;
 345
 346                         assembly.Save ();
 347
 348 #if STATIC
 349                         references_loader.Dispose ();
 350 #endif
 351                         tr.StopTotal ();
 352                         tr.ShowStats ();
 353
 354                         return Report.Errors == 0;
 355                 }
 356         }
 357
 358         //
 359         // This is the only public entry point
 360         //
 361         public class CompilerCallableEntryPoint : MarshalByRefObject {
 362                 public static bool InvokeCompiler (string [] args, TextWriter error)
 363                 {
 364                         try {
 365                                 var r = new Report (new StreamReportPrinter (error));
 366                                 CommandLineParser cmd = new CommandLineParser (r, error);
 367                                 var setting = cmd.ParseArguments (args);
 368                                 if (setting == null || r.Errors > 0)
 369                                         return false;
 370
 371                                 var d = new Driver (new CompilerContext (setting, r));
 372                                 return d.Compile ();
 373                         } finally {
 374                                 Reset ();
 375                         }
 376                 }
 377
 378                 public static int[] AllWarningNumbers {
 379                         get {
 380                                 return Report.AllWarnings;
 381                         }
 382                 }
 383
 384                 public static void Reset ()
 385                 {
 386                         Reset (true);
 387                 }
 388
 389                 public static void PartialReset ()
 390                 {
 391                         Reset (false);
 392                 }
 393
 394                 public static void Reset (bool full_flag)
 395                 {
 396                         CSharpParser.yacc_verbose_flag = 0;
 397                         Location.Reset ();
 398
 399                         if (!full_flag)
 400                                 return;
 401
 402                         AnonymousTypeClass.Reset ();
 403                         AnonymousMethodBody.Reset ();
 404                         AnonymousMethodStorey.Reset ();
 405                         SymbolWriter.Reset ();
 406                         Switch.Reset ();
 407                         Linq.QueryBlock.TransparentParameter.Reset ();
 408                         TypeInfo.Reset ();
 409                 }
 410         }
 411 }