src/Boo.Lang.Compiler/CompilerPipeline.cs

   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 namespace Boo.Lang.Compiler
  30 {
  31         using System;
  32     using System.Reflection;
  33
  34         public class CompilerStepEventArgs : EventArgs
  35         {
  36                 public CompilerContext Context;
  37                 public ICompilerStep Step;
  38
  39                 public CompilerStepEventArgs(CompilerContext context, ICompilerStep step)
  40                 {
  41                         this.Context = context;
  42                         this.Step = step;
  43                 }
  44         }
  45
  46         public delegate void CompilerStepEventHandler(object sender, CompilerStepEventArgs args);
  47
  48         /// <summary>
  49         /// A ordered set of <see cref="ICompilerStep"/> implementations
  50         /// that should be executed in sequence.
  51         /// </summary>
  52         public class CompilerPipeline
  53         {
  54                 public event CompilerStepEventHandler BeforeStep;
  55
  56                 public event CompilerStepEventHandler AfterStep;
  57
  58                 public static CompilerPipeline GetPipeline(string name)
  59                 {
  60             if (null == name) throw new ArgumentNullException("name");
  61                         switch (name)
  62                         {
  63                                 case "parse": return new Pipelines.Parse();
  64                                 case "compile": return new Pipelines.Compile();
  65                                 case "run": return new Pipelines.Run();
  66                                 case "default": return new Pipelines.CompileToFile();
  67                                 case "verify": return new Pipelines.CompileToFileAndVerify();
  68                                 case "roundtrip": return new Pipelines.ParseAndPrint();
  69                                 case "boo": return new Pipelines.CompileToBoo();
  70                                 case "ast": return new Pipelines.ParseAndPrintAst();
  71                                 case "xml": return new Pipelines.ParseAndPrintXml();
  72                                 case "checkforerrors": return new Pipelines.CheckForErrors();
  73                                 case "dumpreferences":
  74                                 {
  75                                         CompilerPipeline pipeline = new Pipelines.CompileToBoo();
  76                                         pipeline.Add(new Boo.Lang.Compiler.Steps.DumpReferences());
  77                                         return pipeline;
  78                                 }
  79                         }
  80                         return LoadCustomPipeline(name);
  81                 }
  82
  83                 private static CompilerPipeline LoadCustomPipeline(string typeName)
  84                 {
  85             if (typeName.IndexOf(',') < 0)
  86                 throw new ArgumentException(Boo.Lang.ResourceManager.Format("BooC.InvalidPipeline", typeName));
  87                         return (CompilerPipeline)Activator.CreateInstance(FindPipelineType(typeName));
  88                 }
  89
  90                 private static System.Type FindPipelineType(string typeName)
  91                 {
  92                         Assembly loaded = FindLoadedAssembly(AssemblySimpleNameFromFullTypeName(typeName));
  93                         if (null != loaded) return loaded.GetType(SimpleTypeNameFromFullTypeName(typeName));
  94                         return Type.GetType(typeName, true);
  95                 }
  96
  97             private static string SimpleTypeNameFromFullTypeName(string name)
  98             {
  99                 return name.Split(',')[0].Trim();
 100             }
 101
 102             private static string AssemblySimpleNameFromFullTypeName(string name)
 103             {
 104                 return name.Split(',')[1].Trim();
 105             }
 106
 107             private static Assembly FindLoadedAssembly(string assemblyName)
 108             {
 109                 foreach (Assembly loaded in AppDomain.CurrentDomain.GetAssemblies())
 110                 {
 111                     if (loaded.GetName().Name == assemblyName) return loaded;
 112                 }
 113                 return null;
 114             }
 115
 116             protected Boo.Lang.List _items;
 117
 118                 protected bool _breakOnErrors;
 119
 120                 public CompilerPipeline()
 121                 {
 122                         _items = new Boo.Lang.List();
 123                         _breakOnErrors = true;
 124                 }
 125
 126                 public bool BreakOnErrors
 127                 {
 128                         get
 129                         {
 130                                 return _breakOnErrors;
 131                         }
 132
 133                         set
 134                         {
 135                                 _breakOnErrors = value;
 136                         }
 137                 }
 138
 139                 public CompilerPipeline Add(ICompilerStep step)
 140                 {
 141                         if (null == step)
 142                         {
 143                                 throw new ArgumentNullException("step");
 144                         }
 145
 146                         _items.Add(step);
 147                         return this;
 148                 }
 149
 150                 public CompilerPipeline RemoveAt(int index)
 151                 {
 152                         _items.RemoveAt(index);
 153                         return this;
 154                 }
 155
 156                 public CompilerPipeline Insert(int index, ICompilerStep step)
 157                 {
 158                         if (null == step)
 159                         {
 160                                 throw new ArgumentNullException("step");
 161                         }
 162
 163                         _items.Insert(index, step);
 164                         return this;
 165                 }
 166
 167                 public CompilerPipeline InsertAfter(Type stepExactType, ICompilerStep step)
 168                 {
 169                         return Insert(Find(stepExactType)+1, step);
 170                 }
 171
 172                 public CompilerPipeline InsertBefore(Type stepExactType, ICompilerStep step)
 173                 {
 174                         return Insert(Find(stepExactType)-1, step);
 175                 }
 176
 177                 public CompilerPipeline Replace(Type stepExactType, ICompilerStep step)
 178                 {
 179                         if (null == step)
 180                         {
 181                                 throw new ArgumentNullException("step");
 182                         }
 183
 184                         int index = Find(stepExactType);
 185                         if (-1 == index)
 186                         {
 187                                 throw new ArgumentException("stepExactType");
 188                         }
 189                         _items[index] = step;
 190                         return this;
 191                 }
 192
 193                 public int Find(Type stepExactType)
 194                 {
 195                         if (null == stepExactType)
 196                         {
 197                                 throw new ArgumentNullException("stepExactType");
 198                         }
 199                         for (int i=0; i<_items.Count; ++i)
 200                         {
 201                                 if (_items[i].GetType() == stepExactType)
 202                                 {
 203                                         return i;
 204                                 }
 205                         }
 206                         return -1;
 207                 }
 208
 209                 public ICompilerStep Get(Type stepExactType)
 210                 {
 211                         int index = Find(stepExactType);
 212                         if (-1 == index) return null;
 213                         return (ICompilerStep)_items[index];
 214                 }
 215
 216                 public int Count
 217                 {
 218                         get
 219                         {
 220                                 return _items.Count;
 221                         }
 222                 }
 223
 224                 public ICompilerStep this[int index]
 225                 {
 226                         get
 227                         {
 228                                 return (ICompilerStep)_items[index];
 229                         }
 230
 231                         set
 232                         {
 233                                 if (null == value)
 234                                 {
 235                                         throw new ArgumentNullException("value");
 236                                 }
 237                                 _items[index] = value;
 238                         }
 239                 }
 240
 241                 virtual public void Clear()
 242                 {
 243                         _items.Clear();
 244                 }
 245
 246                 virtual protected void OnBeforeStep(CompilerContext context, ICompilerStep step)
 247                 {
 248                         if (null != BeforeStep)
 249                         {
 250                                 BeforeStep(this, new CompilerStepEventArgs(context, step));
 251                         }
 252                 }
 253
 254                 virtual protected void OnAfterStep(CompilerContext context, ICompilerStep step)
 255                 {
 256                         if (null != AfterStep)
 257                         {
 258                                 AfterStep(this, new CompilerStepEventArgs(context, step));
 259                         }
 260                 }
 261
 262                 virtual protected void Prepare(CompilerContext context)
 263                 {
 264                 }
 265
 266                 virtual public void Run(CompilerContext context)
 267                 {
 268                         Prepare(context);
 269
 270                         foreach (ICompilerStep step in _items)
 271                         {
 272                                 RunStep(context, step);
 273
 274                                 if (_breakOnErrors && context.Errors.Count > 0)
 275                                 {
 276                                         break;
 277                                 }
 278                         }
 279
 280                         foreach (ICompilerStep step in _items)
 281                         {
 282                                 step.Dispose();
 283                         }
 284                 }
 285
 286                 protected void RunStep(CompilerContext context, ICompilerStep step)
 287                 {
 288                         OnBeforeStep(context, step);
 289
 290                         step.Initialize(context);
 291                         try
 292                         {
 293                                 step.Run();
 294                         }
 295                         catch (Boo.Lang.Compiler.CompilerError error)
 296                         {
 297                                 context.Errors.Add(error);
 298                         }
 299                         catch (System.Exception x)
 300                         {
 301                                 context.Errors.Add(CompilerErrorFactory.StepExecutionError(x, step));
 302                         }
 303                         finally
 304                         {
 305                                 OnAfterStep(context, step);
 306                         }
 307                 }
 308         }
 309 }