IAssemblerPolicy.Assemble( AssembledObjectFile sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString objectFilePath, Bam.Core.Module 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 = objectFilePath.Parse(); var args = new Bam.Core.StringArray(); args.Add(CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool)); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args); args.Add("%(FullPath)"); var customBuild = config.GetSettingsGroup(VSSolutionBuilder.VSSettingsGroup.ESettingsGroup.CustomBuild, include: sender.InputPath, uniqueToProject: true); customBuild.AddSetting("Command", args.ToString(' '), condition: config.ConditionText); customBuild.AddSetting("Message", System.String.Format("Assembling {0}", System.IO.Path.GetFileName(sender.InputPath.Parse())), condition: config.ConditionText); customBuild.AddSetting("Outputs", output, condition: config.ConditionText); sender.MetaData = customBuild; }
protected override void ExecuteInternal( Bam.Core.ExecutionContext context) { var sourceFile = this.SourceModule; var objectFile = this.GeneratedPaths[Key]; this.Policy.Assemble(this, context, objectFile, sourceFile); }
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); }
ICompilationPolicy.Compile( ObjectFile sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString objectFilePath, Bam.Core.Module source) { if (!sender.PerformCompilation) { return; } if (sender.ReasonToExecute.Reason == Bam.Core.ExecuteReasoning.EReason.DeferredEvaluation) { if (!DeferredEvaluationRequiresBuild(sender)) { 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].ParseAndQuoteIfNecessary()); CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine); }
ExecuteInternal( Bam.Core.ExecutionContext context) { var path = this.ScriptPath.ToString(); var dir = System.IO.Path.GetDirectoryName(path); Bam.Core.IOWrapper.CreateDirectoryIfNotExists(dir); var outputName = this.GetEncapsulatingReferencedModule().Macros["OutputName"]; using (var scriptWriter = new System.IO.StreamWriter(path)) { scriptWriter.WriteLine("Name \"{0}\"", outputName.ToString()); var installedExePath = this.CreateTokenizedString("$(buildroot)/$(config)/$(0).exe", outputName); installedExePath.Parse(); scriptWriter.WriteLine("OutFile \"{0}\"", installedExePath.ToString()); scriptWriter.WriteLine("InstallDir $APPDATA\\{0}", outputName.ToString()); scriptWriter.WriteLine("Page directory"); scriptWriter.WriteLine("Page instfiles"); scriptWriter.WriteLine("Section \"\""); foreach (var dep in this.Files) { scriptWriter.WriteLine("\tSetOutPath $INSTDIR"); scriptWriter.WriteLine("\tFile {0}", dep.Key.GeneratedPaths[dep.Value].ToStringQuoteIfNecessary()); } foreach (var dep in this.Paths) { scriptWriter.WriteLine("\tSetOutPath $INSTDIR"); scriptWriter.WriteLine("\tFile /r \"{0}\\*.*\"", dep.Key.GeneratedPaths[dep.Value].ToString()); } scriptWriter.WriteLine("SectionEnd"); } }
IArchivingPolicy.Archive( StaticLibrary sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString libraryPath, System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> objectFiles, System.Collections.ObjectModel.ReadOnlyCollection <Bam.Core.Module> headers) { var commandLineArgs = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLineArgs); var meta = new MakeFileBuilder.MakeFileMeta(sender); var rule = meta.AddRule(); rule.AddTarget(libraryPath); foreach (var input in objectFiles) { rule.AddPrerequisite(input, C.ObjectFile.Key); } var tool = sender.Tool as Bam.Core.ICommandLineTool; var command = new System.Text.StringBuilder(); command.AppendFormat("{0} {1} $^ {2}", CommandLineProcessor.Processor.StringifyTool(tool), commandLineArgs.ToString(' '), CommandLineProcessor.Processor.TerminatingArgs(tool)); rule.AddShellCommand(command.ToString()); var libraryFileDir = System.IO.Path.GetDirectoryName(libraryPath.ToString()); meta.CommonMetaData.Directories.AddUnique(libraryFileDir); meta.CommonMetaData.ExtendEnvironmentVariables(tool.EnvironmentVariables); }
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 ) { Bam.Core.IOWrapper.CreateDirectoryIfNotExists(output_directory.ToString()); var program = executable.ToStringQuoteIfNecessary(); var linearised_args = arguments.ToString(' '); Bam.Core.Log.Info("Running: {0} {1}", program, linearised_args); Bam.Core.OSUtilities.RunExecutable(program, linearised_args); foreach (var expected_file in expected_output_files) { if (!System.IO.File.Exists(expected_file.Value.ToString())) { throw new Bam.Core.Exception( "Expected '{0}' to exist (key={1}), but it does not", expected_file.Value.ToString(), expected_file.Key ); } } }
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); }
IInstallNameToolPolicy.InstallName( InstallNameModule sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString oldName, Bam.Core.TokenizedString newName) { var originalModule = (sender.Source as ICollatedObject).SourceModule; if (originalModule == null) { return; } var commandLine = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine); var commands = new Bam.Core.StringArray(); // TODO: check what happens for prebuilt modules (there shouldn't be any metadata) commands.Add(System.String.Format("{0} {1} {2} {3} {4} {5}", CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool), commandLine.ToString(' '), oldName.ToString(), newName.ToString(), sender.Source.GeneratedPaths[CollatedObject.Key].ToString(), CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool))); var target = originalModule.MetaData as XcodeBuilder.Target; var configuration = target.GetConfiguration(originalModule); target.AddPostBuildCommands(commands, configuration); }
ExecuteInternal( Bam.Core.ExecutionContext context) { if (null == this.policy) { throw new Bam.Core.Exception( "No execution policy for {0} for build mode {1}", this.ToString(), Bam.Core.Graph.Instance.Mode ); } if (null == this.Executable) { throw new Bam.Core.Exception("No executable was specified for {0}", this.ToString()); } this.policy.GenerateSource( this, context, this.Executable, this.Arguments, this.OutputDirectory, this.InternalExpectedOutputFileDictionary, this.InputFiles ); }
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 solution = Bam.Core.Graph.Instance.MetaData as VSSolutionBuilder.VSSolution; var project = solution.EnsureProjectExists(encapsulating); var config = project.GetConfiguration(encapsulating); var args = new Bam.Core.StringArray(); args.Add(System.String.Format("{0} {1}", executable.ToStringQuoteIfNecessary(), arguments.ToString(' '))); foreach (var input in input_files.Values) { config.AddOtherFile(input); var customBuild = config.GetSettingsGroup( VSSolutionBuilder.VSSettingsGroup.ESettingsGroup.CustomBuild, include: input, uniqueToProject: true ); customBuild.AddSetting("Command", args.ToString(' '), condition: config.ConditionText); customBuild.AddSetting("Message", System.String.Format("Generating outputs from {0}", input.ToString()), condition: config.ConditionText); customBuild.AddSetting("Outputs", expected_output_files.Values, condition: config.ConditionText); customBuild.AddSetting("AdditionalInputs", input_files.Values, condition: config.ConditionText); } }
IGeneratedSourcePolicy.GenerateSource( GeneratedSourceModule sender, Bam.Core.ExecutionContext context, Bam.Core.ICommandLineTool compiler, Bam.Core.TokenizedString generatedFilePath) { var encapsulating = sender.GetEncapsulatingReferencedModule(); var solution = Bam.Core.Graph.Instance.MetaData as VSSolutionBuilder.VSSolution; var project = solution.EnsureProjectExists(encapsulating); var config = project.GetConfiguration(encapsulating); // TODO: change this to a configuration directory really var output_dir = Bam.Core.IOWrapper.EncloseSpaceContainingPathWithDoubleQuotes(Bam.Core.Graph.Instance.BuildRoot); var command = new System.Text.StringBuilder(); command.AppendFormat(compiler.Executable.ToStringQuoteIfNecessary()); command.AppendFormat(" {0}", output_dir); command.AppendFormat(" {0}", "Generated"); config.AddPreBuildCommand(command.ToString()); var compilerProject = solution.EnsureProjectExists(compiler as Bam.Core.Module); config.RequiresProject(compilerProject); }
ExecuteInternal( Bam.Core.ExecutionContext context) { var destPath = this.GeneratedPaths[SourceFileKey].ToString(); var destDir = System.IO.Path.GetDirectoryName(destPath); if (!System.IO.Directory.Exists(destDir)) { System.IO.Directory.CreateDirectory(destDir); } var stubPath = this.Macros["templateConfig"].ToString(); var stubText = System.IO.File.ReadAllText(stubPath); // TODO: this should be following the rules in Modules/makesetup and Modules/Setup.dist // for which modules are static (and thus part of the Python library) and which are shared // and separate in the distribution // note that you need to read Setup.dist backward, as some modules are mentioned twice // and it is the 'topmost' that overrules InsertBuiltinModules(ref stubText); using (System.IO.TextWriter writeFile = new System.IO.StreamWriter(destPath)) { writeFile.NewLine = "\n"; writeFile.Write(stubText); } Bam.Core.Log.MessageAll($"Written '{destPath}'"); }
ExecuteInternal( Bam.Core.ExecutionContext context) { var path = this.ScriptPath.Parse(); var dir = System.IO.Path.GetDirectoryName(path); Bam.Core.IOWrapper.CreateDirectoryIfNotExists(dir); var outputName = this.GetEncapsulatingReferencedModule().Macros["OutputName"]; using (var scriptWriter = new System.IO.StreamWriter(path)) { scriptWriter.WriteLine("[Setup]"); scriptWriter.WriteLine("OutputBaseFilename={0}", outputName.ParseAndQuoteIfNecessary()); scriptWriter.WriteLine("OutputDir={0}", this.CreateTokenizedString("@dir($(buildroot)/$(config)/$(0).exe)", outputName).ParseAndQuoteIfNecessary()); scriptWriter.WriteLine("AppName={0}", outputName.Parse()); scriptWriter.WriteLine("AppVersion={0}", "1.0"); // TODO: get this from the main app: this.CreateTokenizedString("$(MajorVersion).$(MinorVersion)#valid(.$(PatchVersion))").Parse()); scriptWriter.WriteLine("DefaultDirName={{userappdata}}\\{0}", outputName.Parse()); scriptWriter.WriteLine("ArchitecturesAllowed=x64"); scriptWriter.WriteLine("ArchitecturesInstallIn64BitMode=x64"); scriptWriter.WriteLine("Uninstallable=No"); scriptWriter.WriteLine("[Files]"); foreach (var dep in this.Files) { scriptWriter.Write(System.String.Format("Source: \"{0}\"; ", dep.Key.GeneratedPaths[dep.Value])); scriptWriter.Write("DestDir: \"{app}\"; "); scriptWriter.Write("DestName: \"Test\""); } foreach (var dep in this.Paths) { scriptWriter.Write(System.String.Format("Source: \"{0}\\*.*\"; ", dep.Key.GeneratedPaths[dep.Value])); scriptWriter.Write("DestDir: \"{app}\"; "); scriptWriter.Write("Flags: recursesubdirs"); } } }
ICompilationPolicy.Compile( ObjectFile sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString objectFilePath, Bam.Core.Module source) { var commandLineArgs = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLineArgs); var meta = new MakeFileBuilder.MakeFileMeta(sender); var rule = meta.AddRule(); rule.AddTarget(objectFilePath); rule.AddPrerequisite(source, C.SourceFile.Key); var tool = sender.Tool as Bam.Core.ICommandLineTool; var command = new System.Text.StringBuilder(); command.AppendFormat("{0} {1} $< {2}", CommandLineProcessor.Processor.StringifyTool(tool), commandLineArgs.ToString(' '), CommandLineProcessor.Processor.TerminatingArgs(tool)); rule.AddShellCommand(command.ToString()); var objectFileDir = System.IO.Path.GetDirectoryName(objectFilePath.ToString()); meta.CommonMetaData.Directories.AddUnique(objectFileDir); meta.CommonMetaData.ExtendEnvironmentVariables(tool.EnvironmentVariables); }
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()); }
IZipToolPolicy.Zip( ZipModule sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString zipOutputPath, Bam.Core.TokenizedString zipInputPath) { var meta = new MakeFileBuilder.MakeFileMeta(sender); var rule = meta.AddRule(); var dir = sender.CreateTokenizedString("@dir($(0))", zipOutputPath); dir.Parse(); meta.CommonMetaData.AddDirectory(dir.ToString()); rule.AddTarget(zipOutputPath); var commandLine = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine); var args = new Bam.Core.StringArray(); args.Add(System.String.Format("cd {0};", zipInputPath.ToString())); args.Add( System.String.Format("{0} {1} -o {2} {3} {4}", CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool), commandLine.ToString(' '), zipOutputPath.ToString(), "*", CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool) ) ); rule.AddShellCommand(args.ToString(' ')); }
IZipToolPolicy.Zip( ZipModule sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString zipOutputPath, Bam.Core.TokenizedString zipInputPath) { var zipDir = System.IO.Path.GetDirectoryName(zipOutputPath.ToString()); Bam.Core.IOWrapper.CreateDirectoryIfNotExists(zipDir); var commandLine = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine); if (sender.Tool is ZipPosix) { commandLine.Add("-o"); commandLine.Add(Bam.Core.IOWrapper.EscapeSpacesInPath(zipOutputPath.ToString())); } else { commandLine.Add(zipOutputPath.ToStringQuoteIfNecessary()); } commandLine.Add("*"); CommandLineProcessor.Processor.Execute( context, sender.Tool as Bam.Core.ICommandLineTool, commandLine, zipInputPath.ToString() ); }
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].FirstTarget.VariableName)); // TODO: change this to a configuration directory really var output_dir = Bam.Core.IOWrapper.EncloseSpaceContainingPathWithDoubleQuotes(Bam.Core.Graph.Instance.BuildRoot); var commandLineArgs = new Bam.Core.StringArray(); commandLineArgs.Add(output_dir); commandLineArgs.Add("Generated"); var command = new System.Text.StringBuilder(); command.AppendFormat("{0} {1} $^", compiler.Executable.ToStringQuoteIfNecessary(), commandLineArgs.ToString(' ')); rule.AddShellCommand(command.ToString()); }
ExecuteInternal( Bam.Core.ExecutionContext context) { var destPath = this.GeneratedPaths[Key].ToString(); var destDir = System.IO.Path.GetDirectoryName(destPath); Bam.Core.IOWrapper.CreateDirectoryIfNotExists(destDir); using (System.IO.TextWriter writeFile = new System.IO.StreamWriter(destPath)) { writeFile.NewLine = "\n"; var guard = this.GuardString; writeFile.WriteLine("/* Procedurally generated by BuildAMation from module {0} */", this.ToString()); if (null != guard) { writeFile.WriteLine("#ifndef {0}", guard); writeFile.WriteLine("#define {0}", guard); writeFile.WriteLine(this.Contents); writeFile.WriteLine("#endif /* {0} */", guard); } else { writeFile.WriteLine(this.Contents); } } Bam.Core.Log.Info("Written procedurally generated header : {0}", destPath); }
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.ToString()); } } commandLineArgs.AddRange(commandLine); if (null != tool.TerminatingArguments) { foreach (var arg in tool.TerminatingArguments) { commandLineArgs.Add(arg.ToString()); } } Execute( context, tool.Executable.ToString(), commandLineArgs, workingDirectory: workingDirectory, inheritedEnvironmentVariables: tool.InheritedEnvironmentVariables, addedEnvironmentVariables: tool.EnvironmentVariables, useResponseFileOption: tool.UseResponseFileOption); }
IAssemblerPolicy.Assemble( AssembledObjectFile sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString objectFilePath, Bam.Core.Module source) { if (!sender.PerformCompilation) { return; } var meta = new MakeFileBuilder.MakeFileMeta(sender); var rule = meta.AddRule(); rule.AddTarget(objectFilePath); rule.AddPrerequisite(source, C.SourceFile.Key); var outputPath = objectFilePath.Parse(); var args = new Bam.Core.StringArray(); args.Add(CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool)); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args); args.Add("$<"); rule.AddShellCommand(args.ToString(' ')); meta.CommonMetaData.AddDirectory(System.IO.Path.GetDirectoryName(outputPath)); }
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) { if (sender.ReasonToExecute.Reason == Bam.Core.ExecuteReasoning.EReason.DeferredEvaluation) { if (!DeferredEvaluationRequiresBuild(sender, objectFiles)) { return; } } var commandLine = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine); var libraryFileDir = System.IO.Path.GetDirectoryName(libraryPath.ToString()); Bam.Core.IOWrapper.CreateDirectoryIfNotExists(libraryFileDir); foreach (var input in objectFiles) { if (!(input as C.ObjectFileBase).PerformCompilation) { continue; } commandLine.Add(input.GeneratedPaths[C.ObjectFile.Key].ToString()); } CommandLineProcessor.Processor.Execute(context, sender.Tool as Bam.Core.ICommandLineTool, commandLine); }
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 meta = new MakeFileBuilder.MakeFileMeta(sender); var rule = meta.AddRule(); rule.AddTarget(expected_output_files.Values.First()); foreach (var input in input_files.Values) { rule.AddPrerequisite(input); } rule.AddShellCommand( System.String.Format("{0} {1}", executable.ToStringQuoteIfNecessary(), arguments.ToString(' ')) ); meta.CommonMetaData.AddDirectory(output_directory.ToString()); }
IZipToolPolicy.Zip( ZipModule sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString zipOutputPath, Bam.Core.TokenizedString zipInputPath) { var encapsulating = sender.GetEncapsulatingReferencedModule(); var workspace = Bam.Core.Graph.Instance.MetaData as XcodeBuilder.WorkspaceMeta; var target = workspace.EnsureTargetExists(encapsulating); target.EnsureOutputFileReferenceExists( zipOutputPath, XcodeBuilder.FileReference.EFileType.ZipArchive, XcodeBuilder.Target.EProductType.Utility); var configuration = target.GetConfiguration(encapsulating); configuration.SetProductName(Bam.Core.TokenizedString.CreateVerbatim("PythonZip")); var commands = new Bam.Core.StringArray(); var args = new Bam.Core.StringArray(); args.Add(System.String.Format("cd {0} &&", Bam.Core.IOWrapper.EscapeSpacesInPath(zipInputPath.ToString()))); args.Add(CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool)); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(args); args.Add(System.String.Format("{0}", Bam.Core.IOWrapper.EscapeSpacesInPath(zipOutputPath.ToString()))); args.Add("*"); args.Add("|| true"); // because zip returns 12 (nothing to do) upon success args.Add(CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool)); commands.Add(args.ToString(' ')); target.AddPreBuildCommands(commands, configuration); }
IObjCopyToolPolicy.ObjCopy( ObjCopyModule sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString originalPath, Bam.Core.TokenizedString copiedPath) { var mode = (sender.Settings as IObjCopyToolSettings).Mode; // if linking debug data, add to the strip var meta = (EObjCopyToolMode.AddGNUDebugLink == mode) ? sender.SourceModule.MetaData as MakeFileBuilder.MakeFileMeta : new MakeFileBuilder.MakeFileMeta(sender); var rule = (EObjCopyToolMode.AddGNUDebugLink == mode) ? meta.Rules[0] :meta.AddRule(); if (EObjCopyToolMode.AddGNUDebugLink == mode) { rule.AddOrderOnlyDependency(copiedPath.Parse()); } else { meta.CommonMetaData.AddDirectory(sender.CreateTokenizedString("@dir($(0))", copiedPath).Parse()); var sourceFilename = System.IO.Path.GetFileName(originalPath.Parse()); rule.AddTarget(copiedPath, variableName: "objcopy_" + sourceFilename); rule.AddPrerequisite(originalPath); } var commandLine = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine); rule.AddShellCommand(System.String.Format("{0} {1} {2}", CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool), commandLine.ToString(' '), CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool))); }
IStripToolPolicy.Strip( StripModule sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString originalPath, Bam.Core.TokenizedString copiedPath) { var meta = new MakeFileBuilder.MakeFileMeta(sender); var rule = meta.AddRule(); var sourceFilename = System.IO.Path.GetFileName(originalPath.Parse()); meta.CommonMetaData.Directories.AddUnique(sender.CreateTokenizedString("@dir($(0))", copiedPath).Parse()); rule.AddTarget(copiedPath, variableName: "strip_" + sourceFilename); var commandLine = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLine); rule.AddShellCommand(System.String.Format("{0} {1} {2} -o {3} {4}", CommandLineProcessor.Processor.StringifyTool(sender.Tool as Bam.Core.ICommandLineTool), commandLine.ToString(' '), originalPath.Parse(), copiedPath.Parse(), CommandLineProcessor.Processor.TerminatingArgs(sender.Tool as Bam.Core.ICommandLineTool))); }
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); }
ICompilationPolicy.Compile( ObjectFile sender, Bam.Core.ExecutionContext context, Bam.Core.TokenizedString objectFilePath, Bam.Core.Module source) { if (!sender.PerformCompilation) { return; } var commandLineArgs = new Bam.Core.StringArray(); (sender.Settings as CommandLineProcessor.IConvertToCommandLine).Convert(commandLineArgs); var meta = new MakeFileBuilder.MakeFileMeta(sender); var rule = meta.AddRule(); rule.AddTarget(objectFilePath); rule.AddPrerequisite(source, C.SourceFile.Key); var tool = sender.Tool as Bam.Core.ICommandLineTool; var command = new System.Text.StringBuilder(); command.AppendFormat("{0} {1} $< {2}", CommandLineProcessor.Processor.StringifyTool(tool), commandLineArgs.ToString(' '), CommandLineProcessor.Processor.TerminatingArgs(tool)); rule.AddShellCommand(command.ToString()); var objectFileDir = System.IO.Path.GetDirectoryName(objectFilePath.ToString()); meta.CommonMetaData.AddDirectory(objectFileDir); meta.CommonMetaData.ExtendEnvironmentVariables(tool.EnvironmentVariables); // add dependencies, such as procedurally generated headers foreach (var dep in sender.Dependents) { if (null == dep.MetaData) { continue; } if (dep is C.SourceFile) { continue; } var depMeta = dep.MetaData as MakeFileBuilder.MakeFileMeta; foreach (var depRule in depMeta.Rules) { depRule.ForEachTarget(target => { if (!target.IsPhony) { rule.AddPrerequisite(target.Path); } }); } } }
ExecuteInternal( Bam.Core.ExecutionContext context) { if (null != this.Policy) { this.Policy.CreateDMG(this, context, this.Tool as DiskImageCompiler, this.SourceFolderPath, this.GeneratedPaths[Key]); } }