?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(DISTFILES): Comment out a few missing files.
[mono-project.git] / mcs / mcs / driver.cs
blob29850d83cb7c171a5854f488274465833e32b516
1 //
2 // driver.cs: The compiler command line driver.
3 //
4 // Author: Miguel de Icaza (miguel@gnu.org)
5 //
6 // Licensed under the terms of the GNU GPL
7 //
8 // (C) 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
9 //
10
11 namespace Mono.CSharp
12 {
13 using System;
14 using System.Reflection;
15 using System.Reflection.Emit;
16 using System.Collections;
17 using System.IO;
18 using System.Text;
19 using System.Globalization;
20 using System.Diagnostics;
21
22 public enum Target {
23 Library, Exe, Module, WinExe
24 };
25
26 /// <summary>
27 /// The compiler driver.
28 /// </summary>
29 public class Driver
30 {
31
32 //
33 // Assemblies references to be linked. Initialized with
34 // mscorlib.dll here.
35 static ArrayList references;
36
37 //
38 // If any of these fail, we ignore the problem. This is so
39 // that we can list all the assemblies in Windows and not fail
40 // if they are missing on Linux.
41 //
42 static ArrayList soft_references;
43
44 //
45 // Modules to be linked
46 //
47 static ArrayList modules;
48
49 // Lookup paths
50 static ArrayList link_paths;
51
52 // Whether we want Yacc to output its progress
53 static bool yacc_verbose = false;
54
55 // Whether we want to only run the tokenizer
56 static bool tokenize = false;
57
58 static string first_source;
59
60 static bool want_debugging_support = false;
61
62 static bool parse_only = false;
63 static bool timestamps = false;
64 static bool pause = false;
65 static bool show_counters = false;
66 public static bool parser_verbose = false;
67
68 //
69 // Whether to load the initial config file (what CSC.RSP has by default)
70 //
71 static bool load_default_config = true;
72
73 static Hashtable response_file_list;
74
75 //
76 // A list of resource files
77 //
78 static ArrayList resources;
79 static ArrayList embedded_resources;
80 static string win32ResourceFile;
81 static string win32IconFile;
82
83 //
84 // An array of the defines from the command line
85 //
86 static ArrayList defines;
87
88 //
89 // Output file
90 //
91 static string output_file = null;
92
93 //
94 // Last time we took the time
95 //
96 static DateTime last_time, first_time;
97
98 //
99 // Encoding: ISO-Latin1 is 28591
100 //
101 static Encoding encoding;
102
103 //
104 // Whether the user has specified a different encoder manually
105 //
106 static bool using_default_encoder = true;
107
108 public static void ShowTime (string msg)
109 {
110 if (!timestamps)
111 return;
112
113 DateTime now = DateTime.Now;
114 TimeSpan span = now - last_time;
115 last_time = now;
116
117 Console.WriteLine (
118 "[{0:00}:{1:000}] {2}",
119 (int) span.TotalSeconds, span.Milliseconds, msg);
120 }
121
122 public static void ShowTotalTime (string msg)
123 {
124 if (!timestamps)
125 return;
126
127 DateTime now = DateTime.Now;
128 TimeSpan span = now - first_time;
129 last_time = now;
130
131 Console.WriteLine (
132 "[{0:00}:{1:000}] {2}",
133 (int) span.TotalSeconds, span.Milliseconds, msg);
134 }
135
136 static void tokenize_file (SourceFile file)
137 {
138 Stream input;
139
140 try {
141 input = File.OpenRead (file.Name);
142 } catch {
143 Report.Error (2001, "Source file '" + file.Name + "' could not be opened");
144 return;
145 }
146
147 using (input){
148 SeekableStreamReader reader = new SeekableStreamReader (input, encoding, using_default_encoder);
149 Tokenizer lexer = new Tokenizer (reader, file, defines);
150 int token, tokens = 0, errors = 0;
151
152 while ((token = lexer.token ()) != Token.EOF){
153 tokens++;
154 if (token == Token.ERROR)
155 errors++;
156 }
157 Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors");
158 }
159
160 return;
161 }
162
163 // MonoTODO("Change error code for aborted compilation to something reasonable")]
164 static void parse (SourceFile file)
165 {
166 CSharpParser parser;
167 Stream input;
168
169 try {
170 input = File.OpenRead (file.Name);
171 } catch {
172 Report.Error (2001, "Source file '" + file.Name + "' could not be opened");
173 return;
174 }
175
176 SeekableStreamReader reader = new SeekableStreamReader (input, encoding, using_default_encoder);
177
178 parser = new CSharpParser (reader, file, defines);
179 parser.yacc_verbose_flag = yacc_verbose;
180 try {
181 parser.parse ();
182 } catch (Exception ex) {
183 Report.Error(666, "Compilation aborted: " + ex);
184 } finally {
185 input.Close ();
186 }
187 }
188
189 static void OtherFlags ()
190 {
191 Console.WriteLine (
192 "Other flags in the compiler\n" +
193 " --fatal Makes errors fatal\n" +
194 " --parse Only parses the source file\n" +
195 " --stacktrace Shows stack trace at error location\n" +
196 " --timestamp Displays time stamps of various compiler events\n" +
197 " -2 Enables experimental C# features\n" +
198 " -v Verbose parsing (for debugging the parser)\n" +
199 " --mcs-debug X Sets MCS debugging level to X\n");
200 }
201
202 static void Usage ()
203 {
204 Console.WriteLine (
205 "Mono C# compiler, (C) 2001 - 2003 Ximian, Inc.\n" +
206 "mcs [options] source-files\n" +
207 " --about About the Mono C# compiler\n" +
208 " -addmodule:MODULE Adds the module to the generated assembly\n" +
209 " -checked[+|-] Set default context to checked\n" +
210 " -codepage:ID Sets code page to the one in ID\n" +
211 " (number, `utf8' or `reset')\n" +
212 " -clscheck[+|-] Disables CLS Compliance verifications" + Environment.NewLine +
213 " -define:S1[;S2] Defines one or more symbols (short: /d:)\n" +
214 " -debug[+|-] Generate debugging information\n" +
215 " -delaysign[+|-] Only insert the public key into the assembly (no signing)\n" +
216 " -doc:FILE XML Documentation file to generate\n" +
217 " -g Generate debugging information\n" +
218 " -keycontainer:NAME The key pair container used to strongname the assembly\n" +
219 " -keyfile:FILE The strongname key file used to strongname the assembly\n" +
220 " -langversion:TEXT Specifies language version modes: ISO-1 or Default" + Environment.NewLine +
221 " -lib:PATH1,PATH2 Adds the paths to the assembly link path\n" +
222 " -main:class Specified the class that contains the entry point\n" +
223 " -noconfig[+|-] Disables implicit references to assemblies\n" +
224 " -nostdlib[+|-] Does not load core libraries\n" +
225 " -nowarn:W1[,W2] Disables one or more warnings\n" +
226 " -out:FNAME Specifies output file\n" +
227 " -pkg:P1[,Pn] References packages P1..Pn\n" +
228 " --expect-error X Expect that error X will be encountered\n" +
229 " -recurse:SPEC Recursively compiles the files in SPEC ([dir]/file)\n" +
230 " -reference:ASS References the specified assembly (-r:ASS)\n" +
231 " -target:KIND Specifies the target (KIND is one of: exe, winexe,\n" +
232 " library, module), (short: /t:)\n" +
233 " -unsafe[+|-] Allows unsafe code\n" +
234 " -warnaserror[+|-] Treat warnings as errors\n" +
235 " -warn:LEVEL Sets warning level (the highest is 4, the default is 2)\n" +
236 " -help2 Show other help flags\n" +
237 "\n" +
238 "Resources:\n" +
239 " -linkresource:FILE[,ID] Links FILE as a resource\n" +
240 " -resource:FILE[,ID] Embed FILE as a resource\n" +
241 " -win32res:FILE Specifies Win32 resource file (.res)\n" +
242 " -win32icon:FILE Use this icon for the output\n" +
243 " @file Read response file for more options\n\n" +
244 "Options can be of the form -option or /option");
245 }
246
247 static void TargetUsage ()
248 {
249 Report.Error (2019, "Valid options for -target: are exe, winexe, library or module");
250 }
251
252 static void About ()
253 {
254 Console.WriteLine (
255 "The Mono C# compiler is (C) 2001, 2002, 2003 Ximian, Inc.\n\n" +
256 "The compiler source code is released under the terms of the GNU GPL\n\n" +
257
258 "For more information on Mono, visit the project Web site\n" +
259 " http://www.go-mono.com\n\n" +
260
261 "The compiler was written by Miguel de Icaza, Ravi Pratap, Martin Baulig and Marek Safar");
262 Environment.Exit (0);
263 }
264
265 public static int counter1, counter2;
266
267 public static int Main (string[] args)
268 {
269 bool ok = MainDriver (args);
270
271 if (ok && Report.Errors == 0) {
272 Console.Write("Compilation succeeded");
273 if (Report.Warnings > 0) {
274 Console.Write(" - {0} warning(s)", Report.Warnings);
275 }
276 Console.WriteLine();
277 if (show_counters){
278 Console.WriteLine ("Counter1: " + counter1);
279 Console.WriteLine ("Counter2: " + counter2);
280 }
281 if (pause)
282 Console.ReadLine ();
283 return 0;
284 } else {
285 Console.WriteLine("Compilation failed: {0} error(s), {1} warnings",
286 Report.Errors, Report.Warnings);
287 return 1;
288 }
289 }
290
291 static public void LoadAssembly (string assembly, bool soft)
292 {
293 Assembly a;
294 string total_log = "";
295
296 try {
297 char[] path_chars = { '/', '\\' };
298
299 if (assembly.IndexOfAny (path_chars) != -1) {
300 a = Assembly.LoadFrom (assembly);
301 } else {
302 string ass = assembly;
303 if (ass.EndsWith (".dll"))
304 ass = assembly.Substring (0, assembly.Length - 4);
305 a = Assembly.Load (ass);
306 }
307 TypeManager.AddAssembly (a);
308
309 } catch (FileNotFoundException){
310 foreach (string dir in link_paths){
311 string full_path = Path.Combine (dir, assembly);
312 if (!assembly.EndsWith (".dll"))
313 full_path += ".dll";
314
315 try {
316 a = Assembly.LoadFrom (full_path);
317 TypeManager.AddAssembly (a);
318 return;
319 } catch (FileNotFoundException ff) {
320 total_log += ff.FusionLog;
321 continue;
322 }
323 }
324 if (!soft) {
325 Report.Error (6, "Cannot find assembly `" + assembly + "'" );
326 Console.WriteLine ("Log: \n" + total_log);
327 }
328 } catch (BadImageFormatException f) {
329 Report.Error(6, "Cannot load assembly (bad file format)" + f.FusionLog);
330 } catch (FileLoadException f){
331 Report.Error(6, "Cannot load assembly " + f.FusionLog);
332 } catch (ArgumentNullException){
333 Report.Error(6, "Cannot load assembly (null argument)");
334 }
335 }
336
337 static public void LoadModule (MethodInfo adder_method, string module)
338 {
339 Module m;
340 string total_log = "";
341
342 try {
343 try {
344 m = (Module)adder_method.Invoke (CodeGen.Assembly.Builder, new object [] { module });
345 }
346 catch (TargetInvocationException ex) {
347 throw ex.InnerException;
348 }
349 TypeManager.AddModule (m);
350
351 }
352 catch (FileNotFoundException){
353 foreach (string dir in link_paths){
354 string full_path = Path.Combine (dir, module);
355 if (!module.EndsWith (".netmodule"))
356 full_path += ".netmodule";
357
358 try {
359 try {
360 m = (Module)adder_method.Invoke (CodeGen.Assembly.Builder, new object [] { full_path });
361 }
362 catch (TargetInvocationException ex) {
363 throw ex.InnerException;
364 }
365 TypeManager.AddModule (m);
366 return;
367 } catch (FileNotFoundException ff) {
368 total_log += ff.FusionLog;
369 continue;
370 }
371 }
372 Report.Error (6, "Cannot find module `" + module + "'" );
373 Console.WriteLine ("Log: \n" + total_log);
374 } catch (BadImageFormatException f) {
375 Report.Error(6, "Cannot load module (bad file format)" + f.FusionLog);
376 } catch (FileLoadException f){
377 Report.Error(6, "Cannot load module " + f.FusionLog);
378 } catch (ArgumentNullException){
379 Report.Error(6, "Cannot load module (null argument)");
380 }
381 }
382
383 /// <summary>
384 /// Loads all assemblies referenced on the command line
385 /// </summary>
386 static public void LoadReferences ()
387 {
388 foreach (string r in references)
389 LoadAssembly (r, false);
390
391 foreach (string r in soft_references)
392 LoadAssembly (r, true);
393
394 return;
395 }
396
397 static void SetupDefaultDefines ()
398 {
399 defines = new ArrayList ();
400 defines.Add ("__MonoCS__");
401 }
402
403 static string [] LoadArgs (string file)
404 {
405 StreamReader f;
406 ArrayList args = new ArrayList ();
407 string line;
408 try {
409 f = new StreamReader (file);
410 } catch {
411 return null;
412 }
413
414 StringBuilder sb = new StringBuilder ();
415
416 while ((line = f.ReadLine ()) != null){
417 int t = line.Length;
418
419 for (int i = 0; i < t; i++){
420 char c = line [i];
421
422 if (c == '"' || c == '\''){
423 char end = c;
424
425 for (i++; i < t; i++){
426 c = line [i];
427
428 if (c == end)
429 break;
430 sb.Append (c);
431 }
432 } else if (c == ' '){
433 if (sb.Length > 0){
434 args.Add (sb.ToString ());
435 sb.Length = 0;
436 }
437 } else
438 sb.Append (c);
439 }
440 if (sb.Length > 0){
441 args.Add (sb.ToString ());
442 sb.Length = 0;
443 }
444 }
445
446 string [] ret_value = new string [args.Count];
447 args.CopyTo (ret_value, 0);
448
449 return ret_value;
450 }
451
452 //
453 // Returns the directory where the system assemblies are installed
454 //
455 static string GetSystemDir ()
456 {
457 Assembly [] assemblies = AppDomain.CurrentDomain.GetAssemblies ();
458
459 foreach (Assembly a in assemblies){
460 string codebase = a.Location;
461 string fn = System.IO.Path.GetFileName (codebase);
462 if (fn == "corlib.dll" || fn == "mscorlib.dll"){
463 return codebase.Substring (0, codebase.LastIndexOf (System.IO.Path.DirectorySeparatorChar));
464 }
465 }
466
467 Report.Error (-15, "Can not compute my system path");
468 return "";
469 }
470
471 //
472 // Given a path specification, splits the path from the file/pattern
473 //
474 static void SplitPathAndPattern (string spec, out string path, out string pattern)
475 {
476 int p = spec.LastIndexOf ('/');
477 if (p != -1){
478 //
479 // Windows does not like /file.cs, switch that to:
480 // "\", "file.cs"
481 //
482 if (p == 0){
483 path = "\\";
484 pattern = spec.Substring (1);
485 } else {
486 path = spec.Substring (0, p);
487 pattern = spec.Substring (p + 1);
488 }
489 return;
490 }
491
492 p = spec.LastIndexOf ('\\');
493 if (p != -1){
494 path = spec.Substring (0, p);
495 pattern = spec.Substring (p + 1);
496 return;
497 }
498
499 path = ".";
500 pattern = spec;
501 }
502
503 static void ProcessFile (string f)
504 {
505 if (first_source == null)
506 first_source = f;
507
508 Location.AddFile (f);
509 }
510
511 static void ProcessFiles ()
512 {
513 Location.Initialize ();
514
515 foreach (SourceFile file in Location.SourceFiles) {
516 if (tokenize) {
517 tokenize_file (file);
518 } else {
519 parse (file);
520 }
521 }
522 }
523
524 static void CompileFiles (string spec, bool recurse)
525 {
526 string path, pattern;
527
528 SplitPathAndPattern (spec, out path, out pattern);
529 if (pattern.IndexOf ('*') == -1){
530 ProcessFile (spec);
531 return;
532 }
533
534 string [] files = null;
535 try {
536 files = Directory.GetFiles (path, pattern);
537 } catch (System.IO.DirectoryNotFoundException) {
538 Report.Error (2001, "Source file `" + spec + "' could not be found");
539 return;
540 } catch (System.IO.IOException){
541 Report.Error (2001, "Source file `" + spec + "' could not be found");
542 return;
543 }
544 foreach (string f in files) {
545 ProcessFile (f);
546 }
547
548 if (!recurse)
549 return;
550
551 string [] dirs = null;
552
553 try {
554 dirs = Directory.GetDirectories (path);
555 } catch {
556 }
557
558 foreach (string d in dirs) {
559
560 // Don't include path in this string, as each
561 // directory entry already does
562 CompileFiles (d + "/" + pattern, true);
563 }
564 }
565
566 static void DefineDefaultConfig ()
567 {
568 //
569 // For now the "default config" is harcoded into the compiler
570 // we can move this outside later
571 //
572 string [] default_config = {
573 "System",
574 "System.Xml",
575 #if false
576 //
577 // Is it worth pre-loading all this stuff?
578 //
579 "Accessibility",
580 "System.Configuration.Install",
581 "System.Data",
582 "System.Design",
583 "System.DirectoryServices",
584 "System.Drawing.Design",
585 "System.Drawing",
586 "System.EnterpriseServices",
587 "System.Management",
588 "System.Messaging",
589 "System.Runtime.Remoting",
590 "System.Runtime.Serialization.Formatters.Soap",
591 "System.Security",
592 "System.ServiceProcess",
593 "System.Web",
594 "System.Web.RegularExpressions",
595 "System.Web.Services",
596 "System.Windows.Forms"
597 #endif
598 };
599
600 int p = 0;
601 foreach (string def in default_config)
602 soft_references.Insert (p++, def);
603 }
604
605 static void SetOutputFile (string name)
606 {
607 output_file = name;
608 }
609
610 static void SetWarningLevel (string s)
611 {
612 int level = 0;
613
614 try {
615 level = Int32.Parse (s);
616 } catch {
617 Report.Error (
618 1900,
619 "--wlevel requires a value from 0 to 4");
620 Environment.Exit (1);
621 }
622 if (level < 0 || level > 4){
623 Report.Error (1900, "Warning level must be 0 to 4");
624 Environment.Exit (1);
625 }
626 RootContext.WarningLevel = level;
627 TestWarningConflict ();
628 }
629
630 static void TestWarningConflict ()
631 {
632 if (RootContext.WarningLevel == 0 && Report.WarningsAreErrors) {
633 Report.Error (1901, "Conflicting options specified: Warning level 0; Treat warnings as errors");
634 Environment.Exit (1);
635 }
636 }
637
638 static void SetupV2 ()
639 {
640 RootContext.Version = LanguageVersion.Default;
641 defines.Add ("__V2__");
642 }
643
644 static void Version ()
645 {
646 string version = Assembly.GetExecutingAssembly ().GetName ().Version.ToString ();
647 Console.WriteLine ("Mono C# compiler version {0}", version);
648 Environment.Exit (0);
649 }
650
651 //
652 // Currently handles the Unix-like command line options, but will be
653 // deprecated in favor of the CSCParseOption, which will also handle the
654 // options that start with a dash in the future.
655 //
656 static bool UnixParseOption (string arg, ref string [] args, ref int i)
657 {
658 switch (arg){
659 case "-vv":
660 parser_verbose = true;
661 return true;
662
663 case "-v":
664 yacc_verbose = true;
665 return true;
666
667 case "--version":
668 Version ();
669 return true;
670
671 case "--parse":
672 parse_only = true;
673 return true;
674
675 case "--main": case "-m":
676 if ((i + 1) >= args.Length){
677 Usage ();
678 Environment.Exit (1);
679 }
680 RootContext.MainClass = args [++i];
681 return true;
682
683 case "--unsafe":
684 RootContext.Unsafe = true;
685 return true;
686
687 case "/?": case "/h": case "/help":
688 case "--help":
689 Usage ();
690 Environment.Exit (0);
691 return true;
692
693 case "--define":
694 if ((i + 1) >= args.Length){
695 Usage ();
696 Environment.Exit (1);
697 }
698 defines.Add (args [++i]);
699 return true;
700
701 case "--show-counters":
702 show_counters = true;
703 return true;
704
705 case "--expect-error": {
706 int code = 0;
707
708 try {
709 code = Int32.Parse (
710 args [++i], NumberStyles.AllowLeadingSign);
711 Report.ExpectedError = code;
712 } catch {
713 Report.Error (-14, "Invalid number specified");
714 }
715 return true;
716 }
717
718 case "--tokenize":
719 tokenize = true;
720 return true;
721
722 case "-o":
723 case "--output":
724 if ((i + 1) >= args.Length){
725 Usage ();
726 Environment.Exit (1);
727 }
728 SetOutputFile (args [++i]);
729 return true;
730
731 case "--checked":
732 RootContext.Checked = true;
733 return true;
734
735 case "--stacktrace":
736 Report.Stacktrace = true;
737 return true;
738
739 case "--linkresource":
740 case "--linkres":
741 if ((i + 1) >= args.Length){
742 Usage ();
743 Report.Error (5, "Missing argument to --linkres");
744 Environment.Exit (1);
745 }
746 if (resources == null)
747 resources = new ArrayList ();
748
749 resources.Add (args [++i]);
750 return true;
751
752 case "--resource":
753 case "--res":
754 if ((i + 1) >= args.Length){
755 Usage ();
756 Report.Error (5, "Missing argument to --resource");
757 Environment.Exit (1);
758 }
759 if (embedded_resources == null)
760 embedded_resources = new ArrayList ();
761
762 embedded_resources.Add (args [++i]);
763 return true;
764
765 case "--target":
766 if ((i + 1) >= args.Length){
767 Environment.Exit (1);
768 return true;
769 }
770
771 string type = args [++i];
772 switch (type){
773 case "library":
774 RootContext.Target = Target.Library;
775 RootContext.TargetExt = ".dll";
776 break;
777
778 case "exe":
779 RootContext.Target = Target.Exe;
780 break;
781
782 case "winexe":
783 RootContext.Target = Target.WinExe;
784 break;
785
786 case "module":
787 RootContext.Target = Target.Module;
788 RootContext.TargetExt = ".dll";
789 break;
790 default:
791 TargetUsage ();
792 Environment.Exit (1);
793 break;
794 }
795 return true;
796
797 case "-r":
798 if ((i + 1) >= args.Length){
799 Usage ();
800 Environment.Exit (1);
801 }
802
803 references.Add (args [++i]);
804 return true;
805
806 case "-L":
807 if ((i + 1) >= args.Length){
808 Usage ();
809 Environment.Exit (1);
810 }
811 link_paths.Add (args [++i]);
812 return true;
813
814 case "--nostdlib":
815 RootContext.StdLib = false;
816 return true;
817
818 case "--fatal":
819 Report.Fatal = true;
820 return true;
821
822 case "--werror":
823 Report.WarningsAreErrors = true;
824 TestWarningConflict();
825 return true;
826
827 case "--nowarn":
828 if ((i + 1) >= args.Length){
829 Usage ();
830 Environment.Exit (1);
831 }
832 int warn = 0;
833
834 try {
835 warn = Int32.Parse (args [++i]);
836 } catch {
837 Usage ();
838 Environment.Exit (1);
839 }
840 Report.SetIgnoreWarning (warn);
841 return true;
842
843 case "--wlevel":
844 if ((i + 1) >= args.Length){
845 Report.Error (
846 1900,
847 "--wlevel requires a value from 0 to 4");
848 Environment.Exit (1);
849 }
850
851 SetWarningLevel (args [++i]);
852 return true;
853
854 case "--mcs-debug":
855 if ((i + 1) >= args.Length){
856 Report.Error (5, "--mcs-debug requires an argument");
857 Environment.Exit (1);
858 }
859
860 try {
861 Report.DebugFlags = Int32.Parse (args [++i]);
862 } catch {
863 Report.Error (5, "Invalid argument to --mcs-debug");
864 Environment.Exit (1);
865 }
866 return true;
867
868 case "--about":
869 About ();
870 return true;
871
872 case "--recurse":
873 if ((i + 1) >= args.Length){
874 Report.Error (5, "--recurse requires an argument");
875 Environment.Exit (1);
876 }
877 CompileFiles (args [++i], true);
878 return true;
879
880 case "--timestamp":
881 timestamps = true;
882 last_time = first_time = DateTime.Now;
883 return true;
884
885 case "--pause":
886 pause = true;
887 return true;
888
889 case "--debug": case "-g":
890 want_debugging_support = true;
891 return true;
892
893 case "--noconfig":
894 load_default_config = false;
895 return true;
896 }
897
898 return false;
899 }
900
901 //
902 // Currently it is very basic option parsing, but eventually, this will
903 // be the complete option parser
904 //
905 static bool CSCParseOption (string option, ref string [] args, ref int i)
906 {
907 int idx = option.IndexOf (':');
908 string arg, value;
909
910 if (idx == -1){
911 arg = option;
912 value = "";
913 } else {
914 arg = option.Substring (0, idx);
915
916 value = option.Substring (idx + 1);
917 }
918
919 switch (arg){
920 case "/nologo":
921 return true;
922
923 case "/t":
924 case "/target":
925 switch (value){
926 case "exe":
927 RootContext.Target = Target.Exe;
928 break;
929
930 case "winexe":
931 RootContext.Target = Target.WinExe;
932 break;
933
934 case "library":
935 RootContext.Target = Target.Library;
936 RootContext.TargetExt = ".dll";
937 break;
938
939 case "module":
940 RootContext.Target = Target.Module;
941 RootContext.TargetExt = ".netmodule";
942 break;
943
944 default:
945 TargetUsage ();
946 Environment.Exit (1);
947 break;
948 }
949 return true;
950
951 case "/out":
952 if (value == ""){
953 Usage ();
954 Environment.Exit (1);
955 }
956 SetOutputFile (value);
957 return true;
958
959 case "/optimize":
960 case "/optimize+":
961 case "/optimize-":
962 case "/incremental":
963 case "/incremental+":
964 case "/incremental-":
965 // nothing.
966 return true;
967
968 case "/d":
969 case "/define": {
970 string [] defs;
971
972 if (value == ""){
973 Usage ();
974 Environment.Exit (1);
975 }
976
977 defs = value.Split (new Char [] {';', ','});
978 foreach (string d in defs){
979 defines.Add (d);
980 }
981 return true;
982 }
983
984 case "/linkres":
985 case "/linkresource":
986 if (value == ""){
987 Report.Error (5, arg + " requires an argument");
988 Environment.Exit (1);
989 }
990 if (resources == null)
991 resources = new ArrayList ();
992
993 resources.Add (value);
994 return true;
995
996 case "/pkg": {
997 string packages;
998
999 if (value == ""){
1000 Usage ();
1001 Environment.Exit (1);
1002 }
1003 packages = String.Join (" ", value.Split (new Char [] { ';', ',', '\n', '\r'}));
1004
1005 ProcessStartInfo pi = new ProcessStartInfo ();
1006 pi.FileName = "pkg-config";
1007 pi.RedirectStandardOutput = true;
1008 pi.UseShellExecute = false;
1009 pi.Arguments = "--libs " + packages;
1010 Process p = null;
1011 try {
1012 p = Process.Start (pi);
1013 } catch (Exception e) {
1014 Report.Error (-27, "Couldn't run pkg-config: " + e.Message);
1015 Environment.Exit (1);
1016 }
1017
1018 if (p.StandardOutput == null){
1019 Report.Warning (-27, "Specified package did not return any information");
1020 return true;
1021 }
1022 string pkgout = p.StandardOutput.ReadToEnd ();
1023 p.WaitForExit ();
1024 if (p.ExitCode != 0) {
1025 Report.Error (-27, "Error running pkg-config. Check the above output.");
1026 Environment.Exit (1);
1027 }
1028
1029 if (pkgout != null){
1030 string [] xargs = pkgout.Trim (new Char [] {' ', '\n', '\r', '\t'}).
1031 Split (new Char [] { ' ', '\t'});
1032 args = AddArgs (args, xargs);
1033 }
1034
1035 p.Close ();
1036 return true;
1037 }
1038
1039 case "/res":
1040 case "/resource":
1041 if (value == ""){
1042 Report.Error (5, "-resource requires an argument");
1043 Environment.Exit (1);
1044 }
1045 if (embedded_resources == null)
1046 embedded_resources = new ArrayList ();
1047
1048 if (embedded_resources.Contains (value)) {
1049 Report.Error (1508, String.Format ("The resource identifier '{0}' has already been used in this assembly.", value));
1050 }
1051 else if (value.IndexOf (',') != -1 && embedded_resources.Contains (value.Split (',')[1])) {
1052 Report.Error (1508, String.Format ("The resource identifier '{0}' has already been used in this assembly.", value));
1053 }
1054 else {
1055 embedded_resources.Add (value);
1056 }
1057 return true;
1058
1059 case "/recurse":
1060 if (value == ""){
1061 Report.Error (5, "-recurse requires an argument");
1062 Environment.Exit (1);
1063 }
1064 CompileFiles (value, true);
1065 return true;
1066
1067 case "/r":
1068 case "/reference": {
1069 if (value == ""){
1070 Report.Error (5, "-reference requires an argument");
1071 Environment.Exit (1);
1072 }
1073
1074 string [] refs = value.Split (new char [] { ';', ',' });
1075 foreach (string r in refs){
1076 references.Add (r);
1077 }
1078 return true;
1079 }
1080 case "/addmodule": {
1081 if (value == ""){
1082 Report.Error (5, arg + " requires an argument");
1083 Environment.Exit (1);
1084 }
1085
1086 string [] refs = value.Split (new char [] { ';', ',' });
1087 foreach (string r in refs){
1088 modules.Add (r);
1089 }
1090 return true;
1091 }
1092 case "/win32res": {
1093 if (value == "") {
1094 Report.Error (5, arg + " requires an argument");
1095 Environment.Exit (1);
1096 }
1097
1098 win32ResourceFile = value;
1099 return true;
1100 }
1101 case "/win32icon": {
1102 if (value == "") {
1103 Report.Error (5, arg + " requires an argument");
1104 Environment.Exit (1);
1105 }
1106
1107 win32IconFile = value;
1108 return true;
1109 }
1110 case "/doc": {
1111 if (value == ""){
1112 Report.Error (5, arg + " requires an argument");
1113 Environment.Exit (1);
1114 }
1115 // TODO handle the /doc argument to generate xml doc
1116 return true;
1117 }
1118 case "/lib": {
1119 string [] libdirs;
1120
1121 if (value == ""){
1122 Report.Error (5, "/lib requires an argument");
1123 Environment.Exit (1);
1124 }
1125
1126 libdirs = value.Split (new Char [] { ',' });
1127 foreach (string dir in libdirs)
1128 link_paths.Add (dir);
1129 return true;
1130 }
1131
1132 case "/debug-":
1133 want_debugging_support = false;
1134 return true;
1135
1136 case "/debug":
1137 case "/debug+":
1138 want_debugging_support = true;
1139 return true;
1140
1141 case "/checked":
1142 case "/checked+":
1143 RootContext.Checked = true;
1144 return true;
1145
1146 case "/checked-":
1147 RootContext.Checked = false;
1148 return true;
1149
1150 case "/clscheck":
1151 case "/clscheck+":
1152 return true;
1153
1154 case "/clscheck-":
1155 RootContext.VerifyClsCompliance = false;
1156 return true;
1157
1158 case "/unsafe":
1159 case "/unsafe+":
1160 RootContext.Unsafe = true;
1161 return true;
1162
1163 case "/unsafe-":
1164 RootContext.Unsafe = false;
1165 return true;
1166
1167 case "/warnaserror":
1168 case "/warnaserror+":
1169 Report.WarningsAreErrors = true;
1170 TestWarningConflict();
1171 return true;
1172
1173 case "/warnaserror-":
1174 Report.WarningsAreErrors = false;
1175 return true;
1176
1177 case "/warn":
1178 SetWarningLevel (value);
1179 return true;
1180
1181 case "/nowarn": {
1182 string [] warns;
1183
1184 if (value == ""){
1185 Report.Error (5, "/nowarn requires an argument");
1186 Environment.Exit (1);
1187 }
1188
1189 warns = value.Split (new Char [] {','});
1190 foreach (string wc in warns){
1191 try {
1192 int warn = Int32.Parse (wc);
1193 if (warn < 1) {
1194 throw new ArgumentOutOfRangeException("warn");
1195 }
1196 Report.SetIgnoreWarning (warn);
1197 } catch {
1198 Report.Error (1904, String.Format("'{0}' is not a valid warning number", wc));
1199 Environment.Exit (1);
1200 }
1201 }
1202 return true;
1203 }
1204
1205 case "/noconfig-":
1206 load_default_config = true;
1207 return true;
1208
1209 case "/noconfig":
1210 case "/noconfig+":
1211 load_default_config = false;
1212 return true;
1213
1214 case "/help2":
1215 OtherFlags ();
1216 Environment.Exit(0);
1217 return true;
1218
1219 case "/help":
1220 case "/?":
1221 Usage ();
1222 Environment.Exit (0);
1223 return true;
1224
1225 case "/main":
1226 case "/m":
1227 if (value == ""){
1228 Report.Error (5, arg + " requires an argument");
1229 Environment.Exit (1);
1230 }
1231 RootContext.MainClass = value;
1232 return true;
1233
1234 case "/nostdlib":
1235 case "/nostdlib+":
1236 RootContext.StdLib = false;
1237 return true;
1238
1239 case "/nostdlib-":
1240 RootContext.StdLib = true;
1241 return true;
1242
1243 case "/fullpaths":
1244 return true;
1245
1246 case "/keyfile":
1247 if (value == String.Empty) {
1248 Report.Error (5, arg + " requires an argument");
1249 Environment.Exit (1);
1250 }
1251 RootContext.StrongNameKeyFile = value;
1252 return true;
1253 case "/keycontainer":
1254 if (value == String.Empty) {
1255 Report.Error (5, arg + " requires an argument");
1256 Environment.Exit (1);
1257 }
1258 RootContext.StrongNameKeyContainer = value;
1259 return true;
1260 case "/delaysign+":
1261 RootContext.StrongNameDelaySign = true;
1262 return true;
1263 case "/delaysign-":
1264 RootContext.StrongNameDelaySign = false;
1265 return true;
1266
1267 case "/v2":
1268 case "/2":
1269 Console.WriteLine ("The compiler option -2 is obsolete. Please use /langversion instead");
1270 SetupV2 ();
1271 return true;
1272
1273 case "/langversion":
1274 switch (value.ToLower (CultureInfo.InvariantCulture)) {
1275 case "iso-1":
1276 RootContext.Version = LanguageVersion.ISO_1;
1277 return true;
1278
1279 case "default":
1280 SetupV2 ();
1281 return true;
1282 }
1283 Report.Error (1617, "Invalid option '{0}' for /langversion; must be ISO-1 or Default", value);
1284 Environment.Exit (1);
1285 return false;
1286
1287 case "/codepage":
1288 int cp = -1;
1289
1290 if (value == "utf8"){
1291 encoding = new UTF8Encoding();
1292 using_default_encoder = false;
1293 return true;
1294 }
1295 if (value == "reset"){
1296 //
1297 // 28591 is the code page for ISO-8859-1 encoding.
1298 //
1299 cp = 28591;
1300 using_default_encoder = true;
1301 }
1302
1303 try {
1304 cp = Int32.Parse (value);
1305 encoding = Encoding.GetEncoding (cp);
1306 using_default_encoder = false;
1307 } catch {
1308 Report.Error (2016, String.Format("Code page '{0}' is invalid or not installed", cp));
1309 Environment.Exit (1);
1310 }
1311 return true;
1312 }
1313
1314 //Report.Error (2007, String.Format ("Unrecognized command-line option: '{0}'", option));
1315 //Environment.Exit (1);
1316 return false;
1317 }
1318
1319 static string [] AddArgs (string [] args, string [] extra_args)
1320 {
1321 string [] new_args;
1322
1323 new_args = new string [extra_args.Length + args.Length];
1324 args.CopyTo (new_args, 0);
1325 extra_args.CopyTo (new_args, args.Length);
1326
1327 return new_args;
1328 }
1329
1330 /// <summary>
1331 /// Parses the arguments, and drives the compilation
1332 /// process.
1333 /// </summary>
1334 ///
1335 /// <remarks>
1336 /// TODO: Mostly structured to debug the compiler
1337 /// now, needs to be turned into a real driver soon.
1338 /// </remarks>
1339 // [MonoTODO("Change error code for unknown argument to something reasonable")]
1340 internal static bool MainDriver (string [] args)
1341 {
1342 int i;
1343 bool parsing_options = true;
1344
1345 try {
1346 encoding = Encoding.GetEncoding (28591);
1347 } catch {
1348 Console.WriteLine ("Error: could not load encoding 28591, trying 1252");
1349 encoding = Encoding.GetEncoding (1252);
1350 }
1351
1352 references = new ArrayList ();
1353 soft_references = new ArrayList ();
1354 modules = new ArrayList ();
1355 link_paths = new ArrayList ();
1356
1357 SetupDefaultDefines ();
1358
1359 //
1360 // Setup defaults
1361 //
1362 // This is not required because Assembly.Load knows about this
1363 // path.
1364 //
1365
1366 for (i = 0; i < args.Length; i++){
1367 string arg = args [i];
1368 if (arg == "")
1369 continue;
1370
1371 if (arg.StartsWith ("@")){
1372 string [] extra_args;
1373 string response_file = arg.Substring (1);
1374
1375 if (response_file_list == null)
1376 response_file_list = new Hashtable ();
1377
1378 if (response_file_list.Contains (response_file)){
1379 Report.Error (
1380 1515, "Response file `" + response_file +
1381 "' specified multiple times");
1382 Environment.Exit (1);
1383 }
1384
1385 response_file_list.Add (response_file, response_file);
1386
1387 extra_args = LoadArgs (response_file);
1388 if (extra_args == null){
1389 Report.Error (2011, "Unable to open response file: " +
1390 response_file);
1391 return false;
1392 }
1393
1394 args = AddArgs (args, extra_args);
1395 continue;
1396 }
1397
1398 if (parsing_options){
1399 if (arg == "--"){
1400 parsing_options = false;
1401 continue;
1402 }
1403
1404 if (arg.StartsWith ("-")){
1405 if (UnixParseOption (arg, ref args, ref i))
1406 continue;
1407
1408 // Try a -CSCOPTION
1409 string csc_opt = "/" + arg.Substring (1);
1410 if (CSCParseOption (csc_opt, ref args, ref i))
1411 continue;
1412 } else {
1413 if (arg.StartsWith ("/")){
1414 if (CSCParseOption (arg, ref args, ref i))
1415 continue;
1416 }
1417 }
1418 }
1419
1420 CompileFiles (arg, false);
1421 }
1422
1423 ProcessFiles ();
1424
1425 if (tokenize)
1426 return true;
1427
1428 //
1429 // If we are an exe, require a source file for the entry point
1430 //
1431 if (RootContext.Target == Target.Exe || RootContext.Target == Target.WinExe){
1432 if (first_source == null){
1433 Report.Error (2008, "No files to compile were specified");
1434 return false;
1435 }
1436
1437 }
1438
1439 //
1440 // If there is nothing to put in the assembly, and we are not a library
1441 //
1442 if (first_source == null && embedded_resources == null && resources == null){
1443 Report.Error (2008, "No files to compile were specified");
1444 return false;
1445 }
1446
1447 if (Report.Errors > 0)
1448 return false;
1449
1450 if (parse_only)
1451 return true;
1452
1453 Tokenizer.Cleanup ();
1454
1455 //
1456 // Load Core Library for default compilation
1457 //
1458 if (RootContext.StdLib)
1459 references.Insert (0, "mscorlib");
1460
1461 if (load_default_config)
1462 DefineDefaultConfig ();
1463
1464 if (Report.Errors > 0){
1465 return false;
1466 }
1467
1468 //
1469 // Load assemblies required
1470 //
1471 if (timestamps)
1472 ShowTime ("Loading references");
1473 link_paths.Add (GetSystemDir ());
1474 link_paths.Add (Directory.GetCurrentDirectory ());
1475 LoadReferences ();
1476
1477 if (timestamps)
1478 ShowTime (" References loaded");
1479
1480 if (Report.Errors > 0){
1481 return false;
1482 }
1483
1484 //
1485 // Quick hack
1486 //
1487 if (output_file == null){
1488 int pos = first_source.LastIndexOf ('.');
1489
1490 if (pos > 0)
1491 output_file = first_source.Substring (0, pos) + RootContext.TargetExt;
1492 else
1493 output_file = first_source + RootContext.TargetExt;
1494 }
1495
1496 CodeGen.Init (output_file, output_file, want_debugging_support);
1497
1498 if (RootContext.Target == Target.Module) {
1499 PropertyInfo module_only = typeof (AssemblyBuilder).GetProperty ("IsModuleOnly", BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
1500 if (module_only == null) {
1501 Report.Error (0, new Location (-1), "Cannot use /target:module on this runtime: try the Mono runtime instead.");
1502 Environment.Exit (1);
1503 }
1504
1505 MethodInfo set_method = module_only.GetSetMethod (true);
1506 set_method.Invoke (CodeGen.Assembly.Builder, BindingFlags.Default, null, new object[]{true}, null);
1507 }
1508
1509 TypeManager.AddModule (CodeGen.Module.Builder);
1510
1511 if (modules.Count > 0) {
1512 MethodInfo adder_method = typeof (AssemblyBuilder).GetMethod ("AddModule", BindingFlags.Instance|BindingFlags.NonPublic);
1513 if (adder_method == null) {
1514 Report.Error (0, new Location (-1), "Cannot use /addmodule on this runtime: Try the Mono runtime instead.");
1515 Environment.Exit (1);
1516 }
1517
1518 foreach (string module in modules)
1519 LoadModule (adder_method, module);
1520 }
1521
1522 TypeManager.ComputeNamespaces ();
1523
1524 //
1525 // Before emitting, we need to get the core
1526 // types emitted from the user defined types
1527 // or from the system ones.
1528 //
1529 if (timestamps)
1530 ShowTime ("Initializing Core Types");
1531 if (!RootContext.StdLib){
1532 RootContext.ResolveCore ();
1533 if (Report.Errors > 0)
1534 return false;
1535 }
1536
1537 TypeManager.InitCoreTypes ();
1538 if (timestamps)
1539 ShowTime (" Core Types done");
1540
1541 //
1542 // The second pass of the compiler
1543 //
1544 if (timestamps)
1545 ShowTime ("Resolving tree");
1546 RootContext.ResolveTree ();
1547 if (Report.Errors > 0)
1548 return false;
1549 if (timestamps)
1550 ShowTime ("Populate tree");
1551 if (!RootContext.StdLib)
1552 RootContext.BootCorlib_PopulateCoreTypes ();
1553
1554 RootContext.PopulateTypes ();
1555 RootContext.DefineTypes ();
1556
1557 TypeManager.InitCodeHelpers ();
1558
1559 //
1560 // Verify using aliases now
1561 //
1562 Namespace.VerifyUsing ();
1563
1564 if (Report.Errors > 0){
1565 return false;
1566 }
1567
1568 if (RootContext.VerifyClsCompliance) {
1569 CodeGen.Assembly.ResolveClsCompliance ();
1570 if (CodeGen.Assembly.IsClsCompliant) {
1571 AttributeTester.VerifyModulesClsCompliance ();
1572 TypeManager.LoadAllImportedTypes ();
1573 AttributeTester.VerifyTopLevelNameClsCompliance ();
1574 }
1575 }
1576
1577 //
1578 // The code generator
1579 //
1580 if (timestamps)
1581 ShowTime ("Emitting code");
1582 ShowTotalTime ("Total so far");
1583 RootContext.EmitCode ();
1584 if (timestamps)
1585 ShowTime (" done");
1586
1587 if (Report.Errors > 0){
1588 return false;
1589 }
1590
1591 if (timestamps)
1592 ShowTime ("Closing types");
1593
1594 RootContext.CloseTypes ();
1595
1596 PEFileKinds k = PEFileKinds.ConsoleApplication;
1597
1598 switch (RootContext.Target) {
1599 case Target.Library:
1600 case Target.Module:
1601 k = PEFileKinds.Dll; break;
1602 case Target.Exe:
1603 k = PEFileKinds.ConsoleApplication; break;
1604 case Target.WinExe:
1605 k = PEFileKinds.WindowApplication; break;
1606 }
1607
1608 if (RootContext.NeedsEntryPoint) {
1609 MethodInfo ep = RootContext.EntryPoint;
1610
1611 if (ep == null) {
1612 if (RootContext.MainClass != null) {
1613 object main_cont = RootContext.Tree.Decls [RootContext.MainClass];
1614 if (main_cont == null) {
1615 Report.Error (1555, output_file, "Could not find '{0}' specified for Main method", RootContext.MainClass);
1616 return false;
1617 }
1618
1619 if (!(main_cont is ClassOrStruct)) {
1620 Report.Error (1556, output_file, "'{0}' specified for Main method must be a valid class or struct", RootContext.MainClass);
1621 return false;
1622 }
1623 }
1624
1625 if (Report.Errors == 0)
1626 Report.Error (5001, "Program " + output_file +
1627 " does not have an entry point defined");
1628 return false;
1629 }
1630
1631 CodeGen.Assembly.Builder.SetEntryPoint (ep, k);
1632 } else if (RootContext.MainClass != null) {
1633 Report.Error (2017, "Can not specify -main: when building module or library");
1634 }
1635
1636 //
1637 // Add the resources
1638 //
1639 if (resources != null){
1640 foreach (string spec in resources){
1641 string file, res;
1642 int cp;
1643
1644 cp = spec.IndexOf (',');
1645 if (cp != -1){
1646 file = spec.Substring (0, cp);
1647 res = spec.Substring (cp + 1);
1648 } else
1649 file = res = spec;
1650
1651 CodeGen.Assembly.Builder.AddResourceFile (res, file);
1652 }
1653 }
1654
1655 if (embedded_resources != null){
1656 object[] margs = new object [2];
1657 Type[] argst = new Type [2];
1658 argst [0] = argst [1] = typeof (string);
1659
1660 MethodInfo embed_res = typeof (AssemblyBuilder).GetMethod (
1661 "EmbedResourceFile", BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic,
1662 null, CallingConventions.Any, argst, null);
1663
1664 if (embed_res == null) {
1665 Report.Warning (0, new Location (-1),
1666 "Cannot embed resources on this runtime: try the Mono runtime instead.");
1667 } else {
1668 foreach (string spec in embedded_resources) {
1669 int cp;
1670
1671 cp = spec.IndexOf (',');
1672 if (cp != -1){
1673 margs [0] = spec.Substring (cp + 1);
1674 margs [1] = spec.Substring (0, cp);
1675 } else {
1676 margs [1] = spec;
1677 margs [0] = Path.GetFileName (spec);
1678 }
1679
1680 if (File.Exists ((string) margs [1]))
1681 embed_res.Invoke (CodeGen.Assembly.Builder, margs);
1682 else {
1683 Report.Error (1566, "Can not find the resource " + margs [1]);
1684 }
1685 }
1686 }
1687 }
1688
1689 //
1690 // Add Win32 resources
1691 //
1692
1693 CodeGen.Assembly.Builder.DefineVersionInfoResource ();
1694
1695 if (win32ResourceFile != null) {
1696 try {
1697 CodeGen.Assembly.Builder.DefineUnmanagedResource (win32ResourceFile);
1698 }
1699 catch (ArgumentException) {
1700 Report.Warning (0, new Location (-1), "Cannot embed win32 resources on this runtime: try the Mono runtime instead.");
1701 }
1702 }
1703
1704 if (win32IconFile != null) {
1705 MethodInfo define_icon = typeof (AssemblyBuilder).GetMethod ("DefineIconResource", BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
1706 if (define_icon == null) {
1707 Report.Warning (0, new Location (-1), "Cannot embed icon resource on this runtime: try the Mono runtime instead.");
1708 }
1709 define_icon.Invoke (CodeGen.Assembly.Builder, new object [] { win32IconFile });
1710 }
1711
1712 if (Report.Errors > 0)
1713 return false;
1714
1715 CodeGen.Save (output_file);
1716 if (timestamps) {
1717 ShowTime ("Saved output");
1718 ShowTotalTime ("Total");
1719 }
1720
1721 Timer.ShowTimers ();
1722
1723 if (Report.ExpectedError != 0) {
1724 if (Report.Errors == 0) {
1725 Console.WriteLine ("Failed to report expected error " + Report.ExpectedError + ".\n" +
1726 "No other errors reported.");
1727
1728 Environment.Exit (2);
1729 } else {
1730 Console.WriteLine ("Failed to report expected error " + Report.ExpectedError + ".\n" +
1731 "However, other errors were reported.");
1732
1733 Environment.Exit (1);
1734 }
1735
1736
1737 return false;
1738 }
1739
1740 #if DEBUGME
1741 Console.WriteLine ("Size of strings held: " + DeclSpace.length);
1742 Console.WriteLine ("Size of strings short: " + DeclSpace.small);
1743 #endif
1744 return (Report.Errors == 0);
1745 }
1746
1747 }
1748
1749 //
1750 // This is the only public entry point
1751 //
1752 public class CompilerCallableEntryPoint : MarshalByRefObject {
1753 static bool used = false;
1754
1755 public bool InvokeCompiler (string [] args)
1756 {
1757 if (used)
1758 Reset ();
1759 bool ok = Driver.MainDriver (args);
1760 return ok && Report.Errors == 0;
1761 }
1762
1763 public void Reset ()
1764 {
1765 }
1766 }
1767 }
Mirror of the official Mono project git repository