The Labs \ Source Viewer \ SSCLI \ System.CodeDom.Compiler \ CompilerInfo

  1. //------------------------------------------------------------------------------
  2. // <copyright file="CompilerInfo.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.CodeDom.Compiler
  16. {
  17.     using System;
  18.     using System.Reflection;
  19.     using System.Security.Permissions;
  20.     using System.CodeDom.Compiler;
  21.     using System.Configuration;
  22.    
  23.     [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
  24.     public sealed class CompilerInfo
  25.     {
  26.         internal string _codeDomProviderTypeName;
  27.         // This can never by null
  28.         internal CompilerParameters _compilerParams;
  29.         // This can never by null
  30.         internal string[] _compilerLanguages;
  31.         // This can never by null
  32.         internal string[] _compilerExtensions;
  33.         // This can never by null
  34.         internal string configFileName;
  35.         internal int configFileLineNumber;
  36.         internal bool _mapped;
  37.        
  38.         private Type type;
  39.        
  40.         private CompilerInfo()
  41.         {
  42.         }
  43.         // Not createable
  44.         public string[] GetLanguages()
  45.         {
  46.             return CloneCompilerLanguages();
  47.         }
  48.        
  49.         public string[] GetExtensions()
  50.         {
  51.             return CloneCompilerExtensions();
  52.         }
  53.        
  54.         public Type CodeDomProviderType {
  55.             get {
  56.                 if (type == null) {
  57.                     lock (this) {
  58.                         if (type == null) {
  59.                             type = Type.GetType(_codeDomProviderTypeName);
  60.                             if (type == null) {
  61.                                 if (configFileName == null) {
  62.                                     throw new ConfigurationErrorsException(SR.GetString(SR.Unable_To_Locate_Type, _codeDomProviderTypeName, string.Empty, 0));
  63.                                 }
  64.                                 else {
  65.                                     throw new ConfigurationErrorsException(SR.GetString(SR.Unable_To_Locate_Type, _codeDomProviderTypeName), configFileName, configFileLineNumber);
  66.                                 }
  67.                             }
  68.                         }
  69.                     }
  70.                 }
  71.                
  72.                 return type;
  73.             }
  74.         }
  75.        
  76.         public bool IsCodeDomProviderTypeValid {
  77.             get {
  78.                 Type type = Type.GetType(_codeDomProviderTypeName);
  79.                 return (type != null);
  80.             }
  81.         }
  82.        
  83.         public CodeDomProvider CreateProvider()
  84.         {
  85.             return (CodeDomProvider)Activator.CreateInstance(CodeDomProviderType);
  86.         }
  87.        
  88.         public CompilerParameters CreateDefaultCompilerParameters()
  89.         {
  90.             return CloneCompilerParameters();
  91.         }
  92.        
  93.        
  94.         internal CompilerInfo(CompilerParameters compilerParams, string codeDomProviderTypeName, string[] compilerLanguages, string[] compilerExtensions)
  95.         {
  96.             _compilerLanguages = compilerLanguages;
  97.             _compilerExtensions = compilerExtensions;
  98.             _codeDomProviderTypeName = codeDomProviderTypeName;
  99.             if (compilerParams == null)
  100.                 compilerParams = new CompilerParameters();
  101.            
  102.             _compilerParams = compilerParams;
  103.         }
  104.        
  105.         internal CompilerInfo(CompilerParameters compilerParams, string codeDomProviderTypeName)
  106.         {
  107.             _codeDomProviderTypeName = codeDomProviderTypeName;
  108.             if (compilerParams == null)
  109.                 compilerParams = new CompilerParameters();
  110.            
  111.             _compilerParams = compilerParams;
  112.         }
  113.        
  114.        
  115.         public override int GetHashCode()
  116.         {
  117.             return _codeDomProviderTypeName.GetHashCode();
  118.         }
  119.        
  120.         public override bool Equals(object o)
  121.         {
  122.             CompilerInfo other = o as CompilerInfo;
  123.             if (o == null)
  124.                 return false;
  125.            
  126.             return CodeDomProviderType == other.CodeDomProviderType && CompilerParams.WarningLevel == other.CompilerParams.WarningLevel && CompilerParams.IncludeDebugInformation == other.CompilerParams.IncludeDebugInformation && CompilerParams.CompilerOptions == other.CompilerParams.CompilerOptions;
  127.         }
  128.        
  129.         private CompilerParameters CloneCompilerParameters()
  130.         {
  131.             CompilerParameters copy = new CompilerParameters();
  132.             copy.IncludeDebugInformation = _compilerParams.IncludeDebugInformation;
  133.             copy.TreatWarningsAsErrors = _compilerParams.TreatWarningsAsErrors;
  134.             copy.WarningLevel = _compilerParams.WarningLevel;
  135.             copy.CompilerOptions = _compilerParams.CompilerOptions;
  136.             return copy;
  137.         }
  138.        
  139.         private string[] CloneCompilerLanguages()
  140.         {
  141.             string[] compilerLanguages = new string[_compilerLanguages.Length];
  142.             Array.Copy(_compilerLanguages, compilerLanguages, _compilerLanguages.Length);
  143.             return compilerLanguages;
  144.         }
  145.        
  146.         private string[] CloneCompilerExtensions()
  147.         {
  148.             string[] compilerExtensions = new string[_compilerExtensions.Length];
  149.             Array.Copy(_compilerExtensions, compilerExtensions, _compilerExtensions.Length);
  150.             return compilerExtensions;
  151.         }
  152.        
  153.         internal CompilerParameters CompilerParams {
  154.             get { return _compilerParams; }
  155.         }
  156.     }
  157. }

Developer Fusion