?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix bug #566087.
[mcs.git] / mcs / driver.cs
blob3674bd6ce81292db2306a2181b2610e1ec388f98
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 namespace Mono.CSharp
15 {
16 using System;
17 using System.Reflection;
18 using System.Reflection.Emit;
19 using System.Collections.Generic;
20 using System.IO;
21 using System.Text;
22 using System.Globalization;
23 using System.Diagnostics;
24
25 public enum Target {
26 Library, Exe, Module, WinExe
27 };
28
29 public enum Platform {
30 AnyCPU, X86, X64, IA64
31 }
32
33 /// <summary>
34 /// The compiler driver.
35 /// </summary>
36 class Driver
37 {
38 //
39 // Assemblies references to be linked. Initialized with
40 // mscorlib.dll here.
41 List<string> references;
42
43 //
44 // If any of these fail, we ignore the problem. This is so
45 // that we can list all the assemblies in Windows and not fail
46 // if they are missing on Linux.
47 //
48 List<string> soft_references;
49
50 //
51 // External aliases for assemblies.
52 //
53 Dictionary<string, string> external_aliases;
54
55 //
56 // Modules to be linked
57 //
58 List<string> modules;
59
60 // Lookup paths
61 List<string> link_paths;
62
63 // Whether we want to only run the tokenizer
64 bool tokenize;
65
66 string first_source;
67
68 bool want_debugging_support;
69 bool parse_only;
70 bool timestamps;
71 bool fatal_errors;
72
73 //
74 // Whether to load the initial config file (what CSC.RSP has by default)
75 //
76 bool load_default_config = true;
77
78 //
79 // A list of resource files
80 //
81 Resources embedded_resources;
82 string win32ResourceFile;
83 string win32IconFile;
84
85 //
86 // Output file
87 //
88 static string output_file;
89
90 //
91 // Last time we took the time
92 //
93 DateTime last_time, first_time;
94
95 //
96 // Encoding.
97 //
98 Encoding encoding;
99
100 readonly CompilerContext ctx;
101
102 static readonly char[] argument_value_separator = new char [] { ';', ',' };
103
104 static public void Reset ()
105 {
106 output_file = null;
107 }
108
109 private Driver (CompilerContext ctx)
110 {
111 this.ctx = ctx;
112 encoding = Encoding.Default;
113 }
114
115 public static Driver Create (string[] args, bool require_files, ReportPrinter printer)
116 {
117 Driver d = new Driver (new CompilerContext (new Report (printer)));
118
119 if (!d.ParseArguments (args, require_files))
120 return null;
121
122 return d;
123 }
124
125 Report Report {
126 get { return ctx.Report; }
127 }
128
129 void ShowTime (string msg)
130 {
131 if (!timestamps)
132 return;
133
134 DateTime now = DateTime.Now;
135 TimeSpan span = now - last_time;
136 last_time = now;
137
138 Console.WriteLine (
139 "[{0:00}:{1:000}] {2}",
140 (int) span.TotalSeconds, span.Milliseconds, msg);
141 }
142
143 void ShowTotalTime (string msg)
144 {
145 if (!timestamps)
146 return;
147
148 DateTime now = DateTime.Now;
149 TimeSpan span = now - first_time;
150 last_time = now;
151
152 Console.WriteLine (
153 "[{0:00}:{1:000}] {2}",
154 (int) span.TotalSeconds, span.Milliseconds, msg);
155 }
156
157 void tokenize_file (CompilationUnit file, CompilerContext ctx)
158 {
159 Stream input;
160
161 try {
162 input = File.OpenRead (file.Name);
163 } catch {
164 Report.Error (2001, "Source file `" + file.Name + "' could not be found");
165 return;
166 }
167
168 using (input){
169 SeekableStreamReader reader = new SeekableStreamReader (input, encoding);
170 Tokenizer lexer = new Tokenizer (reader, file, ctx);
171 int token, tokens = 0, errors = 0;
172
173 while ((token = lexer.token ()) != Token.EOF){
174 tokens++;
175 if (token == Token.ERROR)
176 errors++;
177 }
178 Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors");
179 }
180
181 return;
182 }
183
184 void Parse (CompilationUnit file)
185 {
186 Stream input;
187
188 try {
189 input = File.OpenRead (file.Name);
190 } catch {
191 Report.Error (2001, "Source file `{0}' could not be found", file.Name);
192 return;
193 }
194
195 SeekableStreamReader reader = new SeekableStreamReader (input, encoding);
196
197 // Check 'MZ' header
198 if (reader.Read () == 77 && reader.Read () == 90) {
199 Report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
200 input.Close ();
201 return;
202 }
203
204 reader.Position = 0;
205 Parse (reader, file);
206 reader.Dispose ();
207 input.Close ();
208 }
209
210 void Parse (SeekableStreamReader reader, CompilationUnit file)
211 {
212 CSharpParser parser = new CSharpParser (reader, file, ctx);
213 parser.parse ();
214 }
215
216 static void OtherFlags ()
217 {
218 Console.WriteLine (
219 "Other flags in the compiler\n" +
220 " --fatal Makes errors fatal\n" +
221 " --parse Only parses the source file\n" +
222 " --typetest Tests the tokenizer's built-in type parser\n" +
223 " --stacktrace Shows stack trace at error location\n" +
224 " --timestamp Displays time stamps of various compiler events\n" +
225 " --expect-error X Expect that error X will be encountered\n" +
226 " -v Verbose parsing (for debugging the parser)\n" +
227 " --mcs-debug X Sets MCS debugging level to X\n");
228 }
229
230 static void Usage ()
231 {
232 Console.WriteLine (
233 "Mono C# compiler, Copyright 2001 - 2008 Novell, Inc.\n" +
234 "mcs [options] source-files\n" +
235 " --about About the Mono C# compiler\n" +
236 " -addmodule:M1[,Mn] Adds the module to the generated assembly\n" +
237 " -checked[+|-] Sets default aritmetic overflow context\n" +
238 " -codepage:ID Sets code page to the one in ID (number, utf8, reset)\n" +
239 " -clscheck[+|-] Disables CLS Compliance verifications\n" +
240 " -define:S1[;S2] Defines one or more conditional symbols (short: -d)\n" +
241 " -debug[+|-], -g Generate debugging information\n" +
242 " -delaysign[+|-] Only insert the public key into the assembly (no signing)\n" +
243 " -doc:FILE Process documentation comments to XML file\n" +
244 " -help Lists all compiler options (short: -?)\n" +
245 " -keycontainer:NAME The key pair container used to sign the output assembly\n" +
246 " -keyfile:FILE The key file used to strongname the ouput assembly\n" +
247 " -langversion:TEXT Specifies language version: ISO-1, ISO-2, Default, or Future\n" +
248 " -lib:PATH1[,PATHn] Specifies the location of referenced assemblies\n" +
249 " -main:CLASS Specifies the class with the Main method (short: -m)\n" +
250 " -noconfig Disables implicitly referenced assemblies\n" +
251 " -nostdlib[+|-] Does not reference mscorlib.dll library\n" +
252 " -nowarn:W1[,Wn] Suppress one or more compiler warnings\n" +
253 " -optimize[+|-] Enables advanced compiler optimizations (short: -o)\n" +
254 " -out:FILE Specifies output assembly name\n" +
255 #if !SMCS_SOURCE
256 " -pkg:P1[,Pn] References packages P1..Pn\n" +
257 #endif
258 " -platform:ARCH Specifies the target platform of the output assembly\n" +
259 " ARCH can be one of: anycpu, x86, x64 or itanium\n" +
260 " -recurse:SPEC Recursively compiles files according to SPEC pattern\n" +
261 " -reference:A1[,An] Imports metadata from the specified assembly (short: -r)\n" +
262 " -reference:ALIAS=A Imports metadata using specified extern alias (short: -r)\n" +
263 " -target:KIND Specifies the format of the output assembly (short: -t)\n" +
264 " KIND can be one of: exe, winexe, library, module\n" +
265 " -unsafe[+|-] Allows to compile code which uses unsafe keyword\n" +
266 " -warnaserror[+|-] Treats all warnings as errors\n" +
267 " -warnaserror[+|-]:W1[,Wn] Treats one or more compiler warnings as errors\n" +
268 " -warn:0-4 Sets warning level, the default is 4 (short -w:)\n" +
269 " -help2 Shows internal compiler options\n" +
270 "\n" +
271 "Resources:\n" +
272 " -linkresource:FILE[,ID] Links FILE as a resource (short: -linkres)\n" +
273 " -resource:FILE[,ID] Embed FILE as a resource (short: -res)\n" +
274 " -win32res:FILE Specifies Win32 resource file (.res)\n" +
275 " -win32icon:FILE Use this icon for the output\n" +
276 " @file Read response file for more options\n\n" +
277 "Options can be of the form -option or /option");
278 }
279
280 void TargetUsage ()
281 {
282 Report.Error (2019, "Invalid target type for -target. Valid options are `exe', `winexe', `library' or `module'");
283 }
284
285 static void About ()
286 {
287 Console.WriteLine (
288 "The Mono C# compiler is Copyright 2001-2008, Novell, Inc.\n\n" +
289 "The compiler source code is released under the terms of the \n"+
290 "MIT X11 or GNU GPL licenses\n\n" +
291
292 "For more information on Mono, visit the project Web site\n" +
293 " http://www.mono-project.com\n\n" +
294
295 "The compiler was written by Miguel de Icaza, Ravi Pratap, Martin Baulig, Marek Safar, Raja R Harinath, Atushi Enomoto");
296 Environment.Exit (0);
297 }
298
299 public static int Main (string[] args)
300 {
301 Location.InEmacs = Environment.GetEnvironmentVariable ("EMACS") == "t";
302 var crp = new ConsoleReportPrinter ();
303 Driver d = Driver.Create (args, true, crp);
304 if (d == null)
305 return 1;
306
307 crp.Fatal = d.fatal_errors;
308
309 if (d.Compile () && d.Report.Errors == 0) {
310 if (d.Report.Warnings > 0) {
311 Console.WriteLine ("Compilation succeeded - {0} warning(s)", d.Report.Warnings);
312 }
313 Environment.Exit (0);
314 return 0;
315 }
316
317
318 Console.WriteLine("Compilation failed: {0} error(s), {1} warnings",
319 d.Report.Errors, d.Report.Warnings);
320 Environment.Exit (1);
321 return 1;
322 }
323
324 public void LoadAssembly (string assembly, bool soft)
325 {
326 LoadAssembly (assembly, null, soft);
327 }
328
329 void Error6 (string name, string log)
330 {
331 if (log != null && log.Length > 0)
332 Report.ExtraInformation (Location.Null, "Log:\n" + log + "\n(log related to previous ");
333 Report.Error (6, "cannot find metadata file `{0}'", name);
334 }
335
336 void Error9 (string type, string filename, string log)
337 {
338 if (log != null && log.Length > 0)
339 Report.ExtraInformation (Location.Null, "Log:\n" + log + "\n(log related to previous ");
340 Report.Error (9, "file `{0}' has invalid `{1}' metadata", filename, type);
341 }
342
343 void BadAssembly (string filename, string log)
344 {
345 MethodInfo adder_method = AssemblyClass.AddModule_Method;
346
347 if (adder_method != null) {
348 AssemblyName an = new AssemblyName ();
349 an.Name = ".temp";
350 AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
351 try {
352 object m = null;
353 try {
354 m = adder_method.Invoke (ab, new object [] { filename });
355 } catch (TargetInvocationException ex) {
356 throw ex.InnerException;
357 }
358
359 if (m != null) {
360 Report.Error (1509, "Referenced file `{0}' is not an assembly. Consider using `-addmodule' option instead",
361 Path.GetFileName (filename));
362 return;
363 }
364 } catch (FileNotFoundException) {
365 // did the file get deleted during compilation? who cares? swallow the exception
366 } catch (BadImageFormatException) {
367 // swallow exception
368 } catch (FileLoadException) {
369 // swallow exception
370 }
371 }
372 Error9 ("assembly", filename, log);
373 }
374
375 public void LoadAssembly (string assembly, string alias, bool soft)
376 {
377 Assembly a = null;
378 string total_log = "";
379
380 try {
381 try {
382 char[] path_chars = { '/', '\\' };
383
384 if (assembly.IndexOfAny (path_chars) != -1) {
385 a = Assembly.LoadFrom (assembly);
386 } else {
387 string ass = assembly;
388 if (ass.EndsWith (".dll") || ass.EndsWith (".exe"))
389 ass = assembly.Substring (0, assembly.Length - 4);
390 a = Assembly.Load (ass);
391 }
392 } catch (FileNotFoundException) {
393 bool err = !soft;
394 foreach (string dir in link_paths) {
395 string full_path = Path.Combine (dir, assembly);
396 if (!assembly.EndsWith (".dll") && !assembly.EndsWith (".exe"))
397 full_path += ".dll";
398
399 try {
400 a = Assembly.LoadFrom (full_path);
401 err = false;
402 break;
403 } catch (FileNotFoundException ff) {
404 if (soft)
405 return;
406 total_log += ff.FusionLog;
407 }
408 }
409 if (err) {
410 Error6 (assembly, total_log);
411 return;
412 }
413 }
414
415 // Extern aliased refs require special handling
416 if (alias == null)
417 GlobalRootNamespace.Instance.AddAssemblyReference (a);
418 else
419 GlobalRootNamespace.Instance.DefineRootNamespace (alias, a, ctx);
420
421 } catch (BadImageFormatException f) {
422 // .NET 2.0 throws this if we try to load a module without an assembly manifest ...
423 BadAssembly (f.FileName, f.FusionLog);
424 } catch (FileLoadException f) {
425 // ... while .NET 1.1 throws this
426 BadAssembly (f.FileName, f.FusionLog);
427 }
428 }
429
430 public void LoadModule (string module)
431 {
432 Module m = null;
433 string total_log = "";
434
435 try {
436 try {
437 m = CodeGen.Assembly.AddModule (module);
438 } catch (FileNotFoundException) {
439 bool err = true;
440 foreach (string dir in link_paths) {
441 string full_path = Path.Combine (dir, module);
442 if (!module.EndsWith (".netmodule"))
443 full_path += ".netmodule";
444
445 try {
446 m = CodeGen.Assembly.AddModule (full_path);
447 err = false;
448 break;
449 } catch (FileNotFoundException ff) {
450 total_log += ff.FusionLog;
451 }
452 }
453 if (err) {
454 Error6 (module, total_log);
455 return;
456 }
457 }
458
459 GlobalRootNamespace.Instance.AddModuleReference (m);
460
461 } catch (BadImageFormatException f) {
462 Error9 ("module", f.FileName, f.FusionLog);
463 } catch (FileLoadException f) {
464 Error9 ("module", f.FileName, f.FusionLog);
465 }
466 }
467
468 /// <summary>
469 /// Loads all assemblies referenced on the command line
470 /// </summary>
471 public void LoadReferences ()
472 {
473 link_paths.Add (GetSystemDir ());
474 link_paths.Add (Directory.GetCurrentDirectory ());
475
476 //
477 // Load Core Library for default compilation
478 //
479 if (RootContext.StdLib)
480 LoadAssembly ("mscorlib", false);
481
482 foreach (string r in soft_references)
483 LoadAssembly (r, true);
484
485 foreach (string r in references)
486 LoadAssembly (r, false);
487
488 foreach (var entry in external_aliases)
489 LoadAssembly (entry.Value, entry.Key, false);
490
491 GlobalRootNamespace.Instance.ComputeNamespaces (ctx);
492 }
493
494 static string [] LoadArgs (string file)
495 {
496 StreamReader f;
497 var args = new List<string> ();
498 string line;
499 try {
500 f = new StreamReader (file);
501 } catch {
502 return null;
503 }
504
505 StringBuilder sb = new StringBuilder ();
506
507 while ((line = f.ReadLine ()) != null){
508 int t = line.Length;
509
510 for (int i = 0; i < t; i++){
511 char c = line [i];
512
513 if (c == '"' || c == '\''){
514 char end = c;
515
516 for (i++; i < t; i++){
517 c = line [i];
518
519 if (c == end)
520 break;
521 sb.Append (c);
522 }
523 } else if (c == ' '){
524 if (sb.Length > 0){
525 args.Add (sb.ToString ());
526 sb.Length = 0;
527 }
528 } else
529 sb.Append (c);
530 }
531 if (sb.Length > 0){
532 args.Add (sb.ToString ());
533 sb.Length = 0;
534 }
535 }
536
537 return args.ToArray ();
538 }
539
540 //
541 // Returns the directory where the system assemblies are installed
542 //
543 static string GetSystemDir ()
544 {
545 return Path.GetDirectoryName (typeof (object).Assembly.Location);
546 }
547
548 //
549 // Given a path specification, splits the path from the file/pattern
550 //
551 static void SplitPathAndPattern (string spec, out string path, out string pattern)
552 {
553 int p = spec.LastIndexOf ('/');
554 if (p != -1){
555 //
556 // Windows does not like /file.cs, switch that to:
557 // "\", "file.cs"
558 //
559 if (p == 0){
560 path = "\\";
561 pattern = spec.Substring (1);
562 } else {
563 path = spec.Substring (0, p);
564 pattern = spec.Substring (p + 1);
565 }
566 return;
567 }
568
569 p = spec.LastIndexOf ('\\');
570 if (p != -1){
571 path = spec.Substring (0, p);
572 pattern = spec.Substring (p + 1);
573 return;
574 }
575
576 path = ".";
577 pattern = spec;
578 }
579
580 void AddSourceFile (string f)
581 {
582 if (first_source == null)
583 first_source = f;
584
585 Location.AddFile (Report, f);
586 }
587
588 bool ParseArguments (string[] args, bool require_files)
589 {
590 references = new List<string> ();
591 external_aliases = new Dictionary<string, string> ();
592 soft_references = new List<string> ();
593 modules = new List<string> (2);
594 link_paths = new List<string> ();
595
596 List<string> response_file_list = null;
597 bool parsing_options = true;
598
599 for (int i = 0; i < args.Length; i++) {
600 string arg = args [i];
601 if (arg.Length == 0)
602 continue;
603
604 if (arg [0] == '@') {
605 string [] extra_args;
606 string response_file = arg.Substring (1);
607
608 if (response_file_list == null)
609 response_file_list = new List<string> ();
610
611 if (response_file_list.Contains (response_file)) {
612 Report.Error (
613 1515, "Response file `" + response_file +
614 "' specified multiple times");
615 return false;
616 }
617
618 response_file_list.Add (response_file);
619
620 extra_args = LoadArgs (response_file);
621 if (extra_args == null) {
622 Report.Error (2011, "Unable to open response file: " +
623 response_file);
624 return false;
625 }
626
627 args = AddArgs (args, extra_args);
628 continue;
629 }
630
631 if (parsing_options) {
632 if (arg == "--") {
633 parsing_options = false;
634 continue;
635 }
636
637 if (arg [0] == '-') {
638 if (UnixParseOption (arg, ref args, ref i))
639 continue;
640
641 // Try a -CSCOPTION
642 string csc_opt = "/" + arg.Substring (1);
643 if (CSCParseOption (csc_opt, ref args))
644 continue;
645
646 Error_WrongOption (arg);
647 return false;
648 }
649 if (arg [0] == '/') {
650 if (CSCParseOption (arg, ref args))
651 continue;
652
653 // Need to skip `/home/test.cs' however /test.cs is considered as error
654 if (arg.Length < 2 || arg.IndexOf ('/', 2) == -1) {
655 Error_WrongOption (arg);
656 return false;
657 }
658 }
659 }
660
661 ProcessSourceFiles (arg, false);
662 }
663
664 if (require_files == false)
665 return true;
666
667 //
668 // If we are an exe, require a source file for the entry point
669 //
670 if (RootContext.Target == Target.Exe || RootContext.Target == Target.WinExe || RootContext.Target == Target.Module) {
671 if (first_source == null) {
672 Report.Error (2008, "No files to compile were specified");
673 return false;
674 }
675
676 }
677
678 //
679 // If there is nothing to put in the assembly, and we are not a library
680 //
681 if (first_source == null && embedded_resources == null) {
682 Report.Error (2008, "No files to compile were specified");
683 return false;
684 }
685
686 return true;
687 }
688
689 public void Parse ()
690 {
691 Location.Initialize ();
692
693 var cu = Location.SourceFiles;
694 for (int i = 0; i < cu.Count; ++i) {
695 if (tokenize) {
696 tokenize_file (cu [i], ctx);
697 } else {
698 Parse (cu [i]);
699 }
700 }
701 }
702
703 void ProcessSourceFiles (string spec, bool recurse)
704 {
705 string path, pattern;
706
707 SplitPathAndPattern (spec, out path, out pattern);
708 if (pattern.IndexOf ('*') == -1){
709 AddSourceFile (spec);
710 return;
711 }
712
713 string [] files = null;
714 try {
715 files = Directory.GetFiles (path, pattern);
716 } catch (System.IO.DirectoryNotFoundException) {
717 Report.Error (2001, "Source file `" + spec + "' could not be found");
718 return;
719 } catch (System.IO.IOException){
720 Report.Error (2001, "Source file `" + spec + "' could not be found");
721 return;
722 }
723 foreach (string f in files) {
724 AddSourceFile (f);
725 }
726
727 if (!recurse)
728 return;
729
730 string [] dirs = null;
731
732 try {
733 dirs = Directory.GetDirectories (path);
734 } catch {
735 }
736
737 foreach (string d in dirs) {
738
739 // Don't include path in this string, as each
740 // directory entry already does
741 ProcessSourceFiles (d + "/" + pattern, true);
742 }
743 }
744
745 public void ProcessDefaultConfig ()
746 {
747 if (!load_default_config)
748 return;
749
750 //
751 // For now the "default config" is harcoded into the compiler
752 // we can move this outside later
753 //
754 string [] default_config = {
755 "System",
756 "System.Xml",
757 #if NET_2_1
758 "System.Net",
759 "System.Windows",
760 "System.Windows.Browser",
761 #endif
762 #if false
763 //
764 // Is it worth pre-loading all this stuff?
765 //
766 "Accessibility",
767 "System.Configuration.Install",
768 "System.Data",
769 "System.Design",
770 "System.DirectoryServices",
771 "System.Drawing.Design",
772 "System.Drawing",
773 "System.EnterpriseServices",
774 "System.Management",
775 "System.Messaging",
776 "System.Runtime.Remoting",
777 "System.Runtime.Serialization.Formatters.Soap",
778 "System.Security",
779 "System.ServiceProcess",
780 "System.Web",
781 "System.Web.RegularExpressions",
782 "System.Web.Services",
783 "System.Windows.Forms"
784 #endif
785 };
786
787 soft_references.AddRange (default_config);
788
789 if (RootContext.Version > LanguageVersion.ISO_2)
790 soft_references.Add ("System.Core");
791 if (RootContext.Version > LanguageVersion.V_3)
792 soft_references.Add ("Microsoft.CSharp");
793 }
794
795 public static string OutputFile
796 {
797 set {
798 output_file = value;
799 }
800 get {
801 return Path.GetFileName (output_file);
802 }
803 }
804
805 void SetWarningLevel (string s)
806 {
807 int level = -1;
808
809 try {
810 level = Int32.Parse (s);
811 } catch {
812 }
813 if (level < 0 || level > 4){
814 Report.Error (1900, "Warning level must be in the range 0-4");
815 return;
816 }
817 Report.WarningLevel = level;
818 }
819
820 static void Version ()
821 {
822 string version = Assembly.GetExecutingAssembly ().GetName ().Version.ToString ();
823 Console.WriteLine ("Mono C# compiler version {0}", version);
824 Environment.Exit (0);
825 }
826
827 //
828 // Currently handles the Unix-like command line options, but will be
829 // deprecated in favor of the CSCParseOption, which will also handle the
830 // options that start with a dash in the future.
831 //
832 bool UnixParseOption (string arg, ref string [] args, ref int i)
833 {
834 switch (arg){
835 case "-v":
836 CSharpParser.yacc_verbose_flag++;
837 return true;
838
839 case "--version":
840 Version ();
841 return true;
842
843 case "--parse":
844 parse_only = true;
845 return true;
846
847 case "--main": case "-m":
848 Report.Warning (-29, 1, "Compatibility: Use -main:CLASS instead of --main CLASS or -m CLASS");
849 if ((i + 1) >= args.Length){
850 Usage ();
851 Environment.Exit (1);
852 }
853 RootContext.MainClass = args [++i];
854 return true;
855
856 case "--unsafe":
857 Report.Warning (-29, 1, "Compatibility: Use -unsafe instead of --unsafe");
858 RootContext.Unsafe = true;
859 return true;
860
861 case "/?": case "/h": case "/help":
862 case "--help":
863 Usage ();
864 Environment.Exit (0);
865 return true;
866
867 case "--define":
868 Report.Warning (-29, 1, "Compatibility: Use -d:SYMBOL instead of --define SYMBOL");
869 if ((i + 1) >= args.Length){
870 Usage ();
871 Environment.Exit (1);
872 }
873 RootContext.AddConditional (args [++i]);
874 return true;
875
876 case "--tokenize":
877 tokenize = true;
878 return true;
879
880 case "-o":
881 case "--output":
882 Report.Warning (-29, 1, "Compatibility: Use -out:FILE instead of --output FILE or -o FILE");
883 if ((i + 1) >= args.Length){
884 Usage ();
885 Environment.Exit (1);
886 }
887 OutputFile = args [++i];
888 return true;
889
890 case "--checked":
891 Report.Warning (-29, 1, "Compatibility: Use -checked instead of --checked");
892 RootContext.Checked = true;
893 return true;
894
895 case "--stacktrace":
896 Report.Printer.Stacktrace = true;
897 return true;
898
899 case "--linkresource":
900 case "--linkres":
901 Report.Warning (-29, 1, "Compatibility: Use -linkres:VALUE instead of --linkres VALUE");
902 if ((i + 1) >= args.Length){
903 Usage ();
904 Report.Error (5, "Missing argument to --linkres");
905 Environment.Exit (1);
906 }
907 if (embedded_resources == null)
908 embedded_resources = new Resources (ctx);
909
910 embedded_resources.Add (false, args [++i], args [i]);
911 return true;
912
913 case "--resource":
914 case "--res":
915 Report.Warning (-29, 1, "Compatibility: Use -res:VALUE instead of --res VALUE");
916 if ((i + 1) >= args.Length){
917 Usage ();
918 Report.Error (5, "Missing argument to --resource");
919 Environment.Exit (1);
920 }
921 if (embedded_resources == null)
922 embedded_resources = new Resources (ctx);
923
924 embedded_resources.Add (true, args [++i], args [i]);
925 return true;
926
927 case "--target":
928 Report.Warning (-29, 1, "Compatibility: Use -target:KIND instead of --target KIND");
929 if ((i + 1) >= args.Length){
930 Environment.Exit (1);
931 return true;
932 }
933
934 string type = args [++i];
935 switch (type){
936 case "library":
937 RootContext.Target = Target.Library;
938 RootContext.TargetExt = ".dll";
939 break;
940
941 case "exe":
942 RootContext.Target = Target.Exe;
943 break;
944
945 case "winexe":
946 RootContext.Target = Target.WinExe;
947 break;
948
949 case "module":
950 RootContext.Target = Target.Module;
951 RootContext.TargetExt = ".dll";
952 break;
953 default:
954 TargetUsage ();
955 break;
956 }
957 return true;
958
959 case "-r":
960 Report.Warning (-29, 1, "Compatibility: Use -r:LIBRARY instead of -r library");
961 if ((i + 1) >= args.Length){
962 Usage ();
963 Environment.Exit (1);
964 }
965
966 string val = args [++i];
967 int idx = val.IndexOf ('=');
968 if (idx > -1) {
969 string alias = val.Substring (0, idx);
970 string assembly = val.Substring (idx + 1);
971 AddExternAlias (alias, assembly);
972 return true;
973 }
974
975 references.Add (val);
976 return true;
977
978 case "-L":
979 Report.Warning (-29, 1, "Compatibility: Use -lib:ARG instead of --L arg");
980 if ((i + 1) >= args.Length){
981 Usage ();
982 Environment.Exit (1);
983 }
984 link_paths.Add (args [++i]);
985 return true;
986
987 case "--nostdlib":
988 Report.Warning (-29, 1, "Compatibility: Use -nostdlib instead of --nostdlib");
989 RootContext.StdLib = false;
990 return true;
991
992 case "--fatal":
993 fatal_errors = true;
994 return true;
995
996 case "--nowarn":
997 Report.Warning (-29, 1, "Compatibility: Use -nowarn instead of --nowarn");
998 if ((i + 1) >= args.Length){
999 Usage ();
1000 Environment.Exit (1);
1001 }
1002 int warn = 0;
1003
1004 try {
1005 warn = Int32.Parse (args [++i]);
1006 } catch {
1007 Usage ();
1008 Environment.Exit (1);
1009 }
1010 Report.SetIgnoreWarning (warn);
1011 return true;
1012
1013 case "--wlevel":
1014 Report.Warning (-29, 1, "Compatibility: Use -warn:LEVEL instead of --wlevel LEVEL");
1015 if ((i + 1) >= args.Length){
1016 Report.Error (
1017 1900,
1018 "--wlevel requires a value from 0 to 4");
1019 Environment.Exit (1);
1020 }
1021
1022 SetWarningLevel (args [++i]);
1023 return true;
1024
1025 case "--mcs-debug":
1026 if ((i + 1) >= args.Length){
1027 Report.Error (5, "--mcs-debug requires an argument");
1028 Environment.Exit (1);
1029 }
1030
1031 try {
1032 Report.DebugFlags = Int32.Parse (args [++i]);
1033 } catch {
1034 Report.Error (5, "Invalid argument to --mcs-debug");
1035 Environment.Exit (1);
1036 }
1037 return true;
1038
1039 case "--about":
1040 About ();
1041 return true;
1042
1043 case "--recurse":
1044 Report.Warning (-29, 1, "Compatibility: Use -recurse:PATTERN option instead --recurse PATTERN");
1045 if ((i + 1) >= args.Length){
1046 Report.Error (5, "--recurse requires an argument");
1047 Environment.Exit (1);
1048 }
1049 ProcessSourceFiles (args [++i], true);
1050 return true;
1051
1052 case "--timestamp":
1053 timestamps = true;
1054 last_time = first_time = DateTime.Now;
1055 return true;
1056
1057 case "--debug": case "-g":
1058 Report.Warning (-29, 1, "Compatibility: Use -debug option instead of -g or --debug");
1059 want_debugging_support = true;
1060 return true;
1061
1062 case "--noconfig":
1063 Report.Warning (-29, 1, "Compatibility: Use -noconfig option instead of --noconfig");
1064 load_default_config = false;
1065 return true;
1066 }
1067
1068 return false;
1069 }
1070
1071 #if !SMCS_SOURCE
1072 public static string GetPackageFlags (string packages, bool fatal, Report report)
1073 {
1074 ProcessStartInfo pi = new ProcessStartInfo ();
1075 pi.FileName = "pkg-config";
1076 pi.RedirectStandardOutput = true;
1077 pi.UseShellExecute = false;
1078 pi.Arguments = "--libs " + packages;
1079 Process p = null;
1080 try {
1081 p = Process.Start (pi);
1082 } catch (Exception e) {
1083 report.Error (-27, "Couldn't run pkg-config: " + e.Message);
1084 if (fatal)
1085 Environment.Exit (1);
1086 p.Close ();
1087 return null;
1088 }
1089
1090 if (p.StandardOutput == null){
1091 report.Warning (-27, 1, "Specified package did not return any information");
1092 p.Close ();
1093 return null;
1094 }
1095 string pkgout = p.StandardOutput.ReadToEnd ();
1096 p.WaitForExit ();
1097 if (p.ExitCode != 0) {
1098 report.Error (-27, "Error running pkg-config. Check the above output.");
1099 if (fatal)
1100 Environment.Exit (1);
1101 p.Close ();
1102 return null;
1103 }
1104 p.Close ();
1105
1106 return pkgout;
1107 }
1108 #endif
1109
1110 //
1111 // This parses the -arg and /arg options to the compiler, even if the strings
1112 // in the following text use "/arg" on the strings.
1113 //
1114 bool CSCParseOption (string option, ref string [] args)
1115 {
1116 int idx = option.IndexOf (':');
1117 string arg, value;
1118
1119 if (idx == -1){
1120 arg = option;
1121 value = "";
1122 } else {
1123 arg = option.Substring (0, idx);
1124
1125 value = option.Substring (idx + 1);
1126 }
1127
1128 switch (arg.ToLower (CultureInfo.InvariantCulture)){
1129 case "/nologo":
1130 return true;
1131
1132 case "/t":
1133 case "/target":
1134 switch (value){
1135 case "exe":
1136 RootContext.Target = Target.Exe;
1137 break;
1138
1139 case "winexe":
1140 RootContext.Target = Target.WinExe;
1141 break;
1142
1143 case "library":
1144 RootContext.Target = Target.Library;
1145 RootContext.TargetExt = ".dll";
1146 break;
1147
1148 case "module":
1149 RootContext.Target = Target.Module;
1150 RootContext.TargetExt = ".netmodule";
1151 break;
1152
1153 default:
1154 TargetUsage ();
1155 break;
1156 }
1157 return true;
1158
1159 case "/out":
1160 if (value.Length == 0){
1161 Usage ();
1162 Environment.Exit (1);
1163 }
1164 OutputFile = value;
1165 return true;
1166
1167 case "/o":
1168 case "/o+":
1169 case "/optimize":
1170 case "/optimize+":
1171 RootContext.Optimize = true;
1172 return true;
1173
1174 case "/o-":
1175 case "/optimize-":
1176 RootContext.Optimize = false;
1177 return true;
1178
1179 case "/incremental":
1180 case "/incremental+":
1181 case "/incremental-":
1182 // nothing.
1183 return true;
1184
1185 case "/d":
1186 case "/define": {
1187 if (value.Length == 0){
1188 Usage ();
1189 Environment.Exit (1);
1190 }
1191
1192 foreach (string d in value.Split (argument_value_separator)) {
1193 string conditional = d.Trim ();
1194 if (!Tokenizer.IsValidIdentifier (conditional)) {
1195 Report.Warning (2029, 1, "Invalid conditional define symbol `{0}'", conditional);
1196 continue;
1197 }
1198 RootContext.AddConditional (conditional);
1199 }
1200 return true;
1201 }
1202
1203 case "/bugreport":
1204 //
1205 // We should collect data, runtime, etc and store in the file specified
1206 //
1207 Console.WriteLine ("To file bug reports, please visit: http://www.mono-project.com/Bugs");
1208 return true;
1209 #if !SMCS_SOURCE
1210 case "/pkg": {
1211 string packages;
1212
1213 if (value.Length == 0){
1214 Usage ();
1215 Environment.Exit (1);
1216 }
1217 packages = String.Join (" ", value.Split (new Char [] { ';', ',', '\n', '\r'}));
1218 string pkgout = GetPackageFlags (packages, true, Report);
1219
1220 if (pkgout != null){
1221 string [] xargs = pkgout.Trim (new Char [] {' ', '\n', '\r', '\t'}).
1222 Split (new Char [] { ' ', '\t'});
1223 args = AddArgs (args, xargs);
1224 }
1225
1226 return true;
1227 }
1228 #endif
1229 case "/linkres":
1230 case "/linkresource":
1231 case "/res":
1232 case "/resource":
1233 if (embedded_resources == null)
1234 embedded_resources = new Resources (ctx);
1235
1236 bool embeded = arg [1] == 'r' || arg [1] == 'R';
1237 string[] s = value.Split (argument_value_separator);
1238 switch (s.Length) {
1239 case 1:
1240 if (s[0].Length == 0)
1241 goto default;
1242 embedded_resources.Add (embeded, s [0], Path.GetFileName (s[0]));
1243 break;
1244 case 2:
1245 embedded_resources.Add (embeded, s [0], s [1]);
1246 break;
1247 case 3:
1248 if (s [2] != "public" && s [2] != "private") {
1249 Report.Error (1906, "Invalid resource visibility option `{0}'. Use either `public' or `private' instead", s [2]);
1250 return true;
1251 }
1252 embedded_resources.Add (embeded, s [0], s [1], s [2] == "private");
1253 break;
1254 default:
1255 Report.Error (-2005, "Wrong number of arguments for option `{0}'", option);
1256 break;
1257 }
1258
1259 return true;
1260
1261 case "/recurse":
1262 if (value.Length == 0){
1263 Report.Error (5, "-recurse requires an argument");
1264 Environment.Exit (1);
1265 }
1266 ProcessSourceFiles (value, true);
1267 return true;
1268
1269 case "/r":
1270 case "/reference": {
1271 if (value.Length == 0){
1272 Report.Error (5, "-reference requires an argument");
1273 Environment.Exit (1);
1274 }
1275
1276 string[] refs = value.Split (argument_value_separator);
1277 foreach (string r in refs){
1278 string val = r;
1279 int index = val.IndexOf ('=');
1280 if (index > -1) {
1281 string alias = r.Substring (0, index);
1282 string assembly = r.Substring (index + 1);
1283 AddExternAlias (alias, assembly);
1284 return true;
1285 }
1286
1287 if (val.Length != 0)
1288 references.Add (val);
1289 }
1290 return true;
1291 }
1292 case "/addmodule": {
1293 if (value.Length == 0){
1294 Report.Error (5, arg + " requires an argument");
1295 Environment.Exit (1);
1296 }
1297
1298 string[] refs = value.Split (argument_value_separator);
1299 foreach (string r in refs){
1300 modules.Add (r);
1301 }
1302 return true;
1303 }
1304 case "/win32res": {
1305 if (value.Length == 0) {
1306 Report.Error (5, arg + " requires an argument");
1307 Environment.Exit (1);
1308 }
1309
1310 if (win32IconFile != null)
1311 Report.Error (1565, "Cannot specify the `win32res' and the `win32ico' compiler option at the same time");
1312
1313 win32ResourceFile = value;
1314 return true;
1315 }
1316 case "/win32icon": {
1317 if (value.Length == 0) {
1318 Report.Error (5, arg + " requires an argument");
1319 Environment.Exit (1);
1320 }
1321
1322 if (win32ResourceFile != null)
1323 Report.Error (1565, "Cannot specify the `win32res' and the `win32ico' compiler option at the same time");
1324
1325 win32IconFile = value;
1326 return true;
1327 }
1328 case "/doc": {
1329 if (value.Length == 0){
1330 Report.Error (2006, arg + " requires an argument");
1331 Environment.Exit (1);
1332 }
1333 RootContext.Documentation = new Documentation (value);
1334 return true;
1335 }
1336 case "/lib": {
1337 string [] libdirs;
1338
1339 if (value.Length == 0){
1340 Report.Error (5, "/lib requires an argument");
1341 Environment.Exit (1);
1342 }
1343
1344 libdirs = value.Split (argument_value_separator);
1345 foreach (string dir in libdirs)
1346 link_paths.Add (dir);
1347 return true;
1348 }
1349
1350 case "/debug-":
1351 want_debugging_support = false;
1352 return true;
1353
1354 case "/debug":
1355 if (value == "full" || value == "")
1356 want_debugging_support = true;
1357
1358 return true;
1359
1360 case "/debug+":
1361 want_debugging_support = true;
1362 return true;
1363
1364 case "/checked":
1365 case "/checked+":
1366 RootContext.Checked = true;
1367 return true;
1368
1369 case "/checked-":
1370 RootContext.Checked = false;
1371 return true;
1372
1373 case "/clscheck":
1374 case "/clscheck+":
1375 return true;
1376
1377 case "/clscheck-":
1378 RootContext.VerifyClsCompliance = false;
1379 return true;
1380
1381 case "/unsafe":
1382 case "/unsafe+":
1383 RootContext.Unsafe = true;
1384 return true;
1385
1386 case "/unsafe-":
1387 RootContext.Unsafe = false;
1388 return true;
1389
1390 case "/warnaserror":
1391 case "/warnaserror+":
1392 if (value.Length == 0) {
1393 Report.WarningsAreErrors = true;
1394 } else {
1395 foreach (string wid in value.Split (argument_value_separator))
1396 Report.AddWarningAsError (wid);
1397 }
1398 return true;
1399
1400 case "/warnaserror-":
1401 if (value.Length == 0) {
1402 Report.WarningsAreErrors = false;
1403 } else {
1404 foreach (string wid in value.Split (argument_value_separator))
1405 Report.RemoveWarningAsError (wid);
1406 }
1407 return true;
1408
1409 case "/warn":
1410 SetWarningLevel (value);
1411 return true;
1412
1413 case "/nowarn": {
1414 string [] warns;
1415
1416 if (value.Length == 0){
1417 Report.Error (5, "/nowarn requires an argument");
1418 Environment.Exit (1);
1419 }
1420
1421 warns = value.Split (argument_value_separator);
1422 foreach (string wc in warns){
1423 try {
1424 if (wc.Trim ().Length == 0)
1425 continue;
1426
1427 int warn = Int32.Parse (wc);
1428 if (warn < 1) {
1429 throw new ArgumentOutOfRangeException("warn");
1430 }
1431 Report.SetIgnoreWarning (warn);
1432 } catch {
1433 Report.Error (1904, String.Format("`{0}' is not a valid warning number", wc));
1434 }
1435 }
1436 return true;
1437 }
1438
1439 case "/noconfig":
1440 load_default_config = false;
1441 return true;
1442
1443 case "/platform":
1444 switch (value.ToLower (CultureInfo.InvariantCulture)) {
1445 case "anycpu":
1446 RootContext.Platform = Platform.AnyCPU;
1447 break;
1448 case "x86":
1449 RootContext.Platform = Platform.X86;
1450 break;
1451 case "x64":
1452 RootContext.Platform = Platform.X64;
1453 break;
1454 case "itanium":
1455 RootContext.Platform = Platform.IA64;
1456 break;
1457 default:
1458 Report.Error (1672, "Invalid platform type for -platform. Valid options are `anycpu', `x86', `x64' or `itanium'");
1459 break;
1460 }
1461
1462 return true;
1463
1464 // We just ignore this.
1465 case "/errorreport":
1466 case "/filealign":
1467 return true;
1468
1469 case "/help2":
1470 OtherFlags ();
1471 Environment.Exit(0);
1472 return true;
1473
1474 case "/help":
1475 case "/?":
1476 Usage ();
1477 Environment.Exit (0);
1478 return true;
1479
1480 case "/main":
1481 case "/m":
1482 if (value.Length == 0){
1483 Report.Error (5, arg + " requires an argument");
1484 Environment.Exit (1);
1485 }
1486 RootContext.MainClass = value;
1487 return true;
1488
1489 case "/nostdlib":
1490 case "/nostdlib+":
1491 RootContext.StdLib = false;
1492 return true;
1493
1494 case "/nostdlib-":
1495 RootContext.StdLib = true;
1496 return true;
1497
1498 case "/fullpaths":
1499 return true;
1500
1501 case "/keyfile":
1502 if (value == String.Empty) {
1503 Report.Error (5, arg + " requires an argument");
1504 Environment.Exit (1);
1505 }
1506 RootContext.StrongNameKeyFile = value;
1507 return true;
1508 case "/keycontainer":
1509 if (value == String.Empty) {
1510 Report.Error (5, arg + " requires an argument");
1511 Environment.Exit (1);
1512 }
1513 RootContext.StrongNameKeyContainer = value;
1514 return true;
1515 case "/delaysign+":
1516 RootContext.StrongNameDelaySign = true;
1517 return true;
1518 case "/delaysign-":
1519 RootContext.StrongNameDelaySign = false;
1520 return true;
1521
1522 case "/langversion":
1523 switch (value.ToLower (CultureInfo.InvariantCulture)) {
1524 case "iso-1":
1525 RootContext.Version = LanguageVersion.ISO_1;
1526 return true;
1527 case "default":
1528 RootContext.Version = LanguageVersion.Default;
1529 RootContext.AddConditional ("__V2__");
1530 return true;
1531 case "iso-2":
1532 RootContext.Version = LanguageVersion.ISO_2;
1533 return true;
1534 case "3":
1535 RootContext.Version = LanguageVersion.V_3;
1536 return true;
1537 case "future":
1538 RootContext.Version = LanguageVersion.Future;
1539 return true;
1540 }
1541
1542 Report.Error (1617, "Invalid -langversion option `{0}'. It must be `ISO-1', `ISO-2', `3' or `Default'", value);
1543 return true;
1544
1545 case "/codepage":
1546 switch (value) {
1547 case "utf8":
1548 encoding = new UTF8Encoding();
1549 break;
1550 case "reset":
1551 encoding = Encoding.Default;
1552 break;
1553 default:
1554 try {
1555 encoding = Encoding.GetEncoding (
1556 Int32.Parse (value));
1557 } catch {
1558 Report.Error (2016, "Code page `{0}' is invalid or not installed", value);
1559 }
1560 break;
1561 }
1562 return true;
1563 }
1564
1565 return false;
1566 }
1567
1568 void Error_WrongOption (string option)
1569 {
1570 Report.Error (2007, "Unrecognized command-line option: `{0}'", option);
1571 }
1572
1573 static string [] AddArgs (string [] args, string [] extra_args)
1574 {
1575 string [] new_args;
1576 new_args = new string [extra_args.Length + args.Length];
1577
1578 // if args contains '--' we have to take that into account
1579 // split args into first half and second half based on '--'
1580 // and add the extra_args before --
1581 int split_position = Array.IndexOf (args, "--");
1582 if (split_position != -1)
1583 {
1584 Array.Copy (args, new_args, split_position);
1585 extra_args.CopyTo (new_args, split_position);
1586 Array.Copy (args, split_position, new_args, split_position + extra_args.Length, args.Length - split_position);
1587 }
1588 else
1589 {
1590 args.CopyTo (new_args, 0);
1591 extra_args.CopyTo (new_args, args.Length);
1592 }
1593
1594 return new_args;
1595 }
1596
1597 void AddExternAlias (string identifier, string assembly)
1598 {
1599 if (assembly.Length == 0) {
1600 Report.Error (1680, "Invalid reference alias '" + identifier + "='. Missing filename");
1601 return;
1602 }
1603
1604 if (!IsExternAliasValid (identifier)) {
1605 Report.Error (1679, "Invalid extern alias for /reference. Alias '" + identifier + "' is not a valid identifier");
1606 return;
1607 }
1608
1609 // Could here hashtable throw an exception?
1610 external_aliases [identifier] = assembly;
1611 }
1612
1613 static bool IsExternAliasValid (string identifier)
1614 {
1615 if (identifier.Length == 0)
1616 return false;
1617 if (identifier [0] != '_' && !Char.IsLetter (identifier [0]))
1618 return false;
1619
1620 for (int i = 1; i < identifier.Length; i++) {
1621 char c = identifier [i];
1622 if (Char.IsLetter (c) || Char.IsDigit (c))
1623 continue;
1624
1625 UnicodeCategory category = Char.GetUnicodeCategory (c);
1626 if (category != UnicodeCategory.Format || category != UnicodeCategory.NonSpacingMark ||
1627 category != UnicodeCategory.SpacingCombiningMark ||
1628 category != UnicodeCategory.ConnectorPunctuation)
1629 return false;
1630 }
1631
1632 return true;
1633 }
1634
1635 //
1636 // Main compilation method
1637 //
1638 public bool Compile ()
1639 {
1640 // TODO: Should be passed to parser as an argument
1641 RootContext.ToplevelTypes = new ModuleCompiled (ctx, RootContext.Unsafe);
1642
1643 Parse ();
1644 if (Report.Errors > 0)
1645 return false;
1646
1647 if (tokenize || parse_only)
1648 return true;
1649
1650 if (RootContext.ToplevelTypes.NamespaceEntry != null)
1651 throw new InternalErrorException ("who set it?");
1652
1653 ProcessDefaultConfig ();
1654
1655 //
1656 // Quick hack
1657 //
1658 if (output_file == null){
1659 if (first_source == null){
1660 Report.Error (1562, "If no source files are specified you must specify the output file with -out:");
1661 return false;
1662 }
1663
1664 int pos = first_source.LastIndexOf ('.');
1665
1666 if (pos > 0)
1667 output_file = first_source.Substring (0, pos) + RootContext.TargetExt;
1668 else
1669 output_file = first_source + RootContext.TargetExt;
1670 }
1671
1672 if (!CodeGen.Init (output_file, output_file, want_debugging_support, ctx))
1673 return false;
1674
1675 if (RootContext.Target == Target.Module) {
1676 PropertyInfo module_only = typeof (AssemblyBuilder).GetProperty ("IsModuleOnly", BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
1677 if (module_only == null) {
1678 Report.RuntimeMissingSupport (Location.Null, "/target:module");
1679 Environment.Exit (1);
1680 }
1681
1682 MethodInfo set_method = module_only.GetSetMethod (true);
1683 set_method.Invoke (CodeGen.Assembly.Builder, BindingFlags.Default, null, new object[]{true}, null);
1684 }
1685
1686 GlobalRootNamespace.Instance.AddModuleReference (RootContext.ToplevelTypes.Builder);
1687
1688 //
1689 // Load assemblies required
1690 //
1691 if (timestamps)
1692 ShowTime ("Loading references");
1693
1694 LoadReferences ();
1695
1696 if (modules.Count > 0) {
1697 foreach (string module in modules)
1698 LoadModule (module);
1699 }
1700
1701 if (timestamps)
1702 ShowTime ("References loaded");
1703
1704 if (!TypeManager.InitCoreTypes (ctx) || Report.Errors > 0)
1705 return false;
1706
1707 TypeManager.InitOptionalCoreTypes (ctx);
1708
1709 if (timestamps)
1710 ShowTime (" Core Types done");
1711
1712 //
1713 // The second pass of the compiler
1714 //
1715 if (timestamps)
1716 ShowTime ("Resolving tree");
1717 RootContext.ResolveTree ();
1718
1719 if (Report.Errors > 0)
1720 return false;
1721 if (timestamps)
1722 ShowTime ("Populate tree");
1723 if (!RootContext.StdLib)
1724 RootContext.BootCorlib_PopulateCoreTypes ();
1725 RootContext.PopulateTypes ();
1726
1727 if (Report.Errors == 0 &&
1728 RootContext.Documentation != null &&
1729 !RootContext.Documentation.OutputDocComment (
1730 output_file, Report))
1731 return false;
1732
1733 //
1734 // Verify using aliases now
1735 //
1736 NamespaceEntry.VerifyAllUsing ();
1737
1738 if (Report.Errors > 0){
1739 return false;
1740 }
1741
1742 CodeGen.Assembly.Resolve ();
1743
1744 if (RootContext.VerifyClsCompliance) {
1745 if (CodeGen.Assembly.IsClsCompliant) {
1746 AttributeTester.VerifyModulesClsCompliance (ctx);
1747 TypeManager.LoadAllImportedTypes ();
1748 }
1749 }
1750 if (Report.Errors > 0)
1751 return false;
1752
1753 //
1754 // The code generator
1755 //
1756 if (timestamps)
1757 ShowTime ("Emitting code");
1758 ShowTotalTime ("Total so far");
1759 RootContext.EmitCode ();
1760 if (timestamps)
1761 ShowTime (" done");
1762
1763 if (Report.Errors > 0){
1764 return false;
1765 }
1766
1767 if (timestamps)
1768 ShowTime ("Closing types");
1769
1770 RootContext.CloseTypes ();
1771
1772 PEFileKinds k = PEFileKinds.ConsoleApplication;
1773
1774 switch (RootContext.Target) {
1775 case Target.Library:
1776 case Target.Module:
1777 k = PEFileKinds.Dll; break;
1778 case Target.Exe:
1779 k = PEFileKinds.ConsoleApplication; break;
1780 case Target.WinExe:
1781 k = PEFileKinds.WindowApplication; break;
1782 }
1783
1784 if (RootContext.NeedsEntryPoint) {
1785 Method ep = RootContext.EntryPoint;
1786
1787 if (ep == null) {
1788 if (RootContext.MainClass != null) {
1789 DeclSpace main_cont = RootContext.ToplevelTypes.GetDefinition (RootContext.MainClass) as DeclSpace;
1790 if (main_cont == null) {
1791 Report.Error (1555, "Could not find `{0}' specified for Main method", RootContext.MainClass);
1792 return false;
1793 }
1794
1795 if (!(main_cont is ClassOrStruct)) {
1796 Report.Error (1556, "`{0}' specified for Main method must be a valid class or struct", RootContext.MainClass);
1797 return false;
1798 }
1799
1800 Report.Error (1558, main_cont.Location, "`{0}' does not have a suitable static Main method", main_cont.GetSignatureForError ());
1801 return false;
1802 }
1803
1804 if (Report.Errors == 0)
1805 Report.Error (5001, "Program `{0}' does not contain a static `Main' method suitable for an entry point",
1806 output_file);
1807 return false;
1808 }
1809
1810 CodeGen.Assembly.Builder.SetEntryPoint (ep.MethodBuilder, k);
1811 } else if (RootContext.MainClass != null) {
1812 Report.Error (2017, "Cannot specify -main if building a module or library");
1813 }
1814
1815 if (embedded_resources != null){
1816 if (RootContext.Target == Target.Module) {
1817 Report.Error (1507, "Cannot link resource file when building a module");
1818 return false;
1819 }
1820
1821 embedded_resources.Emit ();
1822 }
1823
1824 //
1825 // Add Win32 resources
1826 //
1827
1828 if (win32ResourceFile != null) {
1829 try {
1830 CodeGen.Assembly.Builder.DefineUnmanagedResource (win32ResourceFile);
1831 } catch (ArgumentException) {
1832 Report.RuntimeMissingSupport (Location.Null, "resource embedding ");
1833 }
1834 } else {
1835 CodeGen.Assembly.Builder.DefineVersionInfoResource ();
1836 }
1837
1838 if (win32IconFile != null) {
1839 MethodInfo define_icon = typeof (AssemblyBuilder).GetMethod ("DefineIconResource", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
1840 if (define_icon == null) {
1841 Report.RuntimeMissingSupport (Location.Null, "resource embedding");
1842 } else {
1843 define_icon.Invoke (CodeGen.Assembly.Builder, new object [] { win32IconFile });
1844 }
1845 }
1846
1847 if (Report.Errors > 0)
1848 return false;
1849
1850 CodeGen.Save (output_file, want_debugging_support, Report);
1851 if (timestamps) {
1852 ShowTime ("Saved output");
1853 ShowTotalTime ("Total");
1854 }
1855
1856 Timer.ShowTimers ();
1857
1858 #if DEBUGME
1859 Console.WriteLine ("Size of strings held: " + DeclSpace.length);
1860 Console.WriteLine ("Size of strings short: " + DeclSpace.small);
1861 #endif
1862 return (Report.Errors == 0);
1863 }
1864 }
1865
1866 class Resources
1867 {
1868 interface IResource
1869 {
1870 void Emit (CompilerContext cc);
1871 string FileName { get; }
1872 }
1873
1874 class EmbededResource : IResource
1875 {
1876 static MethodInfo embed_res;
1877 readonly object[] args;
1878
1879 public EmbededResource (string name, string file, bool isPrivate)
1880 {
1881 args = new object [3];
1882 args [0] = name;
1883 args [1] = file;
1884 args [2] = isPrivate ? ResourceAttributes.Private : ResourceAttributes.Public;
1885 }
1886
1887 public void Emit (CompilerContext cc)
1888 {
1889 if (embed_res == null) {
1890 var argst = new [] {
1891 typeof (string), typeof (string), typeof (ResourceAttributes)
1892 };
1893
1894 embed_res = typeof (AssemblyBuilder).GetMethod (
1895 "EmbedResourceFile", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
1896 null, CallingConventions.Any, argst, null);
1897
1898 if (embed_res == null) {
1899 cc.Report.RuntimeMissingSupport (Location.Null, "Resource embedding");
1900 }
1901 }
1902
1903 embed_res.Invoke (CodeGen.Assembly.Builder, args);
1904 }
1905
1906 public string FileName {
1907 get {
1908 return (string)args [1];
1909 }
1910 }
1911 }
1912
1913 class LinkedResource : IResource
1914 {
1915 readonly string file;
1916 readonly string name;
1917 readonly ResourceAttributes attribute;
1918
1919 public LinkedResource (string name, string file, bool isPrivate)
1920 {
1921 this.name = name;
1922 this.file = file;
1923 this.attribute = isPrivate ? ResourceAttributes.Private : ResourceAttributes.Public;
1924 }
1925
1926 public void Emit (CompilerContext cc)
1927 {
1928 CodeGen.Assembly.Builder.AddResourceFile (name, Path.GetFileName(file), attribute);
1929 }
1930
1931 public string FileName {
1932 get {
1933 return file;
1934 }
1935 }
1936 }
1937
1938
1939 Dictionary<string, IResource> embedded_resources = new Dictionary<string, IResource> ();
1940 readonly CompilerContext ctx;
1941
1942 public Resources (CompilerContext ctx)
1943 {
1944 this.ctx = ctx;
1945 }
1946
1947 public void Add (bool embeded, string file, string name)
1948 {
1949 Add (embeded, file, name, false);
1950 }
1951
1952 public void Add (bool embeded, string file, string name, bool isPrivate)
1953 {
1954 if (embedded_resources.ContainsKey (name)) {
1955 ctx.Report.Error (1508, "The resource identifier `{0}' has already been used in this assembly", name);
1956 return;
1957 }
1958 IResource r = embeded ?
1959 (IResource) new EmbededResource (name, file, isPrivate) :
1960 new LinkedResource (name, file, isPrivate);
1961
1962 embedded_resources.Add (name, r);
1963 }
1964
1965 public void Emit ()
1966 {
1967 foreach (IResource r in embedded_resources.Values) {
1968 if (!File.Exists (r.FileName)) {
1969 ctx.Report.Error (1566, "Error reading resource file `{0}'", r.FileName);
1970 continue;
1971 }
1972
1973 r.Emit (ctx);
1974 }
1975 }
1976 }
1977
1978 //
1979 // This is the only public entry point
1980 //
1981 public class CompilerCallableEntryPoint : MarshalByRefObject {
1982 public static bool InvokeCompiler (string [] args, TextWriter error)
1983 {
1984 try {
1985 StreamReportPrinter srp = new StreamReportPrinter (error);
1986 Driver d = Driver.Create (args, true, srp);
1987 if (d == null)
1988 return false;
1989
1990 return d.Compile () && srp.ErrorsCount == 0;
1991 } finally {
1992 Reset ();
1993 }
1994 }
1995
1996 public static int[] AllWarningNumbers {
1997 get {
1998 return Report.AllWarnings;
1999 }
2000 }
2001
2002 public static void Reset ()
2003 {
2004 Reset (true);
2005 }
2006
2007 public static void PartialReset ()
2008 {
2009 Reset (false);
2010 }
2011
2012 public static void Reset (bool full_flag)
2013 {
2014 Driver.Reset ();
2015 CSharpParser.yacc_verbose_flag = 0;
2016 RootContext.Reset (full_flag);
2017 Location.Reset ();
2018 TypeManager.Reset ();
2019 PredefinedAttributes.Reset ();
2020 TypeHandle.Reset ();
2021
2022 if (full_flag)
2023 GlobalRootNamespace.Reset ();
2024
2025 NamespaceEntry.Reset ();
2026 CodeGen.Reset ();
2027 Attribute.Reset ();
2028 AttributeTester.Reset ();
2029 AnonymousTypeClass.Reset ();
2030 AnonymousMethodBody.Reset ();
2031 AnonymousMethodStorey.Reset ();
2032 SymbolWriter.Reset ();
2033 Switch.Reset ();
2034 Linq.QueryBlock.TransparentParameter.Reset ();
2035 Convert.Reset ();
2036 TypeInfo.Reset ();
2037 DynamicExpressionStatement.Reset ();
2038 }
2039 }
2040 }
git-svn mirror of mcs