/// <summary>
/// Runs pkg-config with the specified arguments and returns a
/// <see cref="bool" /> based on the exit code.
/// </summary>
/// <param name="args">The arguments to pass to pkg-config.</param>
/// <returns>
/// <see langword="true" /> if pkg-config exited with exit code 0;
/// otherwise, <see langword="false" />
/// </returns>
private bool RunPkgConfigBool(Argument[] args) {
MemoryStream ms = new MemoryStream();
ExecTask execTask = GetTask(ms);
execTask.Arguments.AddRange(args);
try {
execTask.Execute();
return true;
} catch (Exception) {
if (execTask.ExitCode == ExternalProgramBase.UnknownExitCode) {
// process could not be started or did not exit in time
throw;
}
return false;
}
}
/// <summary>
/// Runs pkg-config with the specified arguments and returns the result
/// as a <see cref="string" />.
/// </summary>
/// <param name="args">The arguments to pass to pkg-config.</param>
/// <returns>
/// The result of running pkg-config with the specified arguments.
/// </returns>
private string RunPkgConfigString(Argument[] args) {
MemoryStream ms = new MemoryStream();
ExecTask execTask = GetTask(ms);
execTask.Arguments.AddRange(args);
try {
execTask.Execute();
ms.Position = 0;
StreamReader sr = new StreamReader(ms);
string output = sr.ReadLine();
sr.Close();
return output;
} catch (Exception ex) {
ms.Position = 0;
StreamReader sr = new StreamReader(ms);
string output = sr.ReadToEnd();
sr.Close();
if (output.Length != 0) {
throw new BuildException(output, ex);
} else {
throw;
}
}
}
private void RunLinker(Configuration solutionConfiguration)
{
const string noinherit = "$(noinherit)";
// obtain project configuration (corresponding with solution configuration)
VcProjectConfiguration projectConfig = (VcProjectConfiguration) BuildConfigurations[solutionConfiguration];
// check if linking needs to be performed
if (projectConfig.ObjFiles.Count == 0) {
Log(Level.Debug, "No files to link.");
return;
}
// create instance of Link task
LinkTask linkTask = new LinkTask();
// inherit project from solution task
linkTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
linkTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
linkTask.Parent = SolutionTask;
// inherit verbose setting from solution task
linkTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
linkTask.InitializeTaskConfiguration();
// set parent of child elements
linkTask.Sources.Parent = linkTask;
linkTask.LibDirs.Parent = linkTask;
linkTask.Modules.Parent = linkTask;
linkTask.EmbeddedResources.Project = linkTask.Project;
// inherit project from solution task for child elements
linkTask.Sources.Project = linkTask.Project;
linkTask.LibDirs.Project = linkTask.Project;
linkTask.Modules.Project = linkTask.Project;
linkTask.EmbeddedResources.Project = linkTask.Project;
// inherit namespace manager from parent
linkTask.Sources.NamespaceManager = linkTask.NamespaceManager;
linkTask.LibDirs.NamespaceManager = linkTask.NamespaceManager;
linkTask.Modules.NamespaceManager = linkTask.NamespaceManager;
linkTask.EmbeddedResources.NamespaceManager = linkTask.NamespaceManager;
// set base directory of filesets
linkTask.Sources.BaseDirectory = ProjectDirectory;
linkTask.LibDirs.BaseDirectory = ProjectDirectory;
linkTask.Modules.BaseDirectory = ProjectDirectory;
linkTask.EmbeddedResources.BaseDirectory = ProjectDirectory;
string addDeps = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AdditionalDependencies");
if (!String.IsNullOrEmpty(addDeps)) {
// only include default libraries if noinherit is not set
if (addDeps.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit) == -1) {
foreach (string defaultLib in _defaultLibraries) {
linkTask.Sources.FileNames.Add(defaultLib);
}
} else {
addDeps = addDeps.Remove(addDeps.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit), noinherit.Length);
}
foreach (string addDep in addDeps.Split(' ')) {
if (Path.GetExtension(addDep) == ".obj") {
// skip obj files are these are handled in
// VcProjectConfiguration
continue;
}
linkTask.Sources.FileNames.Add(addDep);
}
} else {
// always include default libraries if no additional dependencies
// are specified
foreach (string defaultLib in _defaultLibraries) {
linkTask.Sources.FileNames.Add(defaultLib);
}
}
string delayLoadedDlls = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "DelayLoadDLLs");
if (!String.IsNullOrEmpty(delayLoadedDlls)) {
foreach (string dll in delayLoadedDlls.Split(';')) {
linkTask.DelayLoadedDlls.FileNames.Add(dll);
}
}
foreach (string objFile in projectConfig.ObjFiles) {
linkTask.Sources.FileNames.Add(objFile);
}
// add output generated by referenced projects and explicit project
// dependencies
ProjectBaseCollection projectDependencies = GetVcProjectDependencies();
foreach (VcProject vcProject in projectDependencies) {
VcProjectConfiguration vcProjectConfig = vcProject.BuildConfigurations[
solutionConfiguration] as VcProjectConfiguration;
switch (vcProjectConfig.Type) {
case VcProjectConfiguration.ConfigurationType.Application:
case VcProjectConfiguration.ConfigurationType.DynamicLibrary:
FileInfo dependencyImportLibrary = vcProjectConfig.LinkerConfiguration.ImportLibrary;
if (dependencyImportLibrary != null) {
linkTask.Sources.FileNames.Add(
dependencyImportLibrary.FullName);
}
break;
case VcProjectConfiguration.ConfigurationType.StaticLibrary:
linkTask.Sources.FileNames.Add(vcProjectConfig.OutputPath);
break;
}
}
linkTask.OutputFile = new FileInfo(projectConfig.OutputPath);
// ensure directory exists
if (!linkTask.OutputFile.Directory.Exists) {
linkTask.OutputFile.Directory.Create();
linkTask.OutputFile.Directory.Refresh();
}
// generation of debug information
linkTask.Debug = bool.Parse(projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "GenerateDebugInformation", "FALSE"));
string pdbFile = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "ProgramDatabaseFile");
// use default value if pdb was not explicitly disabled (by setting it to empty string)
if (pdbFile == null && linkTask.Debug) {
pdbFile = projectConfig.ExpandMacros("$(OutDir)/$(ProjectName).pdb");
}
if (!String.IsNullOrEmpty(pdbFile)) {
if (OutputDir != null) {
pdbFile = FileUtils.CombinePaths(OutputDir.FullName, Path.GetFileName(pdbFile));
} else {
pdbFile = FileUtils.CombinePaths(ProjectDirectory.FullName, pdbFile);
}
linkTask.ProgramDatabaseFile = new FileInfo(pdbFile);
// ensure directory exists
if (!linkTask.ProgramDatabaseFile.Directory.Exists) {
linkTask.ProgramDatabaseFile.Directory.Create();
linkTask.ProgramDatabaseFile.Directory.Refresh();
}
}
// generation of import library
FileInfo importLibrary = projectConfig.LinkerConfiguration.ImportLibrary;
if (importLibrary != null) {
Argument importLibraryArg = new Argument();
importLibraryArg.Line = "/IMPLIB:" + LinkTask.QuoteArgumentValue(
importLibrary.FullName);
linkTask.Arguments.Add(importLibraryArg);
// ensure directory exists
if (!importLibrary.Directory.Exists) {
importLibrary.Directory.Create();
importLibrary.Directory.Refresh();
}
}
// Ignore Specific Libraries
string ignoreDefaultLibraries = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool,
"IgnoreDefaultLibraryNames");
if (!String.IsNullOrEmpty(ignoreDefaultLibraries)) {
foreach (string ignoreLibrary in ignoreDefaultLibraries.Split(';')) {
linkTask.IgnoreLibraries.Add(new Library(ignoreLibrary));
}
}
// Forced Symbol References
string symbolReferences = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool,
"ForceSymbolReferences");
if (!String.IsNullOrEmpty(symbolReferences)) {
foreach (string symbol in symbolReferences.Split(';')) {
linkTask.Symbols.Add(new Symbol(symbol));
}
}
// generation of map file during linking
bool generateMapFile = bool.Parse(projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "GenerateMapFile", "FALSE"));
if (generateMapFile) {
Argument mapArg = new Argument();
string mapFileName = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "MapFileName");
if (!String.IsNullOrEmpty(mapFileName)) {
mapArg.Line = "/MAP:" + LinkTask.QuoteArgumentValue(mapFileName);;
} else {
mapArg.Line = "/MAP";
}
linkTask.Arguments.Add(mapArg);
}
// total heap allocation size
string heapReserveSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "HeapReserveSize");
if (!String.IsNullOrEmpty(heapReserveSize)) {
Argument heapArg = new Argument();
string heapCommitSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "HeapCommitSize");
if (!String.IsNullOrEmpty(heapCommitSize)) {
heapArg.Line = string.Format(CultureInfo.InvariantCulture,
"/HEAP:{0},{1}", heapReserveSize, heapCommitSize);
} else {
heapArg.Line = "/HEAP:" + heapReserveSize;
}
linkTask.Arguments.Add(heapArg);
}
// total stack allocation size
string stackReserveSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "StackReserveSize");
if (!String.IsNullOrEmpty(stackReserveSize)) {
Argument stackArg = new Argument();
string stackCommitSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "StackCommitSize");
if (!String.IsNullOrEmpty(stackCommitSize)) {
stackArg.Line = string.Format(CultureInfo.InvariantCulture,
"/STACK:{0},{1}", stackReserveSize, stackCommitSize);
} else {
stackArg.Line = "/STACK:" + stackReserveSize;
}
linkTask.Arguments.Add(stackArg);
}
if (projectConfig.Type == VcProjectConfiguration.ConfigurationType.DynamicLibrary) {
linkTask.Arguments.Add(new Argument("/DLL"));
}
string addLibDirs = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AdditionalLibraryDirectories");
if (!String.IsNullOrEmpty(addLibDirs)) {
foreach (string addLibDir in addLibDirs.Split(',', ';')) {
if (addLibDir.Length == 0) {
continue;
}
linkTask.LibDirs.DirectoryNames.Add(addLibDir);
}
}
// links to modules
string modules = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AddModuleNamesToAssembly");
if (!String.IsNullOrEmpty(modules)) {
foreach (string module in modules.Split(';')) {
linkTask.Modules.FileNames.Add(module);
}
}
// embedded resources
string embeddedResources = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "EmbedManagedResourceFile");
if (!String.IsNullOrEmpty(embeddedResources)) {
foreach (string embeddedResource in embeddedResources.Split(';')) {
linkTask.EmbeddedResources.FileNames.Add(embeddedResource);
}
}
Hashtable linkerArgs = projectConfig.GetToolArguments(VcConfigurationBase.LinkerTool, _linkerArgMap);
foreach (string arg in linkerArgs.Values) {
Argument linkArg = new Argument();
linkArg.Line = (string) arg;
linkTask.Arguments.Add(linkArg);
}
string addOptions = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AdditionalOptions");
if (!String.IsNullOrEmpty(addOptions)) {
using (StringReader reader = new StringReader(addOptions)) {
string addOptionsLine = reader.ReadLine();
while (addOptionsLine != null) {
foreach (string addOption in addOptionsLine.Split(' ')) {
linkTask.Arguments.Add(new Argument(addOption));
}
addOptionsLine = reader.ReadLine();
}
}
}
if (projectConfig.WholeProgramOptimization) {
linkTask.Arguments.Add(new Argument("/LTCG"));
}
// execute the task
ExecuteInProjectDirectory(linkTask);
}
private void BuildCPPFiles(ArrayList fileNames, Configuration solutionConfiguration, VcConfigurationBase fileConfig)
{
// obtain project configuration (corresponding with solution configuration)
VcProjectConfiguration projectConfig = (VcProjectConfiguration) BuildConfigurations[solutionConfiguration];
string intermediateDir = FileUtils.CombinePaths(ProjectDirectory.FullName,
projectConfig.IntermediateDir);
// create instance of Cl task
ClTask clTask = new ClTask();
// inherit project from solution task
clTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
clTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
clTask.Parent = SolutionTask;
// inherit verbose setting from solution task
clTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
clTask.InitializeTaskConfiguration();
// set parent of child elements
clTask.IncludeDirs.Parent = clTask;
clTask.Sources.Parent = clTask;
clTask.MetaDataIncludeDirs.Parent = clTask;
clTask.ForcedUsingFiles.Parent = clTask;
// inherit project from solution task for child elements
clTask.IncludeDirs.Project = clTask.Project;
clTask.Sources.Project = clTask.Project;
clTask.MetaDataIncludeDirs.Project = clTask.Project;
clTask.ForcedUsingFiles.Project = clTask.Project;
// set namespace manager of child elements
clTask.IncludeDirs.NamespaceManager = clTask.NamespaceManager;
clTask.Sources.NamespaceManager = clTask.NamespaceManager;
clTask.MetaDataIncludeDirs.NamespaceManager = clTask.NamespaceManager;
clTask.ForcedUsingFiles.NamespaceManager = clTask.NamespaceManager;
// set base directories
clTask.IncludeDirs.BaseDirectory = ProjectDirectory;
clTask.Sources.BaseDirectory = ProjectDirectory;
clTask.MetaDataIncludeDirs.BaseDirectory = ProjectDirectory;
clTask.ForcedUsingFiles.BaseDirectory = ProjectDirectory;
// set task properties
clTask.OutputDir = new DirectoryInfo(intermediateDir);
// TODO: add support for disabling specific warnings !!!
// check if precompiled headers are used
if (fileConfig.UsePrecompiledHeader != UsePrecompiledHeader.No && fileConfig.UsePrecompiledHeader != UsePrecompiledHeader.Unspecified) {
// get location of precompiled header file
string pchFile = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"PrecompiledHeaderFile", "$(IntDir)/$(TargetName).pch");
// we must set an absolute path for the PCH location file,
// otherwise <cl> assumes a location relative to the output
// directory - not the project directory.
if (!String.IsNullOrEmpty(pchFile)) {
clTask.PchFile = FileUtils.CombinePaths(ProjectDirectory.FullName, pchFile);
}
// check if a header file is specified for the precompiled header
// file, use "StdAfx.h" as default value
string headerThrough = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"PrecompiledHeaderThrough", "StdAfx.h");
if (!String.IsNullOrEmpty(headerThrough)) {
clTask.PchThroughFile = headerThrough;
}
switch (fileConfig.UsePrecompiledHeader) {
case UsePrecompiledHeader.Use:
clTask.PchMode = ClTask.PrecompiledHeaderMode.Use;
break;
case UsePrecompiledHeader.AutoCreate:
clTask.PchMode = ClTask.PrecompiledHeaderMode.AutoCreate;
break;
case UsePrecompiledHeader.Create:
clTask.PchMode = ClTask.PrecompiledHeaderMode.Create;
break;
}
}
clTask.CharacterSet = projectConfig.CharacterSet;
// ensure output directory exists
if (!clTask.OutputDir.Exists) {
clTask.OutputDir.Create();
clTask.OutputDir.Refresh();
}
string includeDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(includeDirs)) {
foreach (string includeDir in includeDirs.Split(',', ';')) {
if (includeDir.Length == 0) {
continue;
}
clTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
string metadataDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "AdditionalUsingDirectories");
if (!String.IsNullOrEmpty(metadataDirs)) {
foreach (string metadataDir in metadataDirs.Split(';')) {
if (metadataDir.Length == 0) {
continue;
}
clTask.MetaDataIncludeDirs.DirectoryNames.Add(
CleanPath(fileConfig.ExpandMacros(metadataDir)));
}
}
string forcedUsingFiles = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "ForcedUsingFiles");
if (!String.IsNullOrEmpty(forcedUsingFiles)) {
foreach (string forcedUsingFile in forcedUsingFiles.Split(';')) {
if (forcedUsingFile.Length == 0) {
continue;
}
clTask.ForcedUsingFiles.Includes.Add(
CleanPath(fileConfig.ExpandMacros(forcedUsingFile)));
}
}
// add project and assembly references
foreach (ReferenceBase reference in References) {
if (!reference.IsManaged(solutionConfiguration)) {
continue;
}
StringCollection assemblyReferences = reference.GetAssemblyReferences(
solutionConfiguration);
foreach (string assemblyFile in assemblyReferences) {
clTask.ForcedUsingFiles.Includes.Add(assemblyFile);
}
}
// Since the name of the pdb file is based on the VS version, we need to see
// which version we are targeting to make sure the right pdb file is used.
string pdbTargetFileName;
switch (ProductVersion) {
case ProductVersion.Rosario:
pdbTargetFileName = "$(IntDir)/vc100.pdb";
break;
case ProductVersion.Orcas:
pdbTargetFileName = "$(IntDir)/vc90.pdb";
break;
case ProductVersion.Whidbey:
pdbTargetFileName = "$(IntDir)/vc80.pdb";
break;
default:
pdbTargetFileName = "$(IntDir)/vc70.pdb";
break;
}
// set name of program database file
//
// we must set an absolute path for the program database file,
// otherwise <cl> assumes a location relative to the output
// directory - not the project directory.
string pdbFile = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"ProgramDataBaseFileName", pdbTargetFileName);
if (!String.IsNullOrEmpty(pdbFile)) {
clTask.ProgramDatabaseFile = FileUtils.CombinePaths(ProjectDirectory.FullName,
pdbFile);
}
// set path of object file or directory (can be null)
clTask.ObjectFile = GetObjectFile(fileConfig);
string asmOutput = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AssemblerOutput");
string asmListingLocation = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AssemblerListingLocation");
if (!String.IsNullOrEmpty(asmOutput) && asmOutput != "0" && !String.IsNullOrEmpty(asmListingLocation)) {
// parameter for AssemblerOutput itself will be handled by the map
clTask.Arguments.Add(new Argument("/Fa\"" + asmListingLocation + "\""));
}
foreach (string fileName in fileNames) {
clTask.Sources.FileNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, fileName));
}
string preprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string def in preprocessorDefs.Split(';', ',')) {
if (def.Length != 0) {
Option op = new Option();
op.OptionName = def;
clTask.Defines.Add(op);
}
}
}
string undefinePreprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "UndefinePreprocessorDefinitions");
if (!String.IsNullOrEmpty(undefinePreprocessorDefs)) {
foreach (string def in undefinePreprocessorDefs.Split(';', ',')) {
Option op = new Option();
op.OptionName = def;
clTask.Undefines.Add(op);
}
}
string addOptions = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AdditionalOptions");
if (!String.IsNullOrEmpty(addOptions)) {
using (StringReader reader = new StringReader(addOptions)) {
string addOptionsLine = reader.ReadLine();
while (addOptionsLine != null) {
foreach (string addOption in addOptionsLine.Split(' ')) {
clTask.Arguments.Add(new Argument(addOption));
}
addOptionsLine = reader.ReadLine();
}
}
}
//exception handling stuff
string exceptionHandling = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "ExceptionHandling");
if (exceptionHandling == null) {
if (ProductVersion >= ProductVersion.Whidbey) {
exceptionHandling = "2";
} else {
exceptionHandling = "false";
}
} else {
exceptionHandling = exceptionHandling.ToLower();
}
switch(exceptionHandling) {
case "0":
case "false":
break;
case "1":
case "true":
clTask.Arguments.Add(new Argument("/EHsc"));
break;
case "2":
clTask.Arguments.Add(new Argument("/EHa"));
break;
}
string browseInformation = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "BrowseInformation");
if (!String.IsNullOrEmpty(browseInformation) && browseInformation != "0") {
// determine file name of browse information file
string browseInformationFile = fileConfig.GetToolSetting(
VcConfigurationBase.CLCompilerTool, "BrowseInformationFile",
"$(IntDir)/");
if (!String.IsNullOrEmpty(browseInformationFile)) {
switch (browseInformation) {
case "1": // Include All Browse Information
clTask.Arguments.Add(new Argument("/FR\""
+ browseInformationFile + "\""));
break;
case "2": // No Local Symbols
clTask.Arguments.Add(new Argument("/Fr\""
+ browseInformationFile + "\""));
break;
}
} else {
switch (browseInformation) {
case "1": // Include All Browse Information
clTask.Arguments.Add(new Argument("/FR"));
break;
case "2": // No Local Symbols
clTask.Arguments.Add(new Argument("/Fr"));
break;
}
}
}
if (projectConfig.Type == VcProjectConfiguration.ConfigurationType.DynamicLibrary) {
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_WINDLL"));
}
if (projectConfig.WholeProgramOptimization) {
clTask.Arguments.Add(new Argument("/GL"));
}
// used to ignore some arguments
VcArgumentMap.ArgGroup vcArgIgnoreGroup = VcArgumentMap.ArgGroup.Unassigned;
// if optimzation level is Minimum Size (1) or Maximum size (2), we
// need to ignore all the arguments of the group "OptiIgnoreGroup"
string optimization = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "Optimization");
if (!String.IsNullOrEmpty(optimization)) {
int optimizationLevel = int.Parse(optimization);
if (optimizationLevel == 1 || optimizationLevel == 2) {
vcArgIgnoreGroup |= VcArgumentMap.ArgGroup.OptiIgnoreGroup;
}
}
Hashtable compilerArgs = fileConfig.GetToolArguments(VcConfigurationBase.CLCompilerTool,
_clArgMap, vcArgIgnoreGroup);
foreach (string arg in compilerArgs.Values) {
Argument compilerArg = new Argument();
compilerArg.Line = arg;
clTask.Arguments.Add(compilerArg);
}
// check for shared MFC
if (projectConfig.UseOfMFC == UseOfMFC.Shared) {
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_AFXDLL"));
}
// check for shared ATL
switch (projectConfig.UseOfATL) {
case UseOfATL.Shared:
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_ATL_DLL"));
break;
case UseOfATL.Static:
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_ATL_STATIC_REGISTRY"));
break;
}
// enable/disable Managed Extensions for C++
clTask.ManagedExtensions = projectConfig.ManagedExtensions;
// execute the task
ExecuteInProjectDirectory(clTask);
}
/// <summary>
/// Initializes a new instance of the <see cref="ArgumentCollection"/> class
/// with the specified array of <see cref="Argument"/> instances.
/// </summary>
public ArgumentCollection(Argument[] value)
{
AddRange(value);
}
/// <summary>
/// Build Interface Definition Language files for the given
/// configuration.
/// </summary>
/// <param name="fileNames">The IDL files to build.</param>
/// <param name="projectConfig">The project configuration.</param>
/// <param name="fileConfig">The build configuration.</param>
/// <remarks>
/// TODO: refactor this as we should always get only one element in the
/// <paramref name="fileNames" /> list. Each IDL file should be built
/// with its own file configuration.
/// </remarks>
private void BuildIDLFiles(ArrayList fileNames, VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig)
{
// create instance of MIDL task
MidlTask midlTask = new MidlTask();
// inherit project from solution task
midlTask.Project = SolutionTask.Project;
// Set the base directory
midlTask.BaseDirectory = ProjectDirectory;
// inherit namespace manager from solution task
midlTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
midlTask.Parent = SolutionTask;
// inherit verbose setting from solution task
midlTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
midlTask.InitializeTaskConfiguration();
// set parent of child elements
midlTask.IncludeDirs.Parent = midlTask;
// inherit project from solution task for child elements
midlTask.IncludeDirs.Project = midlTask.Project;
// set namespace manager of child elements
midlTask.IncludeDirs.NamespaceManager = midlTask.NamespaceManager;
// set base directories
midlTask.IncludeDirs.BaseDirectory = ProjectDirectory;
// If outputDirectory is not supplied in the configuration, assume
// it's the project directory
string outputDirectory = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "OutputDirectory");
if (String.IsNullOrEmpty(outputDirectory)) {
outputDirectory = ProjectDirectory.FullName;
} else {
outputDirectory = FileUtils.CombinePaths(ProjectDirectory.FullName,
outputDirectory);
}
// ensure output directory exists
if (!LongPathDirectory.Exists(outputDirectory)) {
LongPathDirectory.Create(outputDirectory);
}
midlTask.Arguments.Add(new Argument("/out"));
midlTask.Arguments.Add(new Argument(outputDirectory));
string typeLibraryName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool,
"TypeLibraryName", "$(IntDir)/$(ProjectName).tlb");
if (!String.IsNullOrEmpty(typeLibraryName)) {
midlTask.Tlb = new FileInfo(FileUtils.CombinePaths(outputDirectory,
typeLibraryName));
// ensure tlb directory exists
if (!midlTask.Tlb.Directory.Exists) {
midlTask.Tlb.Directory.Create();
midlTask.Tlb.Directory.Refresh();
}
}
string proxyFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "ProxyFileName");
if (!String.IsNullOrEmpty(proxyFileName)) {
midlTask.Proxy = new FileInfo(FileUtils.CombinePaths(outputDirectory,
proxyFileName));
// ensure proxy directory exists
if (!midlTask.Proxy.Directory.Exists) {
midlTask.Proxy.Directory.Create();
midlTask.Proxy.Directory.Refresh();
}
}
string interfaceIdentifierFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "InterfaceIdentifierFileName");
if (!String.IsNullOrEmpty(interfaceIdentifierFileName)) {
midlTask.Iid = new FileInfo(FileUtils.CombinePaths(outputDirectory,
interfaceIdentifierFileName));
// ensure IID directory exists
if (!midlTask.Iid.Directory.Exists) {
midlTask.Iid.Directory.Create();
midlTask.Iid.Directory.Refresh();
}
}
string dllDataFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "DLLDataFileName");
if (!String.IsNullOrEmpty(dllDataFileName)) {
midlTask.DllData = new FileInfo(FileUtils.CombinePaths(outputDirectory,
dllDataFileName));
// ensure DllData directory exists
if (!midlTask.DllData.Directory.Exists) {
midlTask.DllData.Directory.Create();
midlTask.DllData.Directory.Refresh();
}
}
string headerFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "HeaderFileName");
if (!String.IsNullOrEmpty(headerFileName)) {
midlTask.Header = new FileInfo(FileUtils.CombinePaths(outputDirectory,
headerFileName));
// ensure Header directory exists
if (!midlTask.Header.Directory.Exists) {
midlTask.Header.Directory.Create();
midlTask.Header.Directory.Refresh();
}
}
string preprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string preprocessorDef in preprocessorDefs.Split(';')) {
if (preprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = preprocessorDef;
midlTask.Defines.Add(op);
}
}
string undefinePreprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "UndefinePreprocessorDefinitions");
if (!String.IsNullOrEmpty(undefinePreprocessorDefs)) {
foreach (string undefinePreprocessorDef in undefinePreprocessorDefs.Split(';')) {
if (undefinePreprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = undefinePreprocessorDef;
midlTask.Undefines.Add(op);
}
}
string additionalIncludeDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(additionalIncludeDirs)) {
foreach (string includeDir in additionalIncludeDirs.Split(';')) {
if (includeDir.Length == 0) {
continue;
}
midlTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
string cPreprocessOptions = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "CPreprocessOptions");
if (!String.IsNullOrEmpty(cPreprocessOptions)) {
foreach (string cPreprocessOption in cPreprocessOptions.Split(';')) {
if (cPreprocessOption.Length == 0) {
continue;
}
midlTask.Arguments.Add(new Argument(string.Format("/cpp_opt\"{0}\"", cPreprocessOption)));
}
}
Hashtable midlArgs = fileConfig.GetToolArguments(VcConfigurationBase.MIDLTool, _midlArgMap);
foreach (string key in midlArgs.Keys) {
switch (key) {
case "TargetEnvironment":
midlTask.Env = (string) midlArgs[key];
break;
case "DefaultCharType":
midlTask.Char = (string) midlArgs[key];
break;
default:
Argument midlArg = new Argument();
midlArg.Line = (string) midlArgs[key];
midlTask.Arguments.Add(midlArg);
break;
}
}
// Compile each idl file
foreach (string idlFile in fileNames) {
midlTask.Filename = new FileInfo(FileUtils.CombinePaths(
ProjectDirectory.FullName, idlFile));
// execute the task
ExecuteInProjectDirectory(midlTask);
}
}
/// <summary>
/// Inserts a <see cref="Argument"/> into the collection at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
/// <param name="item">The <see cref="Argument"/> to insert.</param>
public void Insert(int index, Argument item)
{
base.List.Insert(index, item);
}
/// <summary>
/// Removes a member from the collection.
/// </summary>
/// <param name="item">The <see cref="Argument"/> to remove from the collection.</param>
public void Remove(Argument item)
{
base.List.Remove(item);
}
/// <summary>
/// Retrieves the index of a specified <see cref="Argument"/> object in the collection.
/// </summary>
/// <param name="item">The <see cref="Argument"/> object for which the index is returned.</param>
/// <returns>
/// The index of the specified <see cref="Argument"/>. If the <see cref="Argument"/> is not currently a member of the collection, it returns -1.
/// </returns>
public int IndexOf(Argument item)
{
return base.List.IndexOf(item);
}
/// <summary>
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
/// </summary>
/// <param name="array">The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.</param>
/// <param name="index">The zero-based index in <paramref name="array"/> at which copying begins.</param>
public void CopyTo(Argument[] array, int index)
{
base.List.CopyTo(array, index);
}
/// <summary>
/// Determines whether a <see cref="Argument"/> is in the collection.
/// </summary>
/// <param name="item">The <see cref="Argument"/> to locate in the collection.</param>
/// <returns>
/// <see langword="true" /> if <paramref name="item"/> is found in the
/// collection; otherwise, <see langword="false" />.
/// </returns>
public bool Contains(Argument item)
{
return base.List.Contains(item);
}
/// <summary>
/// Adds the elements of a <see cref="Argument"/> array to the end of the collection.
/// </summary>
/// <param name="items">The array of <see cref="Argument"/> elements to be added to the end of the collection.</param>
public void AddRange(Argument[] items)
{
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
/// <summary>
/// Adds a <see cref="Argument"/> to the end of the collection.
/// </summary>
/// <param name="item">The <see cref="Argument"/> to be added to the end of the collection.</param>
/// <returns>The position into which the new element was inserted.</returns>
public int Add(Argument item)
{
return base.List.Add(item);
}
