private void RunLibrarian(VcProjectConfiguration projectConfig)
{
// check if there's anything to do
if (projectConfig.ObjFiles.Count == 0) {
Log(Level.Debug, "No files to compile.");
return;
}
// create instance of Lib task
LibTask libTask = new LibTask();
// inherit project from solution task
libTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
libTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
libTask.Parent = SolutionTask;
// inherit verbose setting from solution task
libTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
libTask.InitializeTaskConfiguration();
// set parent of child elements
libTask.Sources.Parent = libTask;
// inherit project from solution task for child elements
libTask.Sources.Project = libTask.Project;
// inherit namespace manager from parent
libTask.Sources.NamespaceManager = libTask.NamespaceManager;
libTask.OutputFile = new FileInfo(projectConfig.OutputPath);
// Additional Library Directory
string addLibDirs = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "AdditionalLibraryDirectories");
if (!String.IsNullOrEmpty(addLibDirs)) {
foreach (string addLibDir in addLibDirs.Split(',', ';')) {
if (addLibDir.Length == 0) {
continue;
}
libTask.LibDirs.DirectoryNames.Add(addLibDir);
}
}
// Additional Dependencies
string addDeps = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "AdditionalDependencies");
if (!String.IsNullOrEmpty(addDeps)) {
int insertedDeps = 0;
foreach (string addDep in addDeps.Split(' ')) {
if (Path.GetExtension(addDep) == ".obj") {
projectConfig.ObjFiles.Insert(insertedDeps++, addDep);
} else {
libTask.Sources.FileNames.Add(addDep);
}
}
}
foreach (string objFile in projectConfig.ObjFiles) {
libTask.Sources.FileNames.Add(objFile);
}
// Module Definition File Name
string moduleDefinitionFile = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "ModuleDefinitionFile");
if (!String.IsNullOrEmpty(moduleDefinitionFile)) {
libTask.ModuleDefinitionFile = new FileInfo(FileUtils.CombinePaths(
ProjectDirectory.FullName, moduleDefinitionFile));
}
// Ignore All Default Libraries
string ignoreAllDefaultLibraries = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "IgnoreAllDefaultLibraries");
if (string.Compare(ignoreAllDefaultLibraries, "TRUE", true, CultureInfo.InvariantCulture) == 0) {
libTask.Options = "/NODEFAULTLIB";
}
// Ignore Specific Libraries
string ignoreDefaultLibraries = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "IgnoreDefaultLibraryNames");
if (!String.IsNullOrEmpty(ignoreDefaultLibraries)) {
foreach (string ignoreLibrary in ignoreDefaultLibraries.Split(';')) {
libTask.IgnoreLibraries.Add(new Library(ignoreLibrary));
}
}
// Export Named Functions
// TODO
// Forced Symbol References
string symbolReferences = projectConfig.GetToolSetting(VcConfigurationBase.LibTool,
"ForceSymbolReferences");
if (!String.IsNullOrEmpty(symbolReferences)) {
foreach (string symbol in symbolReferences.Split(';')) {
libTask.Symbols.Add(new Symbol(symbol));
}
}
// execute the task
ExecuteInProjectDirectory(libTask);
}
private bool PreLink(VcProjectConfiguration projectConfig)
{
// check if the build event should be executed
string excludedFromBuild = projectConfig.GetToolSetting(VcConfigurationBase.PreLinkEventTool,
"ExcludedFromBuild");
if (excludedFromBuild != null) {
if (string.Compare(excludedFromBuild.Trim(), "true", true, CultureInfo.InvariantCulture) == 0) {
return true;
}
}
string commandLine = projectConfig.GetToolSetting(VcConfigurationBase.PreLinkEventTool,
"CommandLine");
if (!String.IsNullOrEmpty(commandLine)) {
Log(Level.Info, "Performing Pre-Link Event...");
return ExecuteBuildEvent("Pre-Link", commandLine, projectConfig);
}
return true;
}
private bool RunCustomBuildStep(Configuration solutionConfiguration, VcProjectConfiguration projectConfig)
{
// check if a custom build step is configured
string commandLine = projectConfig.GetToolSetting(VcConfigurationBase.CustomBuildTool,
"CommandLine");
if (String.IsNullOrEmpty(commandLine)) {
return true;
}
DateTime oldestOutputFile = DateTime.MinValue;
string outputs = projectConfig.GetToolSetting(VcConfigurationBase.CustomBuildTool,
"Outputs");
if (!String.IsNullOrEmpty(outputs)) {
foreach (string output in outputs.Split(';')) {
if (output.Length == 0) {
continue;
}
string outputFile = Path.Combine (ProjectDirectory.FullName,
output);
if (File.Exists(outputFile)) {
DateTime lastWriteTime = File.GetLastWriteTime(outputFile);
if (lastWriteTime < oldestOutputFile || oldestOutputFile == DateTime.MinValue) {
oldestOutputFile = lastWriteTime;
}
}
}
}
bool runCustomBuildStep = false;
// when at least one of the output files of the custom build step
// does not exist or is older than the project output file, then
// the custom build step must be executed
string projectOutputFile = GetOutputPath(solutionConfiguration);
if (projectOutputFile != null && File.Exists (projectOutputFile)) {
DateTime lastWriteTime = File.GetLastWriteTime(projectOutputFile);
if (lastWriteTime > oldestOutputFile) {
runCustomBuildStep = true;
}
}
// if one of the additional dependencies was updated after the oldest
// output file of the custom build step, then the custom build step
// must also be executed
if (!runCustomBuildStep) {
string additionalDependencies = projectConfig.GetToolSetting(
VcConfigurationBase.CustomBuildTool, "AdditionalDependencies");
if (!String.IsNullOrEmpty(additionalDependencies)) {
foreach (string dependency in additionalDependencies.Split(';')) {
if (dependency.Length == 0) {
continue;
}
string dependencyFile = Path.Combine (ProjectDirectory.FullName,
dependency);
if (File.Exists (dependencyFile)) {
DateTime lastWriteTime = File.GetLastWriteTime(dependencyFile);
if (lastWriteTime > oldestOutputFile) {
runCustomBuildStep = true;
break;
}
}
}
}
}
if (!runCustomBuildStep) {
return true;
}
string description = projectConfig.GetToolSetting(VcConfigurationBase.CustomBuildTool,
"Description", "Performing Custom Build Step");
Log(Level.Info, description);
return ExecuteBuildEvent("Custom-Build", commandLine, projectConfig);
}
/// <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;
}
