Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System/compmod/system/codedom/compiler/CompilerParameters.cs

@@ -0,0 +1,363 @@
+//------------------------------------------------------------------------------
+// <copyright file="CompilerParameters.cs" company="Microsoft">
+// 
+// <OWNER>[....]</OWNER>
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.CodeDom.Compiler {
+    using System;
+    using System.CodeDom;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using Microsoft.Win32;
+    using Microsoft.Win32.SafeHandles;
+    using System.Runtime.InteropServices;
+    using System.Security.Permissions;
+    using System.Security.Policy;
+    using System.Runtime.Serialization;
+    using System.Runtime.Versioning;
+
+    /// <devdoc>
+    ///    <para>
+    ///       Represents the parameters used in to invoke the compiler.
+    ///    </para>
+    /// </devdoc>
+    [PermissionSet(SecurityAction.LinkDemand, Name="FullTrust")]
+    [PermissionSet(SecurityAction.InheritanceDemand, Name="FullTrust")]
+    [Serializable]
+    public class CompilerParameters {
+
+        [OptionalField]
+        private string coreAssemblyFileName = String.Empty;
+
+        private StringCollection assemblyNames = new StringCollection();
+
+        [OptionalField] 
+        private StringCollection embeddedResources = new StringCollection();
+        [OptionalField]         
+        private StringCollection linkedResources = new StringCollection();
+        
+        private string outputName;
+        private string mainClass;
+        private bool generateInMemory = false;
+        private bool includeDebugInformation = false;
+        private int warningLevel = -1;  // -1 means not set (use compiler default)
+        private string compilerOptions;
+        private string win32Resource;
+        private bool treatWarningsAsErrors = false;
+        private bool generateExecutable = false;
+        private TempFileCollection tempFiles;
+        [NonSerializedAttribute]
+#if MONO
+        IntPtr userToken;
+#else
+        private SafeUserTokenHandle userToken;
+#endif
+        private Evidence evidence = null;
+
+        /// <devdoc>
+        ///    <para>
+        ///       Initializes a new instance of <see cref='System.CodeDom.Compiler.CompilerParameters'/>.
+        ///    </para>
+        /// </devdoc>
+        [ResourceExposure(ResourceScope.None)]
+        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
+        public CompilerParameters() :
+            this(null, null) {
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Initializes a new instance of <see cref='System.CodeDom.Compiler.CompilerParameters'/> using the specified
+        ///       assembly names.
+        ///    </para>
+        /// </devdoc>
+        [ResourceExposure(ResourceScope.None)]
+        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
+        public CompilerParameters(string[] assemblyNames) :
+            this(assemblyNames, null, false) {
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Initializes a new instance of <see cref='System.CodeDom.Compiler.CompilerParameters'/> using the specified
+        ///       assembly names and output name.
+        ///    </para>
+        /// </devdoc>
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        public CompilerParameters(string[] assemblyNames, string outputName) :
+            this(assemblyNames, outputName, false) {
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Initializes a new instance of <see cref='System.CodeDom.Compiler.CompilerParameters'/> using the specified
+        ///       assembly names, output name and a whether to include debug information flag.
+        ///    </para>
+        /// </devdoc>
+        [ResourceExposure(ResourceScope.Machine)]
+        public CompilerParameters(string[] assemblyNames, string outputName, bool includeDebugInformation) {
+            if (assemblyNames != null) {
+                ReferencedAssemblies.AddRange(assemblyNames);
+            }
+            this.outputName = outputName;
+            this.includeDebugInformation = includeDebugInformation;
+        }
+
+
+        /// <summary>
+        /// The "core" or "standard" assembly that contains basic types such as <code>Object</code>, <code>Int32</code> and the like
+        /// that is to be used for the compilation.<br />
+        /// If the value of this property is an empty string (or <code>null</code>), the default core assembly will be used by the
+        /// compiler (depending on the compiler version this may be <code>mscorlib.dll</code> or <code>System.Runtime.dll</code> in
+        /// a Framework or reference assembly directory).<br />
+        /// If the value of this property is not empty, CodeDOM will emit compiler options to not reference <em>any</em> assemblies
+        /// implicitly during compilation. It will also explicitly reference the assembly file specified in this property.<br />
+        /// For compilers that only implicitly reference the "core" or "standard" assembly by default, this option can be used on its own.
+        /// For compilers that implicitly reference more assemblies on top of the "core" / "standard" assembly, using this option may require
+        /// specifying additional entries in the <code>System.CodeDom.Compiler.<bold>ReferencedAssemblies</bold></code> collection.<br />
+        /// Note: An <code>ICodeCompiler</code> / <code>CoodeDomProvider</code> implementation may choose to ignore this property.
+        /// </summary>
+        public string CoreAssemblyFileName {
+            get {
+                return coreAssemblyFileName;
+            }
+            set {
+                coreAssemblyFileName = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets whether to generate an executable.
+        ///    </para>
+        /// </devdoc>
+        public bool GenerateExecutable {
+            get {
+                return generateExecutable;
+            }
+            set {
+                generateExecutable = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets whether to generate in memory.
+        ///    </para>
+        /// </devdoc>
+        public bool GenerateInMemory {
+            get {
+                return generateInMemory;
+            }
+            set {
+                generateInMemory = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets the assemblies referenced by the source to compile.
+        ///    </para>
+        /// </devdoc>
+        public StringCollection ReferencedAssemblies {
+            get {
+                return assemblyNames;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets the main class.
+        ///    </para>
+        /// </devdoc>
+        public string MainClass {
+            get {
+                return mainClass;
+            }
+            set {
+                mainClass = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets the output assembly.
+        ///    </para>
+        /// </devdoc>
+        public string OutputAssembly {
+            [ResourceExposure(ResourceScope.Machine)]
+            get {
+                return outputName;
+            }
+            [ResourceExposure(ResourceScope.Machine)]
+            set {
+                outputName = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets the temp files.
+        ///    </para>
+        /// </devdoc>
+        public TempFileCollection TempFiles {
+            get {
+                if (tempFiles == null)
+                    tempFiles = new TempFileCollection();
+                return tempFiles;
+            }
+            set {
+                tempFiles = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets whether to include debug information in the compiled
+        ///       executable.
+        ///    </para>
+        /// </devdoc>
+        public bool IncludeDebugInformation {
+            get {
+                return includeDebugInformation;
+            }
+            set {
+                includeDebugInformation = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool TreatWarningsAsErrors {
+            get {
+                return treatWarningsAsErrors;
+            }
+            set {
+                treatWarningsAsErrors = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public int WarningLevel {
+            get {
+                return warningLevel;
+            }
+            set {
+                warningLevel = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public string CompilerOptions {
+            get {
+                return compilerOptions;
+            }
+            set {
+                compilerOptions = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public string Win32Resource {
+            get {
+                return win32Resource;
+            }
+            set {
+                win32Resource = value;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets the resources to be compiled into the target
+        ///    </para>
+        /// </devdoc>
+        [ComVisible(false)]        
+        public StringCollection EmbeddedResources {
+            get {
+                return embeddedResources;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets the linked resources
+        ///    </para>
+        /// </devdoc>
+        [ComVisible(false)]        
+        public StringCollection LinkedResources {
+            get {
+                return linkedResources;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Gets or sets user token to be employed when creating the compiler process.
+        ///    </para>
+        /// </devdoc>
+        public IntPtr UserToken {
+            get {
+#if MONO
+                return userToken;
+#else
+                if (userToken != null)
+                    return userToken.DangerousGetHandle();
+                else
+                    return IntPtr.Zero;
+#endif
+            }
+            set {
+#if MONO
+                userToken = value;
+#else
+                if (userToken != null)
+                    userToken.Close();
+                
+                userToken = new SafeUserTokenHandle(value, false);
+#endif
+            }
+        }
+#if !MONO
+        internal SafeUserTokenHandle SafeUserToken {
+            get {
+                return userToken;
+            }
+        }
+#endif
+        /// <devdoc>
+        ///    <para>
+        ///       Set the evidence for partially trusted scenarios.
+        ///    </para>
+        /// </devdoc>
+        [Obsolete("CAS policy is obsolete and will be removed in a future release of the .NET Framework."
+                + " Please see http://go2.microsoft.com/fwlink/?LinkId=131738 for more information.")]
+        public Evidence Evidence {
+            get {
+                Evidence e = null;
+                if (evidence != null)
+                    e = evidence.Clone();
+                return e;
+            }
+
+            [SecurityPermissionAttribute( SecurityAction.Demand, ControlEvidence = true )]
+            set {
+                if (value != null)
+                    evidence = value.Clone();
+                else
+                    evidence = null;
+            }
+        }
+    }
+}