Experiments/Attic/Rook/Castle.Rook.Compiler/Compiler.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Rook.Compiler
  16 {
  17         using System;
  18         using System.IO;
  19         using Castle.Rook.Compiler.AST;
  20         using Castle.Rook.Compiler.Services;
  21         using Castle.Rook.Compiler.Services.Passes;
  22
  23         public delegate void PassInfoHandler(
  24                 object sender, ICompilerPass pass, CompilationUnit unit, IErrorReport errorService);
  25
  26
  27         public class Compiler
  28         {
  29                 private CompilerContainer container;
  30
  31                 public event PassInfoHandler PrePassExecution;
  32
  33                 public event PassInfoHandler PostPassExecution;
  34
  35                 public Compiler() : this(new CompilerContainer())
  36                 {
  37                 }
  38
  39                 public Compiler(CompilerContainer container)
  40                 {
  41                         this.container = container;
  42                 }
  43
  44                 public ICompilerOptionsSet OptionsSet
  45                 {
  46                         get { return (ICompilerOptionsSet) container[ typeof(ICompilerOptionsSet) ]; }
  47                 }
  48
  49                 public bool Compile( String textContent )
  50                 {
  51                         return Compile( new StringReader(textContent) );
  52                 }
  53
  54                 public bool Compile( FileInfo fileInfo )
  55                 {
  56                         using(StreamReader reader = new StreamReader(fileInfo.FullName))
  57                         {
  58                                 return Compile( reader );
  59                         }
  60                 }
  61
  62                 public bool Compile( CompilationUnit unit, FileInfo fileInfo )
  63                 {
  64                         using(StreamReader reader = new StreamReader(fileInfo.FullName))
  65                         {
  66                                 return Compile( unit, reader );
  67                         }
  68                 }
  69
  70                 public bool Compile( String[] files )
  71                 {
  72                         CompilationUnit cunit = new CompilationUnit();
  73
  74                         foreach( String file in files )
  75                         {
  76                                 if (!Compile(cunit, new FileInfo(file)))
  77                                 {
  78                                         return false;
  79                                 }
  80                         }
  81
  82                         return RunPasses(cunit);
  83                 }
  84
  85                 public bool Compile( TextReader reader )
  86                 {
  87                         CompilationUnit cunit = new CompilationUnit();
  88
  89                         if (Compile(cunit, reader))
  90                         {
  91                                 return RunPasses(cunit);
  92                         }
  93
  94                         return false;
  95                 }
  96
  97                 public bool Compile( CompilationUnit cunit, TextReader reader )
  98                 {
  99                         container.ParserService.Parse(cunit, reader);
 100
 101                         return !container.ErrorReportService.HasErrors;
 102                 }
 103
 104                 private bool RunPasses(CompilationUnit cunit)
 105                 {
 106                         if (!container.ErrorReportService.HasErrors)
 107                         {
 108                                 ICompilerPass builderSkeleton =
 109                                         container[ typeof(CreateBuilderSkeleton) ] as ICompilerPass;
 110
 111                                 ExecutePass( builderSkeleton, cunit );
 112                         }
 113
 114                         if (!container.ErrorReportService.HasErrors)
 115                         {
 116                                 ICompilerPass scopePass =
 117                                         container[ typeof(ScopePass) ] as ICompilerPass;
 118
 119                                 ExecutePass( scopePass, cunit );
 120                         }
 121
 122                         if (!container.ErrorReportService.HasErrors)
 123                         {
 124                                 ICompilerPass typeResPass =
 125                                         container[ typeof(TypeResolutionPass) ] as ICompilerPass;
 126
 127                                 ExecutePass( typeResPass, cunit );
 128                         }
 129
 130                         if (!container.ErrorReportService.HasErrors)
 131                         {
 132                                 ICompilerPass emission =
 133                                         container[ typeof(Emission) ] as ICompilerPass;
 134
 135                                 emission.ExecutePass(cunit);
 136                         }
 137
 138                         return !container.ErrorReportService.HasErrors;
 139                 }
 140
 141                 private void ExecutePass(ICompilerPass pass, CompilationUnit unit)
 142                 {
 143                         if (PrePassExecution != null)
 144                         {
 145                                 PrePassExecution(this, pass, unit, container.ErrorReportService);
 146                         }
 147
 148                         pass.ExecutePass(unit);
 149
 150                         if (PostPassExecution != null)
 151                         {
 152                                 PostPassExecution(this, pass, unit, container.ErrorReportService);
 153                         }
 154                 }
 155         }
 156 }