364 lines
12 KiB
C#
364 lines
12 KiB
C#
//------------------------------------------------------------------------------
|
|
// <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;
|
|
}
|
|
}
|
|
}
|
|
}
|