/// <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); }