src/Boo.Lang.Compiler/Compilation.cs

   1 #region license
   2 // Copyright (c) 2003, 2004, 2005 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
  30 using System;
  31 using System.Reflection;
  32 using System.Runtime.CompilerServices;
  33 using Boo.Lang.Compiler.Ast;
  34 using Module=Boo.Lang.Compiler.Ast.Module;
  35
  36 namespace Boo.Lang.Compiler.MetaProgramming
  37 {
  38         public class CompilationErrorsException : System.Exception
  39         {
  40                 private CompilerErrorCollection _errors;
  41
  42                 public CompilationErrorsException(CompilerErrorCollection errors) : base(errors.ToString())
  43                 {
  44                         _errors = errors;
  45                 }
  46
  47                 public CompilerErrorCollection Errors
  48                 {
  49                         get { return _errors;  }
  50                 }
  51         }
  52
  53         [CompilerGlobalScope]
  54         public sealed class Compilation
  55         {
  56                 public static Type compile(ClassDefinition klass, params System.Reflection.Assembly[] references)
  57                 {
  58                         Assembly generatedAssembly = compile(CreateCompileUnit(klass), references);
  59                         return generatedAssembly.GetType(klass.Name);
  60                 }
  61
  62                 public static Assembly compile(Module module, params System.Reflection.Assembly[] references)
  63                 {
  64                         return compile(new CompileUnit(module), references);
  65                 }
  66
  67                 public static CompilerContext compile_(Module module, params System.Reflection.Assembly[] references)
  68                 {
  69                         return compile_(new CompileUnit(module), references);
  70                 }
  71
  72                 public static Assembly compile(CompileUnit unit, params Assembly[] references)
  73                 {
  74                         CompilerContext result = compile_(unit, references);
  75                         if (result.Errors.Count > 0) throw new CompilationErrorsException(result.Errors);
  76                         return result.GeneratedAssembly;
  77                 }
  78
  79                 public static CompilerContext compile_(CompileUnit unit, Assembly[] references)
  80                 {
  81                         BooCompiler compiler = CompilerFor(unit, references);
  82                         return compiler.Run(unit);
  83                 }
  84
  85                 private static BooCompiler CompilerFor(CompileUnit unit, Assembly[] references)
  86                 {
  87                         BooCompiler compiler = new BooCompiler();
  88                         compiler.Parameters.OutputType = IsApplication(unit) ? CompilerOutputType.ConsoleApplication : CompilerOutputType.Library;
  89                         compiler.Parameters.Pipeline = new Boo.Lang.Compiler.Pipelines.CompileToMemory();
  90                         compiler.Parameters.References.Extend(references);
  91                         return compiler;
  92                 }
  93
  94                 private static bool IsApplication(CompileUnit unit)
  95                 {
  96                         foreach (Module m in unit.Modules)
  97                         {
  98                                 if (m.Globals.HasStatements) return true;
  99                         }
 100                         return false;
 101                 }
 102
 103                 private static CompileUnit CreateCompileUnit(ClassDefinition klass)
 104                 {
 105                         return new CompileUnit(CreateModule(klass));
 106                 }
 107
 108                 private static Module CreateModule(ClassDefinition klass)
 109                 {
 110                         Module module = new Module();
 111                         module.Name = klass.Name;
 112                         module.Members.Add(klass);
 113                         return module;
 114                 }
 115         }
 116 }