void IMocGenerationPolicy.Moc(
MocGeneratedSource sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool mocCompiler,
Bam.Core.TokenizedString generatedMocSource,
C.HeaderFile source)
{
var encapsulating = sender.GetEncapsulatingReferencedModule();
var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta;
var target = workspace.EnsureTargetExists(encapsulating);
var configuration = target.GetConfiguration(encapsulating);
var output = generatedMocSource.Parse();
var sourcePath = source.InputPath.Parse();
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("[[ ! -d {0} ]] && mkdir -p {0}", System.IO.Path.GetDirectoryName(output)));
var args = new Bam.Core.StringArray();
args.Add(CommandLineProcessor.Processor.StringifyTool(mocCompiler));
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args);
args.Add(System.String.Format("-o {0}", output));
args.Add(sourcePath);
var moc_commandLine = args.ToString(' ');
commands.Add(System.String.Format("if [[ ! -e {0} || {1} -nt {0} ]]", output, sourcePath));
commands.Add("then");
commands.Add(System.String.Format("\techo {0}", moc_commandLine));
commands.Add(System.String.Format("\t{0}", moc_commandLine));
commands.Add("fi");
target.AddPreBuildCommands(commands, configuration);
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
var sourcePath = sender.SourcePath;
if (null == sender.Reference)
{
// the main file is not copied anywhere, as we copy required files around it where VS wrote the main file
// this is managed by the Collation class, querying the build mode for where publishing is relative to
// ignore any subdirectory on this module
return;
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
if (sender.SourceModule != null && sender.SourceModule.MetaData != null)
{
var destinationPath = sender.Macros["CopyDir"].Parse();
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("IF NOT EXIST {0} MKDIR {0}", destinationPath));
commands.Add(System.String.Format(@"{0} {1} $(OutputPath)$(TargetFileName) {2} {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
destinationPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
var project = sender.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.SourceModule);
config.AddPostBuildCommands(commands);
}
else
{
var commands = new Bam.Core.StringArray();
if (sender is CollatedDirectory)
{
// Windows XCOPY requires the directory name to be added to the destination, while Posix cp does not
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.CreateTokenizedString("$(0)/@ifnotempty($(CopiedFilename),$(CopiedFilename),@filename($(1)))", sender.SubDirectory, sourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.SubDirectory,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
var project = sender.Reference.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.Reference.SourceModule);
config.AddPostBuildCommands(commands);
}
}
void IRccGenerationPolicy.Rcc(
RccGeneratedSource sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool rccCompiler,
Bam.Core.TokenizedString generatedRccSource,
QRCFile source)
{
var encapsulating = sender.GetEncapsulatingReferencedModule();
var solution = Bam.Core.Graph.Instance.MetaData as VSSolutionBuilder.VSSolution;
var project = solution.EnsureProjectExists(encapsulating);
var config = project.GetConfiguration(encapsulating);
var output = generatedRccSource.Parse();
var args = new Bam.Core.StringArray();
args.Add(CommandLineProcessor.Processor.StringifyTool(rccCompiler));
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args);
args.Add(System.String.Format("-o {0}", output));
args.Add("%(FullPath)");
config.AddOtherFile(source);
var customBuild = config.GetSettingsGroup(VSSolutionBuilder.VSSettingsGroup.ESettingsGroup.CustomBuild, include: source.InputPath, uniqueToProject: true);
customBuild.AddSetting("Command", args.ToString(' '), condition: config.ConditionText);
customBuild.AddSetting("Message", System.String.Format("Rccing {0}", System.IO.Path.GetFileName(source.InputPath.Parse())), condition: config.ConditionText);
customBuild.AddSetting("Outputs", output, condition: config.ConditionText);
}
void IGeneratedSourcePolicy.GenerateSource(
GeneratedSourceModule sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool compiler,
Bam.Core.TokenizedString generatedFilePath)
{
var args = new Bam.Core.StringArray();
// TODO: change this to a configuration directory really
args.Add(Bam.Core.TokenizedString.Create("$(buildroot)", null).Parse());
args.Add("Generated");
CommandLineProcessor.Processor.Execute(context, compiler, args);
}
IChangeRPathPolicy.Change(
ChangeRPathModule sender,
Bam.Core.ExecutionContext context,
CollatedFile source,
string newRPath)
{
var commandLine = new Bam.Core.StringArray();
commandLine.Add("-r");
commandLine.Add(newRPath);
commandLine.Add(source.GeneratedPaths[CollatedObject.Key].Parse());
CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine);
}
IInstallNameToolPolicy.InstallName(
InstallNameModule sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString oldName,
Bam.Core.TokenizedString newName)
{
var originalModule = sender.Source.SourceModule;
if (originalModule == null)
{
return;
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
var commands = new Bam.Core.StringArray();
if (sender.Source.SourceModule != null && sender.Source.SourceModule.MetaData != null)
{
commands.Add(System.String.Format("{0} {1} {2} {3} {4} {5}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
oldName.Parse(),
newName.Parse(),
sender.Source.GeneratedPaths[CollatedObject.Key].Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
var target = sender.Source.SourceModule.MetaData as XcodeBuilder.Target;
var configuration = target.GetConfiguration(sender.Source.SourceModule);
target.AddPostBuildCommands(commands, configuration);
}
else
{
var destinationFolder = "$CONFIGURATION_BUILD_DIR";
if (sender.Source.Reference != null)
{
destinationFolder = "$CONFIGURATION_BUILD_DIR/$EXECUTABLE_FOLDER_PATH";
}
commands.Add(System.String.Format("{0} {1} {2} {3} {4}/{5} {6}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
oldName.Parse(),
newName.Parse(),
destinationFolder,
sender.Source.CreateTokenizedString("$(0)/@filename($(1))", sender.Source.SubDirectory, sender.Source.SourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
var target = sender.Source.Reference.SourceModule.MetaData as XcodeBuilder.Target;
var configuration = target.GetConfiguration(sender.Source.Reference.SourceModule);
target.AddPostBuildCommands(commands, configuration);
}
}
IInstallNameToolPolicy.InstallName(
InstallNameModule sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString oldName,
Bam.Core.TokenizedString newName)
{
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
commandLine.Add(newName.Parse());
commandLine.Add(sender.Source.GeneratedPaths[CollatedObject.Key].Parse());
CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine);
}
void IGeneratedSourcePolicy.GenerateSource(
GeneratedSourceModule sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool compiler,
Bam.Core.TokenizedString generatedFilePath)
{
var encapsulating = sender.GetEncapsulatingReferencedModule();
var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta;
var target = workspace.EnsureTargetExists(encapsulating);
var configuration = target.GetConfiguration(encapsulating);
var command = new System.Text.StringBuilder();
// recode the executable path for Xcode
var xcodePath = encapsulating.CreateTokenizedString("$(packagebuilddir)/$(config)").Parse();
xcodePath += "/" + System.IO.Path.GetFileName(compiler.Executable.Parse());
command.AppendFormat(xcodePath);
// TODO: change this to a configuration directory really
command.AppendFormat(" {0}", Bam.Core.TokenizedString.Create("$(buildroot)", null).Parse());
command.AppendFormat(" {0}", "Generated");
var commands = new Bam.Core.StringArray();
commands.Add(command.ToString());
target.AddPreBuildCommands(commands, configuration);
var compilerTarget = workspace.EnsureTargetExists(compiler as Bam.Core.Module);
target.Requires(compilerTarget);
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
if (sender is CollatedFile)
{
if (!(sender as CollatedFile).FailWhenSourceDoesNotExist)
{
var source = sender.SourcePath.Parse();
if (!System.IO.File.Exists(source))
{
Bam.Core.Log.Detail("File {0} cannot be copied as it does not exist. Ignoring.", source);
return;
}
}
}
var isSymLink = (sender is CollatedSymbolicLink);
var sourcePath = isSymLink ? sender.Macros["LinkTarget"] : sender.SourcePath;
var destinationPath = isSymLink ? sender.GeneratedPaths[CollatedObject.Key].Parse() : sender.Macros["CopyDir"].Parse();
if (!isSymLink)
{
// synchronize, so that multiple modules don't try to create the same directories simultaneously
lock ((sender.Reference != null) ? sender.Reference : sender)
{
if (!System.IO.Directory.Exists(destinationPath))
{
System.IO.Directory.CreateDirectory(destinationPath);
}
}
}
var copySource = sourcePath.ParseAndQuoteIfNecessary();
if (sender is CollatedDirectory && sender.Tool is CopyFilePosix & sender.Macros["CopiedFilename"].IsAliased)
{
copySource = System.String.Format("{0}/*", copySource);
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
commandLine.Add(copySource);
commandLine.Add(destinationPath);
CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine);
}
public object Build(
XmlUtilities.XmlModule moduleToBuild,
out bool success)
{
var node = moduleToBuild.OwningNode;
var xmlLocation = moduleToBuild.Locations[XmlUtilities.XmlModule.OutputFile];
var xmlPath = xmlLocation.GetSinglePath();
if (null == xmlPath)
{
throw new Bam.Core.Exception("XML output path was not set");
}
// dependency checking
{
var outputFiles = new Bam.Core.StringArray();
outputFiles.Add(xmlPath);
if (!RequiresBuilding(outputFiles, new Bam.Core.StringArray()))
{
Bam.Core.Log.DebugMessage("'{0}' is up-to-date", node.UniqueModuleName);
success = true;
return null;
}
}
Bam.Core.Log.Info("Writing XML file '{0}'", xmlPath);
// create all directories required
var dirsToCreate = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.Directory, Bam.Core.Location.EExists.WillExist);
foreach (var dir in dirsToCreate)
{
var dirPath = dir.GetSinglePath();
NativeBuilder.MakeDirectory(dirPath);
}
// serialize the XML to disk
var settings = new System.Xml.XmlWriterSettings();
settings.CheckCharacters = true;
settings.CloseOutput = true;
settings.ConformanceLevel = System.Xml.ConformanceLevel.Auto;
settings.Indent = true;
settings.IndentChars = new string(' ', 4);
settings.NewLineChars = "\n";
settings.NewLineHandling = System.Xml.NewLineHandling.None;
settings.NewLineOnAttributes = false;
settings.OmitXmlDeclaration = false;
settings.Encoding = new System.Text.UTF8Encoding(false); // do not write BOM
using (var xmlWriter = System.Xml.XmlWriter.Create(xmlPath, settings))
{
moduleToBuild.Document.WriteTo(xmlWriter);
xmlWriter.WriteWhitespace(settings.NewLineChars);
}
success = true;
return null;
}
IStripToolPolicy.Strip(
StripModule sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString originalPath,
Bam.Core.TokenizedString strippedPath)
{
var strippedDir = System.IO.Path.GetDirectoryName(strippedPath.Parse());
if (!System.IO.Directory.Exists(strippedDir))
{
System.IO.Directory.CreateDirectory(strippedDir);
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
commandLine.Add(originalPath.Parse());
commandLine.Add(System.String.Format("-o {0}", strippedPath.Parse()));
CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine);
}
public object Build(
XmlUtilities.XmlModule moduleToBuild,
out bool success)
{
var isPlist = moduleToBuild is XmlUtilities.OSXPlistModule;
var locationMap = moduleToBuild.Locations;
var outputDir = locationMap[XmlUtilities.OSXPlistModule.OutputDir];
var outputDirPath = outputDir.GetSingleRawPath();
if (!System.IO.Directory.Exists(outputDirPath))
{
System.IO.Directory.CreateDirectory(outputDirPath);
}
var xmlFileLoc = locationMap[XmlUtilities.XmlModule.OutputFile];
var xmlFilePath = xmlFileLoc.GetSingleRawPath();
// write a script that can be invoked by the MakeFile to generate the XML file
var shellScriptLeafName = isPlist ? "writePList.py" : "writeXMLFile.py";
var shellScriptLoc = Bam.Core.FileLocation.Get(outputDir, shellScriptLeafName, Bam.Core.Location.EExists.WillExist);
var shellScriptPath = shellScriptLoc.GetSingleRawPath();
XmlUtilities.XmlDocumentToPythonScript.Write(moduleToBuild.Document, shellScriptPath, xmlFilePath);
var node = moduleToBuild.OwningNode;
var makeFile = new MakeFile(node, this.topLevelMakeFilePath);
var dirsToCreate = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.Directory, Bam.Core.Location.EExists.WillExist);
var recipe = new Bam.Core.StringArray();
recipe.Add(System.String.Format("$(shell python {0})", shellScriptPath));
var rule = new MakeFileRule(
moduleToBuild,
XmlUtilities.XmlModule.OutputFile,
node.UniqueModuleName,
dirsToCreate,
null,
null,
recipe);
rule.OutputLocationKeys = new Bam.Core.Array<Bam.Core.LocationKey>(XmlUtilities.XmlModule.OutputFile);
makeFile.RuleArray.Add(rule);
var makeFilePath = MakeFileBuilder.GetMakeFilePathName(node);
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(makeFilePath));
using (var makeFileWriter = new System.IO.StreamWriter(makeFilePath))
{
makeFile.Write(makeFileWriter);
}
var exportedTargets = makeFile.ExportedTargets;
var exportedVariables = makeFile.ExportedVariables;
var returnData = new MakeFileData(makeFilePath, exportedTargets, exportedVariables, null);
success = true;
return returnData;
}
INSISPolicy.CreateInstaller(
NSISInstaller sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool compiler,
Bam.Core.TokenizedString scriptPath)
{
var args = new Bam.Core.StringArray();
args.Add(scriptPath.Parse());
CommandLineProcessor.Processor.Execute(context, compiler, args);
}
void IMocGenerationPolicy.Moc(
MocGeneratedSource sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool mocCompiler,
Bam.Core.TokenizedString generatedMocSource,
C.HeaderFile source)
{
var mocOutputPath = generatedMocSource.Parse();
var mocOutputDir = System.IO.Path.GetDirectoryName(mocOutputPath);
if (!System.IO.Directory.Exists(mocOutputDir))
{
System.IO.Directory.CreateDirectory(mocOutputDir);
}
var args = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args);
args.Add(System.String.Format("-o {0}", mocOutputPath));
args.Add(source.InputPath.Parse());
CommandLineProcessor.Processor.Execute(context, mocCompiler, args);
}
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);
}
void IGeneratedSourcePolicy.GenerateSource(
GeneratedSourceModule sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool compiler,
Bam.Core.TokenizedString generatedFilePath)
{
var meta = new MakeFileBuilder.MakeFileMeta(sender);
var rule = meta.AddRule();
rule.AddTarget(generatedFilePath);
var buildTool = (compiler as Bam.Core.Module).MetaData as MakeFileBuilder.MakeFileMeta;
rule.AddOrderOnlyDependency(System.String.Format("$({0})", buildTool.Rules[0].Targets[0].VariableName));
var commandLineArgs = new Bam.Core.StringArray();
// TODO: change this to a configuration directory really
commandLineArgs.Add(Bam.Core.TokenizedString.Create("$(buildroot)", null).Parse());
commandLineArgs.Add("Generated");
var command = new System.Text.StringBuilder();
command.AppendFormat("{0} {1} $^", compiler.Executable.ParseAndQuoteIfNecessary(), commandLineArgs.ToString(' '));
rule.AddShellCommand(command.ToString());
}
void IRccGenerationPolicy.Rcc(
RccGeneratedSource sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool rccCompiler,
Bam.Core.TokenizedString generatedRccSource,
QRCFile source)
{
var encapsulating = sender.GetEncapsulatingReferencedModule();
var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta;
var target = workspace.EnsureTargetExists(encapsulating);
var configuration = target.GetConfiguration(encapsulating);
var output = generatedRccSource.Parse();
var sourcePath = source.InputPath.Parse();
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("[[ ! -d {0} ]] && mkdir -p {0}", System.IO.Path.GetDirectoryName(output)));
var args = new Bam.Core.StringArray();
args.Add(CommandLineProcessor.Processor.StringifyTool(rccCompiler));
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args);
args.Add(System.String.Format("-o {0}", output));
args.Add(sourcePath);
target.EnsureFileOfTypeExists(source.InputPath, XcodeBuilder.FileReference.EFileType.TextFile,
relativePath: target.Project.GetRelativePathToProject(source.InputPath),
explicitType: false);
var rcc_commandLine = args.ToString(' ');
commands.Add(System.String.Format("if [[ ! -e {0} || {1} -nt {0} ]]", output, sourcePath));
commands.Add("then");
commands.Add(System.String.Format("\techo {0}", rcc_commandLine));
commands.Add(System.String.Format("\t{0}", rcc_commandLine));
commands.Add("fi");
target.AddPreBuildCommands(commands, configuration);
}
void IRccGenerationPolicy.Rcc(
RccGeneratedSource sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool rccCompiler,
Bam.Core.TokenizedString generatedRccSource,
QRCFile source)
{
var meta = new MakeFileBuilder.MakeFileMeta(sender);
var rule = meta.AddRule();
rule.AddTarget(generatedRccSource);
rule.AddPrerequisite(source, C.HeaderFile.Key);
var rccOutputPath = generatedRccSource.Parse();
var rccOutputDir = System.IO.Path.GetDirectoryName(rccOutputPath);
var args = new Bam.Core.StringArray();
args.Add(CommandLineProcessor.Processor.StringifyTool(rccCompiler));
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args);
args.Add(System.String.Format("-o {0}", rccOutputPath));
args.Add(source.InputPath.Parse());
rule.AddShellCommand(args.ToString(' '));
meta.CommonMetaData.Directories.AddUnique(rccOutputDir);
}
public object Build(
XmlUtilities.TextFileModule moduleToBuild,
out bool success)
{
var node = moduleToBuild.OwningNode;
var outputLoc = moduleToBuild.Locations[XmlUtilities.TextFileModule.OutputFile];
var outputPath = outputLoc.GetSinglePath();
if (null == outputPath)
{
throw new Bam.Core.Exception("Text output path was not set");
}
// dependency checking
{
var outputFiles = new Bam.Core.StringArray();
outputFiles.Add(outputPath);
if (!RequiresBuilding(outputFiles, new Bam.Core.StringArray()))
{
Bam.Core.Log.DebugMessage("'{0}' is up-to-date", node.UniqueModuleName);
success = true;
return null;
}
}
Bam.Core.Log.Info("Writing text file '{0}'", outputPath);
// create all directories required
var dirsToCreate = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.Directory, Bam.Core.Location.EExists.WillExist);
foreach (var dir in dirsToCreate)
{
var dirPath = dir.GetSinglePath();
NativeBuilder.MakeDirectory(dirPath);
}
using (var writer = new System.IO.StreamWriter(outputPath, false, System.Text.Encoding.ASCII))
{
var content = moduleToBuild.Content.ToString();
writer.Write(content);
}
success = true;
return null;
}
IChangeRPathPolicy.Change(
ChangeRPathModule sender,
Bam.Core.ExecutionContext context,
CollatedFile source,
string newRPath)
{
// add another shell command to the rule for copying the file
var meta = source.MetaData as MakeFileBuilder.MakeFileMeta;
var rule = meta.Rules[0];
var commandLine = new Bam.Core.StringArray();
commandLine.Add("-r");
rule.AddShellCommand(System.String.Format(@"{0} {1} {2} $@ {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
newRPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
Convert(
this C.ICOnlyCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.LanguageStandard.HasValue)
{
switch (settings.LanguageStandard.Value)
{
case C.ELanguageStandard.C89:
break;
case C.ELanguageStandard.C99:
commandLine.Add("-std=c99");
break;
default:
throw new Bam.Core.Exception("Invalid C language standard, {0}", settings.LanguageStandard.Value.ToString());
}
}
}
IChangeRPathPolicy.Change(
ChangeRPathModule sender,
Bam.Core.ExecutionContext context,
CollatedFile source,
string newRPath)
{
// add another shell command to the rule for copying the file
var meta = source.MetaData as MakeFileBuilder.MakeFileMeta;
var rule = meta.Rules[0];
var commandLine = new Bam.Core.StringArray();
commandLine.Add("-r");
rule.AddShellCommand(System.String.Format(@"{0} {1} {2} $@ {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
newRPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
IAssemblerPolicy.Assemble(
AssembledObjectFile sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString objectFilePath,
Bam.Core.Module source)
{
if (!sender.PerformCompilation)
{
return;
}
var objectFileDir = System.IO.Path.GetDirectoryName(objectFilePath.ToString());
Bam.Core.IOWrapper.CreateDirectoryIfNotExists(objectFileDir);
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
commandLine.Add(source.GeneratedPaths[SourceFile.Key].ToStringQuoteIfNecessary());
CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine);
}
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 executableDir = System.IO.Path.GetDirectoryName(executablePath.ToString());
Bam.Core.IOWrapper.CreateDirectoryIfNotExists(executableDir);
var commandLine = new Bam.Core.StringArray();
// first object files
foreach (var input in objectFiles)
{
if (!(input as C.ObjectFileBase).PerformCompilation)
{
continue;
}
commandLine.Add(input.GeneratedPaths[C.ObjectFile.Key].ToStringQuoteIfNecessary());
}
// 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);
}
Convert(
this VisualCCommon.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.NoLogo.HasValue)
{
if (settings.NoLogo.Value)
{
commandLine.Add("-nologo");
}
}
if (settings.RuntimeLibrary.HasValue)
{
switch (settings.RuntimeLibrary.Value)
{
case ERuntimeLibrary.MultiThreaded:
commandLine.Add("-MT");
break;
case ERuntimeLibrary.MultiThreadedDebug:
commandLine.Add("-MTd");
break;
case ERuntimeLibrary.MultiThreadedDebugDLL:
commandLine.Add("-MDd");
break;
case ERuntimeLibrary.MultiThreadedDLL:
commandLine.Add("-MD");
break;
default:
throw new Bam.Core.Exception("Unknown runtime library, {0}", settings.RuntimeLibrary.Value.ToString());
}
}
if (settings.WarningLevel.HasValue)
{
commandLine.Add(System.String.Format("-W{0}", settings.WarningLevel.Value.ToString("D")));
}
}
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);
Bam.Core.IOWrapper.CreateDirectoryIfNotExists(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);
}
Convert(
this C.ICxxOnlyCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.ExceptionHandler.HasValue)
{
switch (settings.ExceptionHandler.Value)
{
case C.Cxx.EExceptionHandler.Disabled:
commandLine.Add("-fno-exceptions");
break;
case C.Cxx.EExceptionHandler.Asynchronous:
case C.Cxx.EExceptionHandler.Synchronous:
commandLine.Add("-fexceptions");
break;
default:
throw new Bam.Core.Exception("Unrecognized exception handler option, {0}", settings.ExceptionHandler.Value.ToString());
}
}
if (settings.LanguageStandard.HasValue)
{
switch (settings.LanguageStandard.Value)
{
case C.Cxx.ELanguageStandard.Cxx98:
commandLine.Add("-std=c++98");
break;
case C.Cxx.ELanguageStandard.GnuCxx98:
commandLine.Add("-std=gnu++98");
break;
case C.Cxx.ELanguageStandard.Cxx11:
commandLine.Add("-std=c++11");
break;
default:
throw new Bam.Core.Exception("Invalid C++ language standard, {0}", settings.LanguageStandard.Value.ToString());
}
}
if (settings.StandardLibrary.HasValue)
{
switch (settings.StandardLibrary.Value)
{
case C.Cxx.EStandardLibrary.NotSet:
break;
case C.Cxx.EStandardLibrary.libstdcxx:
commandLine.Add("-stdlib=libstdc++");
break;
case C.Cxx.EStandardLibrary.libcxx:
commandLine.Add("-stdlib=libc++");
break;
default:
throw new Bam.Core.Exception("Invalid C++ standard library {0}", settings.StandardLibrary.Value.ToString());
}
}
}
Convert(
this ClangCommon.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.AllWarnings.HasValue)
{
if (settings.AllWarnings.Value)
{
commandLine.Add("-Wall");
}
else
{
commandLine.Add("-Wno-all");
}
}
if (settings.ExtraWarnings.HasValue)
{
if (settings.ExtraWarnings.Value)
{
commandLine.Add("-Wextra");
}
else
{
commandLine.Add("-Wno-extra");
}
}
if (settings.Pedantic.HasValue)
{
if (settings.Pedantic.Value)
{
commandLine.Add("-Wpedantic");
}
else
{
commandLine.Add("-Wno-pedantic");
}
}
if (settings.Visibility.HasValue)
{
switch (settings.Visibility.Value)
{
case EVisibility.Default:
commandLine.Add("-fvisibility=default");
break;
case EVisibility.Hidden:
commandLine.Add("-fvisibility=hidden");
break;
case EVisibility.Internal:
commandLine.Add("-fvisibility=internal");
break;
case EVisibility.Protected:
commandLine.Add("-fvisibility=protected");
break;
default:
throw new Bam.Core.Exception("Unrecognized visibility, {0}", settings.Visibility.Value.ToString());
}
}
if (settings.StrictAliasing.HasValue)
{
if (settings.StrictAliasing.Value)
{
commandLine.Add("-fstrict-aliasing");
}
else
{
commandLine.Add("-fno-strict-aliasing");
}
}
if (settings.Optimization.HasValue)
{
var common_optimization = (settings as C.ICommonCompilerSettings).Optimization;
if (common_optimization.HasValue && common_optimization.Value != C.EOptimization.Custom)
{
throw new Bam.Core.Exception("Compiler specific optimizations can only be set when the common optimization is C.EOptimization.Custom");
}
switch (settings.Optimization.Value)
{
case EOptimization.O1:
commandLine.Add("-O1");
break;
case EOptimization.O3:
commandLine.Add("-O3");
break;
case EOptimization.Ofast:
commandLine.Add("-Ofast");
break;
default:
throw new Bam.Core.Exception("Unrecognized Clang optimization, {0}", settings.Optimization.Value.ToString());
}
}
}
Convert(
this C.ICxxOnlyCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.ExceptionHandler.HasValue)
{
switch (settings.ExceptionHandler.Value)
{
case C.Cxx.EExceptionHandler.Disabled:
commandLine.Add("-fno-exceptions");
break;
case C.Cxx.EExceptionHandler.Asynchronous:
case C.Cxx.EExceptionHandler.Synchronous:
commandLine.Add("-fexceptions");
break;
default:
throw new Bam.Core.Exception("Unrecognized exception handler option, {0}", settings.ExceptionHandler.Value.ToString());
}
}
if (settings.EnableRunTimeTypeInfo.HasValue)
{
if (settings.EnableRunTimeTypeInfo.Value)
{
commandLine.Add("-frtti");
}
else
{
commandLine.Add("-fno-rtti");
}
}
if (settings.LanguageStandard.HasValue)
{
switch (settings.LanguageStandard.Value)
{
case C.Cxx.ELanguageStandard.Cxx98:
commandLine.Add("-std=c++98");
break;
case C.Cxx.ELanguageStandard.GnuCxx98:
commandLine.Add("-std=gnu++98");
break;
case C.Cxx.ELanguageStandard.Cxx03:
commandLine.Add("-std=c++03");
break;
case C.Cxx.ELanguageStandard.GnuCxx03:
commandLine.Add("-std=gnu++03");
break;
case C.Cxx.ELanguageStandard.Cxx11:
commandLine.Add("-std=c++11");
break;
case C.Cxx.ELanguageStandard.GnuCxx11:
commandLine.Add("-std=gnu++11");
break;
case C.Cxx.ELanguageStandard.Cxx14:
commandLine.Add("-std=c++14");
break;
case C.Cxx.ELanguageStandard.GnuCxx14:
commandLine.Add("-std=gnu++14");
break;
default:
throw new Bam.Core.Exception("Invalid C++ language standard, {0}", settings.LanguageStandard.Value.ToString());
}
}
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
var sourcePath = sender.SourcePath;
if (null == sender.Reference)
{
// the main file is not copied anywhere, as we copy required files around it where VS wrote the main file
// this is managed by the Collation class, querying the build mode for where publishing is relative to
// ignore any subdirectory on this module
return;
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
if (sender.SourceModule != null && sender.SourceModule.MetaData != null)
{
var destinationPath = sender.Macros["CopyDir"].Parse();
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("IF NOT EXIST {0} MKDIR {0}", destinationPath));
commands.Add(System.String.Format(@"{0} {1} $(OutputPath)$(TargetFileName) {2} {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
destinationPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
var project = sender.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.SourceModule);
config.AddPostBuildCommands(commands);
}
else
{
var commands = new Bam.Core.StringArray();
if (sender is CollatedDirectory)
{
// Windows XCOPY requires the directory name to be added to the destination, while Posix cp does not
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.CreateTokenizedString("$(0)/@ifnotempty($(CopiedFilename),$(CopiedFilename),@filename($(1)))", sender.SubDirectory, sourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.SubDirectory,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
var project = sender.Reference.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.Reference.SourceModule);
config.AddPostBuildCommands(commands);
}
}
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);
}
public object Build(
CodeGenTest2.CodeGenModule moduleToBuild,
out System.Boolean success)
{
var codeGenModuleModule = moduleToBuild as Bam.Core.BaseModule;
var node = codeGenModuleModule.OwningNode;
var target = node.Target;
var codeGenModuleOptions = codeGenModuleModule.Options;
var toolOptions = codeGenModuleOptions as CodeGenTest2.CodeGenOptionCollection;
var tool = target.Toolset.Tool(typeof(CodeGenTest2.ICodeGenTool));
var toolExePath = tool.Executable((Bam.Core.BaseTarget)target);
var inputFiles = new Bam.Core.StringArray();
inputFiles.Add(toolExePath);
// at this point, we know the node outputs need building
// create all directories required
var dirsToCreate = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.Directory, Bam.Core.Location.EExists.WillExist);
var commandLineBuilder = new Bam.Core.StringArray();
if (toolOptions is CommandLineProcessor.ICommandLineSupport)
{
var commandLineOption = toolOptions as CommandLineProcessor.ICommandLineSupport;
commandLineOption.ToCommandLineArguments(commandLineBuilder, target, null);
}
else
{
throw new Bam.Core.Exception("Moc options does not support command line translation");
}
var recipes = new Bam.Core.StringArray();
if (toolExePath.Contains(" "))
{
recipes.Add("\"" + toolExePath + "\" " + commandLineBuilder.ToString());
}
else
{
recipes.Add(toolExePath + " " + commandLineBuilder.ToString());
}
var makeFilePath = MakeFileBuilder.GetMakeFilePathName(node);
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(makeFilePath));
Bam.Core.Log.DebugMessage("Makefile : '{0}'", makeFilePath);
var makeFile = new MakeFile(node, this.topLevelMakeFilePath);
var rule = new MakeFileRule(
moduleToBuild,
CodeGenTest2.CodeGenModule.OutputFile,
node.UniqueModuleName,
dirsToCreate,
null,
inputFiles,
recipes);
rule.OutputLocationKeys = new Bam.Core.Array<Bam.Core.LocationKey>(CodeGenTest2.CodeGenModule.OutputFile);
makeFile.RuleArray.Add(rule);
using (var makeFileWriter = new System.IO.StreamWriter(makeFilePath))
{
makeFile.Write(makeFileWriter);
}
System.Collections.Generic.Dictionary<string, Bam.Core.StringArray> environment = null;
if (tool is Bam.Core.IToolEnvironmentVariables)
{
environment = (tool as Bam.Core.IToolEnvironmentVariables).Variables((Bam.Core.BaseTarget)target);
}
var returnData = new MakeFileData(makeFilePath, makeFile.ExportedTargets, makeFile.ExportedVariables, environment);
success = true;
return returnData;
}
Convert(
this C.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
var module = (settings as Bam.Core.Settings).Module;
if (settings.DebugSymbols.HasValue)
{
if (settings.DebugSymbols.Value)
{
commandLine.Add("-Z7");
}
}
foreach (var warning in settings.DisableWarnings)
{
commandLine.Add(System.String.Format("-wd{0}", warning));
}
foreach (var path in settings.IncludePaths)
{
commandLine.Add(System.String.Format("-I{0}", path.ParseAndQuoteIfNecessary()));
}
if (settings.OmitFramePointer.HasValue)
{
commandLine.Add(settings.OmitFramePointer.Value ? "-Oy" : "-Oy-");
}
if (settings.Optimization.HasValue)
{
switch (settings.Optimization.Value)
{
case C.EOptimization.Off:
commandLine.Add("-Od");
break;
case C.EOptimization.Size:
commandLine.Add("-Os");
break;
case C.EOptimization.Speed:
commandLine.Add("-O1");
break;
case C.EOptimization.Full:
commandLine.Add("-Ox");
break;
default:
throw new Bam.Core.Exception("Unknown optimization level, {0}", settings.Optimization.Value.ToString());
}
}
foreach (var define in settings.PreprocessorDefines)
{
if (System.String.IsNullOrEmpty(define.Value))
{
commandLine.Add(System.String.Format("-D{0}", define.Key));
}
else
{
var value = define.Value;
if (value.Contains("\""))
{
value = value.Replace("\"", "\\\"");
}
commandLine.Add(System.String.Format("-D{0}={1}", define.Key, value));
}
}
foreach (var undefine in settings.PreprocessorUndefines)
{
commandLine.Add(System.String.Format("-U{0}", undefine));
}
foreach (var path in settings.SystemIncludePaths)
{
commandLine.Add(System.String.Format("-I{0}", path.ParseAndQuoteIfNecessary()));
}
if (settings.TargetLanguage.HasValue)
{
switch (settings.TargetLanguage.Value)
{
case C.ETargetLanguage.C:
commandLine.Add("-TC");
break;
case C.ETargetLanguage.Cxx:
commandLine.Add("-TP");
break;
default:
throw new Bam.Core.Exception("Unsupported target language, {0}", settings.TargetLanguage.Value.ToString());
}
}
if (settings.WarningsAsErrors.HasValue)
{
if (settings.WarningsAsErrors.Value)
{
commandLine.Add("-WX");
}
}
if (settings.OutputType.HasValue)
{
switch (settings.OutputType.Value)
{
case C.ECompilerOutput.CompileOnly:
commandLine.Add(System.String.Format("-c -Fo{0}", module.GeneratedPaths[C.ObjectFile.Key].ToString()));
break;
case C.ECompilerOutput.Preprocess:
commandLine.Add(System.String.Format("-E -Fo{0}", module.GeneratedPaths[C.ObjectFile.Key].ToString()));
break;
default:
throw new Bam.Core.Exception("Unknown output type, {0}", settings.OutputType.Value.ToString());
}
}
}
public static void Execute(
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool tool,
Bam.Core.StringArray commandLine,
string workingDirectory = null)
{
var commandLineArgs = new Bam.Core.StringArray();
if (tool.InitialArguments != null)
{
foreach (var arg in tool.InitialArguments)
{
commandLineArgs.Add(arg.Parse());
}
}
commandLineArgs.AddRange(commandLine);
if (null != tool.TerminatingArguments)
{
foreach (var arg in tool.TerminatingArguments)
{
commandLineArgs.Add(arg.Parse());
}
}
Execute(
context,
tool.Executable.Parse(),
commandLineArgs,
workingDirectory: workingDirectory,
inheritedEnvironmentVariables: tool.InheritedEnvironmentVariables,
addedEnvironmentVariables: tool.EnvironmentVariables,
useResponseFileOption: tool.UseResponseFileOption);
}
Convert(
this C.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
var module = (settings as Bam.Core.Settings).Module;
if (settings.DebugSymbols.HasValue)
{
if (settings.DebugSymbols.Value)
{
commandLine.Add("-Z7");
}
}
foreach (var warning in settings.DisableWarnings)
{
commandLine.Add(System.String.Format("-wd{0}", warning));
}
foreach (var path in settings.IncludePaths.ToEnumerableWithoutDuplicates())
{
commandLine.Add(System.String.Format("-I{0}", path.ToStringQuoteIfNecessary()));
}
if (settings.Optimization.HasValue)
{
switch (settings.Optimization.Value)
{
case C.EOptimization.Off:
commandLine.Add("-Od");
break;
case C.EOptimization.Size:
commandLine.Add("-O1");
break;
case C.EOptimization.Speed:
commandLine.Add("-O2");
break;
case C.EOptimization.Custom:
// do nothing - deferred to compiler specific optimization settings
break;
default:
throw new Bam.Core.Exception("Unknown optimization level, {0}", settings.Optimization.Value.ToString());
}
}
if (settings.OmitFramePointer.HasValue)
{
commandLine.Add(settings.OmitFramePointer.Value ? "-Oy" : "-Oy-");
}
foreach (var define in settings.PreprocessorDefines)
{
if (null == define.Value)
{
commandLine.Add(System.String.Format("-D{0}", define.Key));
}
else
{
var defineValue = define.Value.ToString();
if (defineValue.Contains("\""))
{
defineValue = defineValue.Replace("\"", "\\\"");
}
defineValue = Bam.Core.IOWrapper.EncloseSpaceContainingPathWithDoubleQuotes(defineValue);
commandLine.Add(System.String.Format("-D{0}={1}", define.Key, defineValue));
}
}
foreach (var undefine in settings.PreprocessorUndefines)
{
commandLine.Add(System.String.Format("-U{0}", undefine));
}
foreach (var path in settings.SystemIncludePaths.ToEnumerableWithoutDuplicates())
{
commandLine.Add(System.String.Format("-I{0}", path.ToStringQuoteIfNecessary()));
}
if (settings.TargetLanguage.HasValue)
{
switch (settings.TargetLanguage.Value)
{
case C.ETargetLanguage.C:
commandLine.Add("-TC");
break;
case C.ETargetLanguage.Cxx:
commandLine.Add("-TP");
break;
default:
throw new Bam.Core.Exception("Unsupported target language, {0}", settings.TargetLanguage.Value.ToString());
}
}
if (settings.WarningsAsErrors.HasValue)
{
if (settings.WarningsAsErrors.Value)
{
commandLine.Add("-WX");
}
else
{
commandLine.Add("-WX-");
}
}
if (settings.OutputType.HasValue)
{
switch (settings.OutputType.Value)
{
case C.ECompilerOutput.CompileOnly:
commandLine.Add(System.String.Format("-c -Fo{0}", module.GeneratedPaths[C.ObjectFile.Key].ToStringQuoteIfNecessary()));
break;
case C.ECompilerOutput.Preprocess:
commandLine.Add(System.String.Format("-E -Fo{0}", module.GeneratedPaths[C.ObjectFile.Key].ToStringQuoteIfNecessary()));
break;
default:
throw new Bam.Core.Exception("Unknown output type, {0}", settings.OutputType.Value.ToString());
}
}
foreach (var header in settings.NamedHeaders)
{
commandLine.Add(System.String.Format("-FI{0}", header));
}
}
Evaluate()
{
this.ReasonToExecute = null;
var graph = Bam.Core.Graph.Instance;
var factory = graph.MetaData as System.Threading.Tasks.TaskFactory;
this.EvaluationTask = factory.StartNew(() =>
{
// does the object file exist?
var objectFilePath = this.GeneratedPaths[Key].Parse();
if (!System.IO.File.Exists(objectFilePath))
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.FileDoesNotExist(this.GeneratedPaths[Key]);
return;
}
var objectFileWriteTime = System.IO.File.GetLastWriteTime(objectFilePath);
// has the source file been evaluated to be rebuilt?
if ((this as IRequiresSourceModule).Source.ReasonToExecute != null)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(this.GeneratedPaths[Key], this.InputPath);
return;
}
// is the source file newer than the object file?
var sourcePath = this.InputPath.Parse();
var sourceWriteTime = System.IO.File.GetLastWriteTime(sourcePath);
if (sourceWriteTime > objectFileWriteTime)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(this.GeneratedPaths[Key], this.InputPath);
return;
}
if (this is WinResource)
{
return;
}
var includeSearchPaths = (this.Settings as C.ICommonCompilerSettings).IncludePaths;
var filesToSearch = new System.Collections.Generic.Queue <string>();
filesToSearch.Enqueue(sourcePath);
var headerPathsFound = new Bam.Core.StringArray();
while (filesToSearch.Count > 0)
{
var fileToSearch = filesToSearch.Dequeue();
string fileContents = null;
using (System.IO.TextReader reader = new System.IO.StreamReader(fileToSearch))
{
fileContents = reader.ReadToEnd();
}
var matches = System.Text.RegularExpressions.Regex.Matches(
fileContents,
"^\\s*#include \"(.*)\"",
System.Text.RegularExpressions.RegexOptions.Multiline);
if (0 == matches.Count)
{
// no #includes
return;
}
foreach (System.Text.RegularExpressions.Match match in matches)
{
bool exists = false;
// search for the file on the include paths the compiler uses
foreach (var includePath in includeSearchPaths)
{
try
{
var potentialPath = System.IO.Path.Combine(includePath.Parse(), match.Groups[1].Value);
if (!System.IO.File.Exists(potentialPath))
{
continue;
}
potentialPath = System.IO.Path.GetFullPath(potentialPath);
var headerWriteTime = System.IO.File.GetLastWriteTime(potentialPath);
// early out - header is newer than generated object file
if (headerWriteTime > objectFileWriteTime)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(
this.GeneratedPaths[Key],
Bam.Core.TokenizedString.CreateVerbatim(potentialPath));
return;
}
if (!headerPathsFound.Contains(potentialPath))
{
headerPathsFound.Add(potentialPath);
filesToSearch.Enqueue(potentialPath);
}
exists = true;
break;
}
catch (System.Exception ex)
{
Bam.Core.Log.MessageAll("IncludeDependency Exception: Cannot locate '{0}' on '{1}' due to {2}", match.Groups[1].Value, includePath, ex.Message);
}
}
if (!exists)
{
#if false
Bam.Core.Log.DebugMessage("***** Could not locate '{0}' on any include search path, included from {1}:\n{2}",
match.Groups[1],
fileToSearch,
entry.includePaths.ToString('\n'));
#endif
}
}
}
return;
});
}
Convert(
this C.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.Bits.HasValue)
{
switch (settings.Bits.Value)
{
case C.EBit.SixtyFour:
commandLine.Add("-arch x86_64");
break;
case C.EBit.ThirtyTwo:
commandLine.Add("-arch i386");
break;
default:
throw new Bam.Core.Exception("Unknown bit depth, {0}", settings.Bits.Value);
}
}
if (settings.DebugSymbols.HasValue)
{
if (settings.DebugSymbols.Value)
{
commandLine.Add("-g");
}
}
foreach (var warning in settings.DisableWarnings)
{
commandLine.Add(System.String.Format("-Wno-{0}", warning));
}
foreach (var path in settings.IncludePaths.ToEnumerableWithoutDuplicates())
{
var quoted_path = path.ToStringQuoteIfNecessary();
if (Bam.Core.Graph.Instance.Mode == "Xcode")
{
quoted_path = quoted_path.Replace("\"", "\\\"");
}
commandLine.Add(System.String.Format("-I{0}", quoted_path));
}
if (settings.Optimization.HasValue)
{
switch (settings.Optimization.Value)
{
case C.EOptimization.Off:
commandLine.Add("-O0");
break;
case C.EOptimization.Size:
commandLine.Add("-Os");
break;
case C.EOptimization.Speed:
commandLine.Add("-O2");
break;
case C.EOptimization.Custom:
// do nothing - defer to the compiler specific optimization settings
break;
default:
throw new Bam.Core.Exception("Unsupported optimization, {0}", settings.Optimization.Value);
}
}
if (settings.OmitFramePointer.HasValue)
{
commandLine.Add(settings.OmitFramePointer.Value ? "-fomit-frame-pointer" : "-fno-omit-frame-pointer");
}
foreach (var define in settings.PreprocessorDefines)
{
if (null == define.Value)
{
commandLine.Add(System.String.Format("-D{0}", define.Key));
}
else
{
var defineValue = define.Value.ToString();
if (defineValue.Contains("\""))
{
if (Bam.Core.Graph.Instance.Mode == "Xcode")
{
// note the number of back slashes here
// required to get \\\" for each " in the original value
defineValue = defineValue.Replace("\"", "\\\\\\\"");
}
else
{
defineValue = defineValue.Replace("\"", "\\\"");
}
}
defineValue = Bam.Core.IOWrapper.EncloseSpaceContainingPathWithDoubleQuotes(defineValue);
commandLine.Add(System.String.Format("-D{0}={1}", define.Key, defineValue));
}
}
foreach (var undefine in settings.PreprocessorUndefines)
{
commandLine.Add(System.String.Format("-U{0}", undefine));
}
foreach (var path in settings.SystemIncludePaths.ToEnumerableWithoutDuplicates())
{
var quoted_path = path.ToStringQuoteIfNecessary();
if (Bam.Core.Graph.Instance.Mode == "Xcode")
{
quoted_path = quoted_path.Replace("\"", "\\\"");
}
commandLine.Add(System.String.Format("-I{0}", quoted_path));
}
if (settings.TargetLanguage.HasValue)
{
switch (settings.TargetLanguage.Value)
{
case C.ETargetLanguage.C:
commandLine.Add("-x c");
break;
case C.ETargetLanguage.Cxx:
commandLine.Add("-x c++");
break;
case C.ETargetLanguage.ObjectiveC:
commandLine.Add("-x objective-c");
break;
case C.ETargetLanguage.ObjectiveCxx:
commandLine.Add("-x objective-c++");
break;
default:
throw new Bam.Core.Exception("Unsupported target language, {0}", settings.TargetLanguage.Value);
}
}
if (settings.WarningsAsErrors.HasValue)
{
if (settings.WarningsAsErrors.Value)
{
commandLine.Add("-Werror");
}
else
{
commandLine.Add("-Wno-error");
}
}
if (settings.OutputType.HasValue)
{
var module = (settings as Bam.Core.Settings).Module;
switch (settings.OutputType.Value)
{
case C.ECompilerOutput.CompileOnly:
commandLine.Add(System.String.Format("-c -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToStringQuoteIfNecessary()));
break;
case C.ECompilerOutput.Preprocess:
commandLine.Add(System.String.Format("-E -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToStringQuoteIfNecessary()));
break;
default:
throw new Bam.Core.Exception("Unsupported output type, {0}", settings.OutputType.Value.ToString());
}
}
foreach (var header in settings.NamedHeaders)
{
commandLine.Add(System.String.Format("-include {0}", header));
}
}
IDiskImagePolicy.CreateDMG(
DiskImage sender,
Bam.Core.ExecutionContext context,
Bam.Core.ICommandLineTool compiler,
Bam.Core.TokenizedString sourceFolderPath,
Bam.Core.TokenizedString outputPath)
{
var volumeNameTS = sender.CreateTokenizedString("$(OutputName)");
lock (volumeNameTS)
{
if (!volumeNameTS.IsParsed)
{
volumeNameTS.Parse();
}
}
var volumeName = volumeNameTS.ToString();
var tempDiskImagePathName = System.IO.Path.GetTempPath() + System.Guid.NewGuid().ToString() + ".dmg"; // must have .dmg extension
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 diskImagePathName = outputPath.ToString();
var dmgDir = System.IO.Path.GetDirectoryName(diskImagePathName);
Bam.Core.IOWrapper.CreateDirectoryIfNotExists(dmgDir);
// hdiutil convert myimg.dmg -format UDZO -o myoutputimg.dmg
// this will fail if the output DMG exists, so always write to a temporary
// file and then move into place
var tempDMGPath = System.IO.Path.GetTempPath() + System.Guid.NewGuid().ToString() + ".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(tempDMGPath);
CommandLineProcessor.Processor.Execute(context, compiler, args);
}
// move the temporary DMG to the expected location
{
var args = new Bam.Core.StringArray();
args.Add("-f");
args.Add("-v");
args.Add(tempDMGPath);
args.Add(outputPath.ToStringQuoteIfNecessary()); // diskImagePathName
CommandLineProcessor.Processor.Execute(context, Bam.Core.OSUtilities.GetInstallLocation("mv").First(), args);
}
}
IExternalSourceGeneratorPolicy.GenerateSource(
ExternalSourceGenerator sender,
Bam.Core.ExecutionContext context,
Bam.Core.TokenizedString executable,
Bam.Core.TokenizedStringArray arguments,
Bam.Core.TokenizedString output_directory,
System.Collections.Generic.IReadOnlyDictionary <string, Bam.Core.TokenizedString> expected_output_files,
System.Collections.Generic.IReadOnlyDictionary <string, Bam.Core.TokenizedString> input_files
)
{
var encapsulating = sender.GetEncapsulatingReferencedModule();
var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta;
var target = workspace.EnsureTargetExists(encapsulating);
if (encapsulating == sender)
{
target.SetType(XcodeBuilder.Target.EProductType.Utility);
}
var configuration = target.GetConfiguration(encapsulating);
if (encapsulating == sender)
{
configuration.SetProductName(Bam.Core.TokenizedString.CreateVerbatim("${TARGET_NAME}"));
}
var commands = new Bam.Core.StringArray();
commands.Add(
System.String.Format(
"[[ ! -d {0} ]] && mkdir -p {0}",
Bam.Core.IOWrapper.EscapeSpacesInPath(output_directory.ToString())
)
);
var condition_text = new System.Text.StringBuilder();
condition_text.Append("if [[ ");
var last_output = expected_output_files.Values.Last();
foreach (var output in expected_output_files.Values)
{
var output_path = Bam.Core.IOWrapper.EscapeSpacesInPath(output.ToString());
condition_text.AppendFormat("! -e {0} ", output_path);
foreach (var input in input_files.Values)
{
var input_path = Bam.Core.IOWrapper.EscapeSpacesInPath(input.ToString());
condition_text.AppendFormat("|| {1} -nt {0} ", output_path, input_path);
}
if (output != last_output)
{
condition_text.AppendFormat("|| ");
}
}
condition_text.AppendLine("]]");
condition_text.AppendLine("then");
var cmd_line = System.String.Format("{0} {1}", executable.ToStringQuoteIfNecessary(), arguments.ToString(' '));
condition_text.AppendLine(System.String.Format("\techo {0}", cmd_line));
condition_text.AppendLine(System.String.Format("\t{0}", cmd_line));
condition_text.AppendLine("fi");
commands.Add(condition_text.ToString());
target.AddPreBuildCommands(commands, configuration);
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
var sourcePath = sender.SourcePath;
if (null == sender.Reference)
{
if ((null != sender.SourceModule.MetaData) || (sender.SourceModule is CollatedObject))
{
// the main file is not copied anywhere, as we copy required files around it where VS wrote the main file
// this is managed by the Collation class, querying the build mode for where publishing is relative to
// ignore any subdirectory on this module
// could also be a DebugSymbols or Stripped copy, in which case, ignore it
return;
}
else
{
// the main reference file was a prebuilt - so create a new project to handle copying files
var solution = Bam.Core.Graph.Instance.MetaData as VSSolutionBuilder.VSSolution;
var project = solution.EnsureProjectExists(sender.SourceModule);
var config = project.GetConfiguration(sender.SourceModule);
config.SetType(VSSolutionBuilder.VSProjectConfiguration.EType.Utility);
config.SetOutputPath(sender.Macros["CopyDir"]);
config.EnableIntermediatePath();
}
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
if (sender.SourceModule != null && sender.SourceModule.MetaData != null && VSSolutionBuilder.VSProject.IsBuildable(sender.SourceModule))
{
var destinationPath = sender.Macros["CopyDir"].Parse();
var project = sender.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.SourceModule);
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("IF NOT EXIST {0} MKDIR {0}", destinationPath));
if (config.Type != VSSolutionBuilder.VSProjectConfiguration.EType.Utility)
{
commands.Add(System.String.Format(@"{0} {1} $(OutputPath)$(TargetFileName) {2} {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
destinationPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
config.AddPostBuildCommands(commands);
}
else
{
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir).\ {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
config.AddPreBuildCommands(commands);
}
}
else
{
var commands = new Bam.Core.StringArray();
if (sender is CollatedDirectory)
{
// Windows XCOPY requires the directory name to be added to the destination, while Posix cp does not
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.CreateTokenizedString("$(0)/@ifnotempty($(CopiedFilename),$(CopiedFilename),@filename($(1)))", sender.SubDirectory, sourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.SubDirectory,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
var project = sender.Reference.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.Reference.SourceModule);
if (config.Type != VSSolutionBuilder.VSProjectConfiguration.EType.Utility)
{
config.AddPostBuildCommands(commands);
}
else
{
config.AddPreBuildCommands(commands);
}
}
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
var sourcePath = sender.SourcePath;
if (null == sender.Reference)
{
if ((null != sender.SourceModule.MetaData) || (sender.SourceModule is CollatedObject))
{
// the main file is not copied anywhere, as we copy required files around it where Xcode wrote the main file
// this is managed by the Collation class, querying the build mode for where publishing is relative to
// ignore any subdirectory on this module
// convert the executable into an app bundle, if EPublishingType.WindowedApplication has been used as the type
if ((sender.SubDirectory != null) && sender.SubDirectory.Parse().Contains(".app/"))
{
var target = sender.SourceModule.MetaData as XcodeBuilder.Target;
target.MakeApplicationBundle();
}
return;
}
else
{
// the main reference file was a prebuilt - so create a new project to handle copying files
var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta;
var target = workspace.EnsureTargetExists(sender.SourceModule);
var configuration = target.GetConfiguration(sender.SourceModule);
target.Type = XcodeBuilder.Target.EProductType.Utility;
configuration.SetProductName(sender.SourceModule.Macros["modulename"]);
//Bam.Core.Log.MessageAll("Configuration {0} for {1}", configuration.Name, sender.SourceModule.ToString());
}
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
var destinationPath = sender.Macros["CopyDir"].Parse();
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("[[ ! -d {0} ]] && mkdir -p {0}", destinationPath));
if (sender.SourceModule != null && sender.SourceModule.MetaData != null)
{
if ((null != sender.Reference) &&
(null != sender.Reference.SourceModule) &&
(sender.SourceModule.PackageDefinition == sender.Reference.SourceModule.PackageDefinition) &&
(null == sender.Reference.SubDirectory) &&
(sender.SubDirectory.Parse() == "."))
{
// special case that the module output is already in the right directory at build
return;
}
var target = sender.SourceModule.MetaData as XcodeBuilder.Target;
if (target.Type != XcodeBuilder.Target.EProductType.Utility)
{
commands.Add(System.String.Format("{0} {1} $CONFIGURATION_BUILD_DIR/$EXECUTABLE_NAME {2} {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
destinationPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
commands.Add(System.String.Format("{0} {1} {2} {3} {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.Parse(),
destinationPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
var configuration = target.GetConfiguration(sender.SourceModule);
if (target.Type != XcodeBuilder.Target.EProductType.Utility)
{
target.AddPostBuildCommands(commands, configuration);
}
else
{
target.AddPreBuildCommands(commands, configuration);
}
}
else
{
var target = sender.Reference.SourceModule.MetaData as XcodeBuilder.Target;
var isSymlink = (sender is CollatedSymbolicLink);
var destinationFolder = "$CONFIGURATION_BUILD_DIR";
if (sender.Reference != null)
{
destinationFolder = "$CONFIGURATION_BUILD_DIR/$EXECUTABLE_FOLDER_PATH";
}
if (target.Type == XcodeBuilder.Target.EProductType.Utility)
{
destinationFolder = destinationPath;
}
if (isSymlink)
{
commands.Add(System.String.Format("{0} {1} {2} {3}/{4} {5}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sender.Macros["LinkTarget"].Parse(),
destinationFolder,
sender.CreateTokenizedString("$(0)/@filename($(1))", sender.SubDirectory, sender.SourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
if (sender is CollatedDirectory)
{
var copySource = sourcePath.Parse();
if (sender.Macros["CopiedFilename"].IsAliased)
{
copySource = System.String.Format("{0}/*", copySource);
}
commands.Add(System.String.Format("{0} {1} {2} {3}/{4}/ {5}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
copySource,
destinationFolder,
sender.CreateTokenizedString("$(0)/@ifnotempty($(CopiedFilename),$(CopiedFilename),)", sender.SubDirectory).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
commands.Add(System.String.Format("{0} {1} {2} {3}/{4}/ {5}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.Parse(),
destinationFolder,
sender.SubDirectory.Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
}
var configuration = target.GetConfiguration(sender.Reference.SourceModule);
if (target.Type != XcodeBuilder.Target.EProductType.Utility)
{
target.AddPostBuildCommands(commands, configuration);
}
else
{
target.AddPreBuildCommands(commands, configuration);
}
}
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
if (sender.Ignore)
{
return;
}
var collatedInterface = sender as ICollatedObject;
var arePostBuildCommands = true;
Bam.Core.Module sourceModule;
if (null != collatedInterface.SourceModule)
{
sourceModule = collatedInterface.SourceModule;
if (null == sourceModule.MetaData)
{
// this can happen for prebuilt frameworks
sourceModule = collatedInterface.Anchor.SourceModule;
}
}
else
{
if (null != collatedInterface.Anchor)
{
// usually preexisting files that are published as part of an executable's distribution
// in which case, their anchor is the executable (or a similar binary)
sourceModule = collatedInterface.Anchor.SourceModule;
}
else
{
if (sender is CollatedPreExistingFile)
{
sourceModule = (sender as CollatedPreExistingFile).ParentOfCollationModule;
var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta;
workspace.EnsureTargetExists(sourceModule);
arePostBuildCommands = false;
}
else
{
throw new Bam.Core.Exception("No anchor set on '{0}' with source path '{1}'", sender.GetType().ToString(), sender.SourcePath);
}
}
}
var target = sourceModule.MetaData as XcodeBuilder.Target;
if (sender.IsAnchor && (null != collatedInterface.SourceModule))
{
if (sender.IsAnchorAnApplicationBundle)
{
// application bundles are a different output type in Xcode
target.MakeApplicationBundle();
}
// since all dependents are copied _beside_ their anchor, the anchor copy is a no-op
return;
}
if (sender.IsInAnchorPackage &&
(null != collatedInterface.SourceModule) &&
!(collatedInterface.Anchor as CollatedObject).IsAnchorAnApplicationBundle)
{
// additionally, any module-based dependents in the same package as the anchor do not need copying as they
// are built into the right directory (since Xcode module build dirs do not include the module name)
return;
}
var copyFileTool = sender.Tool as CopyFileTool;
string copySourcePath;
string destinationDir;
copyFileTool.convertPaths(
sender,
sender.SourcePath,
collatedInterface.PublishingDirectory,
out copySourcePath,
out destinationDir);
if (null == sender.PreExistingSourcePath)
{
Bam.Core.Log.DebugMessage("** {0}[{1}]:\t'{2}' -> '{3}'",
collatedInterface.SourceModule.ToString(),
collatedInterface.SourcePathKey.ToString(),
copyFileTool.escapePath(copySourcePath),
copyFileTool.escapePath(destinationDir));
}
else
{
Bam.Core.Log.DebugMessage("** {0}: '{1}' -> '{2}'",
sender,
copyFileTool.escapePath(copySourcePath),
copyFileTool.escapePath(destinationDir));
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("[[ ! -d {0} ]] && mkdir -p {0}", copyFileTool.escapePath(destinationDir)));
var configuration = target.GetConfiguration(sourceModule);
commands.Add(System.String.Format("{0} {1} {2} {3} {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
copyFileTool.escapePath(copySourcePath),
copyFileTool.escapePath(destinationDir),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
if (!target.isUtilityType && arePostBuildCommands)
{
target.AddPostBuildCommands(commands, configuration);
}
else
{
target.AddPreBuildCommands(commands, configuration);
}
}
public override void Evaluate()
{
this.ReasonToExecute = null;
var graph = Bam.Core.Graph.Instance;
var factory = graph.MetaData as System.Threading.Tasks.TaskFactory;
this.EvaluationTask = factory.StartNew(() =>
{
// does the object file exist?
var objectFilePath = this.GeneratedPaths[Key].Parse();
if (!System.IO.File.Exists(objectFilePath))
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.FileDoesNotExist(this.GeneratedPaths[Key]);
return;
}
var objectFileWriteTime = System.IO.File.GetLastWriteTime(objectFilePath);
// has the source file been evaluated to be rebuilt?
if ((this as IRequiresSourceModule).Source.ReasonToExecute != null)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(this.GeneratedPaths[Key], this.InputPath);
return;
}
// is the source file newer than the object file?
var sourcePath = this.InputPath.Parse();
var sourceWriteTime = System.IO.File.GetLastWriteTime(sourcePath);
if (sourceWriteTime > objectFileWriteTime)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(this.GeneratedPaths[Key], this.InputPath);
return;
}
if (this is WinResource)
{
return;
}
// are there any headers as explicit dependencies (procedurally generated most likely), which are newer?
var explicitHeadersUpdated = new Bam.Core.StringArray();
foreach (var dep in this.Dependents)
{
if (!(dep is HeaderFile))
{
continue;
}
if (null == dep.ReasonToExecute)
{
continue;
}
explicitHeadersUpdated.AddUnique((dep as HeaderFile).InputPath.Parse());
}
var includeSearchPaths = (this.Settings as C.ICommonCompilerSettings).IncludePaths;
var filesToSearch = new System.Collections.Generic.Queue<string>();
filesToSearch.Enqueue(sourcePath);
var headerPathsFound = new Bam.Core.StringArray();
while (filesToSearch.Count > 0)
{
var fileToSearch = filesToSearch.Dequeue();
string fileContents = null;
using (System.IO.TextReader reader = new System.IO.StreamReader(fileToSearch))
{
fileContents = reader.ReadToEnd();
}
// never know if developers are consistent with #include "header.h" or #include <header.h> so look for both
var matches = System.Text.RegularExpressions.Regex.Matches(
fileContents,
"^\\s*#include [\"<]([^\\s]*)[\">]",
System.Text.RegularExpressions.RegexOptions.Multiline);
if (0 == matches.Count)
{
// no #includes
return;
}
foreach (System.Text.RegularExpressions.Match match in matches)
{
var headerFile = match.Groups[1].Value;
bool exists = false;
// search for the file on the include paths the compiler uses
foreach (var includePath in includeSearchPaths)
{
try
{
var potentialPath = System.IO.Path.Combine(includePath.Parse(), headerFile);
if (!System.IO.File.Exists(potentialPath))
{
continue;
}
potentialPath = System.IO.Path.GetFullPath(potentialPath);
var headerWriteTime = System.IO.File.GetLastWriteTime(potentialPath);
// early out - header is newer than generated object file
if (headerWriteTime > objectFileWriteTime)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(
this.GeneratedPaths[Key],
Bam.Core.TokenizedString.CreateVerbatim(potentialPath));
return;
}
if (explicitHeadersUpdated.Contains(potentialPath))
{
// found #included header in list of explicitly dependent headers that have been updated
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(
this.GeneratedPaths[Key],
Bam.Core.TokenizedString.CreateVerbatim(potentialPath));
return;
}
if (!headerPathsFound.Contains(potentialPath))
{
headerPathsFound.Add(potentialPath);
filesToSearch.Enqueue(potentialPath);
}
exists = true;
break;
}
catch (System.Exception ex)
{
Bam.Core.Log.MessageAll("IncludeDependency Exception: Cannot locate '{0}' on '{1}' due to {2}", headerFile, includePath, ex.Message);
}
}
if (!exists)
{
#if false
Bam.Core.Log.DebugMessage("***** Could not locate '{0}' on any include search path, included from {1}:\n{2}",
match.Groups[1],
fileToSearch,
entry.includePaths.ToString('\n'));
#endif
}
}
}
return;
});
}
void ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
var sourcePath = sender.SourcePath;
if (null == sender.Reference)
{
if ((null != sender.SourceModule.MetaData) || (sender.SourceModule is CollatedObject))
{
// the main file is not copied anywhere, as we copy required files around it where VS wrote the main file
// this is managed by the Collation class, querying the build mode for where publishing is relative to
// ignore any subdirectory on this module
// could also be a DebugSymbols or Stripped copy, in which case, ignore it
return;
}
else
{
// the main reference file was a prebuilt - so create a new project to handle copying files
var solution = Bam.Core.Graph.Instance.MetaData as VSSolutionBuilder.VSSolution;
var project = solution.EnsureProjectExists(sender.SourceModule);
var config = project.GetConfiguration(sender.SourceModule);
config.SetType(VSSolutionBuilder.VSProjectConfiguration.EType.Utility);
config.SetOutputPath(sender.Macros["CopyDir"]);
config.EnableIntermediatePath();
}
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
if (sender.SourceModule != null && sender.SourceModule.MetaData != null)
{
var destinationPath = sender.Macros["CopyDir"].Parse();
var project = sender.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.SourceModule);
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("IF NOT EXIST {0} MKDIR {0}", destinationPath));
if (config.Type != VSSolutionBuilder.VSProjectConfiguration.EType.Utility)
{
commands.Add(System.String.Format(@"{0} {1} $(OutputPath)$(TargetFileName) {2} {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
destinationPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
config.AddPostBuildCommands(commands);
}
else
{
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir).\ {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
config.AddPreBuildCommands(commands);
}
}
else
{
var commands = new Bam.Core.StringArray();
if (sender is CollatedDirectory)
{
// Windows XCOPY requires the directory name to be added to the destination, while Posix cp does not
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.CreateTokenizedString("$(0)/@ifnotempty($(CopiedFilename),$(CopiedFilename),@filename($(1)))", sender.SubDirectory, sourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
commands.Add(System.String.Format(@"{0} {1} {2} $(OutDir){3}\ {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.ParseAndQuoteIfNecessary(),
sender.SubDirectory,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
var project = sender.Reference.SourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sender.Reference.SourceModule);
if (config.Type != VSSolutionBuilder.VSProjectConfiguration.EType.Utility)
{
config.AddPostBuildCommands(commands);
}
else
{
config.AddPreBuildCommands(commands);
}
}
}
Build(
XmlUtilities.XmlModule moduleToBuild,
out bool success)
{
var isPlist = moduleToBuild is XmlUtilities.OSXPlistModule;
var locationMap = moduleToBuild.Locations;
var outputDir = locationMap[XmlUtilities.OSXPlistModule.OutputDir];
var outputDirPath = outputDir.GetSingleRawPath();
if (!System.IO.Directory.Exists(outputDirPath))
{
System.IO.Directory.CreateDirectory(outputDirPath);
}
var xmlFileLoc = locationMap[XmlUtilities.XmlModule.OutputFile];
var xmlFilePath = xmlFileLoc.GetSingleRawPath();
// write a script that can be invoked by the MakeFile to generate the XML file
var shellScriptLeafName = isPlist ? "writePList.py" : "writeXMLFile.py";
var shellScriptLoc = Bam.Core.FileLocation.Get(outputDir, shellScriptLeafName, Bam.Core.Location.EExists.WillExist);
var shellScriptPath = shellScriptLoc.GetSingleRawPath();
XmlUtilities.XmlDocumentToPythonScript.Write(moduleToBuild.Document, shellScriptPath, xmlFilePath);
var node = moduleToBuild.OwningNode;
var makeFile = new MakeFile(node, this.topLevelMakeFilePath);
var dirsToCreate = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.Directory, Bam.Core.Location.EExists.WillExist);
var recipe = new Bam.Core.StringArray();
recipe.Add(System.String.Format("$(shell python {0})", shellScriptPath));
var rule = new MakeFileRule(
moduleToBuild,
XmlUtilities.XmlModule.OutputFile,
node.UniqueModuleName,
dirsToCreate,
null,
null,
recipe);
rule.OutputLocationKeys = new Bam.Core.Array <Bam.Core.LocationKey>(XmlUtilities.XmlModule.OutputFile);
makeFile.RuleArray.Add(rule);
var makeFilePath = MakeFileBuilder.GetMakeFilePathName(node);
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(makeFilePath));
using (var makeFileWriter = new System.IO.StreamWriter(makeFilePath))
{
makeFile.Write(makeFileWriter);
}
var exportedTargets = makeFile.ExportedTargets;
var exportedVariables = makeFile.ExportedVariables;
var returnData = new MakeFileData(makeFilePath, exportedTargets, exportedVariables, null);
success = true;
return(returnData);
}
Convert(
this C.ICommonAssemblerSettings settings,
Bam.Core.StringArray commandLine)
{
var module = (settings as Bam.Core.Settings).Module;
switch (settings.Bits.Value)
{
case C.EBit.SixtyFour:
commandLine.Add("-arch x86_64");
break;
case C.EBit.ThirtyTwo:
commandLine.Add("-arch i386");
break;
default:
throw new Bam.Core.Exception("Unknown bit depth, {0}", settings.Bits.Value);
}
if (settings.DebugSymbols)
{
commandLine.Add("-g");
}
switch (settings.OutputType)
{
case C.ECompilerOutput.CompileOnly:
commandLine.Add(System.String.Format("-c -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToStringQuoteIfNecessary()));
break;
case C.ECompilerOutput.Preprocess:
commandLine.Add(System.String.Format("-E -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToStringQuoteIfNecessary()));
break;
default:
throw new Bam.Core.Exception("Unknown output type, {0}", settings.OutputType.ToString());
}
if (settings.WarningsAsErrors)
{
commandLine.Add("-Werror");
}
else
{
commandLine.Add("-Wno-error");
}
foreach (var path in settings.IncludePaths.ToEnumerableWithoutDuplicates())
{
commandLine.Add(System.String.Format("-I{0}", path.ToStringQuoteIfNecessary()));
}
foreach (var define in settings.PreprocessorDefines)
{
if (null == define.Value)
{
commandLine.Add(System.String.Format("-D{0}", define.Key));
}
else
{
var defineValue = define.Value.ToString();
if (defineValue.Contains("\""))
{
defineValue = defineValue.Replace("\"", "\\\"");
}
defineValue = Bam.Core.IOWrapper.EncloseSpaceContainingPathWithDoubleQuotes(defineValue);
commandLine.Add(System.String.Format("-D{0}={1}", define.Key, defineValue));
}
}
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
if (sender.Ignore)
{
return;
}
var collatedInterface = sender as ICollatedObject;
if (sender.IsAnchor && null != collatedInterface.SourceModule)
{
// since all dependents are copied _beside_ their anchor, the anchor copy is a no-op
return;
}
var copyFileTool = sender.Tool as CopyFileTool;
string copySourcePath;
string destinationDir;
copyFileTool.convertPaths(
sender,
sender.SourcePath,
collatedInterface.PublishingDirectory,
out copySourcePath,
out destinationDir);
if (null == sender.PreExistingSourcePath)
{
Bam.Core.Log.DebugMessage("** {0}[{1}]:\t'{2}' -> '{3}'",
collatedInterface.SourceModule.ToString(),
collatedInterface.SourcePathKey.ToString(),
copyFileTool.escapePath(copySourcePath),
copyFileTool.escapePath(destinationDir));
}
else
{
Bam.Core.Log.DebugMessage("** {0}: '{1}' -> '{2}'",
sender,
copyFileTool.escapePath(copySourcePath),
copyFileTool.escapePath(destinationDir));
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("IF NOT EXIST {0} MKDIR {0}", copyFileTool.escapePath(destinationDir)));
var arePostBuildCommands = true;
Bam.Core.Module sourceModule;
if (null != collatedInterface.SourceModule)
{
sourceModule = collatedInterface.SourceModule;
// check for runtime dependencies that won't have projects, use their anchor
if (null == sourceModule.MetaData)
{
sourceModule = collatedInterface.Anchor.SourceModule;
}
}
else
{
if (null != collatedInterface.Anchor)
{
// usually preexisting files that are published as part of an executable's distribution
// in which case, their anchor is the executable (or a similar binary)
sourceModule = collatedInterface.Anchor.SourceModule;
}
else
{
if (sender is CollatedPreExistingFile)
{
sourceModule = (sender as CollatedPreExistingFile).ParentOfCollationModule;
// ensure a project exists, as this collation may be visited prior to
// the source which invoked it
var solution = Bam.Core.Graph.Instance.MetaData as VSSolutionBuilder.VSSolution;
solution.EnsureProjectExists(sourceModule);
arePostBuildCommands = false;
}
else
{
throw new Bam.Core.Exception("No anchor set on '{0}' with source path '{1}'", sender.GetType().ToString(), sender.SourcePath);
}
}
}
var project = sourceModule.MetaData as VSSolutionBuilder.VSProject;
var config = project.GetConfiguration(sourceModule);
commands.Add(System.String.Format(@"{0} {1} {2} {3} {4}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
copyFileTool.escapePath(copySourcePath),
copyFileTool.escapePath(destinationDir),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
if (config.Type != VSSolutionBuilder.VSProjectConfiguration.EType.Utility && arePostBuildCommands)
{
config.AddPostBuildCommands(commands);
}
else
{
config.AddPreBuildCommands(commands);
}
}
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;
}
Convert(
this VisualCCommon.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.NoLogo.HasValue)
{
if (settings.NoLogo.Value)
{
commandLine.Add("-nologo");
}
}
if (settings.RuntimeLibrary.HasValue)
{
switch (settings.RuntimeLibrary.Value)
{
case ERuntimeLibrary.MultiThreaded:
commandLine.Add("-MT");
break;
case ERuntimeLibrary.MultiThreadedDebug:
commandLine.Add("-MTd");
break;
case ERuntimeLibrary.MultiThreadedDebugDLL:
commandLine.Add("-MDd");
break;
case ERuntimeLibrary.MultiThreadedDLL:
commandLine.Add("-MD");
break;
default:
throw new Bam.Core.Exception("Unknown runtime library, {0}", settings.RuntimeLibrary.Value.ToString());
}
}
if (settings.WarningLevel.HasValue)
{
commandLine.Add(System.String.Format("-W{0}", settings.WarningLevel.Value.ToString("D")));
}
if (settings.EnableLanguageExtensions.HasValue)
{
if (!settings.EnableLanguageExtensions.Value)
{
commandLine.Add("-Za");
}
}
if (settings.Optimization.HasValue)
{
var common_optimization = (settings as C.ICommonCompilerSettings).Optimization;
if (common_optimization.HasValue && common_optimization.Value != C.EOptimization.Custom)
{
throw new Bam.Core.Exception("Compiler specific optimizations can only be set when the common optimization is C.EOptimization.Custom");
}
switch (settings.Optimization.Value)
{
case EOptimization.Full:
commandLine.Add("-Ox");
break;
default:
throw new Bam.Core.Exception("Unknown compiler optimization, {0}", settings.Optimization.Value.ToString());
}
}
if (settings.IncreaseObjectFileSectionCount.HasValue)
{
if (settings.IncreaseObjectFileSectionCount.Value)
{
commandLine.Add("-bigobj");
}
}
}
Convert(
this MingwCommon.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.AllWarnings.HasValue)
{
if (settings.AllWarnings.Value)
{
commandLine.Add("-Wall");
}
else
{
commandLine.Add("-Wno-all");
}
}
if (settings.ExtraWarnings.HasValue)
{
if (settings.ExtraWarnings.Value)
{
commandLine.Add("-Wextra");
}
else
{
commandLine.Add("-Wno-extra");
}
}
if (settings.Pedantic.HasValue)
{
if (settings.Pedantic.Value)
{
commandLine.Add("-Wpedantic");
}
else
{
commandLine.Add("-Wno-pedantic");
}
}
if (settings.Visibility.HasValue)
{
switch (settings.Visibility.Value)
{
case EVisibility.Default:
commandLine.Add("-fvisibility=default");
break;
case EVisibility.Hidden:
commandLine.Add("-fvisibility=hidden");
break;
case EVisibility.Internal:
commandLine.Add("-fvisibility=internal");
break;
case EVisibility.Protected:
commandLine.Add("-fvisibility=protected");
break;
default:
throw new Bam.Core.Exception("Unrecognized visibility, {0}", settings.Visibility.Value.ToString());
}
}
if (settings.StrictAliasing.HasValue)
{
if (settings.StrictAliasing.Value)
{
commandLine.Add("-fstrict-aliasing");
}
else
{
commandLine.Add("-fno-strict-aliasing");
}
}
}
ICollatedObjectPolicy.Collate(
CollatedObject sender,
Bam.Core.ExecutionContext context)
{
var sourcePath = sender.SourcePath;
if (null == sender.Reference)
{
// the main file is not copied anywhere, as we copy required files around it where Xcode wrote the main file
// this is managed by the Collation class, querying the build mode for where publishing is relative to
// ignore any subdirectory on this module
// convert the executable into an app bundle, if EPublishingType.WindowedApplication has been used as the type
if ((sender.SubDirectory != null) && sender.SubDirectory.Parse().Contains(".app/"))
{
var target = sender.SourceModule.MetaData as XcodeBuilder.Target;
target.MakeApplicationBundle();
}
return;
}
var commandLine = new Bam.Core.StringArray();
(sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine);
var destinationPath = sender.Macros["CopyDir"].Parse();
var commands = new Bam.Core.StringArray();
commands.Add(System.String.Format("[[ ! -d {0} ]] && mkdir -p {0}", destinationPath));
if (sender.SourceModule != null && sender.SourceModule.MetaData != null)
{
if ((null != sender.Reference) &&
(sender.SourceModule.PackageDefinition == sender.Reference.PackageDefinition) &&
(null == sender.Reference.SubDirectory) &&
(sender.SubDirectory.Parse() == "."))
{
// special case that the module output is already in the right directory at build
return;
}
commands.Add(System.String.Format("{0} {1} $CONFIGURATION_BUILD_DIR/$EXECUTABLE_NAME {2} {3}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
destinationPath,
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
var target = sender.SourceModule.MetaData as XcodeBuilder.Target;
var configuration = target.GetConfiguration(sender.SourceModule);
target.AddPostBuildCommands(commands, configuration);
}
else
{
var isSymlink = (sender is CollatedSymbolicLink);
var destinationFolder = "$CONFIGURATION_BUILD_DIR";
if (sender.Reference != null)
{
destinationFolder = "$CONFIGURATION_BUILD_DIR/$EXECUTABLE_FOLDER_PATH";
}
if (isSymlink)
{
commands.Add(System.String.Format("{0} {1} {2} {3}/{4} {5}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sender.Macros["LinkTarget"].Parse(),
destinationFolder,
sender.CreateTokenizedString("$(0)/@filename($(1))", sender.SubDirectory, sender.SourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
if (sender is CollatedDirectory)
{
var copySource = sourcePath.Parse();
if (sender.Macros["CopiedFilename"].IsAliased)
{
copySource = System.String.Format("{0}/*", copySource);
}
commands.Add(System.String.Format("{0} {1} {2} {3}/{4}/ {5}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
copySource,
destinationFolder,
sender.CreateTokenizedString("$(0)/@ifnotempty($(CopiedFilename),$(CopiedFilename),@filename($(1)))", sender.SubDirectory, sourcePath).Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
else
{
commands.Add(System.String.Format("{0} {1} {2} {3}/{4}/ {5}",
CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool),
commandLine.ToString(' '),
sourcePath.Parse(),
destinationFolder,
sender.SubDirectory.Parse(),
CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)));
}
}
var target = sender.Reference.SourceModule.MetaData as XcodeBuilder.Target;
var configuration = target.GetConfiguration(sender.Reference.SourceModule);
target.AddPostBuildCommands(commands, configuration);
}
}
Evaluate()
{
this.ReasonToExecute = null;
if (!this.PerformCompilation)
{
return;
}
var graph = Bam.Core.Graph.Instance;
var factory = graph.MetaData as System.Threading.Tasks.TaskFactory;
this.EvaluationTask = factory.StartNew(() =>
{
// does the object file exist?
var objectFilePath = this.GeneratedPaths[Key].Parse();
if (!System.IO.File.Exists(objectFilePath))
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.FileDoesNotExist(this.GeneratedPaths[Key]);
return;
}
var objectFileWriteTime = System.IO.File.GetLastWriteTime(objectFilePath);
// has the source file been evaluated to be rebuilt?
if ((this as IRequiresSourceModule).Source.ReasonToExecute != null)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(this.GeneratedPaths[Key], this.InputPath);
return;
}
// is the source file newer than the object file?
var sourcePath = this.InputPath.Parse();
var sourceWriteTime = System.IO.File.GetLastWriteTime(sourcePath);
if (sourceWriteTime > objectFileWriteTime)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(this.GeneratedPaths[Key], this.InputPath);
return;
}
if (this is WinResource)
{
return;
}
// are there any headers as explicit dependencies (procedurally generated most likely), which are newer?
var explicitHeadersUpdated = new Bam.Core.StringArray();
var explicitHeadersDeferred = new Bam.Core.StringArray();
foreach (var dep in this.Dependents)
{
if (!(dep is HeaderFile))
{
continue;
}
if (null == dep.ReasonToExecute)
{
continue;
}
if (dep.ReasonToExecute.Reason == Bam.Core.ExecuteReasoning.EReason.InputFileIsNewer)
{
explicitHeadersUpdated.AddUnique((dep as HeaderFile).InputPath.Parse());
}
else if (dep.ReasonToExecute.Reason == Bam.Core.ExecuteReasoning.EReason.DeferredEvaluation)
{
explicitHeadersDeferred.AddUnique((dep as HeaderFile).InputPath.Parse());
}
}
var includeSearchPaths = (this.Settings as C.ICommonCompilerSettings).IncludePaths;
// implicitly search the same directory as the source path, as this is not needed to be explicitly on the include path list
includeSearchPaths.AddUnique(this.CreateTokenizedString("@dir($(0))", this.InputPath));
var filesToSearch = new System.Collections.Generic.Queue <string>();
filesToSearch.Enqueue(sourcePath);
var headerPathsFound = new Bam.Core.StringArray();
while (filesToSearch.Count > 0)
{
var fileToSearch = filesToSearch.Dequeue();
string fileContents = null;
using (System.IO.TextReader reader = new System.IO.StreamReader(fileToSearch))
{
fileContents = reader.ReadToEnd();
}
// never know if developers are consistent with #include "header.h" or #include <header.h> so look for both
// nor the amount of whitespace after #include
var matches = System.Text.RegularExpressions.Regex.Matches(
fileContents,
"^\\s*#include\\s*[\"<]([^\\s]*)[\">]",
System.Text.RegularExpressions.RegexOptions.Multiline);
if (0 == matches.Count)
{
// no #includes
return;
}
foreach (System.Text.RegularExpressions.Match match in matches)
{
var headerFile = match.Groups[1].Value;
bool exists = false;
// search for the file on the include paths the compiler uses
foreach (var includePath in includeSearchPaths)
{
try
{
var potentialPath = System.IO.Path.Combine(includePath.Parse(), headerFile);
if (!System.IO.File.Exists(potentialPath))
{
continue;
}
potentialPath = System.IO.Path.GetFullPath(potentialPath);
var headerWriteTime = System.IO.File.GetLastWriteTime(potentialPath);
// early out - header is newer than generated object file
if (headerWriteTime > objectFileWriteTime)
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(
this.GeneratedPaths[Key],
Bam.Core.TokenizedString.CreateVerbatim(potentialPath));
return;
}
// found #included header in list of explicitly dependent headers that have been updated
if (explicitHeadersUpdated.Contains(potentialPath))
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.InputFileNewer(
this.GeneratedPaths[Key],
Bam.Core.TokenizedString.CreateVerbatim(potentialPath));
return;
}
// found #included header in list of explicitly dependent headers that require a deferred evaluation
if (explicitHeadersDeferred.Contains(potentialPath))
{
this.ReasonToExecute = Bam.Core.ExecuteReasoning.DeferredUntilBuild(this.GeneratedPaths[Key]);
return;
}
if (!headerPathsFound.Contains(potentialPath))
{
headerPathsFound.Add(potentialPath);
filesToSearch.Enqueue(potentialPath);
}
exists = true;
break;
}
catch (System.Exception ex)
{
Bam.Core.Log.MessageAll("IncludeDependency Exception: Cannot locate '{0}' on '{1}' due to {2}", headerFile, includePath, ex.Message);
}
}
if (!exists)
{
#if false
Bam.Core.Log.DebugMessage("***** Could not locate '{0}' on any include search path, included from {1}:\n{2}",
match.Groups[1],
fileToSearch,
entry.includePaths.ToString('\n'));
#endif
}
}
}
return;
});
}
Convert(
this C.ICommonAssemblerSettings settings,
Bam.Core.StringArray commandLine)
{
var module = (settings as Bam.Core.Settings).Module;
switch (settings.Bits.Value)
{
case C.EBit.SixtyFour:
commandLine.Add("-m64");
break;
case C.EBit.ThirtyTwo:
commandLine.Add("-m32");
break;
default:
throw new Bam.Core.Exception("Unknown machine bit size, {0}", settings.Bits.Value.ToString());
}
if (settings.DebugSymbols)
{
commandLine.Add("-g");
}
switch (settings.OutputType)
{
case C.ECompilerOutput.CompileOnly:
commandLine.Add(System.String.Format("-c -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToString()));
break;
case C.ECompilerOutput.Preprocess:
commandLine.Add(System.String.Format("-E -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToString()));
break;
default:
throw new Bam.Core.Exception("Unknown output type, {0}", settings.OutputType.ToString());
}
if (settings.WarningsAsErrors)
{
commandLine.Add("-Werror");
}
else
{
commandLine.Add("-Wno-error");
}
foreach (var path in settings.IncludePaths)
{
commandLine.Add(System.String.Format("-I{0}", path.ParseAndQuoteIfNecessary()));
}
foreach (var define in settings.PreprocessorDefines)
{
if (System.String.IsNullOrEmpty(define.Value))
{
commandLine.Add(System.String.Format("-D{0}", define.Key));
}
else
{
var value = define.Value;
if (value.Contains("\""))
{
value = value.Replace("\"", "\\\"");
}
commandLine.Add(System.String.Format("-D{0}={1}", define.Key, value));
}
}
}
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);
}
}
Convert(
this C.ICommonCompilerSettings settings,
Bam.Core.StringArray commandLine)
{
if (settings.Bits.HasValue)
{
switch (settings.Bits.Value)
{
case C.EBit.SixtyFour:
commandLine.Add("-m64");
break;
case C.EBit.ThirtyTwo:
commandLine.Add("-m32");
break;
default:
throw new Bam.Core.Exception("Unknown machine bit size, {0}", settings.Bits.Value.ToString());
}
}
if (settings.DebugSymbols.HasValue)
{
if (settings.DebugSymbols.Value)
{
commandLine.Add("-g");
}
}
foreach (var warning in settings.DisableWarnings)
{
commandLine.Add(System.String.Format("-Wno-{0}", warning));
}
foreach (var path in settings.IncludePaths)
{
commandLine.Add(System.String.Format("-I{0}", path.ParseAndQuoteIfNecessary()));
}
if (settings.OmitFramePointer.HasValue)
{
commandLine.Add(settings.OmitFramePointer.Value ? "-fomit-frame-pointer" : "-fno-omit-frame-pointer");
}
if (settings.Optimization.HasValue)
{
switch (settings.Optimization.Value)
{
case C.EOptimization.Off:
commandLine.Add("-O0");
break;
case C.EOptimization.Size:
commandLine.Add("-Os");
break;
case C.EOptimization.Speed:
commandLine.Add("-O1");
break;
case C.EOptimization.Full:
commandLine.Add("-O3");
break;
default:
throw new Bam.Core.Exception("Unknown optimization level, {0}", settings.Optimization.Value.ToString());
}
}
foreach (var define in settings.PreprocessorDefines)
{
if (System.String.IsNullOrEmpty(define.Value))
{
commandLine.Add(System.String.Format("-D{0}", define.Key));
}
else
{
var value = define.Value;
if (value.Contains("\""))
{
value = value.Replace("\"", "\\\"");
}
commandLine.Add(System.String.Format("-D{0}={1}", define.Key, value));
}
}
foreach (var undefine in settings.PreprocessorUndefines)
{
commandLine.Add(System.String.Format("-U{0}", undefine));
}
foreach (var path in settings.SystemIncludePaths)
{
commandLine.Add(System.String.Format("-I{0}", path.ParseAndQuoteIfNecessary()));
}
if (settings.TargetLanguage.HasValue)
{
switch (settings.TargetLanguage.Value)
{
case C.ETargetLanguage.C:
commandLine.Add("-x c");
break;
case C.ETargetLanguage.Cxx:
commandLine.Add("-x c++");
break;
case C.ETargetLanguage.ObjectiveC:
commandLine.Add("-x objective-c");
break;
case C.ETargetLanguage.ObjectiveCxx:
commandLine.Add("-x objective-c++");
break;
default:
throw new Bam.Core.Exception("Unsupported target language, {0}", settings.TargetLanguage.Value.ToString());
}
}
if (settings.WarningsAsErrors.HasValue)
{
if (settings.WarningsAsErrors.Value)
{
commandLine.Add("-Werror");
}
else
{
commandLine.Add("-Wno-error");
}
}
if (settings.OutputType.HasValue)
{
var module = (settings as Bam.Core.Settings).Module;
switch (settings.OutputType)
{
case C.ECompilerOutput.CompileOnly:
commandLine.Add(System.String.Format("-c -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToString()));
break;
case C.ECompilerOutput.Preprocess:
commandLine.Add(System.String.Format("-E -o {0}", module.GeneratedPaths[C.ObjectFile.Key].ToString()));
break;
}
}
}
public object Build(
CSharp.Assembly moduleToBuild,
out System.Boolean success)
{
var assemblyModule = moduleToBuild as Bam.Core.BaseModule;
var node = assemblyModule.OwningNode;
var target = node.Target;
var assemblyOptions = assemblyModule.Options;
var options = assemblyOptions as CSharp.IOptions;
if (node.ExternalDependents != null)
{
var keyFilters = new Bam.Core.Array<Bam.Core.LocationKey>(
CSharp.Assembly.OutputFile
);
var dependentAssemblies = new Bam.Core.LocationArray();
node.ExternalDependents.FilterOutputLocations(keyFilters, dependentAssemblies);
foreach (var loc in dependentAssemblies)
{
options.References.Add(loc.GetSinglePath());
}
}
var sourceFiles = new Bam.Core.StringArray();
var fields = moduleToBuild.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
foreach (var field in fields)
{
// C# files
{
var sourceFileAttributes = field.GetCustomAttributes(typeof(Bam.Core.SourceFilesAttribute), false);
if (null != sourceFileAttributes && sourceFileAttributes.Length > 0)
{
var sourceField = field.GetValue(moduleToBuild);
if (sourceField is Bam.Core.Location)
{
var file = sourceField as Bam.Core.Location;
var absolutePath = file.GetSinglePath();
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Source file '{0}' does not exist", absolutePath);
}
sourceFiles.Add(absolutePath);
}
else if (sourceField is Bam.Core.FileCollection)
{
var sourceCollection = sourceField as Bam.Core.FileCollection;
// TODO: convert to var
foreach (Bam.Core.Location location in sourceCollection)
{
var absolutePath = location.AbsolutePath;
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Source file '{0}' does not exist", absolutePath);
}
sourceFiles.Add(absolutePath);
}
}
else
{
throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
}
}
}
// WPF application definition .xaml file
{
var xamlFileAttributes = field.GetCustomAttributes(typeof(CSharp.ApplicationDefinitionAttribute), false);
if (null != xamlFileAttributes && xamlFileAttributes.Length > 0)
{
var sourceField = field.GetValue(moduleToBuild);
if (sourceField is Bam.Core.Location)
{
var file = sourceField as Bam.Core.Location;
var absolutePath = file.GetSinglePath();
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Application definition file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to application definition file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
else if (sourceField is Bam.Core.FileCollection)
{
var sourceCollection = sourceField as Bam.Core.FileCollection;
if (sourceCollection.Count != 1)
{
throw new Bam.Core.Exception("There can be only one application definition");
}
// TODO: convert to var
foreach (string absolutePath in sourceCollection)
{
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Application definition file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to application definition file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
}
else
{
throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
}
}
}
// WPF page .xaml files
{
var xamlFileAttributes = field.GetCustomAttributes(typeof(CSharp.PagesAttribute), false);
if (null != xamlFileAttributes && xamlFileAttributes.Length > 0)
{
var sourceField = field.GetValue(moduleToBuild);
if (sourceField is Bam.Core.Location)
{
var file = sourceField as Bam.Core.Location;
var absolutePath = file.GetSinglePath();
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Page file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to page file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
else if (sourceField is Bam.Core.FileCollection)
{
var sourceCollection = sourceField as Bam.Core.FileCollection;
if (sourceCollection.Count != 1)
{
throw new Bam.Core.Exception("There can be only one page file");
}
// TODO: convert to var
foreach (string absolutePath in sourceCollection)
{
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Page file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to page file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
}
else
{
throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
}
}
}
}
if (0 == sourceFiles.Count)
{
throw new Bam.Core.Exception("There were no source files specified for the module '{0}'", node.ModuleName);
}
// dependency checking
{
var inputLocations = new Bam.Core.LocationArray();
foreach (var source in sourceFiles)
{
inputLocations.Add(Bam.Core.FileLocation.Get(source));
}
var outputLocations = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.File, Bam.Core.Location.EExists.WillExist);
if (!RequiresBuilding(outputLocations, inputLocations))
{
Bam.Core.Log.DebugMessage("'{0}' is up-to-date", node.UniqueModuleName);
success = true;
return null;
}
}
// at this point, we know the node outputs need building
// create all directories required
var dirsToCreate = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.Directory, Bam.Core.Location.EExists.WillExist);
foreach (var dir in dirsToCreate)
{
var dirPath = dir.GetSinglePath();
NativeBuilder.MakeDirectory(dirPath);
}
var commandLineBuilder = new Bam.Core.StringArray();
if (options is CommandLineProcessor.ICommandLineSupport)
{
var commandLineOption = options as CommandLineProcessor.ICommandLineSupport;
commandLineOption.ToCommandLineArguments(commandLineBuilder, target, null);
}
else
{
throw new Bam.Core.Exception("Compiler options does not support command line translation");
}
foreach (var source in sourceFiles)
{
if (source.Contains(" "))
{
commandLineBuilder.Add(System.String.Format("\"{0}\"", source));
}
else
{
commandLineBuilder.Add(source);
}
}
var compilerTool = target.Toolset.Tool(typeof(CSharp.ICSharpCompilerTool));
var exitCode = CommandLineProcessor.Processor.Execute(node, compilerTool, commandLineBuilder);
success = (0 == exitCode);
return null;
}
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);
Bam.Core.IOWrapper.CreateDirectoryIfNotExists(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);
}
}
public object Build(
CSharp.Assembly moduleToBuild,
out System.Boolean success)
{
var assemblyModule = moduleToBuild as Bam.Core.BaseModule;
var node = assemblyModule.OwningNode;
var target = node.Target;
var assemblyOptions = assemblyModule.Options;
var options = assemblyOptions as CSharp.OptionCollection;
var inputVariables = new MakeFileVariableDictionary();
if (node.ExternalDependents != null)
{
foreach (var dependentNode in node.ExternalDependents)
{
if (null != dependentNode.Data)
{
continue;
}
var keyFilters = new Bam.Core.Array<Bam.Core.LocationKey>(
CSharp.Assembly.OutputFile
);
var assemblyLocations = new Bam.Core.LocationArray();
dependentNode.FilterOutputLocations(keyFilters, assemblyLocations);
var data = dependentNode.Data as MakeFileData;
var csharpOptions = options as CSharp.IOptions;
foreach (var loc in assemblyLocations)
{
csharpOptions.References.Add(loc.GetSinglePath());
inputVariables.Add(CSharp.Assembly.OutputFile, data.VariableDictionary[CSharp.Assembly.OutputDir]);
}
}
}
var sourceFiles = new Bam.Core.StringArray();
var fields = moduleToBuild.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
foreach (var field in fields)
{
// C# files
{
var sourceFileAttributes = field.GetCustomAttributes(typeof(Bam.Core.SourceFilesAttribute), false);
if (null != sourceFileAttributes && sourceFileAttributes.Length > 0)
{
var sourceField = field.GetValue(moduleToBuild);
if (sourceField is Bam.Core.Location)
{
var file = sourceField as Bam.Core.Location;
var absolutePath = file.GetSinglePath();
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Source file '{0}' does not exist", absolutePath);
}
sourceFiles.Add(absolutePath);
}
else if (sourceField is Bam.Core.FileCollection)
{
var sourceCollection = sourceField as Bam.Core.FileCollection;
// TODO: convert to var
foreach (Bam.Core.Location location in sourceCollection)
{
var absolutePath = location.GetSinglePath();
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Source file '{0}' does not exist", absolutePath);
}
sourceFiles.Add(absolutePath);
}
}
else
{
throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
}
}
}
// WPF application definition .xaml file
{
var xamlFileAttributes = field.GetCustomAttributes(typeof(CSharp.ApplicationDefinitionAttribute), false);
if (null != xamlFileAttributes && xamlFileAttributes.Length > 0)
{
var sourceField = field.GetValue(moduleToBuild);
if (sourceField is Bam.Core.Location)
{
var file = sourceField as Bam.Core.Location;
var absolutePath = file.GetSinglePath();
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Application definition file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to application definition file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
else if (sourceField is Bam.Core.FileCollection)
{
var sourceCollection = sourceField as Bam.Core.FileCollection;
if (sourceCollection.Count != 1)
{
throw new Bam.Core.Exception("There can be only one application definition");
}
// TODO: convert to var
foreach (string absolutePath in sourceCollection)
{
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Application definition file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to application definition file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
}
else
{
throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
}
}
}
// WPF page .xaml files
{
var xamlFileAttributes = field.GetCustomAttributes(typeof(CSharp.PagesAttribute), false);
if (null != xamlFileAttributes && xamlFileAttributes.Length > 0)
{
var sourceField = field.GetValue(moduleToBuild);
if (sourceField is Bam.Core.Location)
{
var file = sourceField as Bam.Core.Location;
var absolutePath = file.GetSinglePath();
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Page file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to page file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
else if (sourceField is Bam.Core.FileCollection)
{
var sourceCollection = sourceField as Bam.Core.FileCollection;
if (sourceCollection.Count != 1)
{
throw new Bam.Core.Exception("There can be only one page file");
}
// TODO: convert to var
foreach (string absolutePath in sourceCollection)
{
if (!System.IO.File.Exists(absolutePath))
{
throw new Bam.Core.Exception("Page file '{0}' does not exist", absolutePath);
}
var csPath = absolutePath + ".cs";
if (!System.IO.File.Exists(csPath))
{
throw new Bam.Core.Exception("Associated source file '{0}' to page file '{1}' does not exist", csPath, absolutePath);
}
sourceFiles.Add(csPath);
}
}
else
{
throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
}
}
}
}
if (0 == sourceFiles.Count)
{
throw new Bam.Core.Exception("There were no source files specified for the module '{0}'", node.ModuleName);
}
// at this point, we know the node outputs need building
// create all directories required
var dirsToCreate = moduleToBuild.Locations.FilterByType(Bam.Core.ScaffoldLocation.ETypeHint.Directory, Bam.Core.Location.EExists.WillExist);
var commandLineBuilder = new Bam.Core.StringArray();
if (options is CommandLineProcessor.ICommandLineSupport)
{
var commandLineOption = options as CommandLineProcessor.ICommandLineSupport;
commandLineOption.ToCommandLineArguments(commandLineBuilder, target, null);
}
else
{
throw new Bam.Core.Exception("Compiler options does not support command line translation");
}
foreach (var source in sourceFiles)
{
if (source.Contains(" "))
{
commandLineBuilder.Add(System.String.Format("\"{0}\"", source));
}
else
{
commandLineBuilder.Add(source);
}
}
var compilerInstance = target.Toolset.Tool(typeof(CSharp.ICSharpCompilerTool));
var executablePath = compilerInstance.Executable((Bam.Core.BaseTarget)target);
var recipes = new Bam.Core.StringArray();
if (executablePath.Contains(" "))
{
recipes.Add(System.String.Format("\"{0}\" {1}", executablePath, commandLineBuilder.ToString(' ')));
}
else
{
recipes.Add(System.String.Format("{0} {1}", executablePath, commandLineBuilder.ToString(' ')));
}
var makeFile = new MakeFile(node, this.topLevelMakeFilePath);
var rule = new MakeFileRule(
moduleToBuild,
CSharp.Assembly.OutputFile,
node.UniqueModuleName,
dirsToCreate,
inputVariables,
null,
recipes);
var toolOutputLocKeys = compilerInstance.OutputLocationKeys(moduleToBuild);
var outputFileLocations = moduleToBuild.Locations.Keys(Bam.Core.ScaffoldLocation.ETypeHint.File, Bam.Core.Location.EExists.WillExist);
var outputFileLocationsOfInterest = outputFileLocations.Intersect(toolOutputLocKeys);
rule.OutputLocationKeys = outputFileLocationsOfInterest;
makeFile.RuleArray.Add(rule);
var makeFilePath = MakeFileBuilder.GetMakeFilePathName(node);
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(makeFilePath));
Bam.Core.Log.DebugMessage("Makefile : '{0}'", makeFilePath);
using (System.IO.TextWriter makeFileWriter = new System.IO.StreamWriter(makeFilePath))
{
makeFile.Write(makeFileWriter);
}
success = true;
var compilerTool = compilerInstance as Bam.Core.ITool;
System.Collections.Generic.Dictionary<string, Bam.Core.StringArray> environment = null;
if (compilerTool is Bam.Core.IToolEnvironmentVariables)
{
environment = (compilerTool as Bam.Core.IToolEnvironmentVariables).Variables((Bam.Core.BaseTarget)target);
}
var returnData = new MakeFileData(makeFilePath, makeFile.ExportedTargets, makeFile.ExportedVariables, environment);
return returnData;
}