public override void AddFilesToManifest(BuildManifest Manifest, STBuildBinary Binary) { // ok, this is pretty awful, we want the import libraries that go with the editor, only on the PC if (STBuildTool.BuildingRocket() && Path.GetFileNameWithoutExtension(Binary.Config.OutputFilePath).StartsWith("UE4Editor-", StringComparison.InvariantCultureIgnoreCase) && Path.GetExtension(Binary.Config.OutputFilePath).EndsWith("dll", StringComparison.InvariantCultureIgnoreCase) && Binary.Config.Type == STBuildBinaryType.DynamicLinkLibrary) { // ok, this is pretty awful, we want the import libraries that go with the editor, only on the PC Manifest.AddBuildProduct(Path.Combine(Binary.Config.IntermediateDirectory, Path.GetFileNameWithoutExtension(Binary.Config.OutputFilePath) + ".lib"), ""); } }
public virtual void AddFilesToManifest(BuildManifest Manifest, STBuildBinary Binary) { }
public override void AddFilesToManifest(BuildManifest Manifest, STBuildBinary Binary) { if (BuildConfiguration.bCreateStubIPA) { string StubFile = Path.Combine (Path.GetDirectoryName (Binary.Config.OutputFilePath), Path.GetFileNameWithoutExtension (Binary.Config.OutputFilePath) + ".stub"); Manifest.AddBuildProduct(StubFile); } }
/// <summary> /// Cleans all target intermediate files. May also clean UHT if the target uses UObjects. /// </summary> /// <param name="Binaries">Target binaries</param> /// <param name="Platform">Tareet platform</param> /// <param name="Manifest">Manifest</param> protected void CleanTarget(List<STBuildBinary> Binaries, CPPTargetPlatform Platform, BuildManifest Manifest) { { var LocalTargetName = (TargetType == TargetRules.TargetType.Program) ? AppName : GameName; Log.TraceVerbose("Cleaning target {0} - AppName {1}", LocalTargetName, AppName); var TargetFilename = RulesCompiler.GetTargetFilename(GameName); Log.TraceVerbose("\tTargetFilename {0}", TargetFilename); // Collect all files to delete. var AdditionalFileExtensions = new string[] { ".lib", ".exp", ".dll.response" }; var AllFilesToDelete = new List<string>(Manifest.BuildProducts); foreach (var FileManifestItem in Manifest.BuildProducts) { var FileExt = Path.GetExtension(FileManifestItem); if (FileExt == ".dll" || FileExt == ".exe") { var ManifestFileWithoutExtension = Utils.GetPathWithoutExtension(FileManifestItem); foreach (var AdditionalExt in AdditionalFileExtensions) { var AdditionalFileToDelete = ManifestFileWithoutExtension + AdditionalExt; AllFilesToDelete.Add(AdditionalFileToDelete); } } } //@todo. This does not clean up files that are no longer built by the target... // Delete all output files listed in the manifest as well as any additional files. foreach (var FileToDelete in AllFilesToDelete) { if (File.Exists(FileToDelete)) { Log.TraceVerbose("\t\tDeleting " + FileToDelete); CleanFile(FileToDelete); } } // Generate a list of all the modules of each AppBinaries entry var ModuleList = new List<string>(); var bTargetUsesUObjectModule = false; foreach (var AppBin in AppBinaries) { STBuildBinaryCPP AppBinCPP = AppBin as STBuildBinaryCPP; if (AppBinCPP != null) { // Collect all modules used by this binary. Log.TraceVerbose("\tProcessing AppBinary " + AppBin.Config.OutputFilePaths[0]); foreach (string ModuleName in AppBinCPP.ModuleNames) { if (ModuleList.Contains(ModuleName) == false) { Log.TraceVerbose("\t\tModule: " + ModuleName); ModuleList.Add(ModuleName); if (ModuleName == "CoreUObject") { bTargetUsesUObjectModule = true; } } } } else { Log.TraceVerbose("\t********* Skipping " + AppBin.Config.OutputFilePaths[0]); } } var BaseEngineBuildDataFolder = Path.GetFullPath(BuildConfiguration.BaseIntermediatePath).Replace("\\", "/"); var PlatformEngineBuildDataFolder = BuildConfiguration.BaseIntermediatePath; // Delete generated header files foreach (var ModuleName in ModuleList) { var Module = GetModuleByName(ModuleName); var ModuleIncludeDir = STBuildModuleCPP.GetGeneratedCodeDirectoryForModule(this, Module.ModuleDirectory, ModuleName).Replace("\\", "/"); if (!STBuildTool.RunningRocket() || !ModuleIncludeDir.StartsWith(BaseEngineBuildDataFolder, StringComparison.InvariantCultureIgnoreCase)) { if (Directory.Exists(ModuleIncludeDir)) { Log.TraceVerbose("\t\tDeleting " + ModuleIncludeDir); CleanDirectory(ModuleIncludeDir); } } } // { var AppEnginePath = Path.Combine(PlatformEngineBuildDataFolder, LocalTargetName, Configuration.ToString()); if (Directory.Exists(AppEnginePath)) { CleanDirectory(AppEnginePath); } } // Clean the intermediate directory if (!String.IsNullOrEmpty(ProjectIntermediateDirectory)) { if (Directory.Exists(ProjectIntermediateDirectory)) { CleanDirectory(ProjectIntermediateDirectory); } } if (!STBuildTool.RunningRocket()) { // This is always under Rocket installation folder if (Directory.Exists(GlobalLinkEnvironment.Config.IntermediateDirectory)) { Log.TraceVerbose("\tDeleting " + GlobalLinkEnvironment.Config.IntermediateDirectory); CleanDirectory(GlobalLinkEnvironment.Config.IntermediateDirectory); } } else if (ShouldCompileMonolithic()) { // Only in monolithic, otherwise it's pointing to Rocket installation folder if (Directory.Exists(GlobalLinkEnvironment.Config.OutputDirectory)) { Log.TraceVerbose("\tDeleting " + GlobalLinkEnvironment.Config.OutputDirectory); CleanDirectory(GlobalCompileEnvironment.Config.OutputDirectory); } } // Delete the dependency caches { var FlatCPPIncludeDependencyCacheFilename = FlatCPPIncludeDependencyCache.GetDependencyCachePathForTarget(this); if (File.Exists(FlatCPPIncludeDependencyCacheFilename)) { Log.TraceVerbose("\tDeleting " + FlatCPPIncludeDependencyCacheFilename); CleanFile(FlatCPPIncludeDependencyCacheFilename); } var DependencyCacheFilename = DependencyCache.GetDependencyCachePathForTarget(this); if (File.Exists(DependencyCacheFilename)) { Log.TraceVerbose("\tDeleting " + DependencyCacheFilename); CleanFile(DependencyCacheFilename); } } // Delete the UBT makefile { // Figure out what to call our action graph based on everything we're building var TargetDescs = new List<TargetDescriptor>(); // @todo ubtmake: Only supports cleaning one target at a time :( TargetDescs.Add(new TargetDescriptor { TargetName = GetTargetName(), Platform = this.Platform, Configuration = this.Configuration }); var UBTMakefilePath = STBuildTool.GetUBTMakefilePath(TargetDescs); if (File.Exists(UBTMakefilePath)) { Log.TraceVerbose("\tDeleting " + UBTMakefilePath); CleanFile(UBTMakefilePath); } } // Delete the action history { var ActionHistoryFilename = ActionHistory.GeneratePathForTarget(this); if (File.Exists(ActionHistoryFilename)) { Log.TraceVerbose("\tDeleting " + ActionHistoryFilename); CleanFile(ActionHistoryFilename); } } // Finally clean UnrealHeaderTool if this target uses CoreUObject modules and we're not cleaning UHT already // and we want UHT to be cleaned. if (!STBuildConfiguration.bDoNotBuildUHT && bTargetUsesUObjectModule && GetTargetName() != "UnrealHeaderTool") { CleanUnrealHeaderTool(); } } }
/** Generates a public manifest file for writing out */ public void GenerateManifest(ISTToolChain ToolChain, List<STBuildBinary> Binaries, CPPTargetPlatform Platform, List<string> SpecialRocketLibFilesThatAreBuildProducts) { string ManifestPath; if (STBuildTool.RunningRocket()) { ManifestPath = Path.Combine(STBuildTool.GetUProjectPath(), BuildConfiguration.BaseIntermediateFolder, "Manifest.xml"); } else { ManifestPath = "../Intermediate/Build/Manifest.xml"; } BuildManifest Manifest = new BuildManifest(); if (STBuildConfiguration.bMergeManifests) { // Load in existing manifest (if any) Manifest = Utils.ReadClass<BuildManifest>(ManifestPath); } STTargetPlatform TargetPlatform = CPPTargetPlatformToSTTargetPlatform(Platform); var BuildPlatform = STBuildPlatform.GetBuildPlatform(TargetPlatform); // Iterate over all the binaries, and add the relevant info to the manifest foreach (STBuildBinary Binary in Binaries) { // Get the platform specific extension for debug info files // Don't add static library files to the manifest as we do not check them into perforce. // However, add them to the manifest when cleaning the project as we do want to delete // them in that case. if (STBuildConfiguration.bCleanProject == false) { if (Binary.Config.Type == STBuildBinaryType.StaticLibrary) { continue; } } string DebugInfoExtension = BuildPlatform.GetDebugInfoExtension(Binary.Config.Type); // Create and add the binary and associated debug info foreach (string OutputFilePath in Binary.Config.OutputFilePaths) { Manifest.AddBuildProduct(OutputFilePath, DebugInfoExtension); } // Add all the stripped debug symbols if (STBuildTool.BuildingRocket() && (Platform == CPPTargetPlatform.Win32 || Platform == CPPTargetPlatform.Win64)) { foreach (string OutputFilePath in Binary.Config.OutputFilePaths) { string StrippedPath = Path.Combine(Path.GetDirectoryName(OutputFilePath), Path.GetFileNameWithoutExtension(OutputFilePath) + "-Stripped" + DebugInfoExtension); Manifest.AddBuildProduct(StrippedPath); } } if (Binary.Config.Type == STBuildBinaryType.Executable && GlobalLinkEnvironment.Config.CanProduceAdditionalConsoleApp && STBuildConfiguration.bBuildEditor) { foreach (string OutputFilePath in Binary.Config.OutputFilePaths) { Manifest.AddBuildProduct(STBuildBinary.GetAdditionalConsoleAppPath(OutputFilePath), DebugInfoExtension); } } ToolChain.AddFilesToManifest(Manifest, Binary); } { string DebugInfoExtension = BuildPlatform.GetDebugInfoExtension(STBuildBinaryType.StaticLibrary); foreach (var RedistLib in SpecialRocketLibFilesThatAreBuildProducts) { Manifest.AddBuildProduct(RedistLib, DebugInfoExtension); } } if (STBuildConfiguration.bCleanProject) { CleanTarget(Binaries, Platform, Manifest); } if (STBuildConfiguration.bGenerateManifest) { Utils.WriteClass<BuildManifest>(Manifest, ManifestPath, ""); } }
/// <summary> /// Write the project files manifest /// This is used by CIS to verify all files referenced are checked into perforce. /// </summary> protected virtual bool WriteProjectFileManifest() { BuildManifest Manifest = new BuildManifest(); foreach (var CurProject in GeneratedProjectFiles) { foreach (var SourceFile in CurProject.SourceFiles) { Manifest.AddBuildProduct(SourceFile.FilePath); } } string ManifestName = Path.Combine(ProjectFileGenerator.IntermediateProjectFilesPath, "UE4SourceFiles.xml"); Utils.WriteClass<BuildManifest>(Manifest, ManifestName, ""); return true; }