src/Boo.Lang.Compiler/CompilerContext.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 using System;
  30 using System.Diagnostics;
  31 using Boo.Lang;
  32 using Boo.Lang.Compiler.Ast;
  33 using Assembly = System.Reflection.Assembly;
  34
  35 namespace Boo.Lang.Compiler
  36 {
  37         /// <summary>
  38         /// boo compilation context.
  39         /// </summary>
  40         public class CompilerContext
  41         {
  42                 protected CompilerParameters _parameters;
  43
  44                 protected CompileUnit _unit;
  45
  46                 protected AssemblyCollection _assemblyReferences;
  47
  48                 protected CompilerErrorCollection _errors;
  49
  50                 protected CompilerWarningCollection _warnings;
  51
  52                 protected TypeSystem.TypeSystemServices _typeSystemServices;
  53
  54                 protected readonly TypeSystem.NameResolutionService _nameResolutionService;
  55
  56                 protected TraceSwitch _traceSwitch;
  57
  58                 protected int _localIndex;
  59
  60                 protected Assembly _generatedAssembly;
  61
  62                 protected string _generatedAssemblyFileName;
  63
  64                 protected Hash _properties;
  65
  66                 public CompilerContext() : this(new CompileUnit())
  67                 {
  68                 }
  69
  70                 public CompilerContext(CompileUnit unit) : this(new CompilerParameters(), unit)
  71                 {
  72                 }
  73
  74                 public CompilerContext(bool stdlib) : this(new CompilerParameters(stdlib), new CompileUnit())
  75                 {
  76                 }
  77
  78                 public CompilerContext(CompilerParameters options, CompileUnit unit)
  79                 {
  80                         if (null == options) throw new ArgumentNullException("options");
  81                         if (null == unit) throw new ArgumentNullException("unit");
  82
  83                         _unit = unit;
  84                         _errors = new CompilerErrorCollection();
  85                         _warnings = new CompilerWarningCollection();
  86                         _assemblyReferences = options.References;
  87                         _parameters = options;
  88                         if (_parameters.Debug && !_parameters.Defines.ContainsKey("DEBUG"))
  89                                 _parameters.Defines.Add("DEBUG", null);
  90                         _nameResolutionService = new TypeSystem.NameResolutionService(this);
  91                         _traceSwitch = _parameters.TraceSwitch;
  92                         _properties = new Hash();
  93                 }
  94
  95                 public Hash Properties
  96                 {
  97                         get { return _properties; }
  98                 }
  99
 100                 public string GeneratedAssemblyFileName
 101                 {
 102                         get { return _generatedAssemblyFileName; }
 103
 104                         set
 105                         {
 106                                 if (null == value || 0 == value.Length)
 107                                 {
 108                                         throw new ArgumentException("GeneratedAssemblyFileName");
 109                                 }
 110                                 _generatedAssemblyFileName = value;
 111                         }
 112                 }
 113
 114                 public object this[object key]
 115                 {
 116                         get { return _properties[key]; }
 117
 118                         set { _properties[key] = value; }
 119                 }
 120
 121                 public CompilerParameters Parameters
 122                 {
 123                         get { return _parameters; }
 124                 }
 125
 126                 public AssemblyCollection References
 127                 {
 128                         get { return _assemblyReferences; }
 129                 }
 130
 131                 public CompilerErrorCollection Errors
 132                 {
 133                         get { return _errors; }
 134                 }
 135
 136                 public CompilerWarningCollection Warnings
 137                 {
 138                         get { return _warnings; }
 139                 }
 140
 141                 public CompileUnit CompileUnit
 142                 {
 143                         get { return _unit; }
 144                 }
 145
 146                 public TypeSystem.TypeSystemServices TypeSystemServices
 147                 {
 148                         get { return _typeSystemServices; }
 149
 150                         set
 151                         {
 152                                 if (null == value) throw new ArgumentNullException("TypeSystemServices");
 153                                 _typeSystemServices = value;
 154                         }
 155                 }
 156
 157                 public TypeSystem.BooCodeBuilder CodeBuilder
 158                 {
 159                         get { return _typeSystemServices.CodeBuilder; }
 160                 }
 161
 162                 public TypeSystem.NameResolutionService NameResolutionService
 163                 {
 164                         get { return _nameResolutionService; }
 165                 }
 166
 167                 public Assembly GeneratedAssembly
 168                 {
 169                         get { return _generatedAssembly; }
 170
 171                         set { _generatedAssembly = value; }
 172                 }
 173
 174                 public int AllocIndex()
 175                 {
 176                         return ++_localIndex;
 177                 }
 178
 179                 [Conditional("TRACE")]
 180                 public void TraceEnter(string format, object param)
 181                 {
 182                         if (_traceSwitch.TraceInfo)
 183                         {
 184                                 Trace.WriteLine(string.Format(format, param));
 185                                 ++Trace.IndentLevel;
 186                         }
 187                 }
 188
 189                 [Conditional("TRACE")]
 190                 public void TraceLeave(string format, object param)
 191                 {
 192                         if (_traceSwitch.TraceInfo)
 193                         {
 194                                 --Trace.IndentLevel;
 195                                 Trace.WriteLine(string.Format(format, param));
 196                         }
 197                 }
 198
 199                 [Conditional("TRACE")]
 200                 public void TraceInfo(string format, params object[] args)
 201                 {
 202                         if (_traceSwitch.TraceInfo)
 203                         {
 204                                 Trace.WriteLine(string.Format(format, args));
 205                         }
 206                 }
 207
 208                 [Conditional("TRACE")]
 209                 public void TraceInfo(string message)
 210                 {
 211                         if (_traceSwitch.TraceInfo)
 212                         {
 213                                 Trace.WriteLine(message);
 214                         }
 215                 }
 216
 217                 [Conditional("TRACE")]
 218                 public void TraceWarning(string message)
 219                 {
 220                         if (_traceSwitch.TraceWarning)
 221                         {
 222                                 Trace.WriteLine(message);
 223                         }
 224                 }
 225
 226                 [Conditional("TRACE")]
 227                 public void TraceWarning(string message, params object[] args)
 228                 {
 229                         if (_traceSwitch.TraceWarning)
 230                         {
 231                                 Trace.WriteLine(string.Format(message, args));
 232                         }
 233                 }
 234
 235                 [Conditional("TRACE")]
 236                 public void TraceVerbose(string format, params object[] args)
 237                 {
 238                         if (_traceSwitch.TraceVerbose)
 239                         {
 240                                 Trace.WriteLine(string.Format(format, args));
 241                         }
 242                 }
 243
 244                 [Conditional("TRACE")]
 245                 public void TraceVerbose(string format, object param1, object param2)
 246                 {
 247                         if (_traceSwitch.TraceVerbose)
 248                         {
 249                                 Trace.WriteLine(string.Format(format, param1, param2));
 250                         }
 251                 }
 252
 253                 [Conditional("TRACE")]
 254                 public void TraceVerbose(string format, object param1, object param2, object param3)
 255                 {
 256                         if (_traceSwitch.TraceVerbose)
 257                         {
 258                                 Trace.WriteLine(string.Format(format, param1, param2, param3));
 259                         }
 260                 }
 261
 262                 [Conditional("TRACE")]
 263                 public void TraceVerbose(string format, object param)
 264                 {
 265                         if (_traceSwitch.TraceVerbose)
 266                         {
 267                                 Trace.WriteLine(string.Format(format, param));
 268                         }
 269                 }
 270
 271                 [Conditional("TRACE")]
 272                 public void TraceVerbose(string message)
 273                 {
 274                         if (_traceSwitch.TraceVerbose)
 275                         {
 276                                 Trace.WriteLine(message);
 277                         }
 278                 }
 279
 280                 [Conditional("TRACE")]
 281                 public void TraceError(string message, params object[] args)
 282                 {
 283                         if (_traceSwitch.TraceError)
 284                         {
 285                                 Trace.WriteLine(string.Format(message, args));
 286                         }
 287                 }
 288
 289                 [Conditional("TRACE")]
 290                 public void TraceError(Exception x)
 291                 {
 292                         if (_traceSwitch.TraceError)
 293                         {
 294                                 Trace.WriteLine(x);
 295                         }
 296                 }
 297         }
 298 }