mcs/class/System/System.CodeDom.Compiler/CodeDomProvider.cs

   1 //
   2 // System.CodeDom.Compiler.CodeDomProvider.cs
   3 //
   4 // Authors:
   5 //   Daniel Stodden (stodden@in.tum.de)
   6 //   Marek Safar (marek.safar@seznam.cz)
   7 //   Gonzalo Paniagua Javier (gonzalo@ximian.com)
   8 //   Sebastien Pouliot  <sebastien@ximian.com>
   9 //
  10 // Copyright (C) 2002,2003,2004,2005 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System.Collections;
  33 using System.ComponentModel;
  34 using System.Configuration;
  35 using System.IO;
  36 using System.Runtime.InteropServices;
  37 using System.Security.Permissions;
  38
  39 namespace System.CodeDom.Compiler {
  40
  41 #if NET_2_0
  42         [ComVisible (true)]
  43 #endif
  44         [ToolboxItem (false)]
  45         public abstract class CodeDomProvider : Component
  46         {
  47                 //
  48                 // Constructors
  49                 //
  50                 protected CodeDomProvider()
  51                 {
  52                 }
  53
  54                 //
  55                 // Properties
  56                 //
  57                 public virtual string FileExtension {
  58                         get {
  59                                 return String.Empty;
  60                         }
  61                 }
  62
  63                 public virtual LanguageOptions LanguageOptions {
  64                         get {
  65                                 return LanguageOptions.None;
  66                         }
  67                 }
  68
  69                 //
  70                 // Methods
  71                 //
  72 #if NET_2_0
  73                 [Obsolete ("ICodeCompiler is obsolete")]
  74 #endif
  75                 public abstract ICodeCompiler CreateCompiler();
  76
  77 #if NET_2_0
  78                 [Obsolete ("ICodeGenerator is obsolete")]
  79 #endif
  80                 public abstract ICodeGenerator CreateGenerator();
  81
  82                 public virtual ICodeGenerator CreateGenerator (string fileName)
  83                 {
  84                         return CreateGenerator();
  85                 }
  86
  87                 public virtual ICodeGenerator CreateGenerator (TextWriter output)
  88                 {
  89                         return CreateGenerator();
  90                 }
  91
  92 #if NET_2_0
  93                 [Obsolete ("ICodeParser is obsolete")]
  94 #endif
  95                 public virtual ICodeParser CreateParser()
  96                 {
  97                         return null;
  98                 }
  99
 100                 public virtual TypeConverter GetConverter (Type type)
 101                 {
 102                         return TypeDescriptor.GetConverter (type);
 103                 }
 104
 105 #if NET_2_0
 106                 public virtual CompilerResults CompileAssemblyFromDom (CompilerParameters options, params CodeCompileUnit[] compilationUnits)
 107                 {
 108                         ICodeCompiler cc = CreateCompiler ();
 109                         if (cc == null)
 110                                 throw GetNotImplemented ();
 111                         return cc.CompileAssemblyFromDomBatch (options, compilationUnits);
 112                 }
 113
 114                 public virtual CompilerResults CompileAssemblyFromFile (CompilerParameters options, params string[] fileNames)
 115                 {
 116                         ICodeCompiler cc = CreateCompiler ();
 117                         if (cc == null)
 118                                 throw GetNotImplemented ();
 119                         return cc.CompileAssemblyFromFileBatch (options, fileNames);
 120                 }
 121
 122                 public virtual CompilerResults CompileAssemblyFromSource (CompilerParameters options, params string[] fileNames)
 123                 {
 124                         ICodeCompiler cc = CreateCompiler ();
 125                         if (cc == null)
 126                                 throw GetNotImplemented ();
 127                         return cc.CompileAssemblyFromSourceBatch (options, fileNames);
 128                 }
 129
 130                 public virtual string CreateEscapedIdentifier (string value)
 131                 {
 132                         ICodeGenerator cg = CreateGenerator ();
 133                         if (cg == null)
 134                                 throw GetNotImplemented ();
 135                         return cg.CreateEscapedIdentifier (value);
 136                 }
 137
 138 #if CONFIGURATION_DEP
 139                 [ComVisible (false)]
 140                 [PermissionSet (SecurityAction.LinkDemand, Unrestricted = true)]
 141                 public static CodeDomProvider CreateProvider (string language)
 142                 {
 143                         CompilerInfo ci = GetCompilerInfo (language);
 144                         return (ci == null) ? null : ci.CreateProvider ();
 145                 }
 146 #endif
 147
 148                 public virtual string CreateValidIdentifier (string value)
 149                 {
 150                         ICodeGenerator cg = CreateGenerator ();
 151                         if (cg == null)
 152                                 throw GetNotImplemented ();
 153                         return cg.CreateValidIdentifier (value);
 154                 }
 155
 156                 public virtual void GenerateCodeFromCompileUnit (CodeCompileUnit compileUnit,
 157                         TextWriter writer, CodeGeneratorOptions options)
 158                 {
 159                         ICodeGenerator cg = CreateGenerator ();
 160                         if (cg == null)
 161                                 throw GetNotImplemented ();
 162                         cg.GenerateCodeFromCompileUnit (compileUnit, writer, options);
 163                 }
 164
 165                 public virtual void GenerateCodeFromExpression (CodeExpression expression, TextWriter writer, CodeGeneratorOptions options)
 166                 {
 167                         ICodeGenerator cg = CreateGenerator ();
 168                         if (cg == null)
 169                                 throw GetNotImplemented ();
 170                         cg.GenerateCodeFromExpression (expression, writer, options);
 171                 }
 172
 173                 public virtual void GenerateCodeFromMember (CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options)
 174                 {
 175                         // Documented to always throw an exception (if not overriden)
 176                         throw GetNotImplemented ();
 177                         // Note: the pattern is different from other GenerateCodeFrom* because
 178                         // ICodeGenerator doesn't have a GenerateCodeFromMember member
 179                 }
 180
 181                 public virtual void GenerateCodeFromNamespace (CodeNamespace codeNamespace, TextWriter writer, CodeGeneratorOptions options)
 182                 {
 183                         ICodeGenerator cg = CreateGenerator ();
 184                         if (cg == null)
 185                                 throw GetNotImplemented ();
 186                         cg.GenerateCodeFromNamespace (codeNamespace, writer, options);
 187                 }
 188
 189                 public virtual void GenerateCodeFromStatement (CodeStatement statement, TextWriter writer, CodeGeneratorOptions options)
 190                 {
 191                         ICodeGenerator cg = CreateGenerator ();
 192                         if (cg == null)
 193                                 throw GetNotImplemented ();
 194                         cg.GenerateCodeFromStatement (statement, writer, options);
 195                 }
 196
 197                 public virtual void GenerateCodeFromType (CodeTypeDeclaration codeType, TextWriter writer, CodeGeneratorOptions options)
 198                 {
 199                         ICodeGenerator cg = CreateGenerator ();
 200                         if (cg == null)
 201                                 throw GetNotImplemented ();
 202                         cg.GenerateCodeFromType (codeType, writer, options);
 203                 }
 204
 205 #if CONFIGURATION_DEP
 206                 [ComVisible (false)]
 207                 [PermissionSet (SecurityAction.LinkDemand, Unrestricted = true)]
 208                 public static CompilerInfo[] GetAllCompilerInfo ()
 209                 {
 210
 211                         return (Config == null) ? null : Config.CompilerInfos;
 212                 }
 213
 214
 215                 [ComVisible (false)]
 216                 [PermissionSet (SecurityAction.LinkDemand, Unrestricted = true)]
 217                 public static CompilerInfo GetCompilerInfo (string language)
 218                 {
 219                         if (language == null)
 220                                 throw new ArgumentNullException ("language");
 221                         if (Config == null)
 222                                 return null;
 223                         CompilerCollection cc = Config.Compilers;
 224                         return cc[language];
 225                 }
 226
 227                 [ComVisible (false)]
 228                 [PermissionSet (SecurityAction.LinkDemand, Unrestricted = true)]
 229                 public static string GetLanguageFromExtension (string extension)
 230                 {
 231                         if (extension == null)
 232                                 throw new ArgumentNullException ("extension");
 233
 234                         if (Config != null)
 235                                 return Config.Compilers.GetLanguageFromExtension (extension);
 236                         return null;
 237                 }
 238 #endif
 239
 240                 public virtual string GetTypeOutput (CodeTypeReference type)
 241                 {
 242                         ICodeGenerator cg = CreateGenerator ();
 243                         if (cg == null)
 244                                 throw GetNotImplemented ();
 245                         return cg.GetTypeOutput (type);
 246                 }
 247
 248 #if CONFIGURATION_DEP
 249                 [ComVisible (false)]
 250                 [PermissionSet (SecurityAction.LinkDemand, Unrestricted = true)]
 251                 public static bool IsDefinedExtension (string extension)
 252                 {
 253                         if (extension == null)
 254                                 throw new ArgumentNullException ("extension");
 255
 256                         if (Config != null)
 257                                 return (Config.Compilers.GetCompilerInfoForExtension (extension) != null);
 258
 259                         return false;
 260                 }
 261
 262                 [ComVisible (false)]
 263                 [PermissionSet (SecurityAction.LinkDemand, Unrestricted = true)]
 264                 public static bool IsDefinedLanguage (string language)
 265                 {
 266                         if (language == null)
 267                                 throw new ArgumentNullException ("language");
 268
 269                         if (Config != null)
 270                                 return (Config.Compilers.GetCompilerInfoForLanguage (language) != null);
 271
 272                         return false;
 273                 }
 274 #endif
 275
 276                 public virtual bool IsValidIdentifier (string value)
 277                 {
 278                         ICodeGenerator cg = CreateGenerator ();
 279                         if (cg == null)
 280                                 throw GetNotImplemented ();
 281                         return cg.IsValidIdentifier (value);
 282                 }
 283
 284                 public virtual CodeCompileUnit Parse (TextReader codeStream)
 285                 {
 286                         ICodeParser cp = CreateParser ();
 287                         if (cp == null)
 288                                 throw GetNotImplemented ();
 289                         return cp.Parse (codeStream);
 290                 }
 291
 292                 public virtual bool Supports (GeneratorSupport supports)
 293                 {
 294                         ICodeGenerator cg = CreateGenerator ();
 295                         if (cg == null)
 296                                 throw GetNotImplemented ();
 297                         return cg.Supports (supports);
 298                 }
 299
 300 #if CONFIGURATION_DEP
 301                 static CodeDomConfigurationHandler Config {
 302                         get { return ConfigurationManager.GetSection ("system.codedom") as CodeDomConfigurationHandler; }
 303                 }
 304 #endif
 305
 306                 //
 307                 // This is used to prevent confusing Moma about methods not implemented.
 308                 //
 309                 Exception GetNotImplemented ()
 310                 {
 311                         return new NotImplementedException ();
 312                 }
 313 #endif
 314         }
 315 }