protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/lib:", base.AdditionalLibPaths, ",");
commandLine.AppendPlusOrMinusSwitch("/unsafe", base.Bag, "AllowUnsafeBlocks");
commandLine.AppendPlusOrMinusSwitch("/checked", base.Bag, "CheckForOverflowUnderflow");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", new char[] { ';', ',' });
commandLine.AppendWhenTrue("/fullpaths", base.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendSwitchIfNotNull("/pdb:", this.PdbFile);
commandLine.AppendPlusOrMinusSwitch("/nostdlib", base.Bag, "NoStandardLib");
commandLine.AppendSwitchIfNotNull("/platform:", this.Platform);
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchWithInteger("/warn:", base.Bag, "WarningLevel");
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", this.GetDefineConstantsSwitch(base.DefineConstants));
commandLine.AppendSwitchIfNotNull("/win32res:", base.Win32Resource);
commandLine.AppendSwitchIfNotNull("/main:", base.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/appconfig:", this.ApplicationConfiguration);
this.AddReferencesToCommandLine(commandLine);
base.AddResponseFileCommands(commandLine);
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", new char[] { ';', ',' });
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", new char[] { ';', ',' });
if (base.ResponseFiles != null)
{
foreach (ITaskItem item in base.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", item.ItemSpec);
}
}
}
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/lib:", base.AdditionalLibPaths, ",");
commandLine.AppendPlusOrMinusSwitch("/unsafe", base.Bag, "AllowUnsafeBlocks");
commandLine.AppendPlusOrMinusSwitch("/checked", base.Bag, "CheckForOverflowUnderflow");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", new char[] { ';', ',' });
commandLine.AppendWhenTrue("/fullpaths", base.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendSwitchIfNotNull("/pdb:", this.PdbFile);
commandLine.AppendPlusOrMinusSwitch("/nostdlib", base.Bag, "NoStandardLib");
commandLine.AppendSwitchIfNotNull("/platform:", this.Platform);
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchWithInteger("/warn:", base.Bag, "WarningLevel");
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", this.GetDefineConstantsSwitch(base.DefineConstants));
commandLine.AppendSwitchIfNotNull("/win32res:", base.Win32Resource);
commandLine.AppendSwitchIfNotNull("/main:", base.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/appconfig:", this.ApplicationConfiguration);
this.AddReferencesToCommandLine(commandLine);
base.AddResponseFileCommands(commandLine);
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", new char[] { ';', ',' });
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", new char[] { ';', ',' });
if (base.ResponseFiles != null)
{
foreach (ITaskItem item in base.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", item.ItemSpec);
}
}
}
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
if (((this.OutputAssembly == null) && (this.Sources != null)) && ((this.Sources.Length > 0) && (this.ResponseFiles == null)))
{
try
{
this.OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(this.Sources[0].ItemSpec));
}
catch (ArgumentException exception)
{
throw new ArgumentException(exception.Message, "Sources");
}
if (string.Compare(this.TargetType, "library", StringComparison.OrdinalIgnoreCase) == 0)
{
ITaskItem outputAssembly = this.OutputAssembly;
outputAssembly.ItemSpec = outputAssembly.ItemSpec + ".dll";
}
else if (string.Compare(this.TargetType, "module", StringComparison.OrdinalIgnoreCase) == 0)
{
ITaskItem item2 = this.OutputAssembly;
item2.ItemSpec = item2.ItemSpec + ".netmodule";
}
else
{
ITaskItem item3 = this.OutputAssembly;
item3.ItemSpec = item3.ItemSpec + ".exe";
}
}
commandLine.AppendSwitchIfNotNull("/addmodule:", this.AddModules, ",");
commandLine.AppendSwitchWithInteger("/codepage:", base.Bag, "CodePage");
this.ConfigureDebugProperties();
commandLine.AppendPlusOrMinusSwitch("/debug", base.Bag, "EmitDebugInformation");
commandLine.AppendSwitchIfNotNull("/debug:", this.DebugType);
commandLine.AppendPlusOrMinusSwitch("/delaysign", base.Bag, "DelaySign");
commandLine.AppendSwitchWithInteger("/filealign:", base.Bag, "FileAlignment");
commandLine.AppendSwitchIfNotNull("/keycontainer:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
commandLine.AppendSwitchIfNotNull("/linkresource:", this.LinkResources, new string[] { "LogicalName", "Access" });
commandLine.AppendWhenTrue("/nologo", base.Bag, "NoLogo");
commandLine.AppendWhenTrue("/nowin32manifest", base.Bag, "NoWin32Manifest");
commandLine.AppendPlusOrMinusSwitch("/optimize", base.Bag, "Optimize");
commandLine.AppendSwitchIfNotNull("/out:", this.OutputAssembly);
commandLine.AppendSwitchIfNotNull("/resource:", this.Resources, new string[] { "LogicalName", "Access" });
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendPlusOrMinusSwitch("/warnaserror", base.Bag, "TreatWarningsAsErrors");
commandLine.AppendWhenTrue("/utf8output", base.Bag, "Utf8Output");
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32manifest:", this.Win32Manifest);
commandLine.AppendFileNamesIfNotNull(this.Sources, " ");
}
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
if (((this.OutputAssembly == null) && (this.Sources != null)) && ((this.Sources.Length > 0) && (this.ResponseFiles == null)))
{
try
{
this.OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(this.Sources[0].ItemSpec));
}
catch (ArgumentException exception)
{
throw new ArgumentException(exception.Message, "Sources");
}
if (string.Compare(this.TargetType, "library", StringComparison.OrdinalIgnoreCase) == 0)
{
ITaskItem outputAssembly = this.OutputAssembly;
outputAssembly.ItemSpec = outputAssembly.ItemSpec + ".dll";
}
else if (string.Compare(this.TargetType, "module", StringComparison.OrdinalIgnoreCase) == 0)
{
ITaskItem item2 = this.OutputAssembly;
item2.ItemSpec = item2.ItemSpec + ".netmodule";
}
else
{
ITaskItem item3 = this.OutputAssembly;
item3.ItemSpec = item3.ItemSpec + ".exe";
}
}
commandLine.AppendSwitchIfNotNull("/addmodule:", this.AddModules, ",");
commandLine.AppendSwitchWithInteger("/codepage:", base.Bag, "CodePage");
this.ConfigureDebugProperties();
commandLine.AppendPlusOrMinusSwitch("/debug", base.Bag, "EmitDebugInformation");
commandLine.AppendSwitchIfNotNull("/debug:", this.DebugType);
commandLine.AppendPlusOrMinusSwitch("/delaysign", base.Bag, "DelaySign");
commandLine.AppendSwitchWithInteger("/filealign:", base.Bag, "FileAlignment");
commandLine.AppendSwitchIfNotNull("/keycontainer:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
commandLine.AppendSwitchIfNotNull("/linkresource:", this.LinkResources, new string[] { "LogicalName", "Access" });
commandLine.AppendWhenTrue("/nologo", base.Bag, "NoLogo");
commandLine.AppendWhenTrue("/nowin32manifest", base.Bag, "NoWin32Manifest");
commandLine.AppendPlusOrMinusSwitch("/optimize", base.Bag, "Optimize");
commandLine.AppendSwitchIfNotNull("/out:", this.OutputAssembly);
commandLine.AppendSwitchIfNotNull("/resource:", this.Resources, new string[] { "LogicalName", "Access" });
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendPlusOrMinusSwitch("/warnaserror", base.Bag, "TreatWarningsAsErrors");
commandLine.AppendWhenTrue("/utf8output", base.Bag, "Utf8Output");
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32manifest:", this.Win32Manifest);
commandLine.AppendFileNamesIfNotNull(this.Sources, " ");
}
protected internal override void AddCommandLineCommands(CommandLineBuilderExtension commandLine)
{
base.AddCommandLineCommands(commandLine);
commandLine.AppendSwitchIfTrue("/nostdlib", NoStandardLib);
commandLine.AppendPlusOrMinusSwitch("/optionexplicit", OptionExplicit);
commandLine.AppendSwitchIfNotNull("/rootnamespace:", RootNamespace);
}
/// <summary>
/// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file.
/// </summary>
override protected internal void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/algid:", this.AlgorithmId);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchIfNotNull("/company:", this.CompanyName);
commandLine.AppendSwitchIfNotNull("/configuration:", this.Configuration);
commandLine.AppendSwitchIfNotNull("/copyright:", this.Copyright);
commandLine.AppendSwitchIfNotNull("/culture:", this.Culture);
commandLine.AppendPlusOrMinusSwitch("/delaysign", this.Bag, "DelaySign");
commandLine.AppendSwitchIfNotNull("/description:", this.Description);
commandLine.AppendSwitchIfNotNull("/evidence:", this.EvidenceFile);
commandLine.AppendSwitchIfNotNull("/fileversion:", this.FileVersion);
commandLine.AppendSwitchIfNotNull("/flags:", this.Flags);
commandLine.AppendWhenTrue("/fullpaths", this.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
commandLine.AppendSwitchIfNotNull("/keyname:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/out:", (this.OutputAssembly == null) ? null : this.OutputAssembly.ItemSpec);
commandLine.AppendSwitchIfNotNull("/platform:", this.PlatformWith32BitPreference);
commandLine.AppendSwitchIfNotNull("/product:", this.ProductName);
commandLine.AppendSwitchIfNotNull("/productversion:", this.ProductVersion);
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendSwitchIfNotNull("/template:", this.TemplateFile);
commandLine.AppendSwitchIfNotNull("/title:", this.Title);
commandLine.AppendSwitchIfNotNull("/trademark:", this.Trademark);
commandLine.AppendSwitchIfNotNull("/version:", this.Version);
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32res:", this.Win32Resource);
commandLine.AppendSwitchIfNotNull("", this.SourceModules, new string[] { "TargetFile" });
commandLine.AppendSwitchIfNotNull
(
"/embed:",
this.EmbedResources,
new string[] { "LogicalName", "Access" }
);
commandLine.AppendSwitchIfNotNull
(
"/link:",
this.LinkResources,
new string[] { "LogicalName", "TargetFile", "Access" }
);
// It's a good idea for the response file to be the very last switch passed, just
// from a predictability perspective. This is also consistent with the compiler
// tasks (Csc, etc.)
if (this.ResponseFiles != null)
{
foreach (string responseFile in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", responseFile);
}
}
}
protected internal override void AddCommandLineCommands(CommandLineBuilderExtension commandLine)
{
#if RUNTIME_TYPE_NETCORE
commandLine.AppendFileNameIfNotNull(_executablePath.Value);
commandLine.AppendTextUnquoted(" ");
#endif
commandLine.AppendSwitchIfTrue("/noconfig", NoConfig);
if (References != null)
{
foreach (ITaskItem reference in References)
{
commandLine.AppendSwitchIfNotNull(ReferenceSwitch, reference.ItemSpec);
}
}
commandLine.AppendPlusOrMinusSwitch("/deterministic", Deterministic);
commandLine.AppendSwitchIfTrue("/nologo", NoLogo);
commandLine.AppendPlusOrMinusSwitch("/optimize", Optimize);
commandLine.AppendSwitchIfNotNull("/target:", TargetType);
commandLine.AppendSwitchIfNotNull("/out:", OutputAssembly);
commandLine.AppendFileNamesIfNotNull(Sources, " ");
}
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/algid:", this.AlgorithmId);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchIfNotNull("/company:", this.CompanyName);
commandLine.AppendSwitchIfNotNull("/configuration:", this.Configuration);
commandLine.AppendSwitchIfNotNull("/copyright:", this.Copyright);
commandLine.AppendSwitchIfNotNull("/culture:", this.Culture);
commandLine.AppendPlusOrMinusSwitch("/delaysign", base.Bag, "DelaySign");
commandLine.AppendSwitchIfNotNull("/description:", this.Description);
commandLine.AppendSwitchIfNotNull("/evidence:", this.EvidenceFile);
commandLine.AppendSwitchIfNotNull("/fileversion:", this.FileVersion);
commandLine.AppendSwitchIfNotNull("/flags:", this.Flags);
commandLine.AppendWhenTrue("/fullpaths", base.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
commandLine.AppendSwitchIfNotNull("/keyname:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/out:", (this.OutputAssembly == null) ? null : this.OutputAssembly.ItemSpec);
commandLine.AppendSwitchIfNotNull("/platform:", this.Platform);
commandLine.AppendSwitchIfNotNull("/product:", this.ProductName);
commandLine.AppendSwitchIfNotNull("/productversion:", this.ProductVersion);
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendSwitchIfNotNull("/template:", this.TemplateFile);
commandLine.AppendSwitchIfNotNull("/title:", this.Title);
commandLine.AppendSwitchIfNotNull("/trademark:", this.Trademark);
commandLine.AppendSwitchIfNotNull("/version:", this.Version);
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32res:", this.Win32Resource);
commandLine.AppendSwitchIfNotNull("", this.SourceModules, new string[] { "TargetFile" });
commandLine.AppendSwitchIfNotNull("/embed:", this.EmbedResources, new string[] { "LogicalName", "Access" });
commandLine.AppendSwitchIfNotNull("/link:", this.LinkResources, new string[] { "LogicalName", "TargetFile", "Access" });
if (this.ResponseFiles != null)
{
foreach (string str in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", str);
}
}
}
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/algid:", this.AlgorithmId);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchIfNotNull("/company:", this.CompanyName);
commandLine.AppendSwitchIfNotNull("/configuration:", this.Configuration);
commandLine.AppendSwitchIfNotNull("/copyright:", this.Copyright);
commandLine.AppendSwitchIfNotNull("/culture:", this.Culture);
commandLine.AppendPlusOrMinusSwitch("/delaysign", base.Bag, "DelaySign");
commandLine.AppendSwitchIfNotNull("/description:", this.Description);
commandLine.AppendSwitchIfNotNull("/evidence:", this.EvidenceFile);
commandLine.AppendSwitchIfNotNull("/fileversion:", this.FileVersion);
commandLine.AppendSwitchIfNotNull("/flags:", this.Flags);
commandLine.AppendWhenTrue("/fullpaths", base.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
commandLine.AppendSwitchIfNotNull("/keyname:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/out:", (this.OutputAssembly == null) ? null : this.OutputAssembly.ItemSpec);
commandLine.AppendSwitchIfNotNull("/platform:", this.Platform);
commandLine.AppendSwitchIfNotNull("/product:", this.ProductName);
commandLine.AppendSwitchIfNotNull("/productversion:", this.ProductVersion);
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendSwitchIfNotNull("/template:", this.TemplateFile);
commandLine.AppendSwitchIfNotNull("/title:", this.Title);
commandLine.AppendSwitchIfNotNull("/trademark:", this.Trademark);
commandLine.AppendSwitchIfNotNull("/version:", this.Version);
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32res:", this.Win32Resource);
commandLine.AppendSwitchIfNotNull("", this.SourceModules, new string[] { "TargetFile" });
commandLine.AppendSwitchIfNotNull("/embed:", this.EmbedResources, new string[] { "LogicalName", "Access" });
commandLine.AppendSwitchIfNotNull("/link:", this.LinkResources, new string[] { "LogicalName", "TargetFile", "Access" });
if (this.ResponseFiles != null)
{
foreach (string str in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", str);
}
}
}
/// <summary>
/// Returns a string with those switches and other information that can't go into a response file and
/// must go directly onto the command line.
/// Called after ValidateParameters and SkipTaskExecution
/// </summary>
override protected string GenerateCommandLineCommands()
{
CommandLineBuilderExtension commandLineBuilder = new CommandLineBuilderExtension();
bool serializationAssemblyPathExists = false;
try
{
if (SerializationAssembly == null)
{
Debug.Assert(ShouldGenerateSerializer, "GenerateCommandLineCommands() should not be called if ShouldGenerateSerializer is true and SerializationAssembly is null.");
SerializationAssembly = new TaskItem[] { new TaskItem(SerializationAssemblyPath) };
}
// Add the assembly switch
commandLineBuilder.AppendSwitchIfNotNull("/assembly:", AssemblyFullPath);
commandLineBuilder.AppendWhenTrue("/proxytypes", Bag, "UseProxyTypes");
//add the keep switch
commandLineBuilder.AppendWhenTrue("/keep", Bag, "UseKeep");
// Append the references, if any.
if (References != null)
{
foreach (string reference in References)
{
commandLineBuilder.AppendSwitchIfNotNull("/reference:", reference);
}
}
//Append the Types to the command line, if any.
if (Types != null)
{
foreach (string type in Types)
{
commandLineBuilder.AppendSwitchIfNotNull("/type:", type);
}
}
// The arguments to the "/compiler" switch are themselves switches to be passed to
// the compiler when generating the serialization assembly.
// Add the compiler command switches for strong naming on the serialization assembly
if (KeyFile != null)
{
commandLineBuilder.AppendNestedSwitch("/compiler:", "/keyfile:", KeyFile);
}
else if (KeyContainer != null)
{
commandLineBuilder.AppendNestedSwitch("/compiler:", "/keycontainer:", KeyContainer);
}
commandLineBuilder.AppendPlusOrMinusSwitch("/compiler:/delaysign", Bag, "DelaySign");
// Add the Platform switch to the compiler.
if (Platform != null)
{
commandLineBuilder.AppendNestedSwitch("/compiler:", "/platform:", Platform);
}
serializationAssemblyPathExists = File.Exists(SerializationAssemblyPath);
}
catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
{
// Ignore the expected exceptions because they have already been logged
}
// Delete the assembly if it already exists.
if (serializationAssemblyPathExists)
{
try
{
File.Delete(SerializationAssemblyPath);
}
// Of all of the exceptions that can be thrown on a File.Delete, the only ones we need to
// be immediately concerned with are the UnauthorizedAccessException and the IOException
// (file is in use exception). We need to make sure that the assembly is gone before we
// try to produce a new one because it is possible that after some changes were made to the
// base assembly, there will, in fact, not be a serialization assembly produced. We cannot
// leave the earlier produced assembly around to be propagated by later processes.
catch (UnauthorizedAccessException e)
{
Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message);
}
catch (IOException e)
{
Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message);
}
// The DirectoryNotFoundException is safely ignorable since that means that there is no
// existing serialization assembly. This would be extremely unlikely anyway because we
// found the serializer just a couple of milliseconds ago.
}
return commandLineBuilder.ToString();
}
/// <summary>
/// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file.
/// </summary>
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
// If outputAssembly is not specified, then an "/out: <name>" option won't be added to
// overwrite the one resulting from the OutputAssembly member of the CompilerParameters class.
// In that case, we should set the outputAssembly member based on the first source file.
if (
(OutputAssembly == null) &&
(Sources != null) &&
(Sources.Length > 0) &&
(this.ResponseFiles == null) // The response file may already have a /out: switch in it, so don't try to be smart here.
)
{
try
{
OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec));
}
catch (ArgumentException e)
{
throw new ArgumentException(e.Message, "Sources");
}
if (String.Compare(TargetType, "library", StringComparison.OrdinalIgnoreCase) == 0)
{
OutputAssembly.ItemSpec += ".dll";
}
else if (String.Compare(TargetType, "module", StringComparison.OrdinalIgnoreCase) == 0)
{
OutputAssembly.ItemSpec += ".netmodule";
}
else
{
OutputAssembly.ItemSpec += ".exe";
}
}
commandLine.AppendSwitchIfNotNull("/addmodule:", this.AddModules, ",");
commandLine.AppendSwitchWithInteger("/codepage:", this.Bag, "CodePage");
ConfigureDebugProperties();
// The "DebugType" parameter should be processed after the "EmitDebugInformation" parameter
// because it's more specific. Order matters on the command-line, and the last one wins.
// /debug+ is just a shorthand for /debug:full. And /debug- is just a shorthand for /debug:none.
commandLine.AppendPlusOrMinusSwitch("/debug", this.Bag, "EmitDebugInformation");
commandLine.AppendSwitchIfNotNull("/debug:", this.DebugType);
commandLine.AppendPlusOrMinusSwitch("/delaysign", this.Bag, "DelaySign");
commandLine.AppendSwitchWithInteger("/filealign:", this.Bag, "FileAlignment");
commandLine.AppendSwitchIfNotNull("/keycontainer:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
// If the strings "LogicalName" or "Access" ever change, make sure to search/replace everywhere in vsproject.
commandLine.AppendSwitchIfNotNull("/linkresource:", this.LinkResources, new string[] { "LogicalName", "Access" });
commandLine.AppendWhenTrue("/nologo", this.Bag, "NoLogo");
commandLine.AppendWhenTrue("/nowin32manifest", this.Bag, "NoWin32Manifest");
commandLine.AppendPlusOrMinusSwitch("/optimize", this.Bag, "Optimize");
commandLine.AppendSwitchIfNotNull("/out:", this.OutputAssembly);
commandLine.AppendSwitchIfNotNull("/ruleset:", this.CodeAnalysisRuleSet);
commandLine.AppendSwitchIfNotNull("/subsystemversion:", this.SubsystemVersion);
// If the strings "LogicalName" or "Access" ever change, make sure to search/replace everywhere in vsproject.
commandLine.AppendSwitchIfNotNull("/resource:", this.Resources, new string[] { "LogicalName", "Access" });
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendPlusOrMinusSwitch("/warnaserror", this.Bag, "TreatWarningsAsErrors");
commandLine.AppendWhenTrue("/utf8output", this.Bag, "Utf8Output");
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32manifest:", this.Win32Manifest);
// Append the analyzers.
this.AddAnalyzersToCommandLine(commandLine);
// Append additional files.
this.AddAdditionalFilesToCommandLine(commandLine);
// Append the sources.
commandLine.AppendFileNamesIfNotNull(Sources, " ");
}
protected void AddResponseFileCommandsImpl(CommandLineBuilderExtension commandLine)
{
if (OutputAssembly == null && Sources != null && Sources.Length > 0 && ResponseFiles == null)
{
try
{
OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec));
}
catch (ArgumentException exception)
{
throw new ArgumentException(exception.Message, "Sources", exception);
}
var outputAssembly = OutputAssembly;
switch (TargetType.ToLowerInvariant())
{
case "library":
outputAssembly.ItemSpec = outputAssembly.ItemSpec + ".dll";
break;
case "module":
outputAssembly.ItemSpec = outputAssembly.ItemSpec + ".netmodule";
break;
default:
outputAssembly.ItemSpec = outputAssembly.ItemSpec + ".exe";
break;
}
}
// Don't call base.AddResponseFileCommands()!
//base.AddResponseFileCommands(commandLine);
//System.Diagnostics.Debug.Assert(false);
if (RunDebugger)
commandLine.AppendSwitch("\n/debugger");
if (Optimize)
commandLine.AppendSwitch("\n/optimize");
commandLine.AppendPlusOrMinusSwitch("\n/checked", base.Bag, "CheckIntegerOverflow");
commandLine.AppendSwitch("\n/no-color");
commandLine.AppendSwitchIfNotNull("\n/lib:", base.AdditionalLibPaths, ",");
commandLine.AppendSwitchIfNotNull("\n/nowarn:", this.DisabledWarnings, ",");
commandLine.AppendSwitchIfNotNull("\n/dowarn:", this.EnabledWarnings, ",");
if (NoStdLib)
commandLine.AppendSwitch("\n/no-stdlib");
if (NoStdMacros)
commandLine.AppendSwitch("\n/no-stdmacros");
if (!GreedyReferences)
commandLine.AppendSwitch("\n/greedy-references:-");
if (WarningLevel != 4)
commandLine.AppendSwitchIfNotNull("\n/warn:", this.WarningLevel.ToString());
if (IndentationSyntax)
commandLine.AppendSwitch("\n/indentation-syntax");
commandLine.AppendSwitchIfNotNull("\n/doc:", this.DocumentationFile);
if (!string.IsNullOrEmpty(base.DefineConstants))
{
var defines = base.DefineConstants
.Split(new char[] { ';', ' ', '\r', '\n', '\t' }, StringSplitOptions.RemoveEmptyEntries);
commandLine.AppendSwitchUnquotedIfNotNull("\n/define:", String.Join(";", defines));
}
commandLine.AppendSwitchIfNotNull("\n/win32res:", base.Win32Resource);
commandLine.AppendSwitchIfNotNull("\n/platform:", this.Platform);
// Switchs from base.AddResponseFileCommands()
commandLine.AppendSwitchIfNotNull("\n/addmodule:", this.AddModules, ",");
commandLine.AppendPlusOrMinusSwitch("\n/delaysign", base.Bag, "DelaySign");
commandLine.AppendSwitchIfNotNull("\n/keycontainer:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("\n/keyfile:", this.KeyFile);
commandLine.AppendSwitchIfNotNull("\n/linkresource:", this.LinkResources, new[] { "LogicalName", "Access" });
if (NoLogo)
commandLine.AppendSwitch("\n/nologo");
commandLine.AppendSwitchIfNotNull("\n/resource:", this.Resources, new[] { "LogicalName", "Access" });
commandLine.AppendSwitchIfNotNull("\n/target:", this.TargetType);
commandLine.AppendPlusOrMinusSwitch("\n/warnaserror", base.Bag, "TreatWarningsAsErrors");
commandLine.AppendSwitchIfNotNull("\n/win32icon:", this.Win32Icon);
commandLine.AppendPlusOrMinusSwitch("\n/debug", base.Bag, "EmitDebugInformation");
commandLine.AppendSwitchIfNotNull("\n/project-path:", this.ProjectPath);
commandLine.AppendSwitchIfNotNull("\n/root-namespace:", this.RootNamespace);
commandLine.AppendSwitchIfNotNull("\n/main:", this.MainEntryPoint);
if (CompilerStackSize > 0)
commandLine.AppendSwitchIfNotNull("\n/stack-size:", this.CompilerStackSize.ToString());
// Not supported options:
//commandLine.AppendSwitchWithInteger("\n/codepage:", base.Bag, "CodePage");
//commandLine.AppendSwitchIfNotNull("/debug:", this.DebugType);
//commandLine.AppendSwitchWithInteger("\n/filealign:", base.Bag, "FileAlignment");
//commandLine.AppendWhenTrue("\n/utf8output", base.Bag, "Utf8Output");
// Add sources
if (this.Sources != null)
{
commandLine.Append("\n\n");
commandLine.AppendFileNamesIfNotNull(this.Sources, "\n");
commandLine.Append("\n");
}
if (null != base.ResponseFiles)
{
foreach (var it in base.ResponseFiles)
commandLine.AppendSwitchIfNotNull("\n/fromfile:", it.ItemSpec);
}
if (null != base.References)
{
foreach (var it in base.References)
commandLine.AppendSwitchIfNotNull("\n/ref:", it.ItemSpec);
}
if (null != this.MacroReferences)
{
foreach (var it in this.MacroReferences)
commandLine.AppendSwitchIfNotNull("\n/macros:", it.ItemSpec);
}
if (!string.IsNullOrEmpty(CustomArguments))
commandLine.AppendSwitch(CustomArguments);
commandLine.AppendSwitchIfNotNull("\n\n/out:", OutputAssembly);
}
protected internal override void AddCommandLineCommands(CommandLineBuilderExtension commandLine)
{
base.AddCommandLineCommands(commandLine);
commandLine.AppendPlusOrMinusSwitch("/nostdlib", NoStandardLib);
}
/// <summary>
/// Returns a string with those switches and other information that can't go into a response file and
/// must go directly onto the command line.
/// Called after ValidateParameters and SkipTaskExecution
/// </summary>
override protected string GenerateCommandLineCommands()
{
CommandLineBuilderExtension commandLineBuilder = new CommandLineBuilderExtension();
bool serializationAssemblyPathExists = false;
try
{
if (SerializationAssembly == null)
{
Debug.Assert(ShouldGenerateSerializer, "GenerateCommandLineCommands() should not be called if ShouldGenerateSerializer is true and SerializationAssembly is null.");
SerializationAssembly = new TaskItem[] { new TaskItem(SerializationAssemblyPath) };
}
// Add the assembly switch
commandLineBuilder.AppendSwitchIfNotNull("/assembly:", AssemblyFullPath);
commandLineBuilder.AppendWhenTrue("/proxytypes", Bag, "UseProxyTypes");
//add the keep switch
commandLineBuilder.AppendWhenTrue("/keep", Bag, "UseKeep");
// Append the references, if any.
if (References != null)
{
foreach (string reference in References)
{
commandLineBuilder.AppendSwitchIfNotNull("/reference:", reference);
}
}
//Append the Types to the command line, if any.
if (Types != null)
{
foreach (string type in Types)
{
commandLineBuilder.AppendSwitchIfNotNull("/type:", type);
}
}
// The arguments to the "/compiler" switch are themselves switches to be passed to
// the compiler when generating the serialization assembly.
// Add the compiler command switches for strong naming on the serialization assembly
if (KeyFile != null)
{
commandLineBuilder.AppendNestedSwitch("/compiler:", "/keyfile:", KeyFile);
}
else if (KeyContainer != null)
{
commandLineBuilder.AppendNestedSwitch("/compiler:", "/keycontainer:", KeyContainer);
}
commandLineBuilder.AppendPlusOrMinusSwitch("/compiler:/delaysign", Bag, "DelaySign");
// Add the Platform switch to the compiler.
if (Platform != null)
{
commandLineBuilder.AppendNestedSwitch("/compiler:", "/platform:", Platform);
}
serializationAssemblyPathExists = File.Exists(SerializationAssemblyPath);
}
catch (Exception e) when(ExceptionHandling.IsIoRelatedException(e))
{
// Ignore the expected exceptions because they have already been logged
}
// Delete the assembly if it already exists.
if (serializationAssemblyPathExists)
{
try
{
File.Delete(SerializationAssemblyPath);
}
// Of all of the exceptions that can be thrown on a File.Delete, the only ones we need to
// be immediately concerned with are the UnauthorizedAccessException and the IOException
// (file is in use exception). We need to make sure that the assembly is gone before we
// try to produce a new one because it is possible that after some changes were made to the
// base assembly, there will, in fact, not be a serialization assembly produced. We cannot
// leave the earlier produced assembly around to be propagated by later processes.
catch (UnauthorizedAccessException e)
{
Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message);
}
catch (IOException e)
{
Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message);
}
// The DirectoryNotFoundException is safely ignorable since that means that there is no
// existing serialization assembly. This would be extremely unlikely anyway because we
// found the serializer just a couple of milliseconds ago.
}
return(commandLineBuilder.ToString());
}
/// <summary>
/// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file.
/// </summary>
override protected internal void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/lib:", this.AdditionalLibPaths, ",");
commandLine.AppendPlusOrMinusSwitch("/unsafe", this.Bag, "AllowUnsafeBlocks");
commandLine.AppendPlusOrMinusSwitch("/checked", this.Bag, "CheckForOverflowUnderflow");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", ';', ',');
commandLine.AppendWhenTrue("/fullpaths", this.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendSwitchIfNotNull("/pdb:", this.PdbFile);
commandLine.AppendPlusOrMinusSwitch("/nostdlib", this.Bag, "NoStandardLib");
commandLine.AppendSwitchIfNotNull("/platform:", this.PlatformWith32BitPreference);
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchWithInteger("/warn:", this.Bag, "WarningLevel");
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", this.GetDefineConstantsSwitch(this.DefineConstants));
commandLine.AppendSwitchIfNotNull("/win32res:", this.Win32Resource);
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/appconfig:", this.ApplicationConfiguration);
commandLine.AppendWhenTrue("/errorendlocation", this.Bag, "ErrorEndLocation");
commandLine.AppendSwitchIfNotNull("/preferreduilang:", this.PreferredUILang);
commandLine.AppendPlusOrMinusSwitch("/highentropyva", this.Bag, "HighEntropyVA");
// If not design time build and the globalSessionGuid property was set then add a -globalsessionguid:<guid>
bool designTime = false;
if (this.HostObject != null)
{
var csHost = this.HostObject as ICscHostObject;
designTime = csHost.IsDesignTime();
}
if (!designTime)
{
if (!string.IsNullOrWhiteSpace(this.VsSessionGuid))
{
commandLine.AppendSwitchIfNotNull("/sqmsessionguid:", this.VsSessionGuid);
}
}
this.AddReferencesToCommandLine(commandLine);
base.AddResponseFileCommands(commandLine);
// This should come after the "TreatWarningsAsErrors" flag is processed (in managedcompiler.cs).
// Because if TreatWarningsAsErrors=false, then we'll have a /warnaserror- on the command-line,
// and then any specific warnings that should be treated as errors should be specified with
// /warnaserror+:<list> after the /warnaserror- switch. The order of the switches on the command-line
// does matter.
//
// Note that
// /warnaserror+
// is just shorthand for:
// /warnaserror+:<all possible warnings>
//
// Similarly,
// /warnaserror-
// is just shorthand for:
// /warnaserror-:<all possible warnings>
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", ';', ',');
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", ';', ',');
// It's a good idea for the response file to be the very last switch passed, just
// from a predictability perspective.
if (this.ResponseFiles != null)
{
foreach (ITaskItem response in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", response.ItemSpec);
}
}
}
/// <summary>
/// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file.
/// </summary>
override protected internal void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/algid:", this.AlgorithmId);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchIfNotNull("/company:", this.CompanyName);
commandLine.AppendSwitchIfNotNull("/configuration:", this.Configuration);
commandLine.AppendSwitchIfNotNull("/copyright:", this.Copyright);
commandLine.AppendSwitchIfNotNull("/culture:", this.Culture);
commandLine.AppendPlusOrMinusSwitch("/delaysign", this.Bag, "DelaySign");
commandLine.AppendSwitchIfNotNull("/description:", this.Description);
commandLine.AppendSwitchIfNotNull("/evidence:", this.EvidenceFile);
commandLine.AppendSwitchIfNotNull("/fileversion:", this.FileVersion);
commandLine.AppendSwitchIfNotNull("/flags:", this.Flags);
commandLine.AppendWhenTrue("/fullpaths", this.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
commandLine.AppendSwitchIfNotNull("/keyname:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/out:", (this.OutputAssembly == null) ? null : this.OutputAssembly.ItemSpec);
commandLine.AppendSwitchIfNotNull("/platform:", this.PlatformWith32BitPreference);
commandLine.AppendSwitchIfNotNull("/product:", this.ProductName);
commandLine.AppendSwitchIfNotNull("/productversion:", this.ProductVersion);
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendSwitchIfNotNull("/template:", this.TemplateFile);
commandLine.AppendSwitchIfNotNull("/title:", this.Title);
commandLine.AppendSwitchIfNotNull("/trademark:", this.Trademark);
commandLine.AppendSwitchIfNotNull("/version:", this.Version);
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32res:", this.Win32Resource);
commandLine.AppendSwitchIfNotNull("", this.SourceModules, new string[] { "TargetFile" });
commandLine.AppendSwitchIfNotNull
(
"/embed:",
this.EmbedResources,
new string[] { "LogicalName", "Access" }
);
commandLine.AppendSwitchIfNotNull
(
"/link:",
this.LinkResources,
new string[] { "LogicalName", "TargetFile", "Access" }
);
// It's a good idea for the response file to be the very last switch passed, just
// from a predictability perspective. This is also consistent with the compiler
// tasks (Csc, etc.)
if (this.ResponseFiles != null)
{
foreach (string responseFile in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", responseFile);
}
}
}
/// <summary>
/// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file.
/// </summary>
override protected internal void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/lib:", this.AdditionalLibPaths, ",");
commandLine.AppendPlusOrMinusSwitch("/unsafe", this.Bag, "AllowUnsafeBlocks");
commandLine.AppendPlusOrMinusSwitch("/checked", this.Bag, "CheckForOverflowUnderflow");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", ';', ',');
commandLine.AppendWhenTrue("/fullpaths", this.Bag, "GenerateFullPaths");
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendSwitchIfNotNull("/pdb:", this.PdbFile);
commandLine.AppendPlusOrMinusSwitch("/nostdlib", this.Bag, "NoStandardLib");
commandLine.AppendSwitchIfNotNull("/platform:", this.PlatformWith32BitPreference);
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchWithInteger("/warn:", this.Bag, "WarningLevel");
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.BaseAddress);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", this.GetDefineConstantsSwitch(this.DefineConstants));
commandLine.AppendSwitchIfNotNull("/win32res:", this.Win32Resource);
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
commandLine.AppendSwitchIfNotNull("/appconfig:", this.ApplicationConfiguration);
commandLine.AppendWhenTrue("/errorendlocation", this.Bag, "ErrorEndLocation");
commandLine.AppendSwitchIfNotNull("/preferreduilang:", this.PreferredUILang);
commandLine.AppendPlusOrMinusSwitch("/highentropyva", this.Bag, "HighEntropyVA");
// If not design time build and the globalSessionGuid property was set then add a -globalsessionguid:<guid>
bool designTime = false;
if (this.HostObject != null)
{
var csHost = this.HostObject as ICscHostObject;
designTime = csHost.IsDesignTime();
}
if (!designTime)
{
if (!string.IsNullOrWhiteSpace(this.VsSessionGuid))
{
commandLine.AppendSwitchIfNotNull("/sqmsessionguid:", this.VsSessionGuid);
}
}
this.AddReferencesToCommandLine(commandLine);
base.AddResponseFileCommands(commandLine);
// This should come after the "TreatWarningsAsErrors" flag is processed (in managedcompiler.cs).
// Because if TreatWarningsAsErrors=false, then we'll have a /warnaserror- on the command-line,
// and then any specific warnings that should be treated as errors should be specified with
// /warnaserror+:<list> after the /warnaserror- switch. The order of the switches on the command-line
// does matter.
//
// Note that
// /warnaserror+
// is just shorthand for:
// /warnaserror+:<all possible warnings>
//
// Similarly,
// /warnaserror-
// is just shorthand for:
// /warnaserror-:<all possible warnings>
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", ';', ',');
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", ';', ',');
// It's a good idea for the response file to be the very last switch passed, just
// from a predictability perspective.
if (this.ResponseFiles != null)
{
foreach (ITaskItem response in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", response.ItemSpec);
}
}
}
/// <summary>
/// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file.
/// </summary>
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
// If outputAssembly is not specified, then an "/out: <name>" option won't be added to
// overwrite the one resulting from the OutputAssembly member of the CompilerParameters class.
// In that case, we should set the outputAssembly member based on the first source file.
if (
(OutputAssembly == null) &&
(Sources != null) &&
(Sources.Length > 0) &&
(this.ResponseFiles == null) // The response file may already have a /out: switch in it, so don't try to be smart here.
)
{
try
{
OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec));
}
catch (ArgumentException e)
{
throw new ArgumentException(e.Message, "Sources");
}
if (String.Compare(TargetType, "library", StringComparison.OrdinalIgnoreCase) == 0)
{
OutputAssembly.ItemSpec += ".dll";
}
else if (String.Compare(TargetType, "module", StringComparison.OrdinalIgnoreCase) == 0)
{
OutputAssembly.ItemSpec += ".netmodule";
}
else
{
OutputAssembly.ItemSpec += ".exe";
}
}
commandLine.AppendSwitchIfNotNull("/addmodule:", this.AddModules, ",");
commandLine.AppendSwitchWithInteger("/codepage:", this.Bag, "CodePage");
ConfigureDebugProperties();
// The "DebugType" parameter should be processed after the "EmitDebugInformation" parameter
// because it's more specific. Order matters on the command-line, and the last one wins.
// /debug+ is just a shorthand for /debug:full. And /debug- is just a shorthand for /debug:none.
commandLine.AppendPlusOrMinusSwitch("/debug", this.Bag, "EmitDebugInformation");
commandLine.AppendSwitchIfNotNull("/debug:", this.DebugType);
commandLine.AppendPlusOrMinusSwitch("/delaysign", this.Bag, "DelaySign");
commandLine.AppendSwitchWithInteger("/filealign:", this.Bag, "FileAlignment");
commandLine.AppendSwitchIfNotNull("/keycontainer:", this.KeyContainer);
commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile);
// If the strings "LogicalName" or "Access" ever change, make sure to search/replace everywhere in vsproject.
commandLine.AppendSwitchIfNotNull("/linkresource:", this.LinkResources, new string[] { "LogicalName", "Access" });
commandLine.AppendWhenTrue("/nologo", this.Bag, "NoLogo");
commandLine.AppendWhenTrue("/nowin32manifest", this.Bag, "NoWin32Manifest");
commandLine.AppendPlusOrMinusSwitch("/optimize", this.Bag, "Optimize");
commandLine.AppendSwitchIfNotNull("/out:", this.OutputAssembly);
commandLine.AppendSwitchIfNotNull("/ruleset:", this.CodeAnalysisRuleSet);
commandLine.AppendSwitchIfNotNull("/subsystemversion:", this.SubsystemVersion);
// If the strings "LogicalName" or "Access" ever change, make sure to search/replace everywhere in vsproject.
commandLine.AppendSwitchIfNotNull("/resource:", this.Resources, new string[] { "LogicalName", "Access" });
commandLine.AppendSwitchIfNotNull("/target:", this.TargetType);
commandLine.AppendPlusOrMinusSwitch("/warnaserror", this.Bag, "TreatWarningsAsErrors");
commandLine.AppendWhenTrue("/utf8output", this.Bag, "Utf8Output");
commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon);
commandLine.AppendSwitchIfNotNull("/win32manifest:", this.Win32Manifest);
// Append the analyzers.
this.AddAnalyzersToCommandLine(commandLine);
// Append additional files.
this.AddAdditionalFilesToCommandLine(commandLine);
// Append the sources.
commandLine.AppendFileNamesIfNotNull(Sources, " ");
}
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.GetBaseAddressInHex());
commandLine.AppendSwitchIfNotNull("/libpath:", base.AdditionalLibPaths, ",");
commandLine.AppendSwitchIfNotNull("/imports:", this.Imports, ",");
commandLine.AppendPlusOrMinusSwitch("/doc", base.Bag, "GenerateDocumentation");
commandLine.AppendSwitchIfNotNull("/optioncompare:", this.OptionCompare);
commandLine.AppendPlusOrMinusSwitch("/optionexplicit", base.Bag, "OptionExplicit");
object obj2 = base.Bag["OptionStrict"];
if ((obj2 != null) ? ((bool)obj2) : false)
{
commandLine.AppendSwitch("/optionstrict+");
}
else
{
commandLine.AppendSwitch("/optionstrict:custom");
}
commandLine.AppendSwitchIfNotNull("/optionstrict:", this.OptionStrictType);
commandLine.AppendWhenTrue("/nowarn", base.Bag, "NoWarnings");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", new char[] { ';', ',' });
commandLine.AppendPlusOrMinusSwitch("/optioninfer", base.Bag, "OptionInfer");
commandLine.AppendWhenTrue("/nostdlib", base.Bag, "NoStandardLib");
commandLine.AppendWhenTrue("/novbruntimeref", base.Bag, "NoVBRuntimeReference");
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchIfNotNull("/platform:", this.Platform);
commandLine.AppendPlusOrMinusSwitch("/removeintchecks", base.Bag, "RemoveIntegerChecks");
commandLine.AppendSwitchIfNotNull("/rootnamespace:", this.RootNamespace);
commandLine.AppendSwitchIfNotNull("/sdkpath:", this.SdkPath);
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendWhenTrue("/netcf", base.Bag, "TargetCompactFramework");
if (this.VBRuntime != null)
{
string vBRuntime = this.VBRuntime;
if (string.Compare(vBRuntime, "EMBED", StringComparison.OrdinalIgnoreCase) == 0)
{
commandLine.AppendSwitch("/vbruntime*");
}
else if (string.Compare(vBRuntime, "NONE", StringComparison.OrdinalIgnoreCase) == 0)
{
commandLine.AppendSwitch("/vbruntime-");
}
else if (string.Compare(vBRuntime, "DEFAULT", StringComparison.OrdinalIgnoreCase) == 0)
{
commandLine.AppendSwitch("/vbruntime+");
}
else
{
commandLine.AppendSwitchIfNotNull("/vbruntime:", vBRuntime);
}
}
if ((this.Verbosity != null) && ((string.Compare(this.Verbosity, "quiet", StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(this.Verbosity, "verbose", StringComparison.OrdinalIgnoreCase) == 0)))
{
commandLine.AppendSwitchIfNotNull("/", this.Verbosity);
}
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", GetDefineConstantsSwitch(base.DefineConstants));
this.AddReferencesToCommandLine(commandLine);
commandLine.AppendSwitchIfNotNull("/win32resource:", base.Win32Resource);
if (string.Compare("Sub Main", base.MainEntryPoint, StringComparison.OrdinalIgnoreCase) != 0)
{
commandLine.AppendSwitchIfNotNull("/main:", base.MainEntryPoint);
}
base.AddResponseFileCommands(commandLine);
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", new char[] { ';', ',' });
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", new char[] { ';', ',' });
if (base.ResponseFiles != null)
{
foreach (ITaskItem item in base.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", item.ItemSpec);
}
}
}
protected override string GenerateCommandLineCommands()
{
CommandLineBuilderExtension extension = new CommandLineBuilderExtension();
bool flag = false;
try
{
if (this.SerializationAssembly == null)
{
this.SerializationAssembly = new TaskItem[] { new TaskItem(this.SerializationAssemblyPath) };
}
extension.AppendSwitchIfNotNull("/assembly:", this.AssemblyFullPath);
extension.AppendWhenTrue("/proxytypes", base.Bag, "UseProxyTypes");
if (this.References != null)
{
foreach (string str in this.References)
{
extension.AppendSwitchIfNotNull("/reference:", str);
}
}
if (this.Types != null)
{
foreach (string str2 in this.Types)
{
extension.AppendSwitchIfNotNull("/type:", str2);
}
}
if (this.KeyFile != null)
{
extension.AppendNestedSwitch("/compiler:", "/keyfile:", this.KeyFile);
}
else if (this.KeyContainer != null)
{
extension.AppendNestedSwitch("/compiler:", "/keycontainer:", this.KeyContainer);
}
extension.AppendPlusOrMinusSwitch("/compiler:/delaysign", base.Bag, "DelaySign");
if (this.Platform != null)
{
extension.AppendNestedSwitch("/compiler:", "/platform:", this.Platform);
}
flag = File.Exists(this.SerializationAssemblyPath);
}
catch (Exception exception)
{
if (Microsoft.Build.Shared.ExceptionHandling.NotExpectedException(exception))
{
throw;
}
}
if (flag)
{
try
{
File.Delete(this.SerializationAssemblyPath);
}
catch (UnauthorizedAccessException exception2)
{
base.Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", new object[] { this.SerializationAssemblyPath, exception2.Message });
}
catch (IOException exception3)
{
base.Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", new object[] { this.SerializationAssemblyPath, exception3.Message });
}
}
return extension.ToString();
}
protected override string GenerateCommandLineCommands()
{
CommandLineBuilderExtension extension = new CommandLineBuilderExtension();
bool flag = false;
try
{
if (this.SerializationAssembly == null)
{
this.SerializationAssembly = new TaskItem[] { new TaskItem(this.SerializationAssemblyPath) };
}
extension.AppendSwitchIfNotNull("/assembly:", this.AssemblyFullPath);
extension.AppendWhenTrue("/proxytypes", base.Bag, "UseProxyTypes");
if (this.References != null)
{
foreach (string str in this.References)
{
extension.AppendSwitchIfNotNull("/reference:", str);
}
}
if (this.Types != null)
{
foreach (string str2 in this.Types)
{
extension.AppendSwitchIfNotNull("/type:", str2);
}
}
if (this.KeyFile != null)
{
extension.AppendNestedSwitch("/compiler:", "/keyfile:", this.KeyFile);
}
else if (this.KeyContainer != null)
{
extension.AppendNestedSwitch("/compiler:", "/keycontainer:", this.KeyContainer);
}
extension.AppendPlusOrMinusSwitch("/compiler:/delaysign", base.Bag, "DelaySign");
if (this.Platform != null)
{
extension.AppendNestedSwitch("/compiler:", "/platform:", this.Platform);
}
flag = File.Exists(this.SerializationAssemblyPath);
}
catch (Exception exception)
{
if (Microsoft.Build.Shared.ExceptionHandling.NotExpectedException(exception))
{
throw;
}
}
if (flag)
{
try
{
File.Delete(this.SerializationAssemblyPath);
}
catch (UnauthorizedAccessException exception2)
{
base.Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", new object[] { this.SerializationAssemblyPath, exception2.Message });
}
catch (IOException exception3)
{
base.Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", new object[] { this.SerializationAssemblyPath, exception3.Message });
}
}
return(extension.ToString());
}
/// <summary>
/// Looks at all the parameters that have been set, and builds up the string
/// containing all the command-line switches.
/// </summary>
/// <param name="commandLine"></param>
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.GetBaseAddressInHex());
commandLine.AppendSwitchIfNotNull("/libpath:", this.AdditionalLibPaths, ",");
commandLine.AppendSwitchIfNotNull("/imports:", this.Imports, ",");
// Make sure this /doc+ switch comes *before* the /doc:<file> switch (which is handled in the
// ManagedCompiler.cs base class). /doc+ is really just an alias for /doc:<assemblyname>.xml,
// and the last /doc switch on the command-line wins. If the user provided a specific doc filename,
// we want that one to win.
commandLine.AppendPlusOrMinusSwitch("/doc", this.Bag, "GenerateDocumentation");
commandLine.AppendSwitchIfNotNull("/optioncompare:", this.OptionCompare);
commandLine.AppendPlusOrMinusSwitch("/optionexplicit", this.Bag, "OptionExplicit");
// Make sure this /optionstrict+ switch appears *before* the /optionstrict:xxxx switch below
/* In Orcas a change was made that set Option Strict-, whenever this.DisabledWarnings was
* empty. That was clearly the wrong thing to do and we found it when we had a project with all the warning configuration
* entries set to WARNING. Because this.DisabledWarnings was empty in that case we would end up sending /OptionStrict-
* effectively silencing all the warnings that had been selected.
*
* Now what we do is:
* If option strict+ is specified, that trumps everything and we just set option strict+
* Otherwise, just set option strict:custom.
* You may wonder why we don't try to set Option Strict- The reason is that Option Strict- just implies a certain
* set of warnings that should be disabled (there's ten of them today) You get the same effect by sending
* option strict:custom on along with the correct list of disabled warnings.
* Rather than make this code know the current set of disabled warnings that comprise Option strict-, we just send
* option strict:custom on with the understanding that we'll get the same behavior as option strict- since we are passing
* the /nowarn line on that contains all the warnings OptionStrict- would disable anyway. The IDE knows what they are
* and puts them in the project file so we are good. And by not making this code aware of which warnings comprise
* Option Strict-, we have one less place we have to keep up to date in terms of what comprises option strict-
*/
// Decide whether we are Option Strict+ or Option Strict:custom
object optionStrictSetting = this.Bag["OptionStrict"];
bool optionStrict = optionStrictSetting != null ? (bool)optionStrictSetting : false;
if (optionStrict)
{
commandLine.AppendSwitch("/optionstrict+");
}
else // OptionStrict+ wasn't specified so use :custom.
{
commandLine.AppendSwitch("/optionstrict:custom");
}
commandLine.AppendSwitchIfNotNull("/optionstrict:", this.OptionStrictType);
commandLine.AppendWhenTrue("/nowarn", this.Bag, "NoWarnings");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", ';', ',');
commandLine.AppendPlusOrMinusSwitch("/optioninfer", this.Bag, "OptionInfer");
commandLine.AppendWhenTrue("/nostdlib", this.Bag, "NoStandardLib");
commandLine.AppendWhenTrue("/novbruntimeref", this.Bag, "NoVBRuntimeReference");
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchIfNotNull("/platform:", this.PlatformWith32BitPreference);
commandLine.AppendPlusOrMinusSwitch("/removeintchecks", this.Bag, "RemoveIntegerChecks");
commandLine.AppendSwitchIfNotNull("/rootnamespace:", this.RootNamespace);
commandLine.AppendSwitchIfNotNull("/sdkpath:", this.SdkPath);
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendWhenTrue("/netcf", this.Bag, "TargetCompactFramework");
commandLine.AppendSwitchIfNotNull("/preferreduilang:", this.PreferredUILang);
commandLine.AppendPlusOrMinusSwitch("/highentropyva", this.Bag, "HighEntropyVA");
if (0 == String.Compare(this.VBRuntimePath, this.VBRuntime, StringComparison.OrdinalIgnoreCase))
{
commandLine.AppendSwitchIfNotNull("/vbruntime:", this.VBRuntimePath);
}
else if (this.VBRuntime != null)
{
string vbRuntimeSwitch = this.VBRuntime;
if (0 == String.Compare(vbRuntimeSwitch, "EMBED", StringComparison.OrdinalIgnoreCase))
{
commandLine.AppendSwitch("/vbruntime*");
}
else if (0 == String.Compare(vbRuntimeSwitch, "NONE", StringComparison.OrdinalIgnoreCase))
{
commandLine.AppendSwitch("/vbruntime-");
}
else if (0 == String.Compare(vbRuntimeSwitch, "DEFAULT", StringComparison.OrdinalIgnoreCase))
{
commandLine.AppendSwitch("/vbruntime+");
}
else
{
commandLine.AppendSwitchIfNotNull("/vbruntime:", vbRuntimeSwitch);
}
}
// Verbosity
if (
(this.Verbosity != null) &&
(
(0 == String.Compare(this.Verbosity, "quiet", StringComparison.OrdinalIgnoreCase)) ||
(0 == String.Compare(this.Verbosity, "verbose", StringComparison.OrdinalIgnoreCase))
)
)
{
commandLine.AppendSwitchIfNotNull("/", this.Verbosity);
}
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", Vbc.GetDefineConstantsSwitch(this.DefineConstants));
AddReferencesToCommandLine(commandLine);
commandLine.AppendSwitchIfNotNull("/win32resource:", this.Win32Resource);
// Special case for "Sub Main"
if (0 != String.Compare("Sub Main", this.MainEntryPoint, StringComparison.OrdinalIgnoreCase))
{
commandLine.AppendSwitchIfNotNull("/main:", this.MainEntryPoint);
}
base.AddResponseFileCommands(commandLine);
// This should come after the "TreatWarningsAsErrors" flag is processed (in managedcompiler.cs).
// Because if TreatWarningsAsErrors=false, then we'll have a /warnaserror- on the command-line,
// and then any specific warnings that should be treated as errors should be specified with
// /warnaserror+:<list> after the /warnaserror- switch. The order of the switches on the command-line
// does matter.
//
// Note that
// /warnaserror+
// is just shorthand for:
// /warnaserror+:<all possible warnings>
//
// Similarly,
// /warnaserror-
// is just shorthand for:
// /warnaserror-:<all possible warnings>
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", ';', ',');
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", ';', ',');
// If not design time build and the globalSessionGuid property was set then add a -globalsessionguid:<guid>
bool designTime = false;
if (this.HostObject != null)
{
var vbHost = this.HostObject as IVbcHostObject;
designTime = vbHost.IsDesignTime();
}
if (!designTime)
{
if (!string.IsNullOrWhiteSpace(this.VsSessionGuid))
{
commandLine.AppendSwitchIfNotNull("/sqmsessionguid:", this.VsSessionGuid);
}
}
// It's a good idea for the response file to be the very last switch passed, just
// from a predictability perspective.
if (this.ResponseFiles != null)
{
foreach (ITaskItem response in this.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", response.ItemSpec);
}
}
}
protected internal override void AddResponseFileCommands(CommandLineBuilderExtension commandLine)
{
commandLine.AppendSwitchIfNotNull("/baseaddress:", this.GetBaseAddressInHex());
commandLine.AppendSwitchIfNotNull("/libpath:", base.AdditionalLibPaths, ",");
commandLine.AppendSwitchIfNotNull("/imports:", this.Imports, ",");
commandLine.AppendPlusOrMinusSwitch("/doc", base.Bag, "GenerateDocumentation");
commandLine.AppendSwitchIfNotNull("/optioncompare:", this.OptionCompare);
commandLine.AppendPlusOrMinusSwitch("/optionexplicit", base.Bag, "OptionExplicit");
object obj2 = base.Bag["OptionStrict"];
if ((obj2 != null) ? ((bool) obj2) : false)
{
commandLine.AppendSwitch("/optionstrict+");
}
else
{
commandLine.AppendSwitch("/optionstrict:custom");
}
commandLine.AppendSwitchIfNotNull("/optionstrict:", this.OptionStrictType);
commandLine.AppendWhenTrue("/nowarn", base.Bag, "NoWarnings");
commandLine.AppendSwitchWithSplitting("/nowarn:", this.DisabledWarnings, ",", new char[] { ';', ',' });
commandLine.AppendPlusOrMinusSwitch("/optioninfer", base.Bag, "OptionInfer");
commandLine.AppendWhenTrue("/nostdlib", base.Bag, "NoStandardLib");
commandLine.AppendWhenTrue("/novbruntimeref", base.Bag, "NoVBRuntimeReference");
commandLine.AppendSwitchIfNotNull("/errorreport:", this.ErrorReport);
commandLine.AppendSwitchIfNotNull("/platform:", this.Platform);
commandLine.AppendPlusOrMinusSwitch("/removeintchecks", base.Bag, "RemoveIntegerChecks");
commandLine.AppendSwitchIfNotNull("/rootnamespace:", this.RootNamespace);
commandLine.AppendSwitchIfNotNull("/sdkpath:", this.SdkPath);
commandLine.AppendSwitchIfNotNull("/langversion:", this.LangVersion);
commandLine.AppendSwitchIfNotNull("/moduleassemblyname:", this.ModuleAssemblyName);
commandLine.AppendWhenTrue("/netcf", base.Bag, "TargetCompactFramework");
if (this.VBRuntime != null)
{
string vBRuntime = this.VBRuntime;
if (string.Compare(vBRuntime, "EMBED", StringComparison.OrdinalIgnoreCase) == 0)
{
commandLine.AppendSwitch("/vbruntime*");
}
else if (string.Compare(vBRuntime, "NONE", StringComparison.OrdinalIgnoreCase) == 0)
{
commandLine.AppendSwitch("/vbruntime-");
}
else if (string.Compare(vBRuntime, "DEFAULT", StringComparison.OrdinalIgnoreCase) == 0)
{
commandLine.AppendSwitch("/vbruntime+");
}
else
{
commandLine.AppendSwitchIfNotNull("/vbruntime:", vBRuntime);
}
}
if ((this.Verbosity != null) && ((string.Compare(this.Verbosity, "quiet", StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(this.Verbosity, "verbose", StringComparison.OrdinalIgnoreCase) == 0)))
{
commandLine.AppendSwitchIfNotNull("/", this.Verbosity);
}
commandLine.AppendSwitchIfNotNull("/doc:", this.DocumentationFile);
commandLine.AppendSwitchUnquotedIfNotNull("/define:", GetDefineConstantsSwitch(base.DefineConstants));
this.AddReferencesToCommandLine(commandLine);
commandLine.AppendSwitchIfNotNull("/win32resource:", base.Win32Resource);
if (string.Compare("Sub Main", base.MainEntryPoint, StringComparison.OrdinalIgnoreCase) != 0)
{
commandLine.AppendSwitchIfNotNull("/main:", base.MainEntryPoint);
}
base.AddResponseFileCommands(commandLine);
commandLine.AppendSwitchWithSplitting("/warnaserror+:", this.WarningsAsErrors, ",", new char[] { ';', ',' });
commandLine.AppendSwitchWithSplitting("/warnaserror-:", this.WarningsNotAsErrors, ",", new char[] { ';', ',' });
if (base.ResponseFiles != null)
{
foreach (ITaskItem item in base.ResponseFiles)
{
commandLine.AppendSwitchIfNotNull("@", item.ItemSpec);
}
}
}
