ILinkingPolicy.Link(
ConsoleApplication sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString executablePath,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> objectFiles,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> headers,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> libraries,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> frameworks)
{
// any libraries added prior to here, need to be moved to the end
// they are external dependencies, and thus all built modules (to be added now) may have
// a dependency on them (and not vice versa)
var linker = sender.Settings as C.ICommonLinkerSettings;
var externalLibs = linker.Libraries;
linker.Libraries = new Bam.Core.StringArray();
foreach (var library in libraries)
{
(sender.Tool as C.LinkerTool).ProcessLibraryDependency(sender as CModule, library as CModule);
}
linker.Libraries.AddRange(externalLibs);
var commandLineArgs = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLineArgs);
var meta = new MakeFileBuilder.MakeFileMeta(sender);
var rule = meta.AddRule();
rule.AddTarget(executablePath);
foreach (var module in objectFiles)
{
rule.AddPrerequisite(module, C.ObjectFile.Key);
}
foreach (var module in libraries)
{
if (module is StaticLibrary)
{
rule.AddPrerequisite(module, C.StaticLibrary.Key);
}
else if (module is IDynamicLibrary)
{
if (module.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows))
{
rule.AddPrerequisite(module, C.DynamicLibrary.ImportLibraryKey);
}
else
{
rule.AddPrerequisite(module, C.DynamicLibrary.Key);
}
}
else if (module is CSDKModule)
{
continue;
}
else if (module is OSXFramework)
{
continue;
}
else
{
throw new Bam.Core.Exception("Unknown module library type: {0}", module.GetType());
}
}
var tool = sender.Tool as Bam.Core.ICommandLineTool;
var commands = new System.Text.StringBuilder();
commands.AppendFormat("{0} $^ {1} {2}",
CommandLineProcessor.Processor.StringifyTool(tool),
commandLineArgs.ToString(' '),
CommandLineProcessor.Processor.TerminatingArgs(tool));
rule.AddShellCommand(commands.ToString());
var executableDir = System.IO.Path.GetDirectoryName(executablePath.ToString());
meta.CommonMetaData.Directories.AddUnique(executableDir);
meta.CommonMetaData.ExtendEnvironmentVariables(tool.EnvironmentVariables);
}
ILinkingPolicy.Link(
ConsoleApplication sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString executablePath,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> objectFiles,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> headers,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> libraries)
{
// any libraries added prior to here, need to be moved to the end
// they are external dependencies, and thus all built modules (to be added now) may have
// a dependency on them (and not vice versa)
var linker = sender.Settings as C.ICommonLinkerSettings;
var externalLibs = linker.Libraries;
linker.Libraries = new Bam.Core.StringArray();
foreach (var library in libraries)
{
(sender.Tool as C.LinkerTool).ProcessLibraryDependency(sender as CModule, library as CModule);
}
linker.Libraries.AddRange(externalLibs);
var commandLineArgs = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLineArgs);
var meta = new MakeFileBuilder.MakeFileMeta(sender);
var rule = meta.AddRule();
rule.AddTarget(executablePath);
string objExt = null; // try to get the object file extension from a compiled source file
foreach (var module in objectFiles)
{
if (null == objExt)
{
objExt = module.Tool.Macros["objext"].ToString();
}
if (!(module as C.ObjectFileBase).PerformCompilation)
{
continue;
}
rule.AddPrerequisite(module, C.ObjectFile.Key);
}
foreach (var module in libraries)
{
if (module is StaticLibrary)
{
rule.AddPrerequisite(module, C.StaticLibrary.Key);
}
else if (module is IDynamicLibrary)
{
var dynLib = module as IDynamicLibrary;
if (dynLib.LinkerNameSymbolicLink != null)
{
var linkerNameSymLink = dynLib.LinkerNameSymbolicLink;
rule.AddPrerequisite(linkerNameSymLink, C.SharedObjectSymbolicLink.Key);
}
else
{
rule.AddPrerequisite(module, C.DynamicLibrary.Key);
}
}
else if (module is CSDKModule)
{
continue;
}
else if (module is OSXFramework)
{
continue;
}
else if (module is HeaderLibrary)
{
continue;
}
else
{
throw new Bam.Core.Exception("Unknown module library type: {0}", module.GetType());
}
}
var tool = sender.Tool as Bam.Core.ICommandLineTool;
var commands = new System.Text.StringBuilder();
// if there were no object files, you probably intended to use all prerequisites anyway
var filter = (null != objExt) ? System.String.Format("$(filter %{0},$^)", objExt) : "$^";
commands.AppendFormat("{0} {1} {2} {3}",
CommandLineProcessor.Processor.StringifyTool(tool),
filter,
commandLineArgs.ToString(' '),
CommandLineProcessor.Processor.TerminatingArgs(tool));
rule.AddShellCommand(commands.ToString());
var executableDir = System.IO.Path.GetDirectoryName(executablePath.ToString());
meta.CommonMetaData.AddDirectory(executableDir);
meta.CommonMetaData.ExtendEnvironmentVariables(tool.EnvironmentVariables);
}
ILinkingPolicy.Link(
ConsoleApplication sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString executablePath,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> objectFiles,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> headers,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> libraries)
{
if (0 == objectFiles.Count)
{
return;
}
var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta;
var target = workspace.EnsureTargetExists(sender);
var exeFilename = sender.CreateTokenizedString("@filename($(0))", executablePath);
exeFilename.Parse();
target.EnsureOutputFileReferenceExists(
exeFilename,
(sender is IDynamicLibrary) ? XcodeBuilder.FileReference.EFileType.DynamicLibrary : XcodeBuilder.FileReference.EFileType.Executable,
(sender is IDynamicLibrary) ? XcodeBuilder.Target.EProductType.DynamicLibrary : XcodeBuilder.Target.EProductType.Executable);
var configuration = target.GetConfiguration(sender);
if (sender is IDynamicLibrary && !((sender is Plugin) || (sender is C.Cxx.Plugin)))
{
var productName = sender.Macros["OutputName"].ToString().Equals(sender.Macros["modulename"].ToString()) ?
sender.CreateTokenizedString("${TARGET_NAME}.$(MajorVersion)") :
sender.CreateTokenizedString("$(OutputName).$(MajorVersion)");
lock (productName)
{
if (!productName.IsParsed)
{
productName.Parse();
}
}
configuration.SetProductName(productName);
}
else
{
if (sender.Macros["OutputName"].ToString().Equals(sender.Macros["modulename"].ToString()))
{
configuration.SetProductName(Bam.Core.TokenizedString.CreateVerbatim("${TARGET_NAME}"));
}
else
{
configuration.SetProductName(sender.Macros["OutputName"]);
}
}
foreach (var header in headers)
{
target.EnsureHeaderFileExists((header as HeaderFile).InputPath);
}
var excludedSource = new XcodeBuilder.MultiConfigurationValue();
var realObjectFiles = objectFiles.Where(item => !((item is WinResource) || (item is AssembledObjectFile)));
if (realObjectFiles.Any())
{
var xcodeConvertParameterTypes = new Bam.Core.TypeArray
{
typeof(Bam.Core.Module),
typeof(XcodeBuilder.Configuration)
};
var sharedSettings = C.SettingsBase.SharedSettings(
realObjectFiles,
typeof(ClangCommon.XcodeCompilerImplementation),
typeof(XcodeProjectProcessor.IConvertToProject),
xcodeConvertParameterTypes);
XcodeSharedSettings.Tweak(sharedSettings);
(sharedSettings as XcodeProjectProcessor.IConvertToProject).Convert(sender, configuration);
foreach (var objFile in realObjectFiles)
{
var asObjFileBase = objFile as C.ObjectFileBase;
if (!asObjFileBase.PerformCompilation)
{
var fullPath = asObjFileBase.InputPath.ToString();
var filename = System.IO.Path.GetFileName(fullPath);
excludedSource.Add(filename);
}
var buildFile = objFile.MetaData as XcodeBuilder.BuildFile;
var deltaSettings = (objFile.Settings as C.SettingsBase).CreateDeltaSettings(sharedSettings, objFile);
if (null != deltaSettings)
{
var commandLine = new Bam.Core.StringArray();
(deltaSettings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
if (commandLine.Count > 0)
{
// Cannot set per-file-per-configuration settings, so blend them together
if (null == buildFile.Settings)
{
buildFile.Settings = commandLine;
}
else
{
buildFile.Settings.AddRangeUnique(commandLine);
}
}
}
configuration.BuildFiles.Add(buildFile);
}
// now deal with other object file types
var assembledObjectFiles = objectFiles.Where(item => item is AssembledObjectFile);
foreach (var asmObj in assembledObjectFiles)
{
var buildFile = asmObj.MetaData as XcodeBuilder.BuildFile;
configuration.BuildFiles.Add(buildFile);
}
}
else
{
(objectFiles[0].Settings as XcodeProjectProcessor.IConvertToProject).Convert(sender, configuration);
foreach (var objFile in objectFiles)
{
var asObjFileBase = objFile as C.ObjectFileBase;
if (!asObjFileBase.PerformCompilation)
{
var fullPath = asObjFileBase.InputPath.ToString();
var filename = System.IO.Path.GetFileName(fullPath);
excludedSource.Add(filename);
}
var buildFile = objFile.MetaData as XcodeBuilder.BuildFile;
configuration.BuildFiles.Add(buildFile);
}
}
configuration["EXCLUDED_SOURCE_FILE_NAMES"] = excludedSource;
// add library search paths prior to converting linker settings
var linker = sender.Settings as C.ICommonLinkerSettings;
foreach (var library in libraries)
{
if (library is C.StaticLibrary)
{
var libDir = library.CreateTokenizedString("@dir($(0))", library.GeneratedPaths[C.StaticLibrary.Key]);
lock (libDir)
{
if (!libDir.IsParsed)
{
libDir.Parse();
}
}
linker.LibraryPaths.Add(libDir);
}
else if (library is C.IDynamicLibrary)
{
var libDir = library.CreateTokenizedString("@dir($(0))", library.GeneratedPaths[C.DynamicLibrary.Key]);
lock (libDir)
{
if (!libDir.IsParsed)
{
libDir.Parse();
}
}
linker.LibraryPaths.Add(libDir);
}
else if (library is C.CSDKModule)
{
// SDK modules are collections of libraries, not one in particular
// thus do nothing as they are undefined at this point, and may yet be pulled in automatically
}
else if (library is C.HeaderLibrary)
{
// no library
}
else if (library is OSXFramework)
{
// frameworks are dealt with elsewhere
}
else
{
throw new Bam.Core.Exception("Don't know how to handle this module type, {0}", library.ToString());
}
}
foreach (var library in libraries)
{
var libAsCModule = library as C.CModule;
if (null == libAsCModule)
{
throw new Bam.Core.Exception("Don't know how to handle library module of type '{0}'", library.GetType().ToString());
}
if (libAsCModule.IsPrebuilt)
{
if (library is OSXFramework)
{
// frameworks are dealt with elsewhere
}
else if (library is C.StaticLibrary)
{
(sender.Tool as C.LinkerTool).ProcessLibraryDependency(sender as CModule, libAsCModule);
}
else
{
throw new Bam.Core.Exception("Don't know how to handle this prebuilt module dependency, '{0}'", library.GetType().ToString());
}
}
else
{
if (library is C.StaticLibrary)
{
target.DependsOn(library.MetaData as XcodeBuilder.Target);
}
else if (library is C.IDynamicLibrary)
{
target.DependsOn(library.MetaData as XcodeBuilder.Target);
}
else if (library is C.CSDKModule)
{
// do nothing, just an area for external
}
else if (library is C.HeaderLibrary)
{
// no library
}
else if (library is OSXFramework)
{
// frameworks are dealt with elsewhere
}
else
{
throw new Bam.Core.Exception("Don't know how to handle this module type");
}
}
}
// convert link settings to the Xcode project
(sender.Settings as XcodeProjectProcessor.IConvertToProject).Convert(sender, configuration);
var required_targets = new System.Collections.Generic.HashSet <XcodeBuilder.Target>();
// order only dependencies - recurse into each, so that all layers
// of order only dependencies are included
var queue = new System.Collections.Generic.Queue <Bam.Core.Module>(sender.Requirements);
while (queue.Count > 0)
{
var required = queue.Dequeue();
foreach (var additional in required.Requirements)
{
queue.Enqueue(additional);
}
if (null == required.MetaData)
{
continue;
}
if (required is HeaderLibrary)
{
// the target for a HeaderLibrary has no FileReference output, and thus cannot be an order only dependency
continue;
}
var requiredTarget = required.MetaData as XcodeBuilder.Target;
if (null != requiredTarget)
{
required_targets.Add(requiredTarget);
}
}
// any non-C module projects should be order-only dependencies
foreach (var dependent in sender.Dependents)
{
if (null == dependent.MetaData)
{
continue;
}
if (dependent is C.CModule)
{
continue;
}
var dependentTarget = dependent.MetaData as XcodeBuilder.Target;
if (null != dependentTarget)
{
required_targets.Add(dependentTarget);
}
}
foreach (var reqTarget in required_targets)
{
target.Requires(reqTarget);
}
}
ILinkingPolicy.Link(
ConsoleApplication sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString executablePath,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> objectFiles,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> headers,
System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> libraries)
{
if (0 == objectFiles.Count)
{
if (headers.Count > 0)
{
this.CreateHeaderOnlyLibrary(sender, headers);
}
return;
}
var solution = Bam.Core.Graph.Instance.MetaData as VSSolutionBuilder.VSSolution;
var project = solution.EnsureProjectExists(sender);
var config = project.GetConfiguration(sender);
config.SetType((sender is IDynamicLibrary) ? VSSolutionBuilder.VSProjectConfiguration.EType.DynamicLibrary : VSSolutionBuilder.VSProjectConfiguration.EType.Application);
config.SetOutputPath(executablePath);
config.EnableIntermediatePath();
foreach (var header in headers)
{
config.AddHeaderFile(header as HeaderFile);
}
var compilerGroup = config.GetSettingsGroup(VSSolutionBuilder.VSSettingsGroup.ESettingsGroup.Compiler);
var realObjectFiles = objectFiles.Where(item => !((item is WinResource) || (item is AssembledObjectFile)));
if (realObjectFiles.Any())
{
var vsConvertParameterTypes = new Bam.Core.TypeArray
{
typeof(Bam.Core.Module),
typeof(VSSolutionBuilder.VSSettingsGroup),
typeof(string)
};
var sharedSettings = C.SettingsBase.SharedSettings(
realObjectFiles,
typeof(VisualCCommon.VSSolutionImplementation),
typeof(VisualStudioProcessor.IConvertToProject),
vsConvertParameterTypes);
(sharedSettings as VisualStudioProcessor.IConvertToProject).Convert(sender, compilerGroup);
foreach (var objFile in realObjectFiles)
{
var deltaSettings = (objFile.Settings as C.SettingsBase).CreateDeltaSettings(sharedSettings, objFile);
config.AddSourceFile(objFile, deltaSettings);
}
// now handle the other object file types
// TODO: if there were many resource files, this could also have a common settings group? Not sure if VS supports this
// and it's not as likely to have many resource files, as it would have many source files
var resourceObjectFiles = objectFiles.Where(item => item is WinResource);
foreach (var resObj in resourceObjectFiles)
{
config.AddResourceFile(resObj as WinResource, resObj.Settings);
}
var assembledObjectFiles = objectFiles.Where(item => item is AssembledObjectFile);
foreach (var asmObj in assembledObjectFiles)
{
config.AddAssemblyFile(asmObj as AssembledObjectFile);
}
}
else
{
(objectFiles[0].Settings as VisualStudioProcessor.IConvertToProject).Convert(sender, compilerGroup);
foreach (var objFile in objectFiles)
{
config.AddSourceFile(objFile, null);
}
}
foreach (var input in libraries)
{
if ((null != input.MetaData) && VSSolutionBuilder.VSProject.IsBuildable(input))
{
if ((input is C.StaticLibrary) || (input is C.IDynamicLibrary))
{
config.LinkAgainstProject(solution.EnsureProjectExists(input));
}
else if ((input is C.CSDKModule) || (input is C.HeaderLibrary))
{
continue;
}
else if (input is OSXFramework)
{
throw new Bam.Core.Exception("Frameworks are not supported on Windows: {0}", input.ToString());
}
else
{
throw new Bam.Core.Exception("Don't know how to handle this buildable library module, {0}", input.ToString());
}
}
else
{
if (input is C.StaticLibrary)
{
// TODO: probably a simplification of the DLL codepath
throw new System.NotImplementedException();
}
else if (input is C.IDynamicLibrary)
{
// TODO: this might be able to shift out of the conditional
(sender.Tool as C.LinkerTool).ProcessLibraryDependency(sender as CModule, input as CModule);
}
else if ((input is C.CSDKModule) || (input is C.HeaderLibrary))
{
continue;
}
else if (input is OSXFramework)
{
throw new Bam.Core.Exception("Frameworks are not supported on Windows: {0}", input.ToString());
}
else
{
throw new Bam.Core.Exception("Don't know how to handle this prebuilt library module, {0}", input.ToString());
}
}
}
var linkerGroup = config.GetSettingsGroup(VSSolutionBuilder.VSSettingsGroup.ESettingsGroup.Linker);
(sender.Settings as VisualStudioProcessor.IConvertToProject).Convert(sender, linkerGroup);
// order only dependencies
foreach (var required in sender.Requirements)
{
if (null == required.MetaData)
{
continue;
}
var requiredProject = required.MetaData as VSSolutionBuilder.VSProject;
if (null != requiredProject)
{
config.RequiresProject(requiredProject);
}
}
// any non-C module projects should be order-only dependencies
foreach (var dependent in sender.Dependents)
{
if (null == dependent.MetaData)
{
continue;
}
if (dependent is C.CModule)
{
continue;
}
var dependentProject = dependent.MetaData as VSSolutionBuilder.VSProject;
if (null != dependentProject)
{
config.RequiresProject(dependentProject);
}
}
}
