|
namespace System.Workflow.ComponentModel.Compiler
{
#region Imports
using System;
using System.Text;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.CodeDom;
using System.Reflection;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Runtime.Serialization;
using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Runtime.Versioning;
using System.Security;
using Microsoft.Build.Utilities;
using System.IO;
using System.Runtime.InteropServices;
#endregion
[Serializable]
class MultiTargetingInfo : ISerializable
{
internal static readonly Version DefaultTargetFramework = new Version("4.0");
static readonly Version TargetFramework30 = new Version("3.0");
internal const string TargetFramework30CompilerVersion = "v2.0";
static readonly Version TargetFramework35 = new Version("3.5");
internal const string TargetFramework35CompilerVersion = "v3.5";
static readonly Version TargetFramework40 = new Version("4.0");
internal const string TargetFramework40CompilerVersion = "v4.0";
const string TargetFramework40CompatiblePrefix = "v4.";
const string SerializationItem_TargetFramework = "TargetFramework";
static IDictionary<Version, string> KnownSupportedTargetFrameworksAndRelatedCompilerVersions =
new Dictionary<Version, string>()
{ { TargetFramework30, TargetFramework30CompilerVersion }, { TargetFramework35, TargetFramework35CompilerVersion },
{ TargetFramework40, TargetFramework40CompilerVersion } };
FrameworkName targetFramework;
string compilerVersion;
public MultiTargetingInfo(string targetFramework)
{
this.targetFramework = new FrameworkName(targetFramework);
}
protected MultiTargetingInfo(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
this.targetFramework = new FrameworkName(info.GetString(MultiTargetingInfo.SerializationItem_TargetFramework));
}
public FrameworkName TargetFramework
{
get
{
return this.targetFramework;
}
}
public string CompilerVersion
{
get
{
if (this.compilerVersion == null)
{
this.compilerVersion = MultiTargetingInfo.GetCompilerVersion(this.targetFramework.Version);
}
return this.compilerVersion;
}
}
[SecurityCritical]
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
info.AddValue(MultiTargetingInfo.SerializationItem_TargetFramework, this.targetFramework.FullName, typeof(string));
}
static string GetCompilerVersion(Version targetFrameworkVersion)
{
// As part of the future fx support - every 4.X framework is colided to 4.0
Version versionKey;
if (targetFrameworkVersion.Major == 4)
{
versionKey = TargetFramework40;
}
else
{
versionKey = new Version(targetFrameworkVersion.Major, targetFrameworkVersion.Minor);
}
string compilerVersion;
if (!MultiTargetingInfo.KnownSupportedTargetFrameworksAndRelatedCompilerVersions.TryGetValue(versionKey, out compilerVersion))
{
compilerVersion = string.Empty;
}
return compilerVersion;
}
public static class MultiTargetingUtilities
{
const string RuntimeReferencePrefix = "<RUNTIME>";
const string FrameworkReferencePrefix = "<FRAMEWORK>";
static RuntimeManager runtimeManager;
static ReferenceManager refManager;
public static bool IsFrameworkReferenceAssembly(string path)
{
EnsureReferenceManager();
return refManager.IsFrameworkReferenceAssembly(path);
}
public static WorkflowCompilerParameters NormalizeReferencedAssemblies(WorkflowCompilerParameters parameters)
{
EnsureRuntimeManager();
EnsureReferenceManager();
string[] normalizedAssemblies = new string[parameters.ReferencedAssemblies.Count];
bool wasNormelized = false;
for (int i = 0; i < parameters.ReferencedAssemblies.Count; i++)
{
normalizedAssemblies[i] = NormalizePath(parameters.ReferencedAssemblies[i], ref wasNormelized);
}
if (wasNormelized)
{
return new WorkflowCompilerParameters(parameters, normalizedAssemblies);
}
else
{
return parameters;
}
}
public static WorkflowCompilerParameters RenormalizeReferencedAssemblies(WorkflowCompilerParameters parameters)
{
EnsureRuntimeManager();
EnsureReferenceManager();
string[] renormalizedAssemblies = new string[parameters.ReferencedAssemblies.Count];
bool wasRenormelized = false;
for (int i = 0; i < parameters.ReferencedAssemblies.Count; i++)
{
renormalizedAssemblies[i] = RenormalizePath(parameters.ReferencedAssemblies[i], ref wasRenormelized);
}
if (wasRenormelized)
{
return new WorkflowCompilerParameters(parameters, renormalizedAssemblies);
}
else
{
return parameters;
}
}
static void EnsureRuntimeManager()
{
if (runtimeManager == null)
{
runtimeManager = new RuntimeManager();
}
}
static void EnsureReferenceManager()
{
if (refManager == null)
{
refManager = new ReferenceManager();
}
}
static string NormalizePath(string path, ref bool wasNormelized)
{
path = Path.GetFullPath(path);
if (IsPathUnderDirectory(path, runtimeManager.NetFxRuntimeRoot))
{
wasNormelized = true;
return path.Replace(runtimeManager.NetFxRuntimeRoot, RuntimeReferencePrefix);
}
else if (IsPathUnderDirectory(path, refManager.FrameworkReferenceAssemblyRoot))
{
wasNormelized = true;
return path.Replace(refManager.FrameworkReferenceAssemblyRoot, FrameworkReferencePrefix);
}
else
{
return path;
}
}
static string RenormalizePath(string path, ref bool wasRenormelized)
{
if (path.StartsWith(RuntimeReferencePrefix, StringComparison.Ordinal))
{
wasRenormelized = true;
return path.Replace(RuntimeReferencePrefix, runtimeManager.NetFxRuntimeRoot);
}
else if (path.StartsWith(FrameworkReferencePrefix, StringComparison.Ordinal))
{
wasRenormelized = true;
return path.Replace(FrameworkReferencePrefix, refManager.FrameworkReferenceAssemblyRoot);
}
else
{
return path;
}
}
static bool IsPathUnderDirectory(string path, string parentDirectory)
{
if (!path.StartsWith(parentDirectory, StringComparison.CurrentCultureIgnoreCase))
{
return false;
}
int parentLength = parentDirectory.Length;
if (path.Length == parentLength)
{
return false;
}
if ((path[parentLength] != Path.DirectorySeparatorChar) && (path[parentLength] != Path.AltDirectorySeparatorChar))
{
return false;
}
return true;
}
class RuntimeManager
{
const string NDPSetupRegistryBranch = "SOFTWARE\\Microsoft\\NET Framework Setup\\NDP";
string netFxRuntimeRoot;
public RuntimeManager()
{
string runtimePath = XomlCompilerHelper.TrimDirectorySeparatorChar(RuntimeEnvironment.GetRuntimeDirectory());
this.netFxRuntimeRoot = XomlCompilerHelper.TrimDirectorySeparatorChar(Path.GetDirectoryName(runtimePath));
}
public string NetFxRuntimeRoot
{
get
{
return this.netFxRuntimeRoot;
}
}
}
class ReferenceManager
{
string frameworkReferenceAssemblyRoot;
HashSet<string> frameworkReferenceDirectories;
public ReferenceManager()
{
this.frameworkReferenceAssemblyRoot = ToolLocationHelper.GetProgramFilesReferenceAssemblyRoot();
this.frameworkReferenceDirectories = new HashSet<string>(StringComparer.CurrentCultureIgnoreCase);
IList<string> supportedTargetFrameworks = ToolLocationHelper.GetSupportedTargetFrameworks();
for (int i = 0; i < supportedTargetFrameworks.Count; i++)
{
FrameworkName fxName = new FrameworkName(supportedTargetFrameworks[i]);
IList<string> refDirectories = ToolLocationHelper.GetPathToReferenceAssemblies(fxName);
for (int j = 0; j < refDirectories.Count; j++)
{
string refDir = XomlCompilerHelper.TrimDirectorySeparatorChar(refDirectories[j]);
if (!this.frameworkReferenceDirectories.Contains(refDir))
{
this.frameworkReferenceDirectories.Add(refDir);
}
}
}
}
public string FrameworkReferenceAssemblyRoot
{
get
{
return this.frameworkReferenceAssemblyRoot;
}
}
public bool IsFrameworkReferenceAssembly(string path)
{
string dir = XomlCompilerHelper.TrimDirectorySeparatorChar(Path.GetDirectoryName(Path.GetFullPath(path)));
return this.frameworkReferenceDirectories.Contains(dir);
}
}
}
}
[Serializable]
[Obsolete("The System.Workflow.* types are deprecated. Instead, please use the new types from System.Activities.*")]
public sealed class WorkflowCompilerParameters : CompilerParameters
{
#region Private members
internal const string NoCodeSwitch = "/nocode";
internal const string CheckTypesSwitch = "/checktypes";
private bool generateCCU = false;
private string languageToUse = "CSharp";
private IList<CodeCompileUnit> userCodeCCUs = null;
private StringCollection libraryPaths = null;
private Assembly localAssembly = null;
private bool compileWithNoCode = false;
private bool checkTypes = false;
private string compilerOptions = null;
[OptionalField(VersionAdded = 2)]
MultiTargetingInfo mtInfo = null;
#endregion
#region Constructors
public WorkflowCompilerParameters()
{
}
public WorkflowCompilerParameters(string[] assemblyNames)
: base(assemblyNames)
{
}
public WorkflowCompilerParameters(string[] assemblyNames, string outputName)
: base(assemblyNames, outputName)
{
}
public WorkflowCompilerParameters(string[] assemblyNames, string outputName, bool includeDebugInformation)
: base(assemblyNames, outputName, includeDebugInformation)
{
}
public WorkflowCompilerParameters(WorkflowCompilerParameters parameters)
: this(parameters, null)
{
}
internal WorkflowCompilerParameters(WorkflowCompilerParameters parameters, string[] newReferencedAssemblies)
: this()
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
this.CompilerOptions = parameters.CompilerOptions;
foreach (string embeddedResource in parameters.EmbeddedResources)
{
this.EmbeddedResources.Add(embeddedResource);
}
this.GenerateExecutable = parameters.GenerateExecutable;
this.GenerateInMemory = parameters.GenerateInMemory;
this.IncludeDebugInformation = parameters.IncludeDebugInformation;
foreach (string linkedResource in parameters.LinkedResources)
{
this.LinkedResources.Add(linkedResource);
}
this.MainClass = parameters.MainClass;
this.OutputAssembly = parameters.OutputAssembly;
if (newReferencedAssemblies != null)
{
this.ReferencedAssemblies.AddRange(newReferencedAssemblies);
}
else
{
foreach (string referenceAssembly in parameters.ReferencedAssemblies)
{
this.ReferencedAssemblies.Add(referenceAssembly);
}
}
this.TreatWarningsAsErrors = parameters.TreatWarningsAsErrors;
this.UserToken = parameters.UserToken;
this.WarningLevel = parameters.WarningLevel;
this.Win32Resource = parameters.Win32Resource;
this.generateCCU = parameters.generateCCU;
this.languageToUse = parameters.languageToUse;
if (parameters.libraryPaths != null)
{
this.libraryPaths = new StringCollection();
foreach (string libraryPath in parameters.libraryPaths)
{
this.libraryPaths.Add(libraryPath);
}
}
if (parameters.userCodeCCUs != null)
{
this.userCodeCCUs = new List<CodeCompileUnit>(parameters.userCodeCCUs);
}
this.localAssembly = parameters.localAssembly;
}
#endregion
#region Properties
public new string CompilerOptions
{
get
{
return this.compilerOptions;
}
set
{
this.compilerOptions = value;
base.CompilerOptions =
XomlCompilerHelper.ProcessCompilerOptions(value, out this.compileWithNoCode, out this.checkTypes);
}
}
public bool GenerateCodeCompileUnitOnly
{
get
{
return this.generateCCU;
}
set
{
this.generateCCU = value;
}
}
public string LanguageToUse
{
get
{
return this.languageToUse;
}
set
{
if (String.IsNullOrEmpty(value))
throw new ArgumentNullException("value");
if (String.Compare(value, SupportedLanguages.CSharp.ToString(), StringComparison.OrdinalIgnoreCase) != 0 &&
String.Compare(value, SupportedLanguages.VB.ToString(), StringComparison.OrdinalIgnoreCase) != 0)
throw new NotSupportedException(SR.GetString(SR.Error_LanguageNeedsToBeVBCSharp, value));
this.languageToUse = value;
}
}
public StringCollection LibraryPaths
{
get
{
if (this.libraryPaths == null)
this.libraryPaths = new StringCollection();
return this.libraryPaths;
}
}
public IList<CodeCompileUnit> UserCodeCompileUnits
{
get
{
if (this.userCodeCCUs == null)
this.userCodeCCUs = new List<CodeCompileUnit>();
return this.userCodeCCUs;
}
}
internal Assembly LocalAssembly
{
get
{
return this.localAssembly;
}
set
{
this.localAssembly = value;
}
}
internal bool CompileWithNoCode
{
get
{
return this.compileWithNoCode;
}
}
internal bool CheckTypes
{
get
{
return this.checkTypes;
}
}
internal string CompilerVersion
{
get
{
if (this.mtInfo == null)
{
return string.Empty;
}
else
{
return this.mtInfo.CompilerVersion;
}
}
}
internal MultiTargetingInfo MultiTargetingInformation
{
get
{
return this.mtInfo;
}
set
{
this.mtInfo = value;
}
}
#endregion
internal static string ExtractRootNamespace(WorkflowCompilerParameters parameters)
{
string rootNamespace = string.Empty;
// extract the namespace from the compiler options
if (parameters.CompilerOptions != null && (CompilerHelpers.GetSupportedLanguage(parameters.LanguageToUse) == SupportedLanguages.VB))
{
Regex options = new Regex(@"\s*[/-]rootnamespace[:=]\s*(?<RootNamespace>[^\s]*)");
Match match = options.Match(parameters.CompilerOptions);
if (match.Success)
rootNamespace = match.Groups["RootNamespace"].Value;
}
return rootNamespace;
}
}
}
|