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);
}
internal string GetObjOutputFile(string fileName, VcConfigurationBase fileConfig, string intermediateDir)
{
string objectFile = GetObjectFile(fileConfig);
if (objectFile == null) {
objectFile = intermediateDir;
}
return ClTask.GetObjOutputFile(fileName, objectFile);
}
internal string GetResourceOutputFile(string fileName, VcConfigurationBase fileConfig)
{
return FileUtils.CombinePaths(ProjectDirectory.FullName,
fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool,
"ResourceOutputFileName", "$(IntDir)/$(InputName).res"));
}
/// <summary>
/// Merges the specified tool setting of <paramref name="projectConfig" />
/// with <paramref name="fileConfig" />.
/// </summary>
/// <remarks>
/// The merge is suppressed when the flag $(noinherit) is defined in
/// <paramref name="fileConfig" />.
/// </remarks>
private string MergeToolSetting(VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig, string tool, string setting)
{
const string noinherit = "$(noinherit)";
// get tool setting from either the file configuration or project
// configuration (if setting is not defined on file configuration)
string settingValue = fileConfig.GetToolSetting(tool, setting);
if (settingValue != null) {
if (settingValue.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit) == -1) {
// only add project-level setting to value if noherit if
// "fileConfig" is not actually the project config
if (!object.ReferenceEquals(projectConfig, fileConfig)) {
string baseSettingValue = projectConfig.GetToolSetting(tool, setting);
if (!String.IsNullOrEmpty(baseSettingValue)) {
settingValue += ";" + baseSettingValue;
}
}
} else {
settingValue = settingValue.Remove(settingValue.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit), noinherit.Length);
}
} else {
// if settingValue is null, then its not defined in neither the
// file nor the project configuration
return null;
}
// individual values are separated by ';'
string[] values = settingValue.Split(';');
// holds filtered setting value
settingValue = string.Empty;
// filter duplicate setting values
Hashtable filteredValues = CollectionsUtil.CreateCaseInsensitiveHashtable(values.Length);
foreach (string value in values) {
if (!filteredValues.ContainsKey(value)) {
filteredValues.Add(value, null);
if (settingValue.Length != 0) {
settingValue += ';';
}
settingValue += value;
}
}
return settingValue;
}
/// <summary>
/// Gets the absolute path to the object file or directory.
/// </summary>
/// <param name="fileConfig">The build configuration</param>
/// <returns>
/// The absolute path to the object file or directory, or
/// </returns>
/// <remarks>
/// We use an absolute path for the object file, otherwise
/// <c><cl></c> assumes a location relative to the output
/// directory - not the project directory.
/// </remarks>
private string GetObjectFile(VcConfigurationBase fileConfig)
{
string objectFile = fileConfig.GetToolSetting("VCCLCompilerTool",
"ObjectFile", "$(IntDir)/");
if (!String.IsNullOrEmpty(objectFile)) {
return FileUtils.CombinePaths(ProjectDirectory.FullName,
objectFile);
}
return null;
}
/// <summary>
/// Build resource files for the given configuration.
/// </summary>
/// <param name="fileNames">The resource 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 res file should be built
/// with its own file configuration.
/// </remarks>
private void BuildResourceFiles(ArrayList fileNames, VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig)
{
// create instance of RC task
RcTask rcTask = new RcTask();
// inherit project from solution task
rcTask.Project = SolutionTask.Project;
// Set the base directory
rcTask.BaseDirectory = ProjectDirectory;
// inherit namespace manager from solution task
rcTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
rcTask.Parent = SolutionTask;
// inherit verbose setting from solution task
rcTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
rcTask.InitializeTaskConfiguration();
// set parent of child elements
rcTask.IncludeDirs.Parent = rcTask;
// inherit project from solution task for child elements
rcTask.IncludeDirs.Project = rcTask.Project;
// set namespace manager of child elements
rcTask.IncludeDirs.NamespaceManager = rcTask.NamespaceManager;
// set base directories
rcTask.IncludeDirs.BaseDirectory = ProjectDirectory;
// Store the options to pass to the resource compiler in the options variable
StringBuilder options = new StringBuilder();
// Collect options
string ignoreStandardIncludePath = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "IgnoreStandardIncludePath");
if (ignoreStandardIncludePath != null && string.Compare(ignoreStandardIncludePath, "true", true, CultureInfo.InvariantCulture) == 0) {
options.Append("/X ");
}
string culture = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "Culture");
if (!String.IsNullOrEmpty(culture)) {
int cultureId = Convert.ToInt32(culture);
rcTask.LangId = cultureId;
}
string preprocessorDefs = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string preprocessorDef in preprocessorDefs.Split(';')) {
if (preprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = preprocessorDef;
rcTask.Defines.Add(op);
}
}
string showProgress = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "ShowProgress");
if (showProgress != null && string.Compare(showProgress, "true", true, CultureInfo.InvariantCulture) == 0) {
rcTask.Verbose = true;
}
string addIncludeDirs = MergeToolSetting(projectConfig, fileConfig, VcConfigurationBase.ResourceCompilerTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(addIncludeDirs)) {
foreach (string includeDir in addIncludeDirs.Split(';')) {
if (includeDir.Length == 0) {
continue;
}
rcTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
// check for shared MFC
if (projectConfig.UseOfMFC == UseOfMFC.Shared) {
options.AppendFormat("/d \"_AFXDLL\"");
}
if (options.Length > 0) {
rcTask.Options = options.ToString();
}
// Compile each resource file
foreach (string rcFile in fileNames) {
rcTask.OutputFile = new FileInfo(GetResourceOutputFile(rcFile, fileConfig));
rcTask.RcFile = new FileInfo(FileUtils.CombinePaths(ProjectDirectory.FullName, rcFile));
// execute the task
ExecuteInProjectDirectory(rcTask);
}
}
/// <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);
}
}
private void Initialize()
{
VcProject vcProject = (VcProject)Project;
// determine directory for storing intermediate build output for
// current project build configuration
string intermediateDir = FileUtils.CombinePaths(vcProject.ProjectDirectory.FullName,
IntermediateDir);
foreach (object projectFile in vcProject.ProjectFiles)
{
string fileName = null;
VcConfigurationBase fileConfig = null;
// the array list contains either strings or hashtables
if (projectFile is string)
{
fileName = (string)projectFile;
}
else
{
Hashtable fileConfigurations = (Hashtable)projectFile;
// obtain file configuration for current build configuration
VcFileConfiguration configuration = (VcFileConfiguration)
fileConfigurations[Name];
if (configuration != null && configuration.ExcludeFromBuild)
{
continue;
}
fileConfig = configuration;
// determine relative path
if (configuration == null)
{
// obtain relative path for other build configuration
// as the relative is the same anyway
foreach (DictionaryEntry de in fileConfigurations)
{
configuration = (VcFileConfiguration)de.Value;
break;
}
}
fileName = configuration.RelativePath;
}
string ext = Path.GetExtension(fileName).ToLower(CultureInfo.InvariantCulture);
// if there's no specific file configuration (for the current
// build configuration), then use the project configuration
if (fileConfig == null)
{
fileConfig = this;
}
switch (ext)
{
case ".cpp":
case ".c":
if (!_sourceConfigs.ContainsKey(fileConfig))
{
_sourceConfigs[fileConfig] = new ArrayList(1);
}
// add file to list of sources to build with this config
((ArrayList)_sourceConfigs[fileConfig]).Add(fileName);
// register output file for linking
_objFiles.Add(vcProject.GetObjOutputFile(fileName,
fileConfig, intermediateDir));
break;
case ".rc":
if (!_rcConfigs.ContainsKey(fileConfig))
{
_rcConfigs[fileConfig] = new ArrayList(1);
}
// add file to list of resources to build with this config
((ArrayList)_rcConfigs[fileConfig]).Add(fileName);
// register output file for linking
_objFiles.Add(vcProject.GetResourceOutputFile(fileName,
fileConfig));
break;
case ".idl":
case ".odl": // ODL is used for old OLE objects
if (!_idlConfigs.ContainsKey(fileConfig))
{
_idlConfigs[fileConfig] = new ArrayList(1);
}
// add file to list of idl's to build with this config
((ArrayList)_idlConfigs[fileConfig]).Add(fileName);
break;
}
}
switch (Type)
{
case ConfigurationType.StaticLibrary:
_outputPath = GetLibrarianOutputFile(intermediateDir);
break;
case ConfigurationType.Application:
case ConfigurationType.DynamicLibrary:
_outputPath = GetLinkerOutputFile();
break;
case ConfigurationType.Makefile:
string nmakeOutput = GetToolSetting(VcConfigurationBase.NMakeTool, "Output");
if (!String.IsNullOrEmpty(nmakeOutput))
{
_outputPath = FileUtils.CombinePaths(Project.ProjectDirectory.FullName, nmakeOutput);
}
break;
}
// mark initialization complete
_initialized = true;
}