?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WhiteSpaceAgnostic Boo Printer
[boo.git] / src / booc / App.cs
blob45c8d3339ee07f0b62224e1e8361e5bbfab5a919
1 #region license
2 // Copyright (c) 2004, Rodrigo B. de Oliveira (rbo@acm.org)
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without modification,
6 // are permitted provided that the following conditions are met:
7 //
8 // * Redistributions of source code must retain the above copyright notice,
9 // this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright notice,
11 // this list of conditions and the following disclaimer in the documentation
12 // and/or other materials provided with the distribution.
13 // * Neither the name of Rodrigo B. de Oliveira nor the names of its
14 // contributors may be used to endorse or promote products derived from this
15 // software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #endregion
28
29 using System;
30 using System.Text;
31 using System.Collections;
32 using System.Diagnostics;
33 using System.IO;
34 using System.Globalization;
35 using System.Threading;
36 using Boo.Lang.Compiler.Ast.Visitors;
37 using Assembly = System.Reflection.Assembly;
38 using Boo.Lang.Compiler;
39 using Boo.Lang.Compiler.IO;
40 using Boo.Lang.Compiler.Pipelines;
41 using Boo.Lang.Compiler.Resources;
42 using Boo.Lang;
43
44 namespace BooC
45 {
46 /// <summary>
47 ///
48 /// </summary>
49 class App
50 {
51 ArrayList _responseFileList = new ArrayList();
52 CompilerParameters _options = null;
53
54 ArrayList _references = new ArrayList();
55 ArrayList _packages = new ArrayList();
56 bool _noConfig = false;
57 string _pipelineName = null;
58 bool _debugSteps = false;
59 bool _whiteSpaceAgnostic = false;
60
61 /// <summary>
62 /// The main entry point for the application.
63 /// </summary>
64 [STAThread]
65 static int Main(string[] args)
66 {
67 if (((IList)args).Contains("-utf8"))
68 {
69 using (StreamWriter writer = new StreamWriter(Console.OpenStandardError(), Encoding.UTF8))
70 {
71 // leave the byte order mark in its own line and out
72 writer.WriteLine();
73
74 Console.SetError(writer);
75 return new App().Run(args);
76 }
77 }
78 else
79 {
80 return new App().Run(args);
81 }
82 }
83
84 public int Run(string[] args)
85 {
86 int resultCode = -1;
87
88 AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(AssemblyResolve);
89
90 CheckBooCompiler();
91
92 try
93 {
94 DateTime start = DateTime.Now;
95
96 _options = new CompilerParameters(false); //false means no stdlib loading yet
97 _options.GenerateInMemory = false;
98
99 BooCompiler compiler = new BooCompiler(_options);
100
101 ParseOptions(args);
102
103 if (0 == _options.Input.Count)
104 {
105 throw new ApplicationException(Boo.Lang.ResourceManager.GetString("BooC.NoInputSpecified"));
106 }
107
108 //move standard libpaths below any new ones:
109 _options.LibPaths.Add(_options.LibPaths[0]);
110 _options.LibPaths.Add(_options.LibPaths[1]);
111 _options.LibPaths.RemoveAt(0);
112 _options.LibPaths.RemoveAt(0);
113
114 if (_options.StdLib)
115 {
116 _options.LoadDefaultReferences();
117 }
118 else if (!_noConfig)
119 {
120 _references.Insert(0, "mscorlib");
121 }
122
123 LoadReferences();
124 ConfigurePipeline();
125
126 if (_options.TraceSwitch.TraceInfo)
127 {
128 compiler.Parameters.Pipeline.BeforeStep += new CompilerStepEventHandler(OnBeforeStep);
129 compiler.Parameters.Pipeline.AfterStep += new CompilerStepEventHandler(OnAfterStep);
130 }
131
132 TimeSpan setupTime = DateTime.Now - start;
133
134 start = DateTime.Now;
135 CompilerContext context = compiler.Run();
136 TimeSpan processingTime = DateTime.Now - start;
137
138 if (context.Warnings.Count > 0)
139 {
140 Console.Error.WriteLine(context.Warnings);
141 Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.Warnings", context.Warnings.Count));
142 }
143
144 if (context.Errors.Count > 0)
145 {
146 foreach (CompilerError error in context.Errors)
147 {
148 Console.Error.WriteLine(error.ToString(_options.TraceSwitch.TraceInfo));
149 }
150 Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.Errors", context.Errors.Count));
151 }
152 else
153 {
154 resultCode = 0;
155 }
156
157 if (_options.TraceSwitch.TraceWarning)
158 {
159 Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.ProcessingTime", _options.Input.Count, processingTime.TotalMilliseconds, setupTime.TotalMilliseconds));
160 }
161 }
162 catch (Exception x)
163 {
164 object message = _options.TraceSwitch.TraceWarning ? (object)x : (object)x.Message;
165 Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.FatalError", message));
166 }
167 return resultCode;
168 }
169
170 void LoadReferences()
171 {
172 foreach (string r in _references)
173 {
174 _options.References.Add(_options.LoadAssembly(r, true));
175 }
176 foreach (string p in _packages)
177 {
178 _options.LoadReferencesFromPackage(p);
179 }
180 }
181
182 void CheckBooCompiler()
183 {
184 string path = Path.Combine(Path.GetDirectoryName(
185 Assembly.GetExecutingAssembly().Location),
186 "Boo.Lang.Compiler.dll");
187 if (File.Exists(path))
188 {
189 foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
190 {
191 if (a.FullName.StartsWith("Boo.Lang.Compiler"))
192 {
193 if (string.Compare(a.Location, path, true) != 0)
194 {
195 //can't use ResourceManager, boo.lang.dll may be out of date
196 string msg=string.Format("WARNING: booc is not using the Boo.Lang.Compiler.dll next to booc.exe. Using '{0}' instead of '{1}'. You may need to remove boo dlls from the GAC using gacutil or Mscorcfg.",
197 a.Location, path);
198 //has to be all 1 line for things like msbuild that parse booc output.
199 Console.Error.WriteLine(msg);
200 }
201 break;
202 }
203 }
204 }
205 }
206
207 string Consume(TextReader reader)
208 {
209 StringWriter writer = new StringWriter();
210 string line = reader.ReadLine();
211 while (null != line)
212 {
213 writer.WriteLine(line);
214 line = reader.ReadLine();
215 }
216 return writer.ToString();
217 }
218
219 void DoLogo()
220 {
221 Console.Write("Boo Compiler version "+Builtins.BooVersion.ToString());
222 Console.WriteLine(" (CLR v"+Environment.Version.ToString()+")");
223 }
224
225 void Help ()
226 {
227 Console.WriteLine(
228 "Usage is: booc [options] file1 ...\n" +
229 "Options:\n" +
230 " -c:CULTURE Sets the UI culture to be CULTURE\n" +
231 " -debug[+|-] Generate debugging information (default: +)\n" +
232 " -delaysign Delay assembly signing\n" +
233 " -ducky Turns on duck typing by default\n" +
234 " -checked[+|-] Turns on or off checked operations (default: +)\n" +
235 " -embedres:FILE[,ID] Embeds FILE with the optional ID\n"+
236 " -lib:DIRS Adds the comma-separated DIRS to the assembly search path\n" +
237 " -noconfig Do not load the standard configuration\n" +
238 " -nostdlib Do not reference any of the default libraries\n" +
239 " -nologo Do not display the compiler logo\n" +
240 " -p:PIPELINE Sets the pipeline to PIPELINE\n" +
241 " -o:FILE Set the output file name to FILE\n" +
242 " -keyfile:FILE The strongname key file used to strongname the assembly\n" +
243 " -keycontainer:NAME The key pair container used to strongname the assembly\n" +
244 " -reference:ASS References the specified assembly (-r:ASS)\n" +
245 " -srcdir:DIR Adds DIR as a directory where sources can be found\n" +
246 " -target:TYPE Set the target type (exe, library or winexe)\n" +
247 " -resource:FILE[,ID] Embed FILE as a resource\n" +
248 " -utf8 Source file is in utf8 format\n" +
249 " -v, -vv, -vvv Set verbosity level from warnings to very detailed\n" +
250 " -wsa Enable white-space-agnostic builds\n"
251 );
252 }
253
254
255 void ParseOptions(string[] args)
256 {
257 bool noLogo = false;
258
259 ArrayList arglist = new ArrayList(args);
260 ExpandResponseFiles(ref arglist);
261 AddDefaultResponseFile(ref arglist);
262 foreach (string arg in arglist)
263 {
264 if ("-" == arg)
265 {
266 _options.Input.Add(new StringInput("<stdin>", Consume(Console.In)));
267 continue;
268 }
269 if (!IsFlag(arg))
270 {
271 _options.Input.Add(new FileInput(StripQuotes(arg)));
272 continue;
273 }
274 if ("-utf8" == arg) continue;
275
276 switch (arg[1])
277 {
278 case 'h':
279 {
280 if (arg == "-help" || arg == "-h")
281 {
282 Help();
283 }
284 break;
285 }
286
287 case 'w':
288 {
289 if (arg == "-wsa")
290 {
291 _options.WhiteSpaceAgnostic = _whiteSpaceAgnostic = true;
292 }
293 else
294 {
295 InvalidOption(arg);
296 }
297 break;
298 }
299
300 case 'v':
301 {
302 _options.TraceSwitch.Level = TraceLevel.Warning;
303 Trace.Listeners.Add(new TextWriterTraceListener(Console.Error));
304 if (arg.Length > 2)
305 {
306 switch (arg.Substring(1))
307 {
308 case "vv":
309 {
310 _options.TraceSwitch.Level = TraceLevel.Info;
311 MonitorAppDomain();
312 break;
313 }
314
315 case "vvv":
316 {
317 _options.TraceSwitch.Level = TraceLevel.Verbose;
318 break;
319 }
320 }
321 }
322 else
323 {
324 _options.TraceSwitch.Level = TraceLevel.Warning;
325 }
326 break;
327 }
328
329 case 'r':
330 {
331 if (arg.IndexOf(":") > 2 && arg.Substring(1, 9) != "reference")
332 {
333 switch (arg.Substring(1, 8))
334 {
335 case "resource":
336 {
337 int start = arg.IndexOf(":") + 1;
338 AddResource(StripQuotes(arg.Substring(start)));
339 break;
340 }
341
342 default:
343 {
344 InvalidOption(arg);
345 break;
346 }
347 }
348 }
349 else
350 {
351 string assemblyName = StripQuotes(arg.Substring(arg.IndexOf(":")+1));
352 _references.Add(assemblyName);
353 }
354 break;
355 }
356
357 case 'l':
358 {
359 switch (arg.Substring(1, 3))
360 {
361 case "lib":
362 {
363 string paths = arg.Substring(arg.IndexOf(":")+1);
364 if (paths == "")
365 {
366 Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.BadLibPath", arg));
367 break;
368 }
369
370 foreach(string dir in paths.Split(new Char[] {','}))
371 {
372 if (Directory.Exists(dir))
373 {
374 _options.LibPaths.Add(dir);
375 }
376 else
377 {
378 Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.BadLibPath", dir));
379 }
380 }
381 break;
382 }
383
384 default:
385 {
386 InvalidOption(arg);
387 break;
388 }
389 }
390 break;
391 }
392
393 case 'n':
394 {
395 if (arg == "-nologo")
396 {
397 noLogo = true;
398 }
399 else if (arg == "-noconfig")
400 {
401 _noConfig = true;
402 }
403 else if (arg == "-nostdlib")
404 {
405 _options.StdLib = false;
406 }
407 else
408 {
409 InvalidOption(arg);
410 }
411 break;
412 }
413
414 case 'o':
415 {
416 _options.OutputAssembly = StripQuotes(arg.Substring(arg.IndexOf(":")+1));
417 break;
418 }
419
420 case 't':
421 {
422 string targetType = arg.Substring(arg.IndexOf(":")+1);
423 switch (targetType)
424 {
425 case "library":
426 {
427 _options.OutputType = CompilerOutputType.Library;
428 break;
429 }
430
431 case "exe":
432 {
433 _options.OutputType = CompilerOutputType.ConsoleApplication;
434 break;
435 }
436
437 case "winexe":
438 {
439 _options.OutputType = CompilerOutputType.WindowsApplication;
440 break;
441 }
442
443 default:
444 {
445 InvalidOption(arg);
446 break;
447 }
448 }
449 break;
450 }
451
452 case 'p':
453 {
454 if (arg.StartsWith("-pkg:"))
455 {
456 string packages = StripQuotes(arg.Substring(arg.IndexOf(":")+1));
457 _packages.Add(packages);
458 }
459 else {
460 _pipelineName = StripQuotes(arg.Substring(3));
461 }
462 break;
463 }
464
465 case 'c':
466 {
467 switch (arg.Substring(1))
468 {
469 case "checked":
470 case "checked+":
471 {
472 _options.Checked = true;
473 break;
474 }
475
476 case "checked-":
477 {
478 _options.Checked = false;
479 break;
480 }
481
482 default:
483 {
484 string culture = arg.Substring(3);
485 Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(culture);
486 break;
487 }
488 }
489 break;
490 }
491
492 case 's':
493 {
494 switch (arg.Substring(1, 6))
495 {
496 case "srcdir":
497 {
498 string path = StripQuotes(arg.Substring(8));
499 AddFilesForPath(path, _options);
500 break;
501 }
502
503 default:
504 {
505 InvalidOption(arg);
506 break;
507 }
508 }
509 break;
510 }
511
512 case 'k':
513 {
514 if (arg.Substring(1, 7) == "keyfile")
515 {
516 _options.KeyFile = StripQuotes(arg.Substring(9));
517 }
518 else if (arg.Substring(1, 12) == "keycontainer")
519 {
520 _options.KeyContainer = StripQuotes(arg.Substring(14));
521 }
522 else
523 {
524 InvalidOption(arg);
525 }
526 break;
527 }
528
529 case 'd':
530 {
531 switch (arg.Substring(1))
532 {
533 case "debug":
534 case "debug+":
535 {
536 _options.Debug = true;
537 break;
538 }
539
540 case "debug-":
541 {
542 _options.Debug = false;
543 break;
544 }
545
546 case "ducky":
547 {
548 _options.Ducky = true;
549 break;
550 }
551
552 case "debug-steps":
553 {
554 _debugSteps = true;
555 break;
556 }
557
558 case "delaysign":
559 {
560 _options.DelaySign = true;
561 break;
562 }
563
564 default:
565 {
566 InvalidOption(arg);
567 break;
568 }
569 }
570 break;
571 }
572
573 case 'e':
574 {
575 switch (arg.Substring(1,8))
576 {
577 case "embedres":
578 {
579 if (!IsMono)
580 {
581 throw new ApplicationException("-embedres is only supported on mono. Try -resource.");
582 }
583 int start = arg.IndexOf(":") + 1;
584 EmbedResource(StripQuotes(arg.Substring(start)));
585 break;
586 }
587
588 default:
589 {
590 InvalidOption(arg);
591 break;
592 }
593 }
594 break;
595 }
596
597 default:
598 {
599 InvalidOption(arg);
600 break;
601 }
602 }
603 }
604
605 if (!noLogo)
606 {
607 DoLogo();
608 }
609 }
610
611 private bool IsMono
612 {
613 get { return Type.GetType("System.MonoType", false) != null; }
614 }
615
616 private void EmbedResource(string resourceFile)
617 {
618
619 int comma = resourceFile.LastIndexOf(',');
620 if (comma >= 0)
621 {
622 string resourceName = resourceFile.Substring(comma+1);
623 resourceFile = resourceFile.Substring(0, comma);
624 _options.Resources.Add(new NamedEmbeddedFileResource(resourceFile, resourceName));
625 }
626 else
627 {
628 _options.Resources.Add(new EmbeddedFileResource(resourceFile));
629 }
630 }
631
632 private void AddResource(string resourceFile)
633 {
634 int comma = resourceFile.LastIndexOf(',');
635 if (comma >= 0)
636 {
637 string resourceName = resourceFile.Substring(comma+1);
638 resourceFile = resourceFile.Substring(0, comma);
639 _options.Resources.Add(new NamedFileResource(resourceFile, resourceName));
640 }
641 else
642 {
643 _options.Resources.Add(new FileResource(resourceFile));
644 }
645 }
646
647 private void ConfigurePipeline()
648 {
649 if (null != _pipelineName)
650 {
651 _options.Pipeline = CompilerPipeline.GetPipeline(_pipelineName);
652 }
653 else
654 {
655 _options.Pipeline = new CompileToFile();
656 }
657 if (_whiteSpaceAgnostic)
658 {
659 _options.Pipeline[0] = new Boo.Lang.Parser.WSABooParsingStep();
660 }
661 if (_debugSteps)
662 {
663 _options.Pipeline.AfterStep += new CompilerStepEventHandler(new StepDebugger().AfterStep);
664 }
665 }
666
667 private string StripQuotes(string s)
668 {
669 if (s.Length > 1 && s.StartsWith("\"") && s.EndsWith("\""))
670 {
671 return s.Substring(1,s.Length-2);
672 }
673 return s;
674 }
675
676 private class StepDebugger
677 {
678 string _last;
679
680 public void AfterStep(object sender, CompilerStepEventArgs args)
681 {
682 Console.WriteLine("********* {0} *********", args.Step);
683
684 StringWriter writer = new StringWriter();
685 args.Context.CompileUnit.Accept(new BooPrinterVisitor(writer, BooPrinterVisitor.PrintOptions.PrintLocals));
686 string code = writer.ToString();
687 if (code != _last)
688 {
689 Console.WriteLine(code);
690 }
691 else
692 {
693 Console.WriteLine("no changes");
694 }
695 _last = code;
696 }
697 }
698
699 ArrayList LoadResponseFile(string file)
700 {
701 file = Path.GetFullPath(file);
702 if (_responseFileList.Contains(file))
703 {
704 throw new ApplicationException(
705 Boo.Lang.ResourceManager.Format("BCE0500", file));
706 }
707 _responseFileList.Add(file);
708 if (!File.Exists(file))
709 {
710 throw new ApplicationException(Boo.Lang.ResourceManager.Format("BCE0501", file));
711 }
712 ArrayList arglist = new ArrayList();
713 try
714 {
715 using (StreamReader sr = new StreamReader(file))
716 {
717 string line;
718 while ((line = sr.ReadLine()) != null)
719 {
720 line = line.Trim();
721 if (line.Length > 0 && line[0] != '#')
722 {
723 if (line.StartsWith("@") && line.Length > 2)
724 {
725 arglist.AddRange(LoadResponseFile(line.Substring(1)));
726 }
727 else
728 {
729 arglist.Add(line);
730 }
731 }
732 }
733 }
734 }
735 catch (ApplicationException)
736 {
737 throw;
738 }
739 catch (Exception x)
740 {
741 throw new ApplicationException(
742 Boo.Lang.ResourceManager.Format("BCE0502", file),
743 x);
744 }
745 return arglist;
746 }
747
748 void ExpandResponseFiles(ref ArrayList arglist)
749 {
750 ArrayList result = new ArrayList();
751 foreach (string arg in arglist)
752 {
753 if (arg.StartsWith("@") && arg.Length > 2)
754 {
755 result.AddRange(LoadResponseFile(arg.Substring(1)));
756 }
757 else
758 {
759 result.Add(arg);
760 }
761 }
762 arglist = result;
763 }
764
765 void AddDefaultResponseFile(ref ArrayList arglist)
766 {
767 ArrayList result = new ArrayList();
768 foreach (string arg in arglist)
769 {
770 if (arg == "-noconfig")
771 {
772 _noConfig = true;
773 }
774 else
775 {
776 result.Add(arg);
777 }
778 }
779 if (!_noConfig)
780 {
781 string file = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "booc.rsp");
782 if (File.Exists(file))
783 {
784 result.InsertRange(0, LoadResponseFile(file));
785 }
786 }
787 arglist = result;
788 }
789
790 void OnBeforeStep(object sender, CompilerStepEventArgs args)
791 {
792 args.Context.TraceEnter("Entering {0}", args.Step);
793 }
794
795 void OnAfterStep(object sender, CompilerStepEventArgs args)
796 {
797 args.Context.TraceLeave("Leaving {0}", args.Step);
798 }
799
800 void InvalidOption(string arg)
801 {
802 Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.InvalidOption", arg));
803 }
804
805 bool IsFlag(string arg)
806 {
807 return arg[0] == '-';
808 }
809
810 void AddFilesForPath(string path, CompilerParameters _options)
811 {
812 foreach (string fname in Directory.GetFiles(path, "*.boo"))
813 {
814 if (!fname.EndsWith(".boo")) continue;
815 _options.Input.Add(new FileInput(Path.GetFullPath(fname)));
816 }
817
818 foreach (string dirName in Directory.GetDirectories(path))
819 {
820 AddFilesForPath(dirName, _options);
821 }
822 }
823
824 void MonitorAppDomain()
825 {
826 if (_options.TraceSwitch.TraceInfo)
827 {
828 AppDomain.CurrentDomain.AssemblyLoad += new AssemblyLoadEventHandler(OnAssemblyLoad);
829 foreach(Assembly a in AppDomain.CurrentDomain.GetAssemblies())
830 {
831 Trace.WriteLine("ASSEMBLY AT STARTUP: "+GetAssemblyLocation(a));
832 }
833 }
834 }
835
836 static void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
837 {
838 Trace.WriteLine("ASSEMBLY LOADED: " + GetAssemblyLocation(args.LoadedAssembly));
839 }
840
841 static string GetAssemblyLocation(Assembly a)
842 {
843 string loc;
844 try
845 {
846 loc = a.Location;
847 }
848 catch (Exception)
849 {
850 loc = "<dynamic>"+a.FullName;
851 }
852 return loc;
853 }
854
855 static Assembly AssemblyResolve(object sender, ResolveEventArgs args)
856 {
857 string simpleName = args.Name.Split(',')[0];
858 string fileName = Path.Combine(Environment.CurrentDirectory,
859 simpleName + ".dll");
860 if (File.Exists(fileName))
861 {
862 return Assembly.LoadFile(fileName);
863 }
864 return null;
865 }
866
867 }
868 }
Boo Programming Language