IArchivingPolicy.Archive(
StaticLibrary sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString libraryPath,
System.Collections.ObjectModel.ReadOnlyCollection<Bam.Core.Module> objectFiles,
System.Collections.ObjectModel.ReadOnlyCollection<Bam.Core.Module> headers)
{
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(libraryPath);
foreach (var input in objectFiles)
{
rule.AddPrerequisite(input, C.ObjectFile.Key);
}
var tool = sender.Tool as Bam.Core.ICommandLineTool;
var command = new System.Text.StringBuilder();
command.AppendFormat("{0} {1} $^ {2}",
CommandLineProcessor.Processor.StringifyTool(tool),
commandLineArgs.ToString(' '),
CommandLineProcessor.Processor.TerminatingArgs(tool));
rule.AddShellCommand(command.ToString());
var libraryFileDir = System.IO.Path.GetDirectoryName(libraryPath.ToString());
meta.CommonMetaData.Directories.AddUnique(libraryFileDir);
meta.CommonMetaData.ExtendEnvironmentVariables(tool.EnvironmentVariables);
}
ITarPolicy.CreateTarBall(
TarBall sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool compiler,
Bam.Core.TokenizedString scriptPath,
Bam.Core.TokenizedString outputPath)
{
var tarPath = outputPath.ToString();
var tarDir = System.IO.Path.GetDirectoryName(tarPath);
if (!System.IO.Directory.Exists(tarDir))
{
System.IO.Directory.CreateDirectory(tarDir);
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
commandLine.Add("-c");
commandLine.Add("-v");
commandLine.Add("-T");
commandLine.Add(scriptPath.Parse());
commandLine.Add("-f");
commandLine.Add(tarPath);
CommandLineProcessor.Processor.Execute(context, compiler, commandLine);
}
ICompilationPolicy.Compile(
ObjectFile sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString objectFilePath,
Bam.Core.Module source)
{
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(objectFilePath);
rule.AddPrerequisite(source, C.SourceFile.Key);
var tool = sender.Tool as Bam.Core.ICommandLineTool;
var command = new System.Text.StringBuilder();
command.AppendFormat("{0} {1} $< {2}",
CommandLineProcessor.Processor.StringifyTool(tool),
commandLineArgs.ToString(' '),
CommandLineProcessor.Processor.TerminatingArgs(tool));
rule.AddShellCommand(command.ToString());
var objectFileDir = System.IO.Path.GetDirectoryName(objectFilePath.ToString());
meta.CommonMetaData.Directories.AddUnique(objectFileDir);
meta.CommonMetaData.ExtendEnvironmentVariables(tool.EnvironmentVariables);
}
public Configuration(
Bam.Core.EConfiguration config)
{
this.IsA = "XCBuildConfiguration";
this.Name = config.ToString();
this.Config = config;
this.PreBuildCommands = new Bam.Core.StringArray();
this.PostBuildCommands = new Bam.Core.StringArray();
this.BuildFiles = new Bam.Core.Array<BuildFile>();
}
string Bam.Core.ITool.Executable(
Bam.Core.BaseTarget baseTarget)
{
var module = Bam.Core.ModuleUtilities.GetModule(typeof(CodeGenTest2.CodeGeneratorTool), baseTarget);
if (null == module)
{
throw new Bam.Core.Exception("Unable to locate CodeGeneratorTool module in Graph for basetarget '{0}", baseTarget.ToString());
}
var outputLoc = (module as Bam.Core.BaseModule).Locations[CSharp.Assembly.OutputFile];
return outputLoc.GetSinglePath();
}
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 executableDir = System.IO.Path.GetDirectoryName(executablePath.ToString());
if (!System.IO.Directory.Exists(executableDir))
{
System.IO.Directory.CreateDirectory(executableDir);
}
var commandLine = new Bam.Core.StringArray();
// first object files
foreach (var input in objectFiles)
{
commandLine.Add(input.GeneratedPaths[C.ObjectFile.Key].ToString());
}
// then all options
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine);
}
IArchivingPolicy.Archive(
StaticLibrary sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString libraryPath,
System.Collections.ObjectModel.ReadOnlyCollection<Bam.Core.Module> objectFiles,
System.Collections.ObjectModel.ReadOnlyCollection<Bam.Core.Module> headers)
{
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
var libraryFileDir = System.IO.Path.GetDirectoryName(libraryPath.ToString());
if (!System.IO.Directory.Exists(libraryFileDir))
{
System.IO.Directory.CreateDirectory(libraryFileDir);
}
foreach (var input in objectFiles)
{
commandLine.Add(input.GeneratedPaths[C.ObjectFile.Key].ToString());
}
CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine);
}
IDiskImagePolicy.CreateDMG(
DiskImage sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool compiler,
Bam.Core.TokenizedString sourceFolderPath,
Bam.Core.TokenizedString outputPath)
{
var volumeName = sender.CreateTokenizedString("$(OutputName)").Parse();
var tempDiskImagePathName = System.IO.Path.GetTempPath() + System.Guid.NewGuid().ToString() + ".dmg"; // must have .dmg extension
var diskImagePathName = outputPath.ToString();
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
// create the disk image
{
var settings = sender.Settings as IDiskImageSettings;
var args = new Bam.Core.StringArray();
args.Add("create");
args.AddRange(commandLine);
args.Add("-srcfolder");
args.Add(System.String.Format("\"{0}\"", sourceFolderPath.ToString()));
args.Add("-size");
args.Add(settings.ImageSize);
args.Add("-fs");
args.Add("HFS+");
args.Add("-volname");
args.Add(System.String.Format("\"{0}\"", volumeName));
args.Add(tempDiskImagePathName);
CommandLineProcessor.Processor.Execute(context, compiler, args);
}
// mount disk image
{
var args = new Bam.Core.StringArray();
args.Add("attach");
args.AddRange(commandLine);
args.Add(tempDiskImagePathName);
CommandLineProcessor.Processor.Execute(context, compiler, args);
}
// TODO
/// do a copy
// unmount disk image
{
var args = new Bam.Core.StringArray();
args.Add("detach");
args.AddRange(commandLine);
args.Add(System.String.Format("\"/Volumes/{0}\"", volumeName));
CommandLineProcessor.Processor.Execute(context, compiler, args);
}
var dmgDir = System.IO.Path.GetDirectoryName(diskImagePathName);
if (!System.IO.Directory.Exists(dmgDir))
{
System.IO.Directory.CreateDirectory(dmgDir);
}
// hdiutil convert myimg.dmg -format UDZO -o myoutputimg.dmg
{
var args = new Bam.Core.StringArray();
args.Add("convert");
args.AddRange(commandLine);
args.Add(tempDiskImagePathName);
args.Add("-format");
args.Add("UDZO");
args.Add("-o");
args.Add(diskImagePathName);
CommandLineProcessor.Processor.Execute(context, compiler, args);
}
}
AddSetting(
string name,
Bam.Core.StringArray value,
string condition = null,
bool inheritExisting = false)
{
lock (this.Settings)
{
if (0 == value.Count)
{
return;
}
var linearized = value.ToString(';');
if (this.Settings.Any(item => item.Name == name && item.Condition == condition))
{
var settingOption = this.Settings.Where(item => item.Name == name && item.Condition == condition).First();
if (settingOption.Value.Contains(linearized))
{
return;
}
throw new Bam.Core.Exception("Cannot append {3}, to the option {0} as it already exists for condition {1}: {2}",
name,
condition,
this.Settings.Where(item => item.Name == name && item.Condition == condition).First().Value.ToString(),
linearized);
}
this.Settings.AddUnique(new VSSetting(name, inheritExisting ? System.String.Format("{0};%({1})", linearized, name) : linearized, condition));
}
}
public static void Execute(
Bam.Core.ExecutionContext context,
string executablePath,
Bam.Core.StringArray commandLineArguments,
string workingDirectory = null,
Bam.Core.StringArray inheritedEnvironmentVariables = null,
System.Collections.Generic.Dictionary<string, Bam.Core.TokenizedStringArray> addedEnvironmentVariables = null,
string useResponseFileOption = null)
{
var processStartInfo = new System.Diagnostics.ProcessStartInfo();
processStartInfo.FileName = executablePath;
processStartInfo.ErrorDialog = true;
if (null != workingDirectory)
{
processStartInfo.WorkingDirectory = workingDirectory;
}
var cachedEnvVars = new System.Collections.Generic.Dictionary<string, string>();
// first get the inherited environment variables from the system environment
if (null != inheritedEnvironmentVariables)
{
int envVarCount;
if (inheritedEnvironmentVariables.Count == 1 &&
inheritedEnvironmentVariables[0] == "*")
{
foreach (System.Collections.DictionaryEntry envVar in processStartInfo.EnvironmentVariables)
{
cachedEnvVars.Add(envVar.Key as string, envVar.Value as string);
}
}
else if (inheritedEnvironmentVariables.Count == 1 &&
System.Int32.TryParse(inheritedEnvironmentVariables[0], out envVarCount) &&
envVarCount < 0)
{
envVarCount += processStartInfo.EnvironmentVariables.Count;
foreach (var envVar in processStartInfo.EnvironmentVariables.Cast<System.Collections.DictionaryEntry>().OrderBy(item => item.Key))
{
cachedEnvVars.Add(envVar.Key as string, envVar.Value as string);
--envVarCount;
if (0 == envVarCount)
{
break;
}
}
}
else
{
foreach (var envVar in inheritedEnvironmentVariables)
{
if (!processStartInfo.EnvironmentVariables.ContainsKey(envVar))
{
Bam.Core.Log.Info("Environment variable '{0}' does not exist", envVar);
continue;
}
cachedEnvVars.Add(envVar, processStartInfo.EnvironmentVariables[envVar]);
}
}
}
processStartInfo.EnvironmentVariables.Clear();
if (null != inheritedEnvironmentVariables)
{
foreach (var envVar in cachedEnvVars)
{
processStartInfo.EnvironmentVariables[envVar.Key] = envVar.Value;
}
}
if (null != addedEnvironmentVariables)
{
foreach (var envVar in addedEnvironmentVariables)
{
processStartInfo.EnvironmentVariables[envVar.Key] = envVar.Value.ToString(System.IO.Path.PathSeparator);
}
}
processStartInfo.UseShellExecute = false;
processStartInfo.RedirectStandardOutput = true;
processStartInfo.RedirectStandardError = true;
processStartInfo.RedirectStandardInput = true;
var arguments = commandLineArguments.ToString(' ');
if (Bam.Core.OSUtilities.IsWindowsHosting)
{
//TODO: should this include the length of the executable path too?
if (arguments.Length >= 32767)
{
if (null == useResponseFileOption)
{
throw new Bam.Core.Exception("Command line is {0} characters long, but response files are not supported by the tool {1}", arguments.Length, executablePath);
}
var responseFilePath = System.IO.Path.GetTempFileName();
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(responseFilePath))
{
Bam.Core.Log.DebugMessage("Written response file {0} containing:\n{1}", responseFilePath, arguments);
// escape any back slashes
writer.WriteLine(arguments.Replace(@"\", @"\\"));
}
arguments = System.String.Format("{0}{1}", useResponseFileOption, responseFilePath);
}
}
processStartInfo.Arguments = arguments;
Bam.Core.Log.Detail("{0} {1}", processStartInfo.FileName, processStartInfo.Arguments);
// useful debugging of the command line processor
Bam.Core.Log.DebugMessage("Working directory: '{0}'", processStartInfo.WorkingDirectory);
if (processStartInfo.EnvironmentVariables.Count > 0)
{
Bam.Core.Log.DebugMessage("Environment variables:");
foreach (var envVar in processStartInfo.EnvironmentVariables.Cast<System.Collections.DictionaryEntry>().OrderBy(item => item.Key))
{
Bam.Core.Log.DebugMessage("\t{0} = {1}", envVar.Key, envVar.Value);
}
}
System.Diagnostics.Process process = null;
int exitCode = -1;
try
{
process = new System.Diagnostics.Process();
process.StartInfo = processStartInfo;
process.OutputDataReceived += new System.Diagnostics.DataReceivedEventHandler(context.OutputDataReceived);
process.ErrorDataReceived += new System.Diagnostics.DataReceivedEventHandler(context.ErrorDataReceived);
process.Start();
process.StandardInput.Close();
}
catch (System.ComponentModel.Win32Exception ex)
{
throw new Bam.Core.Exception("'{0}': process filename '{1}'", ex.Message, processStartInfo.FileName);
}
if (null != process)
{
process.BeginOutputReadLine();
process.BeginErrorReadLine();
// TODO: need to poll for an external cancel op?
// poll for the process to exit, as some processes seem to get stuck (hdiutil attach, for example)
while (!process.HasExited)
{
process.WaitForExit(2000);
}
// this additional WaitForExit appears to be needed in order to finish reading the output and error streams asynchronously
// without it, output is missing from a Native build when executed in many threads
process.WaitForExit();
exitCode = process.ExitCode;
//Bam.Core.Log.DebugMessage("Tool exit code: {0}", exitCode);
process.Close();
}
if (exitCode != 0)
{
var message = new System.Text.StringBuilder();
message.AppendFormat("Command failed: {0} {1}", processStartInfo.FileName, processStartInfo.Arguments);
message.AppendLine();
message.AppendFormat("Command exit code: {0}", exitCode);
message.AppendLine();
throw new Bam.Core.Exception(message.ToString());
}
}
DetermineSpecs(
Bam.Core.BaseTarget baseTarget,
Bam.Core.IToolset toolset)
{
// get version
string gccVersion = null;
{
var processStartInfo = new System.Diagnostics.ProcessStartInfo();
processStartInfo.FileName = toolset.Tool(typeof(C.ICompilerTool)).Executable(baseTarget);
processStartInfo.ErrorDialog = true;
processStartInfo.UseShellExecute = false;
processStartInfo.RedirectStandardOutput = true;
processStartInfo.Arguments = "-dumpversion";
System.Diagnostics.Process process = null;
try
{
process = System.Diagnostics.Process.Start(processStartInfo);
}
catch (System.ComponentModel.Win32Exception ex)
{
throw new Bam.Core.Exception("'{0}': process filename '{1}'", ex.Message, processStartInfo.FileName);
}
if (null == process)
{
throw new Bam.Core.Exception("Unable to execute '{0}'", processStartInfo.FileName);
}
gccVersion = process.StandardOutput.ReadToEnd();
process.WaitForExit();
gccVersion = gccVersion.Trim();
}
// get target
string gccTarget = null;
{
var processStartInfo = new System.Diagnostics.ProcessStartInfo();
processStartInfo.FileName = toolset.Tool(typeof(C.ICompilerTool)).Executable(baseTarget);
processStartInfo.ErrorDialog = true;
processStartInfo.UseShellExecute = false;
processStartInfo.RedirectStandardOutput = true;
processStartInfo.Arguments = "-dumpmachine";
System.Diagnostics.Process process = null;
try
{
process = System.Diagnostics.Process.Start(processStartInfo);
}
catch (System.ComponentModel.Win32Exception ex)
{
throw new Bam.Core.Exception("'{0}': process filename '{1}'", ex.Message, processStartInfo.FileName);
}
if (null == process)
{
throw new Bam.Core.Exception("Unable to execute '{0}'", processStartInfo.FileName);
}
gccTarget = process.StandardOutput.ReadToEnd();
process.WaitForExit();
gccTarget = gccTarget.Trim();
}
// get paths and targets
string pathPrefix = null;
string gxxIncludeDir = null;
string libDir = null;
var includePaths = new Bam.Core.StringArray();
{
var processStartInfo = new System.Diagnostics.ProcessStartInfo();
processStartInfo.FileName = toolset.Tool(typeof(C.ICompilerTool)).Executable(baseTarget);
processStartInfo.ErrorDialog = true;
processStartInfo.UseShellExecute = false;
processStartInfo.RedirectStandardOutput = true;
processStartInfo.RedirectStandardError = true;
processStartInfo.Arguments = "-v";
System.Diagnostics.Process process = null;
try
{
process = System.Diagnostics.Process.Start(processStartInfo);
}
catch (System.ComponentModel.Win32Exception ex)
{
throw new Bam.Core.Exception("'{0}': process filename '{1}'", ex.Message, processStartInfo.FileName);
}
if (null == process)
{
throw new Bam.Core.Exception("Unable to execute '{0}'", processStartInfo.FileName);
}
var details = process.StandardOutput.ReadToEnd();
process.WaitForExit();
var splitDetails = details.Split(new string[] { System.Environment.NewLine }, System.StringSplitOptions.None);
foreach (var detail in splitDetails)
{
const string configuredWith = "Configured with: ";
if (detail.StartsWith(configuredWith))
{
var configuredOptions = detail.Substring(configuredWith.Length);
var splitConfigureOptions = configuredOptions.Split(' ');
const string pathPrefixKey = "--prefix=";
const string gxxIncludeDirKey = "--with-gxx-include-dir=";
const string targetKey = "--target=";
const string libexecKey = "--libexecdir=";
const string slibDirKey = "--with-slibdir=";
foreach (var option in splitConfigureOptions)
{
if (option.StartsWith(pathPrefixKey))
{
pathPrefix = option.Substring(pathPrefixKey.Length).Trim(); ;
}
else if (option.StartsWith(gxxIncludeDirKey))
{
gxxIncludeDir = option.Substring(gxxIncludeDirKey.Length).Trim();
}
else if (option.StartsWith(targetKey))
{
gccTarget = option.Substring(targetKey.Length).Trim();
}
else if (option.StartsWith(libexecKey))
{
if (null != libDir)
{
throw new Bam.Core.Exception("lib dir already defined");
}
libDir = option.Substring(libexecKey.Length).Trim();
}
else if (option.StartsWith(slibDirKey))
{
if (null != libDir)
{
throw new Bam.Core.Exception("lib dir already defined");
}
libDir = option.Substring(slibDirKey.Length).Trim();
}
}
break;
}
}
if (null == gccTarget)
{
foreach (var detail in splitDetails)
{
var targetKey = "Target: ";
if (detail.StartsWith(targetKey))
{
gccTarget = detail.Substring(targetKey.Length).Trim();
}
}
}
if ((null != gxxIncludeDir) && !gxxIncludeDir.StartsWith(pathPrefix))
{
// remove any prefix directory separator so that Combine works
gxxIncludeDir = gxxIncludeDir.TrimStart(System.IO.Path.DirectorySeparatorChar);
gxxIncludeDir = System.IO.Path.Combine(pathPrefix, gxxIncludeDir);
}
// C include paths (http://gcc.gnu.org/onlinedocs/cpp/Search-Path.html)
includePaths.Add("/usr/local/include");
includePaths.Add("/usr/include");
// TODO: this looks like the targetIncludeFolder, and has been necessary
{
// this is for some Linux distributions
var path = System.String.Format("/usr/include/{0}", gccTarget);
if (System.IO.Directory.Exists(path))
{
includePaths.Add(path);
}
}
}
var gccDetails = new GccDetailData(gccVersion, includePaths, gxxIncludeDir, gccTarget, libDir);
gccDetailsForTarget[baseTarget] = gccDetails;
Bam.Core.Log.DebugMessage("Gcc version for target '{0}' is '{1}'", baseTarget.ToString(), gccDetails.Version);
Bam.Core.Log.DebugMessage("Gcc machine type for target '{0}' is '{1}'", baseTarget.ToString(), gccDetails.Target);
Bam.Core.Log.DebugMessage("Gxx include path for target '{0}' is '{1}'", baseTarget.ToString(), gccDetails.GxxIncludePath);
return gccDetails;
}
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);
}
void WindowsSDK_LibraryPaths(
Bam.Core.IModule module,
Bam.Core.Target target)
{
var linkerOptions = module.Options as C.ILinkerOptions;
if (null == linkerOptions)
{
return;
}
if (target.HasPlatform(Bam.Core.EPlatform.Win32))
{
linkerOptions.LibraryPaths.Add(lib32Path);
}
else if (target.HasPlatform(Bam.Core.EPlatform.Win64))
{
linkerOptions.LibraryPaths.Add(lib64Path);
}
else
{
throw new Bam.Core.Exception("Windows SDK is not supported on '{0}'; use win32 or win64", target.ToString());
}
}