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